@optave/codegraph 3.4.1 → 3.6.0

package/dist/features/dataflow.js

@@ -14,7 +14,7 @@ import { DATAFLOW_RULES } from '../ast-analysis/rules/index.js';
 import { makeDataflowRules as _makeDataflowRules, buildExtensionSet, buildExtToLangMap, } from '../ast-analysis/shared.js';
 import { walkWithVisitors } from '../ast-analysis/visitor.js';
 import { createDataflowVisitor } from '../ast-analysis/visitors/dataflow-visitor.js';
-import { hasDataflowTable, openReadonlyOrFail } from '../db/index.js';
+import { hasDataflowTable, openReadonlyOrFail, openReadonlyWithNative } from '../db/index.js';
 import { ALL_SYMBOL_KINDS, normalizeSymbol } from '../domain/queries.js';
 import { debug, info } from '../infrastructure/logger.js';
 import { isTestFile } from '../infrastructure/test-filter.js';
@@ -125,8 +125,96 @@ function insertDataflowEdges(insert, data, resolveNode) {
     return edgeCount;
 }
 // ── buildDataflowEdges ──────────────────────────────────────────────────────
-export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts) {
+export async function buildDataflowEdges(db, fileSymbols, rootDir, engineOpts) {
     const extToLang = buildExtToLangMap();
+    // ── Native bulk-insert fast path ──────────────────────────────────────
+    const nativeDb = engineOpts?.nativeDb;
+    if (nativeDb?.bulkInsertDataflow) {
+        let needsJsFallback = false;
+        const nativeEdges = [];
+        const getNodeByNameAndFile = db.prepare(`SELECT id, name, kind, file, line FROM nodes
+       WHERE name = ? AND file = ? AND kind IN ('function', 'method')`);
+        const getNodeByName = db.prepare(`SELECT id, name, kind, file, line FROM nodes
+       WHERE name = ? AND kind IN ('function', 'method')
+       ORDER BY file, line LIMIT 10`);
+        for (const [relPath, symbols] of fileSymbols) {
+            const ext = path.extname(relPath).toLowerCase();
+            if (!DATAFLOW_EXTENSIONS.has(ext))
+                continue;
+            if (!symbols.dataflow) {
+                needsJsFallback = true;
+                break;
+            }
+            const resolveNode = (funcName) => {
+                const local = getNodeByNameAndFile.all(funcName, relPath);
+                if (local.length > 0)
+                    return local[0];
+                const global = getNodeByName.all(funcName);
+                return global.length > 0 ? global[0] : null;
+            };
+            const data = symbols.dataflow;
+            for (const flow of data.argFlows) {
+                const sourceNode = resolveNode(flow.callerFunc);
+                const targetNode = resolveNode(flow.calleeName);
+                if (sourceNode && targetNode) {
+                    nativeEdges.push({
+                        sourceId: sourceNode.id,
+                        targetId: targetNode.id,
+                        kind: 'flows_to',
+                        paramIndex: flow.argIndex,
+                        expression: flow.expression,
+                        line: flow.line,
+                        confidence: flow.confidence,
+                    });
+                }
+            }
+            for (const assignment of data.assignments) {
+                const producerNode = resolveNode(assignment.sourceCallName);
+                const consumerNode = resolveNode(assignment.callerFunc);
+                if (producerNode && consumerNode) {
+                    nativeEdges.push({
+                        sourceId: producerNode.id,
+                        targetId: consumerNode.id,
+                        kind: 'returns',
+                        paramIndex: null,
+                        expression: assignment.expression,
+                        line: assignment.line,
+                        confidence: 1.0,
+                    });
+                }
+            }
+            for (const mut of data.mutations) {
+                const mutatorNode = resolveNode(mut.funcName);
+                if (mutatorNode && mut.binding?.type === 'param') {
+                    nativeEdges.push({
+                        sourceId: mutatorNode.id,
+                        targetId: mutatorNode.id,
+                        kind: 'mutates',
+                        paramIndex: null,
+                        expression: mut.mutatingExpr,
+                        line: mut.line,
+                        confidence: 1.0,
+                    });
+                }
+            }
+        }
+        if (!needsJsFallback) {
+            if (nativeEdges.length > 0) {
+                let inserted;
+                try {
+                    engineOpts?.suspendJsDb?.();
+                    inserted = nativeDb.bulkInsertDataflow(nativeEdges);
+                }
+                finally {
+                    engineOpts?.resumeJsDb?.();
+                }
+                info(`Dataflow (native bulk): ${inserted} edges inserted`);
+            }
+            return;
+        }
+        debug('Dataflow: some files lack pre-computed data — falling back to JS');
+    }
+    // ── JS fallback path ─────────────────────────────────────────────────
     const { parsers, getParserFn } = await initDataflowParsers(fileSymbols);
     const insert = db.prepare(`INSERT INTO dataflow (source_id, target_id, kind, param_index, expression, line, confidence)
      VALUES (?, ?, ?, ?, ?, ?, ?)`);
@@ -157,10 +245,96 @@ export async function buildDataflowEdges(db, fileSymbols, rootDir, _engineOpts)
     tx();
     info(`Dataflow: ${totalEdges} edges inserted`);
 }
-// ── Query functions ─────────────────────────────────────────────────────────
-// findNodes imported from ./shared/find-nodes.js
+function prepareDataflowStmts(db) {
+    return {
+        flowsToOut: db.prepare(`SELECT d.*, n.name AS target_name, n.kind AS target_kind, n.file AS target_file, n.line AS target_line
+     FROM dataflow d JOIN nodes n ON d.target_id = n.id
+     WHERE d.source_id = ? AND d.kind = 'flows_to'`),
+        flowsToIn: db.prepare(`SELECT d.*, n.name AS source_name, n.kind AS source_kind, n.file AS source_file, n.line AS source_line
+     FROM dataflow d JOIN nodes n ON d.source_id = n.id
+     WHERE d.target_id = ? AND d.kind = 'flows_to'`),
+        returnsOut: db.prepare(`SELECT d.*, n.name AS target_name, n.kind AS target_kind, n.file AS target_file, n.line AS target_line
+     FROM dataflow d JOIN nodes n ON d.target_id = n.id
+     WHERE d.source_id = ? AND d.kind = 'returns'`),
+        returnsIn: db.prepare(`SELECT d.*, n.name AS source_name, n.kind AS source_kind, n.file AS source_file, n.line AS source_line
+     FROM dataflow d JOIN nodes n ON d.source_id = n.id
+     WHERE d.target_id = ? AND d.kind = 'returns'`),
+        mutatesOut: db.prepare(`SELECT d.*, n.name AS target_name, n.kind AS target_kind, n.file AS target_file, n.line AS target_line
+     FROM dataflow d JOIN nodes n ON d.target_id = n.id
+     WHERE d.source_id = ? AND d.kind = 'mutates'`),
+        mutatesIn: db.prepare(`SELECT d.*, n.name AS source_name, n.kind AS source_kind, n.file AS source_file, n.line AS source_line
+     FROM dataflow d JOIN nodes n ON d.source_id = n.id
+     WHERE d.target_id = ? AND d.kind = 'mutates'`),
+    };
+}
+function buildNodeDataflowResult(node, stmts, db, hc, noTests) {
+    const sym = normalizeSymbol(node, db, hc);
+    const flowsTo = stmts.flowsToOut.all(node.id).map((r) => ({
+        target: r.target_name,
+        kind: r.target_kind,
+        file: r.target_file,
+        line: r.line,
+        paramIndex: r.param_index,
+        expression: r.expression,
+        confidence: r.confidence,
+    }));
+    const flowsFrom = stmts.flowsToIn.all(node.id).map((r) => ({
+        source: r.source_name,
+        kind: r.source_kind,
+        file: r.source_file,
+        line: r.line,
+        paramIndex: r.param_index,
+        expression: r.expression,
+        confidence: r.confidence,
+    }));
+    const returnConsumers = stmts.returnsOut.all(node.id).map((r) => ({
+        consumer: r.target_name,
+        kind: r.target_kind,
+        file: r.target_file,
+        line: r.line,
+        expression: r.expression,
+    }));
+    const returnedBy = stmts.returnsIn.all(node.id).map((r) => ({
+        producer: r.source_name,
+        kind: r.source_kind,
+        file: r.source_file,
+        line: r.line,
+        expression: r.expression,
+    }));
+    const mutatesTargets = stmts.mutatesOut.all(node.id).map((r) => ({
+        target: r.target_name,
+        expression: r.expression,
+        line: r.line,
+    }));
+    const mutatedBy = stmts.mutatesIn.all(node.id).map((r) => ({
+        source: r.source_name,
+        expression: r.expression,
+        line: r.line,
+    }));
+    if (noTests) {
+        const filter = (arr) => arr.filter((r) => !isTestFile(r.file));
+        return {
+            ...sym,
+            flowsTo: filter(flowsTo),
+            flowsFrom: filter(flowsFrom),
+            returns: returnConsumers.filter((r) => !isTestFile(r.file)),
+            returnedBy: returnedBy.filter((r) => !isTestFile(r.file)),
+            mutates: mutatesTargets,
+            mutatedBy,
+        };
+    }
+    return {
+        ...sym,
+        flowsTo,
+        flowsFrom,
+        returns: returnConsumers,
+        returnedBy,
+        mutates: mutatesTargets,
+        mutatedBy,
+    };
+}
 export function dataflowData(name, customDbPath, opts = {}) {
-    const db = openReadonlyOrFail(customDbPath);
+    const { db, nativeDb, close } = openReadonlyWithNative(customDbPath);
     try {
         const noTests = opts.noTests || false;
         if (!hasDataflowTable(db)) {
@@ -174,98 +348,163 @@ export function dataflowData(name, customDbPath, opts = {}) {
         if (nodes.length === 0) {
             return { name, results: [] };
         }
-        const flowsToOut = db.prepare(`SELECT d.*, n.name AS target_name, n.kind AS target_kind, n.file AS target_file, n.line AS target_line
-     FROM dataflow d JOIN nodes n ON d.target_id = n.id
-     WHERE d.source_id = ? AND d.kind = 'flows_to'`);
-        const flowsToIn = db.prepare(`SELECT d.*, n.name AS source_name, n.kind AS source_kind, n.file AS source_file, n.line AS source_line
-     FROM dataflow d JOIN nodes n ON d.source_id = n.id
-     WHERE d.target_id = ? AND d.kind = 'flows_to'`);
-        const returnsOut = db.prepare(`SELECT d.*, n.name AS target_name, n.kind AS target_kind, n.file AS target_file, n.line AS target_line
-     FROM dataflow d JOIN nodes n ON d.target_id = n.id
-     WHERE d.source_id = ? AND d.kind = 'returns'`);
-        const returnsIn = db.prepare(`SELECT d.*, n.name AS source_name, n.kind AS source_kind, n.file AS source_file, n.line AS source_line
-     FROM dataflow d JOIN nodes n ON d.source_id = n.id
-     WHERE d.target_id = ? AND d.kind = 'returns'`);
-        const mutatesOut = db.prepare(`SELECT d.*, n.name AS target_name, n.kind AS target_kind, n.file AS target_file, n.line AS target_line
-     FROM dataflow d JOIN nodes n ON d.target_id = n.id
-     WHERE d.source_id = ? AND d.kind = 'mutates'`);
-        const mutatesIn = db.prepare(`SELECT d.*, n.name AS source_name, n.kind AS source_kind, n.file AS source_file, n.line AS source_line
-     FROM dataflow d JOIN nodes n ON d.source_id = n.id
-     WHERE d.target_id = ? AND d.kind = 'mutates'`);
-        const hc = new Map();
-        const results = nodes.map((node) => {
-            const sym = normalizeSymbol(node, db, hc);
-            const flowsTo = flowsToOut.all(node.id).map((r) => ({
-                target: r.target_name,
-                kind: r.target_kind,
-                file: r.target_file,
-                line: r.line,
-                paramIndex: r.param_index,
-                expression: r.expression,
-                confidence: r.confidence,
-            }));
-            const flowsFrom = flowsToIn.all(node.id).map((r) => ({
-                source: r.source_name,
-                kind: r.source_kind,
-                file: r.source_file,
-                line: r.line,
-                paramIndex: r.param_index,
-                expression: r.expression,
-                confidence: r.confidence,
-            }));
-            const returnConsumers = returnsOut.all(node.id).map((r) => ({
-                consumer: r.target_name,
-                kind: r.target_kind,
-                file: r.target_file,
-                line: r.line,
-                expression: r.expression,
-            }));
-            const returnedBy = returnsIn.all(node.id).map((r) => ({
-                producer: r.source_name,
-                kind: r.source_kind,
-                file: r.source_file,
-                line: r.line,
-                expression: r.expression,
-            }));
-            const mutatesTargets = mutatesOut.all(node.id).map((r) => ({
-                target: r.target_name,
-                expression: r.expression,
-                line: r.line,
-            }));
-            const mutatedBy = mutatesIn.all(node.id).map((r) => ({
-                source: r.source_name,
-                expression: r.expression,
-                line: r.line,
-            }));
-            if (noTests) {
-                const filter = (arr) => arr.filter((r) => !isTestFile(r.file));
+        // ── Native fast path: 6 queries per node → 1 napi call per node ──
+        if (nativeDb?.getDataflowEdges) {
+            const hc = new Map();
+            const results = nodes.map((node) => {
+                const sym = normalizeSymbol(node, db, hc);
+                const d = nativeDb.getDataflowEdges(node.id);
+                const flowsTo = d.flowsToOut.map((r) => ({
+                    target: r.name,
+                    kind: r.kind,
+                    file: r.file,
+                    line: r.line,
+                    paramIndex: r.paramIndex,
+                    expression: r.expression,
+                    confidence: r.confidence,
+                }));
+                const flowsFrom = d.flowsToIn.map((r) => ({
+                    source: r.name,
+                    kind: r.kind,
+                    file: r.file,
+                    line: r.line,
+                    paramIndex: r.paramIndex,
+                    expression: r.expression,
+                    confidence: r.confidence,
+                }));
+                const returnConsumers = d.returnsOut.map((r) => ({
+                    consumer: r.name,
+                    kind: r.kind,
+                    file: r.file,
+                    line: r.line,
+                    expression: r.expression,
+                }));
+                const returnedBy = d.returnsIn.map((r) => ({
+                    producer: r.name,
+                    kind: r.kind,
+                    file: r.file,
+                    line: r.line,
+                    expression: r.expression,
+                }));
+                const mutatesTargets = d.mutatesOut.map((r) => ({
+                    target: r.name,
+                    expression: r.expression,
+                    line: r.line,
+                }));
+                const mutatedBy = d.mutatesIn.map((r) => ({
+                    source: r.name,
+                    expression: r.expression,
+                    line: r.line,
+                }));
+                if (noTests) {
+                    const filter = (arr) => arr.filter((r) => !isTestFile(r.file));
+                    return {
+                        ...sym,
+                        flowsTo: filter(flowsTo),
+                        flowsFrom: filter(flowsFrom),
+                        returns: returnConsumers.filter((r) => !isTestFile(r.file)),
+                        returnedBy: returnedBy.filter((r) => !isTestFile(r.file)),
+                        mutates: mutatesTargets,
+                        mutatedBy,
+                    };
+                }
                 return {
                     ...sym,
-                    flowsTo: filter(flowsTo),
-                    flowsFrom: filter(flowsFrom),
-                    returns: returnConsumers.filter((r) => !isTestFile(r.file)),
-                    returnedBy: returnedBy.filter((r) => !isTestFile(r.file)),
+                    flowsTo,
+                    flowsFrom,
+                    returns: returnConsumers,
+                    returnedBy,
                     mutates: mutatesTargets,
                     mutatedBy,
                 };
-            }
-            return {
-                ...sym,
-                flowsTo,
-                flowsFrom,
-                returns: returnConsumers,
-                returnedBy,
-                mutates: mutatesTargets,
-                mutatedBy,
-            };
-        });
+            });
+            const base = { name, results };
+            return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+        }
+        // ── JS fallback ───────────────────────────────────────────────────
+        const stmts = prepareDataflowStmts(db);
+        const hc = new Map();
+        const results = nodes.map((node) => buildNodeDataflowResult(node, stmts, db, hc, noTests));
         const base = { name, results };
         return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
     }
     finally {
-        db.close();
+        close();
     }
 }
+/** BFS through dataflow edges to find a path from source to target. */
+function bfsDataflowPath(db, sourceId, targetId, maxDepth, noTests) {
+    const neighborStmt = db.prepare(`SELECT n.id, n.name, n.kind, n.file, n.line, d.kind AS edge_kind, d.expression
+     FROM dataflow d JOIN nodes n ON d.target_id = n.id
+     WHERE d.source_id = ? AND d.kind IN ('flows_to', 'returns')`);
+    const visited = new Set([sourceId]);
+    const parent = new Map();
+    let queue = [sourceId];
+    let found = false;
+    for (let depth = 1; depth <= maxDepth; depth++) {
+        const nextQueue = [];
+        for (const currentId of queue) {
+            const neighbors = neighborStmt.all(currentId);
+            for (const n of neighbors) {
+                if (noTests && isTestFile(n.file))
+                    continue;
+                if (n.id === targetId) {
+                    if (!found) {
+                        found = true;
+                        parent.set(n.id, {
+                            parentId: currentId,
+                            edgeKind: n.edge_kind,
+                            expression: n.expression,
+                        });
+                    }
+                    continue;
+                }
+                if (!visited.has(n.id)) {
+                    visited.add(n.id);
+                    parent.set(n.id, {
+                        parentId: currentId,
+                        edgeKind: n.edge_kind,
+                        expression: n.expression,
+                    });
+                    nextQueue.push(n.id);
+                }
+            }
+        }
+        if (found)
+            break;
+        queue = nextQueue;
+        if (queue.length === 0)
+            break;
+    }
+    return found ? parent : null;
+}
+/** Reconstruct a path from BFS parent map. */
+function reconstructDataflowPath(db, parent, sourceId, targetId) {
+    const nodeById = db.prepare('SELECT * FROM nodes WHERE id = ?');
+    const hc = new Map();
+    const pathItems = [];
+    let cur = targetId;
+    while (cur !== undefined) {
+        const nodeRow = nodeById.get(cur);
+        const parentInfo = parent.get(cur);
+        pathItems.unshift({
+            ...normalizeSymbol(nodeRow, db, hc),
+            edgeKind: parentInfo?.edgeKind ?? null,
+            expression: parentInfo?.expression ?? null,
+        });
+        cur = parentInfo?.parentId;
+        if (cur === sourceId) {
+            const srcRow = nodeById.get(cur);
+            pathItems.unshift({
+                ...normalizeSymbol(srcRow, db, hc),
+                edgeKind: null,
+                expression: null,
+            });
+            break;
+        }
+    }
+    return pathItems;
+}
 export function dataflowPathData(from, to, customDbPath, opts = {}) {
     const db = openReadonlyOrFail(customDbPath);
     try {
@@ -292,90 +531,44 @@ export function dataflowPathData(from, to, customDbPath, opts = {}) {
         if (sourceNode.id === targetNode.id) {
             const hc = new Map();
             const sym = normalizeSymbol(sourceNode, db, hc);
-            return {
-                from,
-                to,
-                found: true,
-                hops: 0,
-                path: [{ ...sym, edgeKind: null }],
-            };
-        }
-        // BFS through flows_to and returns edges
-        const neighborStmt = db.prepare(`SELECT n.id, n.name, n.kind, n.file, n.line, d.kind AS edge_kind, d.expression
-     FROM dataflow d JOIN nodes n ON d.target_id = n.id
-     WHERE d.source_id = ? AND d.kind IN ('flows_to', 'returns')`);
-        const visited = new Set([sourceNode.id]);
-        const parent = new Map();
-        let queue = [sourceNode.id];
-        let found = false;
-        for (let depth = 1; depth <= maxDepth; depth++) {
-            const nextQueue = [];
-            for (const currentId of queue) {
-                const neighbors = neighborStmt.all(currentId);
-                for (const n of neighbors) {
-                    if (noTests && isTestFile(n.file))
-                        continue;
-                    if (n.id === targetNode.id) {
-                        if (!found) {
-                            found = true;
-                            parent.set(n.id, {
-                                parentId: currentId,
-                                edgeKind: n.edge_kind,
-                                expression: n.expression,
-                            });
-                        }
-                        continue;
-                    }
-                    if (!visited.has(n.id)) {
-                        visited.add(n.id);
-                        parent.set(n.id, {
-                            parentId: currentId,
-                            edgeKind: n.edge_kind,
-                            expression: n.expression,
-                        });
-                        nextQueue.push(n.id);
-                    }
-                }
-            }
-            if (found)
-                break;
-            queue = nextQueue;
-            if (queue.length === 0)
-                break;
+            return { from, to, found: true, hops: 0, path: [{ ...sym, edgeKind: null }] };
         }
-        if (!found) {
+        const parent = bfsDataflowPath(db, sourceNode.id, targetNode.id, maxDepth, noTests);
+        if (!parent) {
             return { from, to, found: false };
         }
-        // Reconstruct path
-        const nodeById = db.prepare('SELECT * FROM nodes WHERE id = ?');
-        const hc = new Map();
-        const pathItems = [];
-        let cur = targetNode.id;
-        while (cur !== undefined) {
-            const nodeRow = nodeById.get(cur);
-            const parentInfo = parent.get(cur);
-            pathItems.unshift({
-                ...normalizeSymbol(nodeRow, db, hc),
-                edgeKind: parentInfo?.edgeKind ?? null,
-                expression: parentInfo?.expression ?? null,
-            });
-            cur = parentInfo?.parentId;
-            if (cur === sourceNode.id) {
-                const srcRow = nodeById.get(cur);
-                pathItems.unshift({
-                    ...normalizeSymbol(srcRow, db, hc),
-                    edgeKind: null,
-                    expression: null,
-                });
-                break;
-            }
-        }
+        const pathItems = reconstructDataflowPath(db, parent, sourceNode.id, targetNode.id);
         return { from, to, found: true, hops: pathItems.length - 1, path: pathItems };
     }
     finally {
         db.close();
     }
 }
+/** BFS forward through return-value consumers to build impact levels. */
+function bfsReturnConsumers(node, consumersStmt, db, hc, maxDepth, noTests) {
+    const visited = new Set([node.id]);
+    const levels = {};
+    let frontier = [node.id];
+    for (let d = 1; d <= maxDepth; d++) {
+        const nextFrontier = [];
+        for (const fid of frontier) {
+            const consumers = consumersStmt.all(fid);
+            for (const c of consumers) {
+                if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
+                    visited.add(c.id);
+                    nextFrontier.push(c.id);
+                    if (!levels[d])
+                        levels[d] = [];
+                    levels[d].push(normalizeSymbol(c, db, hc));
+                }
+            }
+        }
+        frontier = nextFrontier;
+        if (frontier.length === 0)
+            break;
+    }
+    return { levels, totalAffected: visited.size - 1 };
+}
 export function dataflowImpactData(name, customDbPath, opts = {}) {
     const db = openReadonlyOrFail(customDbPath);
     try {
@@ -392,39 +585,14 @@ export function dataflowImpactData(name, customDbPath, opts = {}) {
         if (nodes.length === 0) {
             return { name, results: [] };
         }
-        // Forward BFS: who consumes this function's return value (directly or transitively)?
         const consumersStmt = db.prepare(`SELECT DISTINCT n.*
      FROM dataflow d JOIN nodes n ON d.target_id = n.id
      WHERE d.source_id = ? AND d.kind = 'returns'`);
         const hc = new Map();
         const results = nodes.map((node) => {
             const sym = normalizeSymbol(node, db, hc);
-            const visited = new Set([node.id]);
-            const levels = {};
-            let frontier = [node.id];
-            for (let d = 1; d <= maxDepth; d++) {
-                const nextFrontier = [];
-                for (const fid of frontier) {
-                    const consumers = consumersStmt.all(fid);
-                    for (const c of consumers) {
-                        if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
-                            visited.add(c.id);
-                            nextFrontier.push(c.id);
-                            if (!levels[d])
-                                levels[d] = [];
-                            levels[d].push(normalizeSymbol(c, db, hc));
-                        }
-                    }
-                }
-                frontier = nextFrontier;
-                if (frontier.length === 0)
-                    break;
-            }
-            return {
-                ...sym,
-                levels,
-                totalAffected: visited.size - 1,
-            };
+            const { levels, totalAffected } = bfsReturnConsumers(node, consumersStmt, db, hc, maxDepth, noTests);
+            return { ...sym, levels, totalAffected };
         });
         const base = { name, results };
         return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });