auditor-lambda 0.10.3 → 0.10.7

package/dist/coverage.js

@@ -1,3 +1,6 @@
+function buildFileIndex(matrix) {
+    return new Map(matrix.files.map((f) => [f.path, f]));
+}
 export function createCoverageMatrix(paths) {
     return {
         files: paths.map((path) => ({
@@ -11,7 +14,7 @@ export function createCoverageMatrix(paths) {
     };
 }
 export function markExcludedPath(matrix, path, classificationStatus) {
-    const record = matrix.files.find((file) => file.path === path);
+    const record = buildFileIndex(matrix).get(path);
     if (!record)
         return;
     record.classification_status = classificationStatus;
@@ -21,7 +24,7 @@ export function markExcludedPath(matrix, path, classificationStatus) {
     record.unit_ids = [];
 }
 export function applyUnitCoverage(matrix, path, unitId, requiredLenses) {
-    const record = matrix.files.find((file) => file.path === path);
+    const record = buildFileIndex(matrix).get(path);
     if (!record || record.audit_status === "excluded")
         return;
     if (!record.unit_ids.includes(unitId)) {
@@ -33,8 +36,9 @@ export function applyUnitCoverage(matrix, path, unitId, requiredLenses) {
     ];
 }
 export function applyFileCoverage(matrix, fileCoverage) {
+    const index = buildFileIndex(matrix);
     for (const coverage of fileCoverage) {
-        const record = matrix.files.find((file) => file.path === coverage.path);
+        const record = index.get(coverage.path);
         if (!record || record.audit_status === "excluded")
             continue;
         if (coverage.lens &&

package/dist/extractors/analyzers/css.js

@@ -87,8 +87,8 @@ async function analyze(files, context) {
             const tree = parser.parse(content);
             collectFileEdges(normalizeGraphPath(file), tree.rootNode, context.pathLookup, edges);
         }
-        catch {
-            // Degrade to the floor for this file.
+        catch (e) {
+            process.stderr.write(`[audit-code] css-analyzer: parse failed for '${file}': ${e.message ?? String(e)}\n`);
         }
     }
     return { edges };

package/dist/extractors/analyzers/html.js

@@ -78,8 +78,8 @@ async function analyze(files, context) {
             const tree = parser.parse(content);
             collectFileEdges(normalizeGraphPath(file), tree.rootNode, context.pathLookup, edges);
         }
-        catch {
-            // Degrade to the floor for this file.
+        catch (e) {
+            process.stderr.write(`[audit-code] html-analyzer: parse failed for '${file}': ${e.message ?? String(e)}\n`);
         }
     }
     return { edges };

package/dist/extractors/analyzers/python.js

@@ -90,8 +90,8 @@ async function analyze(files, context) {
             const tree = parser.parse(content);
             collectFileEdges(normalizeGraphPath(file), tree.rootNode, context.pathLookup, edges);
         }
-        catch {
-            // A parse failure on one file degrades to the floor for that file.
+        catch (e) {
+            process.stderr.write(`[audit-code] python-analyzer: parse failed for '${file}': ${e.message ?? String(e)}\n`);
         }
     }
     return { edges };

package/dist/extractors/analyzers/registry.js

@@ -24,6 +24,18 @@ export function getAnalyzerById(id) {
 function settingFor(analyzers, id) {
     return analyzers?.[id] ?? "auto";
 }
+function makeEntry(analyzer, setting, supportedCount, resolution, path) {
+    const entry = {
+        id: analyzer.id,
+        dependency: analyzer.dependency,
+        setting,
+        resolution,
+        supportedCount,
+    };
+    if (path !== undefined)
+        entry.path = path;
+    return entry;
+}
 /**
  * Deterministically resolve, without installing anything, how each registered
  * analyzer would run for this repo. The conversation-first CLI uses this to
@@ -42,51 +54,20 @@ export function resolveAnalyzerPlan(root, analyzers, includedFiles, options = {}
         const setting = settingFor(analyzers, analyzer.id);
         const supportedCount = includedFiles.filter((file) => analyzer.supports(file)).length;
         if (supportedCount === 0) {
-            return {
-                id: analyzer.id,
-                dependency: analyzer.dependency,
-                setting,
-                resolution: "not_applicable",
-                supportedCount,
-            };
+            return makeEntry(analyzer, setting, supportedCount, "not_applicable");
         }
         if (setting === "skip") {
-            return {
-                id: analyzer.id,
-                dependency: analyzer.dependency,
-                setting,
-                resolution: "skip",
-                supportedCount,
-            };
+            return makeEntry(analyzer, setting, supportedCount, "skip");
         }
         if (!analyzer.dependency) {
             // No dependency required: always available.
-            return {
-                id: analyzer.id,
-                dependency: analyzer.dependency,
-                setting,
-                resolution: "repo",
-                supportedCount,
-            };
+            return makeEntry(analyzer, setting, supportedCount, "repo");
         }
         const resolved = resolveAnalyzerDep(analyzer.dependency, root, depOptions);
         if (resolved.via === "repo" || resolved.via === "cache") {
-            return {
-                id: analyzer.id,
-                dependency: analyzer.dependency,
-                setting,
-                resolution: resolved.via,
-                path: resolved.path,
-                supportedCount,
-            };
+            return makeEntry(analyzer, setting, supportedCount, resolved.via, resolved.path);
         }
-        return {
-            id: analyzer.id,
-            dependency: analyzer.dependency,
-            setting,
-            resolution: "absent",
-            supportedCount,
-        };
+        return makeEntry(analyzer, setting, supportedCount, "absent");
     });
 }
 /**

package/dist/extractors/analyzers/treeSitter.d.ts

@@ -25,10 +25,19 @@ export interface TsParser {
     setLanguage(language: TsLanguage): void;
     parse(source: string): TsTree;
 }
+/**
+ * Return the number of times tree-sitter fell back to the regex floor since
+ * process start (or since the last `__resetTreeSitterForTests` call). Each
+ * distinct failure path (import failure, init failure, grammar load failure,
+ * parser instantiation failure) increments the counter once. A caller can
+ * snapshot this before and after a batch parse pass to detect systemic
+ * degradation without scraping stderr.
+ */
+export declare function getTreeSitterDegradationCount(): number;
 /**
  * Obtain a parser bound to `grammar` (e.g. "python", "html", "css"), or
  * `undefined` if web-tree-sitter or the grammar wasm cannot be loaded.
  */
 export declare function getTreeSitterParser(grammar: string, dependencyPath?: string): Promise<TsParser | undefined>;
-/** Test seam: reset the memoised runtime/grammar caches. */
+/** Test seam: reset the memoised runtime/grammar caches and degradation counter. */
 export declare function __resetTreeSitterForTests(): void;

package/dist/extractors/analyzers/treeSitter.js

@@ -2,6 +2,18 @@ import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 const requireFromHere = createRequire(import.meta.url);
+let _degradationCount = 0;
+/**
+ * Return the number of times tree-sitter fell back to the regex floor since
+ * process start (or since the last `__resetTreeSitterForTests` call). Each
+ * distinct failure path (import failure, init failure, grammar load failure,
+ * parser instantiation failure) increments the counter once. A caller can
+ * snapshot this before and after a batch parse pass to detect systemic
+ * degradation without scraping stderr.
+ */
+export function getTreeSitterDegradationCount() {
+    return _degradationCount;
+}
 // The parser module is resolved per `dependencyPath`: a call with a different
 // dependencyPath must resolve its own module rather than reusing the first
 // resolution. Keyed by `dependencyPath ?? ""` so the bare-specifier path
@@ -31,6 +43,7 @@ async function importParserModule(dependencyPath) {
             }
         }
         catch (e) {
+            _degradationCount += 1;
             process.stderr.write(`[audit-code] tree-sitter: failed to import '${specifier}': ${e.message ?? String(e)}\n`);
         }
     }
@@ -51,6 +64,7 @@ async function ensureInit(parserModule) {
         cached = parserModule.Parser.init()
             .then(() => true)
             .catch((e) => {
+            _degradationCount += 1;
             process.stderr.write(`[audit-code] tree-sitter: Parser.init() failed: ${e.message ?? String(e)}\n`);
             return false;
         });
@@ -75,22 +89,28 @@ function resolveGrammarPath(grammar) {
     }
 }
 async function loadLanguage(parserModule, grammar) {
-    if (languageCache.has(grammar)) {
-        return languageCache.get(grammar) ?? undefined;
+    let moduleMap = languageCache.get(parserModule);
+    if (!moduleMap) {
+        moduleMap = new Map();
+        languageCache.set(parserModule, moduleMap);
+    }
+    if (moduleMap.has(grammar)) {
+        return moduleMap.get(grammar) ?? undefined;
     }
     const grammarPath = resolveGrammarPath(grammar);
     if (!grammarPath) {
-        languageCache.set(grammar, null);
+        moduleMap.set(grammar, null);
         return undefined;
     }
     try {
         const language = await parserModule.Language.load(grammarPath);
-        languageCache.set(grammar, language);
+        moduleMap.set(grammar, language);
         return language;
     }
     catch (e) {
+        _degradationCount += 1;
         process.stderr.write(`[audit-code] tree-sitter: failed to load grammar '${grammar}' from '${grammarPath}': ${e.message ?? String(e)}\n`);
-        languageCache.set(grammar, null);
+        moduleMap.set(grammar, null);
         return undefined;
     }
 }
@@ -113,13 +133,15 @@ export async function getTreeSitterParser(grammar, dependencyPath) {
         return parser;
     }
     catch (e) {
+        _degradationCount += 1;
         process.stderr.write(`[audit-code] tree-sitter: failed to instantiate parser for grammar '${grammar}': ${e.message ?? String(e)}\n`);
         return undefined;
     }
 }
-/** Test seam: reset the memoised runtime/grammar caches. */
+/** Test seam: reset the memoised runtime/grammar caches and degradation counter. */
 export function __resetTreeSitterForTests() {
     moduleCache.clear();
     initCache.clear();
     languageCache.clear();
+    _degradationCount = 0;
 }

package/dist/extractors/analyzers/typescript.js

@@ -112,104 +112,123 @@ function resolveSymbolToIncluded(state, symbol) {
     }
     return undefined;
 }
-function collectFileEdges(state, sourceFile, fromPath, imports, references, calls) {
+function recordCallEdge(calls, callTargets, fromPath, target) {
+    if (!target || target === fromPath || callTargets.has(target))
+        return;
+    callTargets.add(target);
+    calls.push(graphEdge({
+        from: fromPath,
+        to: target,
+        kind: "ts-call",
+        confidence: TS_CALL_EDGE_CONFIDENCE,
+        reason: `TypeScript checker resolved a cross-file call into '${target}'.`,
+    }));
+}
+function visitHeritageNode(state, references, fromPath, node) {
     const ts = state.ts;
-    const callTargets = new Set();
-    const recordCall = (target) => {
-        if (!target || target === fromPath || callTargets.has(target))
-            return;
-        callTargets.add(target);
-        calls.push(graphEdge({
+    for (const clause of node.heritageClauses ?? []) {
+        const isExtends = clause.token === ts.SyntaxKind.ExtendsKeyword;
+        for (const typeNode of clause.types) {
+            const target = resolveSymbolToIncluded(state, state.checker.getSymbolAtLocation(typeNode.expression));
+            if (!target || target === fromPath)
+                continue;
+            references.push(graphEdge({
+                from: fromPath,
+                to: target,
+                kind: isExtends ? "ts-extends" : "ts-implements",
+                confidence: isExtends
+                    ? TS_EXTENDS_EDGE_CONFIDENCE
+                    : TS_IMPLEMENTS_EDGE_CONFIDENCE,
+                reason: `TypeScript ${isExtends ? "extends" : "implements"} heritage resolves to '${target}'.`,
+            }));
+        }
+    }
+}
+function visitImportDeclaration(state, imports, fromPath, node) {
+    if (!state.ts.isStringLiteral(node.moduleSpecifier))
+        return;
+    const target = resolveSpecifierTarget(state, node.moduleSpecifier.text, node.getSourceFile().fileName);
+    if (target && target !== fromPath) {
+        imports.push(graphEdge({
             from: fromPath,
             to: target,
-            kind: "ts-call",
-            confidence: TS_CALL_EDGE_CONFIDENCE,
-            reason: `TypeScript checker resolved a cross-file call into '${target}'.`,
+            kind: "ts-import",
+            confidence: TS_IMPORT_EDGE_CONFIDENCE,
+            reason: `TypeScript resolved import '${node.moduleSpecifier.text}' to '${target}'.`,
         }));
-    };
-    const visitHeritage = (node) => {
-        for (const clause of node.heritageClauses ?? []) {
-            const isExtends = clause.token === ts.SyntaxKind.ExtendsKeyword;
-            for (const typeNode of clause.types) {
-                const target = resolveSymbolToIncluded(state, state.checker.getSymbolAtLocation(typeNode.expression));
-                if (!target || target === fromPath)
-                    continue;
-                references.push(graphEdge({
-                    from: fromPath,
-                    to: target,
-                    kind: isExtends ? "ts-extends" : "ts-implements",
-                    confidence: isExtends
-                        ? TS_EXTENDS_EDGE_CONFIDENCE
-                        : TS_IMPLEMENTS_EDGE_CONFIDENCE,
-                    reason: `TypeScript ${isExtends ? "extends" : "implements"} heritage resolves to '${target}'.`,
-                }));
-            }
+    }
+}
+function visitExportDeclaration(state, imports, fromPath, node) {
+    if (!node.moduleSpecifier || !state.ts.isStringLiteral(node.moduleSpecifier))
+        return;
+    const target = resolveSpecifierTarget(state, node.moduleSpecifier.text, node.getSourceFile().fileName);
+    if (target && target !== fromPath) {
+        imports.push(graphEdge({
+            from: fromPath,
+            to: target,
+            kind: "ts-reexport",
+            confidence: TS_REEXPORT_EDGE_CONFIDENCE,
+            reason: `TypeScript resolved re-export '${node.moduleSpecifier.text}' to '${target}'.`,
+        }));
+    }
+}
+function visitImportEqualsDeclaration(state, imports, fromPath, node) {
+    const ts = state.ts;
+    if (!ts.isExternalModuleReference(node.moduleReference) ||
+        !ts.isStringLiteral(node.moduleReference.expression)) {
+        return;
+    }
+    const target = resolveSpecifierTarget(state, node.moduleReference.expression.text, node.getSourceFile().fileName);
+    if (target && target !== fromPath) {
+        imports.push(graphEdge({
+            from: fromPath,
+            to: target,
+            kind: "ts-import",
+            confidence: TS_IMPORT_EDGE_CONFIDENCE,
+            reason: `TypeScript resolved import-equals to '${target}'.`,
+        }));
+    }
+}
+function visitCallExpression(state, imports, calls, callTargets, fromPath, node) {
+    const ts = state.ts;
+    if (node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+        node.arguments[0] &&
+        ts.isStringLiteral(node.arguments[0])) {
+        const target = resolveSpecifierTarget(state, node.arguments[0].text, node.getSourceFile().fileName);
+        if (target && target !== fromPath) {
+            imports.push(graphEdge({
+                from: fromPath,
+                to: target,
+                kind: "ts-import",
+                confidence: TS_IMPORT_EDGE_CONFIDENCE,
+                reason: `TypeScript resolved dynamic import to '${target}'.`,
+            }));
         }
-    };
+    }
+    else {
+        recordCallEdge(calls, callTargets, fromPath, resolveSymbolToIncluded(state, state.checker.getSymbolAtLocation(node.expression)));
+    }
+}
+function collectFileEdges(state, sourceFile, fromPath, imports, references, calls) {
+    const ts = state.ts;
+    const callTargets = new Set();
     const visit = (node) => {
-        if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
-            const target = resolveSpecifierTarget(state, node.moduleSpecifier.text, sourceFile.fileName);
-            if (target && target !== fromPath) {
-                imports.push(graphEdge({
-                    from: fromPath,
-                    to: target,
-                    kind: "ts-import",
-                    confidence: TS_IMPORT_EDGE_CONFIDENCE,
-                    reason: `TypeScript resolved import '${node.moduleSpecifier.text}' to '${target}'.`,
-                }));
-            }
+        if (ts.isImportDeclaration(node)) {
+            visitImportDeclaration(state, imports, fromPath, node);
         }
-        else if (ts.isExportDeclaration(node) &&
-            node.moduleSpecifier &&
-            ts.isStringLiteral(node.moduleSpecifier)) {
-            const target = resolveSpecifierTarget(state, node.moduleSpecifier.text, sourceFile.fileName);
-            if (target && target !== fromPath) {
-                imports.push(graphEdge({
-                    from: fromPath,
-                    to: target,
-                    kind: "ts-reexport",
-                    confidence: TS_REEXPORT_EDGE_CONFIDENCE,
-                    reason: `TypeScript resolved re-export '${node.moduleSpecifier.text}' to '${target}'.`,
-                }));
-            }
+        else if (ts.isExportDeclaration(node)) {
+            visitExportDeclaration(state, imports, fromPath, node);
         }
-        else if (ts.isImportEqualsDeclaration(node) &&
-            ts.isExternalModuleReference(node.moduleReference) &&
-            ts.isStringLiteral(node.moduleReference.expression)) {
-            const target = resolveSpecifierTarget(state, node.moduleReference.expression.text, sourceFile.fileName);
-            if (target && target !== fromPath) {
-                imports.push(graphEdge({
-                    from: fromPath,
-                    to: target,
-                    kind: "ts-import",
-                    confidence: TS_IMPORT_EDGE_CONFIDENCE,
-                    reason: `TypeScript resolved import-equals to '${target}'.`,
-                }));
-            }
+        else if (ts.isImportEqualsDeclaration(node)) {
+            visitImportEqualsDeclaration(state, imports, fromPath, node);
         }
         else if (ts.isCallExpression(node)) {
-            if (node.expression.kind === ts.SyntaxKind.ImportKeyword &&
-                node.arguments[0] &&
-                ts.isStringLiteral(node.arguments[0])) {
-                const target = resolveSpecifierTarget(state, node.arguments[0].text, sourceFile.fileName);
-                if (target && target !== fromPath) {
-                    imports.push(graphEdge({
-                        from: fromPath,
-                        to: target,
-                        kind: "ts-import",
-                        confidence: TS_IMPORT_EDGE_CONFIDENCE,
-                        reason: `TypeScript resolved dynamic import to '${target}'.`,
-                    }));
-                }
-            }
-            else {
-                recordCall(resolveSymbolToIncluded(state, state.checker.getSymbolAtLocation(node.expression)));
-            }
+            visitCallExpression(state, imports, calls, callTargets, fromPath, node);
         }
         else if (ts.isClassDeclaration(node) ||
             ts.isClassExpression(node) ||
             ts.isInterfaceDeclaration(node)) {
-            visitHeritage(node);
+            visitHeritageNode(state, references, fromPath, node);
         }
         ts.forEachChild(node, visit);
     };
@@ -247,7 +266,7 @@ async function analyze(files, context) {
         return { edges: [...imports, ...references, ...calls] };
     }
     catch (e) {
-        process.stderr.write(`[audit-code] typescript-analyzer: program analysis failed for ${files.length} file(s) under '${context.root}', degrading to regex floor: ${e.message ?? String(e)}\n`);
+        process.stderr.write(`[audit-code] typescript-analyzer: program analysis failed for ${files.length} file(s) under '${context.root}' — returning 0 edges (all ${files.length} file(s) edges lost), degrading to regex floor: ${e.message ?? String(e)}\n`);
         return { edges: [] };
     }
 }

package/dist/extractors/browserExtension.js

@@ -279,7 +279,10 @@ export function extractHtmlResourceEdges(fromPath, content, pathLookup) {
     return edges;
 }
 export function hasBrowserExtensionManifestFile(repoManifest) {
-    return repoManifest.files.some((file) => normalizeGraphPath(file.path).toLowerCase() === "manifest.json");
+    // Detect a `manifest.json` anywhere in the tree (root or a subdirectory),
+    // using the same basename match as isBrowserExtensionManifestPath so the
+    // repo-level gate and the per-file classifier agree.
+    return repoManifest.files.some((file) => isBrowserExtensionManifestPath(file.path));
 }
 export function deriveBrowserExtensionLensesForPath(path) {
     const normalized = normalizeGraphPath(path).toLowerCase();

package/dist/extractors/designAssessment.js

@@ -18,6 +18,25 @@ function allEdges(graphBundle) {
     }
     return edges;
 }
+function dfsVisit(node, path, adjacency, visited, stack, cycles) {
+    if (stack.has(node)) {
+        const cycleStart = path.indexOf(node);
+        if (cycleStart >= 0) {
+            cycles.push(path.slice(cycleStart));
+        }
+        return;
+    }
+    if (visited.has(node))
+        return;
+    visited.add(node);
+    stack.add(node);
+    path.push(node);
+    for (const neighbor of adjacency.get(node) ?? []) {
+        dfsVisit(neighbor, path, adjacency, visited, stack, cycles);
+    }
+    path.pop();
+    stack.delete(node);
+}
 function detectCycles(edges) {
     const adjacency = new Map();
     for (const edge of edges) {
@@ -28,27 +47,8 @@ function detectCycles(edges) {
     const cycles = [];
     const visited = new Set();
     const stack = new Set();
-    function dfs(node, path) {
-        if (stack.has(node)) {
-            const cycleStart = path.indexOf(node);
-            if (cycleStart >= 0) {
-                cycles.push(path.slice(cycleStart));
-            }
-            return;
-        }
-        if (visited.has(node))
-            return;
-        visited.add(node);
-        stack.add(node);
-        path.push(node);
-        for (const neighbor of adjacency.get(node) ?? []) {
-            dfs(neighbor, path);
-        }
-        path.pop();
-        stack.delete(node);
-    }
     for (const node of adjacency.keys()) {
-        dfs(node, []);
+        dfsVisit(node, [], adjacency, visited, stack, cycles);
     }
     return cycles;
 }
@@ -195,7 +195,7 @@ function detectUnitSprawl(unitManifest, nextId) {
         return [];
     const fileCounts = unitManifest.units.map((u) => u.files.length);
     const totalFiles = fileCounts.reduce((a, b) => a + b, 0);
-    const maxFiles = Math.max(...fileCounts);
+    const maxFiles = fileCounts.reduce((max, n) => n > max ? n : max, 0);
     const findings = [];
     const dominantUnit = unitManifest.units.find((u) => u.files.length === maxFiles);
     if (dominantUnit && maxFiles > totalFiles * 0.5 && totalFiles > 10) {

package/dist/extractors/fsIntake.js

@@ -35,25 +35,43 @@ async function maybeHashFile(path, enabled) {
     const content = await readFile(path);
     return createHash("sha256").update(content).digest("hex");
 }
-async function walk(root, current, ignores, hashFiles, maxFileSizeBytes, results) {
-    const entries = await readdir(current, { withFileTypes: true });
+async function walk(ctx, current, results) {
+    let entries;
+    try {
+        entries = await readdir(current, { withFileTypes: true });
+    }
+    catch (err) {
+        console.warn(`[fsIntake] skipping unreadable directory: ${current} (${err.message})`);
+        return;
+    }
     for (const entry of entries) {
         const absolutePath = join(current, entry.name);
-        const relativePath = normalizePath(relative(root, absolutePath));
-        if (!relativePath || shouldIgnore(relativePath, ignores)) {
+        const relativePath = normalizePath(relative(ctx.root, absolutePath));
+        if (!relativePath || shouldIgnore(relativePath, ctx.ignores)) {
             continue;
         }
         if (entry.isDirectory()) {
-            await walk(root, absolutePath, ignores, hashFiles, maxFileSizeBytes, results);
+            await walk(ctx, absolutePath, results);
             continue;
         }
         if (!entry.isFile()) {
             continue;
         }
-        const info = await stat(absolutePath);
-        const hash = info.size <= maxFileSizeBytes
-            ? await maybeHashFile(absolutePath, hashFiles)
-            : undefined;
+        let info;
+        try {
+            info = await stat(absolutePath);
+        }
+        catch (err) {
+            console.warn(`[fsIntake] skipping unreadable file: ${relativePath} (${err.message})`);
+            continue;
+        }
+        let hash;
+        if (info.size <= ctx.maxFileSizeBytes) {
+            hash = await maybeHashFile(absolutePath, ctx.hashFiles);
+        }
+        else {
+            console.warn(`[fsIntake] skipping oversized file: ${relativePath} (${info.size} bytes > ${ctx.maxFileSizeBytes} limit)`);
+        }
         results.push({
             path: relativePath,
             size_bytes: info.size,
@@ -65,6 +83,12 @@ export async function buildRepoManifestFromFs(options) {
     const root = resolve(options.root);
     const ignore = [...DEFAULT_IGNORES, ...(options.ignore ?? [])];
     const files = [];
-    await walk(root, root, ignore, options.hash_files ?? false, options.max_file_size_bytes ?? 1024 * 1024, files);
+    const ctx = {
+        root,
+        ignores: ignore,
+        hashFiles: options.hash_files ?? false,
+        maxFileSizeBytes: options.max_file_size_bytes ?? 1024 * 1024,
+    };
+    await walk(ctx, root, files);
     return buildRepoManifest(root.split(/[\\/]/).pop() ?? "repo", files);
 }