query cmd

bun.lock

···
   "workspaces": {
     "": {
       "name": "plcbundle",
+      "dependencies": {
+        "@jmespath-community/jmespath": "^1.3.0",
+      },
       "devDependencies": {
         "@types/bun": "^1.3.1",
       },
     },
   },
   "packages": {
+    "@jmespath-community/jmespath": ["@jmespath-community/jmespath@1.3.0", "", { "bin": { "jp": "dist/cli.mjs" } }, "sha512-nzOrEdWKNpognj6CT+1Atr7gw0bqUC1KTBRyasBXS9NjFpz+og7LeFZrIQqV81GRcCzKa5H+DNipvv7NQK3GzA=="],
+
     "@types/bun": ["@types/bun@1.3.1", "", { "dependencies": { "bun-types": "1.3.1" } }, "sha512-4jNMk2/K9YJtfqwoAa28c8wK+T7nvJFOjxI4h/7sORWcypRNxBpr+TPNaCfVWq70tLCJsqoFwcf0oI0JU/fvMQ=="],
 
     "@types/node": ["@types/node@24.9.2", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-uWN8YqxXxqFMX2RqGOrumsKeti4LlmIMIyV0lgut4jx7KQBcBiW6vkDtIBvHnHIquwNfJhk8v2OtmO8zXWHfPA=="],

package.json

···
   "scripts": {
     "test": "bun test",
     "test:watch": "bun test --watch",
-    "test:coverage": "bun test --coverage",
+    "tests:coverage": "bun test --coverage",
     "cli": "bun src/cli.ts",
     "publish": "bunx jsr publish"
   },
···
   },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@jmespath-community/jmespath": "^1.3.0"
   }
 }

src/cli.ts

···
 import { info } from './cmds/info';
 import { verify } from './cmds/verify';
 import { exportCmd } from './cmds/export';
+import { query } from './cmds/query';
 
 const commands = {
   clone,
   detect,
   process: processCmd,
+  query,
+  q: query,  // Alias for query
   info,
   verify,
   export: exportCmd,
···
   bun cli <command> [options]
 
 COMMANDS:
-  clone     Clone bundles from a remote repository
-  detect    Detect and filter operations using a custom function
-  process   Process operations with a custom function
-  info      Show index or bundle information
-  verify    Verify bundle integrity
-  export    Export operations from bundle
-  help      Show this help
+  clone         Clone bundles from a remote repository
+  detect        Detect and filter operations using a custom function
+  process       Process operations with a custom function
+  query (q)     Query operations using JMESPath or simple dot notation
+  info          Show index or bundle information
+  verify        Verify bundle integrity
+  export        Export operations from bundle
+  help          Show this help
 
 Use 'bun cli <command> -h' for command-specific help
 
 EXAMPLES:
   bun cli clone --remote https://plcbundle.atscan.net
   bun cli detect ./examples/detect.ts --bundles 1-100
+  bun cli q did --simple --bundles 1-1000
+  bun cli query 'operation.services.*.endpoint' --bundles 1-100
   bun cli process ./my-processor.ts --threads 4
   bun cli info --dir ./bundles
   bun cli verify --bundle 42

src/cmds/query.ts

···
+import { parseArgs } from 'util';
+import { PLCBundle } from '../plcbundle';
+import { search as jmespathSearch } from '@jmespath-community/jmespath';
+
+export async function query(args: string[]) {
+  if (args.includes('-h') || args.includes('--help')) {
+    console.log(`
+query - Query operations using JMESPath or simple dot notation
+
+USAGE:
+  plcbundle-bun query <expression> [options]
+
+ARGUMENTS:
+  <expression>      Query expression (required)
+
+OPTIONS:
+  --dir <path>      Bundle directory (default: ./)
+  --bundles <spec>  Bundle selection: number (42) or range (1-50)
+  --threads <num>   Number of worker threads (default: 0 = auto-detect CPU cores)
+  --format <type>   Output format: jsonl|count (default: jsonl)
+  --limit <num>     Limit number of results
+  --simple          Use fast simple dot notation (10x faster for basic queries)
+  --no-progress     Disable progress output
+
+QUERY MODES:
+
+  SIMPLE (--simple) - Ultra-fast for basic property access:
+    did                                    Direct property (fastest!)
+    operation.services.atproto_pds        Nested property
+    alsoKnownAs[0]                        Array indexing
+    operation.alsoKnownAs[0].name         Combined access
+
+  JMESPATH (default) - Full query power:
+    operation.services.*.endpoint         Wildcard
+    foo[?age > \`30\`]                    Filtering
+    {did: did, handle: alsoKnownAs[0]}    Projection
+    operation.services[*].endpoint        All endpoints
+
+EXAMPLES:
+  # Ultra-fast simple queries (recommended for basic property access)
+  bun cli q 'did' --simple --bundles 1-10000
+  bun cli q 'operation.services.atproto_pds.endpoint' --simple
+  
+  # Complex JMESPath queries (default)
+  bun cli q 'operation.services.*.endpoint' --bundles 1-100
+  bun cli q '[?operation.alsoKnownAs]' --bundles 1-100
+    `);
+    return;
+  }
+
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      dir: { type: 'string', default: './' },
+      bundles: { type: 'string' },
+      threads: { type: 'string', default: '0' },
+      format: { type: 'string', default: 'jsonl' },
+      limit: { type: 'string' },
+      simple: { type: 'boolean', default: false },
+      'no-progress': { type: 'boolean', default: false },
+    },
+    strict: false,
+    allowPositionals: true,
+  });
+
+  const expression = positionals[0];
+  if (!expression) {
+    console.error('Error: Query expression is required');
+    process.exit(1);
+  }
+
+  const dir = (values.dir as string) || './';
+  let threads = parseInt((values.threads as string) || '0');
+  
+  if (threads === 0) {
+    threads = navigator.hardwareConcurrency || 4;
+  }
+  
+  const format = (values.format as string) || 'jsonl';
+  const limit = values.limit ? parseInt(values.limit as string) : undefined;
+  const useSimple = Boolean(values.simple);
+  const noProgress = Boolean(values['no-progress']);
+
+  const bundle = new PLCBundle(dir);
+  const stats = await bundle.getStats();
+
+  let start: number, end: number;
+
+  if (values.bundles && typeof values.bundles === 'string') {
+    const bundleSpec = values.bundles;
+    if (bundleSpec.includes('-')) {
+      const [startStr, endStr] = bundleSpec.split('-');
+      start = parseInt(startStr.trim());
+      end = parseInt(endStr.trim());
+      if (isNaN(start) || isNaN(end)) {
+        throw new Error(`Invalid bundle range: ${bundleSpec}`);
+      }
+    } else {
+      start = parseInt(bundleSpec);
+      end = start;
+      if (isNaN(start)) {
+        throw new Error(`Invalid bundle number: ${bundleSpec}`);
+      }
+    }
+  } else {
+    start = 1;
+    end = stats.lastBundle;
+  }
+
+  if (start < 1 || end > stats.lastBundle || start > end) {
+    throw new Error(`Invalid bundle range ${start}-${end} (available: 1-${stats.lastBundle})`);
+  }
+
+  const queryType = useSimple ? 'simple' : 'JMESPath';
+  const threadInfo = threads > 1 ? ` (${threads} threads)` : '';
+  console.error(`Querying bundles ${start}-${end}${threadInfo} with ${queryType}: ${expression}\n`);
+
+  const startTime = Date.now();
+  let matchCount = 0;
+  let totalOps = 0;
+  let totalBytes = 0;
+  const totalBundles = end - start + 1;
+  let shouldStop = false;
+
+  // Compile simple expression and detect fast path
+  let queryFn: (op: any) => any;
+  
+  if (useSimple) {
+    const compiled = compileSimplePath(expression);
+    
+    // Ultra-fast path for single property access (e.g., "did")
+    if (compiled.segments.length === 1 && compiled.segments[0].type === 'property') {
+      const prop = compiled.segments[0].value as string;
+      queryFn = (op) => op[prop];
+    } else {
+      // Fast path for dot notation
+      queryFn = (op) => querySimplePath(op, compiled);
+    }
+  } else {
+    // JMESPath
+    queryFn = (op) => jmespathSearch(op, expression);
+  }
+
+  if (threads === 1) {
+    // Single-threaded
+    for (let bundleNum = start; bundleNum <= end; bundleNum++) {
+      for await (const { op, line } of bundle.streamOperations(bundleNum)) {
+        totalOps++;
+        totalBytes += line.length;
+
+        if (!noProgress && totalOps % 5000 === 0) {
+          const elapsed = (Date.now() - startTime) / 1000;
+          const bundlesCompleted = bundleNum - start + 1;
+          const progress = bundlesCompleted / totalBundles;
+          const mbPerSec = totalBytes / elapsed / 1e6;
+          const eta = bundlesCompleted > 0 ? ((totalBundles - bundlesCompleted) / bundlesCompleted) * elapsed : 0;
+          renderProgressBar(elapsed, bundlesCompleted, totalBundles, progress, matchCount, mbPerSec, eta);
+        }
+
+        try {
+          const result = queryFn(op);
+            
+          if (result !== null && result !== undefined) {
+            matchCount++;
+            if (format !== 'count') {
+              console.log(JSON.stringify(result));
+            }
+            if (limit && matchCount >= limit) {
+              shouldStop = true;
+              break;
+            }
+          }
+        } catch (error) {
+          // Skip invalid operations
+        }
+      }
+      if (shouldStop) break;
+    }
+  } else {
+    // Multi-threaded
+    const bundlesPerThread = Math.ceil(totalBundles / threads);
+    const workerPath = new URL('../worker.ts', import.meta.url).pathname;
+    const workers: Worker[] = [];
+    const workerStats: Array<{ 
+      totalOps: number; 
+      totalBytes: number; 
+      matchCount: number;
+      bundlesCompleted: number;
+      threadStart: number;
+    }> = [];
+
+    const workerPromises = [];
+
+    for (let i = 0; i < threads; i++) {
+      const threadStart = start + i * bundlesPerThread;
+      const threadEnd = Math.min(threadStart + bundlesPerThread - 1, end);
+      if (threadStart > end) break;
+
+      const worker = new Worker(workerPath);
+      workers.push(worker);
+      workerStats[i] = { totalOps: 0, totalBytes: 0, matchCount: 0, bundlesCompleted: 0, threadStart };
+
+      const promise = new Promise<any>((resolve) => {
+        worker.onmessage = (event) => {
+          const msg = event.data;
+
+          if (msg.type === 'progress') {
+            workerStats[i].totalOps = msg.totalOps;
+            workerStats[i].totalBytes = msg.totalBytes;
+            workerStats[i].matchCount = msg.matchCount;
+            workerStats[i].bundlesCompleted = Math.max(0, msg.currentBundle - workerStats[i].threadStart + 1);
+
+            let aggOps = 0, aggBytes = 0, aggMatches = 0, totalBundlesCompleted = 0;
+            for (const ws of workerStats) {
+              aggOps += ws.totalOps;
+              aggBytes += ws.totalBytes;
+              aggMatches += ws.matchCount;
+              totalBundlesCompleted += ws.bundlesCompleted;
+            }
+
+            const progress = Math.min(totalBundlesCompleted / totalBundles, 1.0);
+            if (!noProgress) {
+              const elapsed = (Date.now() - startTime) / 1000;
+              const mbPerSec = aggBytes / elapsed / 1e6;
+              const eta = totalBundlesCompleted > 0 ? ((totalBundles - totalBundlesCompleted) / totalBundlesCompleted) * elapsed : 0;
+              renderProgressBar(elapsed, totalBundlesCompleted, totalBundles, progress, aggMatches, mbPerSec, eta);
+            }
+          } else if (msg.type === 'match-batch') {
+            for (const match of msg.matches) {
+              matchCount++;
+              if (format !== 'count') {
+                console.log(JSON.stringify(match.result));
+              }
+              if (limit && matchCount >= limit) {
+                shouldStop = true;
+                workers.forEach(w => w.terminate());
+                break;
+              }
+            }
+          } else if (msg.type === 'result') {
+            totalOps += msg.totalOps;
+            totalBytes += msg.totalBytes;
+            resolve(msg);
+          }
+        };
+      });
+
+      workerPromises.push(promise);
+      worker.postMessage({
+        dir: bundle['dir'],
+        start: threadStart,
+        end: threadEnd,
+        expression: expression,
+        useSimple: useSimple,
+        flush: true,
+        mode: 'query',
+      });
+    }
+
+    await Promise.all(workerPromises);
+    workers.forEach(w => w.terminate());
+  }
+
+  const elapsed = (Date.now() - startTime) / 1000;
+
+  if (!noProgress) {
+    const mbPerSec = totalBytes / elapsed / 1e6;
+    renderProgressBar(elapsed, totalBundles, totalBundles, 1.0, matchCount, mbPerSec, 0);
+    console.error('\n');
+  }
+
+  if (format === 'count') {
+    console.log(matchCount);
+  }
+
+  console.error('');
+  console.error(`✓ Query complete`);
+  console.error(`  Total operations:   ${totalOps.toLocaleString()}`);
+  console.error(`  Matches found:      ${matchCount.toLocaleString()} (${totalOps > 0 ? ((matchCount/totalOps)*100).toFixed(2) : '0.00'}%)`);
+  console.error(`  Total bytes:        ${(totalBytes / 1e6).toFixed(1)} MB`);
+  console.error(`  Time elapsed:       ${elapsed.toFixed(2)}s`);
+  console.error(`  Throughput:         ${(totalOps / elapsed).toFixed(0)} ops/sec | ${(totalBytes / elapsed / 1e6).toFixed(1)} MB/s`);
+  if (threads > 1) {
+    console.error(`  Threads:            ${threads}`);
+  }
+}
+
+// Simple dot notation parser
+interface SimplePath {
+  segments: Array<{ type: 'property' | 'index'; value: string | number }>;
+}
+
+function compileSimplePath(expression: string): SimplePath {
+  const segments: Array<{ type: 'property' | 'index'; value: string | number }> = [];
+  
+  let current = '';
+  let i = 0;
+  
+  while (i < expression.length) {
+    const char = expression[i];
+    
+    if (char === '.') {
+      if (current) {
+        segments.push({ type: 'property', value: current });
+        current = '';
+      }
+      i++;
+    } else if (char === '[') {
+      if (current) {
+        segments.push({ type: 'property', value: current });
+        current = '';
+      }
+      i++;
+      let index = '';
+      while (i < expression.length && expression[i] !== ']') {
+        index += expression[i];
+        i++;
+      }
+      segments.push({ type: 'index', value: parseInt(index) });
+      i++;
+    } else {
+      current += char;
+      i++;
+    }
+  }
+  
+  if (current) {
+    segments.push({ type: 'property', value: current });
+  }
+  
+  return { segments };
+}
+
+function querySimplePath(obj: any, compiled: SimplePath): any {
+  let current = obj;
+  
+  for (const segment of compiled.segments) {
+    if (current == null) return null;
+    
+    if (segment.type === 'property') {
+      current = current[segment.value];
+    } else {
+      if (Array.isArray(current)) {
+        current = current[segment.value as number];
+      } else {
+        return null;
+      }
+    }
+  }
+  
+  return current;
+}
+
+function renderProgressBar(
+  elapsed: number,
+  current: number,
+  total: number,
+  progress: number,
+  matches: number,
+  mbPerSec: number,
+  etaSeconds: number
+) {
+  const barWidth = 40;
+  const filledWidth = Math.floor(progress * barWidth);
+  const hours = Math.floor(elapsed / 3600);
+  const minutes = Math.floor((elapsed % 3600) / 60);
+  const seconds = Math.floor(elapsed % 60);
+  const timeStr = `[${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}]`;
+
+  let bar = '';
+  if (filledWidth === 0) {
+    bar = '>' + ' '.repeat(barWidth - 1);
+  } else if (filledWidth >= barWidth) {
+    bar = '>'.repeat(barWidth);
+  } else {
+    bar = '>' + '-'.repeat(filledWidth - 1) + ' '.repeat(barWidth - filledWidth);
+  }
+
+  const percent = (progress * 100).toFixed(1);
+  let etaStr = '';
+  if (etaSeconds > 0 && etaSeconds < 86400) {
+    if (etaSeconds < 60) {
+      etaStr = `${Math.ceil(etaSeconds)}s`;
+    } else if (etaSeconds < 3600) {
+      etaStr = `${Math.ceil(etaSeconds / 60)}m`;
+    } else {
+      const etaHours = Math.floor(etaSeconds / 3600);
+      const etaMin = Math.ceil((etaSeconds % 3600) / 60);
+      etaStr = `${etaHours}h ${etaMin}m`;
+    }
+  }
+
+  const matchesStr = matches >= 1000000 ? `${(matches / 1000000).toFixed(1)}M` : matches >= 1000 ? `${(matches / 1000).toFixed(0)}k` : matches.toString();
+  const line = etaStr
+    ? `${timeStr} ${bar} ${current}/${total} (${percent}%) ${matchesStr} matches | ${mbPerSec.toFixed(1)} MB/s [ETA: ${etaStr}]`
+    : `${timeStr} ${bar} ${current}/${total} (${percent}%) ${matchesStr} matches | ${mbPerSec.toFixed(1)} MB/s`;
+
+  process.stderr.write(`\r${line}\x1b[K`);
+}

src/worker.ts

···
 /// <reference lib="webworker" />
 
+import { search as jmespathSearch } from '@jmespath-community/jmespath';
+
 export interface WorkerTask {
   dir: string;
   start: number;
   end: number;
-  modulePath: string;
+  modulePath?: string;
+  expression?: string;
+  useSimple?: boolean;
   silent?: boolean;
   flush?: boolean;
-  mode?: 'detect' | 'process'; // Add mode parameter
+  mode?: 'detect' | 'process' | 'query';
 }
 
 export interface WorkerProgress {
   type: 'progress';
+  currentBundle: number;
   totalOps: number;
   totalBytes: number;
+  matchCount: number;
 }
 
-export interface WorkerMatch {
-  type: 'match';
-  bundle: number;
-  position: number;
-  cid: string;
-  size: number;
-  labels: string[];
+export interface WorkerMatchBatch {
+  type: 'match-batch';
+  matches: Array<{ result: any }>;
 }
 
 export interface WorkerResult {
   type: 'result';
   totalOps: number;
   totalBytes: number;
-  matches: Array<{
-    bundle: number;
-    position: number;
-    cid: string;
-    size: number;
-    labels: string[];
-  }>;
+  matchCount: number;
+  data?: any;
 }
 
 self.onmessage = async (event: MessageEvent<WorkerTask>) => {
-  const { dir, start, end, modulePath, silent, flush, mode = 'detect' } = event.data;
+  const { 
+    dir, 
+    start, 
+    end, 
+    modulePath, 
+    expression,
+    useSimple,
+    silent, 
+    flush, 
+    mode = 'detect' 
+  } = event.data;
   
-  // Override console if silent
   if (silent) {
     globalThis.console = {
       log: () => {},
···
     } as any;
   }
   
-  // Load the appropriate function based on mode
-  const mod = await import(modulePath);
-  const userFn = mode === 'detect' 
-    ? (mod.detect || mod.default)
-    : (mod.process || mod.default);
+  let userFn: any;
+  let queryFn: ((op: any) => any) | null = null;
+  
+  if (mode === 'query') {
+    // Query mode
+    if (useSimple) {
+      const compiled = compileSimplePath(expression!);
+      
+      // Ultra-fast path for single property
+      if (compiled.segments.length === 1 && compiled.segments[0].type === 'property') {
+        const prop = compiled.segments[0].value as string;
+        queryFn = (op) => op[prop];
+      } else {
+        queryFn = (op) => querySimplePath(op, compiled);
+      }
+    } else {
+      queryFn = (op) => jmespathSearch(op, expression!);
+    }
+  } else {
+    // Detect or process mode
+    const mod = await import(modulePath!);
+    userFn = mode === 'detect' ? (mod.detect || mod.default) : (mod.process || mod.default);
+  }
   
   let totalOps = 0;
   let totalBytes = 0;
-  const matches: any[] = [];
+  let matchCount = 0;
+  const BATCH_SIZE = 1000;
+  let matchBatch: any[] = [];
+  
+  const flushBatch = () => {
+    if (matchBatch.length > 0) {
+      self.postMessage({ type: 'match-batch', matches: matchBatch } as WorkerMatchBatch);
+      matchBatch = [];
+    }
+  };
   
   for (let bundleNum = start; bundleNum <= end; bundleNum++) {
     const bundlePath = `${dir}${bundleNum.toString().padStart(6, '0')}.jsonl.zst`;
···
       const compressed = await Bun.file(bundlePath).arrayBuffer();
       const decompressed = Bun.zstdDecompressSync(compressed);
       const text = new TextDecoder().decode(decompressed);
-      
       const lines = text.split('\n');
       
       for (let position = 0; position < lines.length; position++) {
···
         
         totalOps++;
         totalBytes += line.length;
-        
         const op = JSON.parse(line);
         
-        if (mode === 'detect') {
-          // Detection mode - look for labels
-          const labels = userFn({ op });
-          
-          if (labels && labels.length > 0) {
-            const match = {
-              bundle: bundleNum,
-              position,
-              cid: op.cid.slice(-4),
-              size: line.length,
-              labels,
-            };
+        if (mode === 'query') {
+          try {
+            const result = queryFn!(op);
             
-            if (flush) {
-              // Send match immediately
-              self.postMessage({
-                type: 'match',
-                ...match,
-              } as WorkerMatch);
-            } else {
-              // Buffer matches
-              matches.push(match);
+            if (result !== null && result !== undefined) {
+              matchCount++;
+              matchBatch.push({ result });
+              if (matchBatch.length >= BATCH_SIZE) flushBatch();
             }
+          } catch (error) {}
+        } else if (mode === 'detect') {
+          const labels = userFn({ op });
+          if (labels && labels.length > 0) {
+            matchCount++;
+            matchBatch.push({ result: { bundle: bundleNum, position, cid: op.cid.slice(-4), labels } });
+            if (matchBatch.length >= BATCH_SIZE) flushBatch();
           }
         } else {
-          // Process mode - just call the function
+          // process mode
           userFn({ op, position, bundle: bundleNum, line });
         }
         
         if (totalOps % 10000 === 0) {
-          self.postMessage({
-            type: 'progress',
-            totalOps,
-            totalBytes,
-          } as WorkerProgress);
+          self.postMessage({ type: 'progress', currentBundle: bundleNum, totalOps, totalBytes, matchCount } as WorkerProgress);
         }
       }
-    } catch (error) {
-      // Continue on error
-    }
+      
+      self.postMessage({ type: 'progress', currentBundle: bundleNum, totalOps, totalBytes, matchCount } as WorkerProgress);
+    } catch (error) {}
   }
+  
+  flushBatch();
 
   let prepareResult: any;
-  if (typeof mod.prepare === 'function') {
-    try {
-      prepareResult = await mod.prepare();
-    } catch (error) {
-      // Silently ignore finalize errors
+  if (mode !== 'query' && modulePath) {
+    const mod = await import(modulePath);
+    if (typeof mod.prepare === 'function') {
+      try {
+        prepareResult = await mod.prepare();
+      } catch (error) {}
     }
   }
   
-  // Send final result
-  self.postMessage({
-    type: 'result',
-    totalOps,
-    totalBytes,
-    matches: flush ? [] : matches,
-    data: prepareResult || null
-  } as WorkerResult);
-};
+  self.postMessage({ type: 'result', totalOps, totalBytes, matchCount, data: prepareResult || null } as WorkerResult);
+};
+
+interface SimplePath {
+  segments: Array<{ type: 'property' | 'index'; value: string | number }>;
+}
+
+function compileSimplePath(expression: string): SimplePath {
+  const segments: Array<{ type: 'property' | 'index'; value: string | number }> = [];
+  let current = '';
+  let i = 0;
+  
+  while (i < expression.length) {
+    const char = expression[i];
+    if (char === '.') {
+      if (current) segments.push({ type: 'property', value: current });
+      current = '';
+      i++;
+    } else if (char === '[') {
+      if (current) segments.push({ type: 'property', value: current });
+      current = '';
+      i++;
+      let index = '';
+      while (i < expression.length && expression[i] !== ']') {
+        index += expression[i];
+        i++;
+      }
+      segments.push({ type: 'index', value: parseInt(index) });
+      i++;
+    } else {
+      current += char;
+      i++;
+    }
+  }
+  if (current) segments.push({ type: 'property', value: current });
+  return { segments };
+}
+
+function querySimplePath(obj: any, compiled: SimplePath): any {
+  let current = obj;
+  for (const segment of compiled.segments) {
+    if (current == null) return null;
+    if (segment.type === 'property') {
+      current = current[segment.value];
+    } else {
+      if (Array.isArray(current)) {
+        current = current[segment.value as number];
+      } else {
+        return null;
+      }
+    }
+  }
+  return current;
+}