auditor-lambda 0.3.3 → 0.3.5

package/dist/extractors/graph.d.ts

@@ -1,4 +1,8 @@
 import type { RepoManifest } from "../types.js";
 import type { FileDisposition } from "../types/disposition.js";
 import type { GraphBundle } from "../types/graph.js";
-export declare function buildGraphBundle(repoManifest: RepoManifest, disposition?: FileDisposition): GraphBundle;
+export interface BuildGraphBundleOptions {
+    fileContents?: Record<string, string>;
+}
+export declare function buildGraphBundleFromFs(repoManifest: RepoManifest, root: string, disposition?: FileDisposition): Promise<GraphBundle>;
+export declare function buildGraphBundle(repoManifest: RepoManifest, disposition?: FileDisposition, options?: BuildGraphBundleOptions): GraphBundle;

package/dist/extractors/graph.js

@@ -1,11 +1,220 @@
+import { readFile } from "node:fs/promises";
+import { isAbsolute, relative, resolve } from "node:path";
+import { posix } from "node:path";
 import { isAuditExcludedStatus } from "./disposition.js";
-export function buildGraphBundle(repoManifest, disposition) {
+const MAX_GRAPH_SOURCE_BYTES = 512 * 1024;
+const RESOLVABLE_EXTENSIONS = [
+    "",
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+];
+const INDEX_EXTENSIONS = [
+    "index.ts",
+    "index.tsx",
+    "index.mts",
+    "index.cts",
+    "index.js",
+    "index.jsx",
+    "index.mjs",
+    "index.cjs",
+    "index.json",
+];
+const SOURCE_LANGUAGES = new Set([
+    "typescript",
+    "javascript",
+    "json",
+    "yaml",
+    "python",
+    "go",
+    "rust",
+    "java",
+    "csharp",
+]);
+const SOURCE_EXTENSIONS = [
+    ".ts",
+    ".tsx",
+    ".mts",
+    ".cts",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".json",
+    ".yml",
+    ".yaml",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".cs",
+];
+const IMPORT_PATTERNS = [
+    {
+        pattern: /\bimport\s+(?:type\s+)?(?:[^"'()]*?\s+from\s+)?["']([^"']+)["']/g,
+        kind: "esm",
+    },
+    {
+        pattern: /\bexport\s+(?:type\s+)?[^"']*?\s+from\s+["']([^"']+)["']/g,
+        kind: "re-export",
+    },
+    {
+        pattern: /\bimport\s*\(\s*["']([^"']+)["']\s*\)/g,
+        kind: "dynamic-import",
+    },
+    {
+        pattern: /\brequire\s*\(\s*["']([^"']+)["']\s*\)/g,
+        kind: "commonjs",
+    },
+];
+const STRING_LITERAL_PATTERN = /["'`]([^"'`\r\n]{1,260})["'`]/g;
+function normalizeGraphPath(path) {
+    return posix
+        .normalize(path.replace(/\\/g, "/"))
+        .replace(/^\.\//, "");
+}
+function graphLookupKey(path) {
+    return normalizeGraphPath(path).toLowerCase();
+}
+function shouldReadForGraph(file) {
+    const normalized = normalizeGraphPath(file.path);
+    return (file.size_bytes <= MAX_GRAPH_SOURCE_BYTES &&
+        (SOURCE_LANGUAGES.has(file.language) ||
+            SOURCE_EXTENSIONS.some((extension) => normalized.endsWith(extension))));
+}
+function buildPathLookup(repoManifest, dispositionMap) {
+    return new Map(repoManifest.files
+        .filter((file) => {
+        const status = dispositionMap.get(file.path);
+        return !(file.excluded || (status && isAuditExcludedStatus(status)));
+    })
+        .map((file) => [graphLookupKey(file.path), file.path]));
+}
+function resolveCandidate(candidate, pathLookup) {
+    const normalized = normalizeGraphPath(candidate);
+    const direct = pathLookup.get(normalized.toLowerCase());
+    if (direct)
+        return direct;
+    for (const extension of RESOLVABLE_EXTENSIONS) {
+        const withExtension = `${normalized}${extension}`;
+        const match = pathLookup.get(withExtension.toLowerCase());
+        if (match)
+            return match;
+    }
+    for (const indexFile of INDEX_EXTENSIONS) {
+        const match = pathLookup.get(posix.join(normalized, indexFile).toLowerCase());
+        if (match)
+            return match;
+    }
+    return undefined;
+}
+function resolveSpecifier(fromPath, specifier, pathLookup) {
+    if (!specifier.startsWith(".")) {
+        return undefined;
+    }
+    const baseDir = posix.dirname(normalizeGraphPath(fromPath));
+    return resolveCandidate(posix.join(baseDir, specifier), pathLookup);
+}
+function resolveReferenceLiteral(fromPath, literal, pathLookup) {
+    const normalizedLiteral = normalizeGraphPath(literal);
+    if (literal.startsWith(".")) {
+        return resolveSpecifier(fromPath, literal, pathLookup);
+    }
+    if (!normalizedLiteral.includes("/")) {
+        return undefined;
+    }
+    return resolveCandidate(normalizedLiteral, pathLookup);
+}
+function edgeSignature(edge) {
+    return `${edge.from}\0${edge.to}\0${edge.kind ?? ""}`;
+}
+function uniqueSortedEdges(edges) {
+    const deduped = new Map();
+    for (const edge of edges) {
+        if (edge.from === edge.to)
+            continue;
+        deduped.set(edgeSignature(edge), edge);
+    }
+    return [...deduped.values()].sort((a, b) => a.from.localeCompare(b.from) ||
+        a.to.localeCompare(b.to) ||
+        (a.kind ?? "").localeCompare(b.kind ?? ""));
+}
+function extractImportEdges(fromPath, content, pathLookup) {
+    const edges = [];
+    for (const { pattern, kind } of IMPORT_PATTERNS) {
+        pattern.lastIndex = 0;
+        for (const match of content.matchAll(pattern)) {
+            const specifier = match[1];
+            if (!specifier)
+                continue;
+            const target = resolveSpecifier(fromPath, specifier, pathLookup);
+            if (target) {
+                edges.push({ from: fromPath, to: target, kind });
+            }
+        }
+    }
+    return edges;
+}
+function extractReferenceEdges(fromPath, content, pathLookup) {
+    const edges = [];
+    STRING_LITERAL_PATTERN.lastIndex = 0;
+    for (const match of content.matchAll(STRING_LITERAL_PATTERN)) {
+        const literal = match[1];
+        if (!literal)
+            continue;
+        const target = resolveReferenceLiteral(fromPath, literal, pathLookup);
+        if (target) {
+            edges.push({
+                from: fromPath,
+                to: target,
+                kind: literal.startsWith(".")
+                    ? "relative-string-reference"
+                    : "repo-path-reference",
+            });
+        }
+    }
+    return edges;
+}
+export async function buildGraphBundleFromFs(repoManifest, root, disposition) {
+    const rootPath = resolve(root);
+    const dispositionMap = new Map(disposition?.files.map((item) => [item.path, item.status]) ?? []);
+    const fileContents = {};
+    await Promise.all(repoManifest.files.map(async (file) => {
+        const status = dispositionMap.get(file.path);
+        if ((status && isAuditExcludedStatus(status)) ||
+            file.excluded ||
+            !shouldReadForGraph(file)) {
+            return;
+        }
+        const absolutePath = resolve(rootPath, file.path);
+        const relativeToRoot = relative(rootPath, absolutePath);
+        if (relativeToRoot.startsWith("..") || isAbsolute(relativeToRoot)) {
+            return;
+        }
+        try {
+            fileContents[file.path] = await readFile(absolutePath, "utf8");
+        }
+        catch {
+            // Best-effort graph extraction should not block structure planning.
+        }
+    }));
+    return buildGraphBundle(repoManifest, disposition, { fileContents });
+}
+export function buildGraphBundle(repoManifest, disposition, options = {}) {
     const imports = [];
+    const references = [];
     const routes = [];
     const dispositionMap = new Map(disposition?.files.map((item) => [item.path, item.status]) ?? []);
+    const pathLookup = buildPathLookup(repoManifest, dispositionMap);
     for (const file of repoManifest.files) {
         const status = dispositionMap.get(file.path);
-        if (status && isAuditExcludedStatus(status)) {
+        if (file.excluded || (status && isAuditExcludedStatus(status))) {
             continue;
         }
         const normalized = file.path.toLowerCase();
@@ -41,6 +250,17 @@ export function buildGraphBundle(repoManifest, disposition) {
                 }
             }
         }
+        const content = options.fileContents?.[file.path];
+        if (content) {
+            imports.push(...extractImportEdges(file.path, content, pathLookup));
+            references.push(...extractReferenceEdges(file.path, content, pathLookup));
+        }
     }
-    return { graphs: { imports, routes } };
+    return {
+        graphs: {
+            imports: uniqueSortedEdges(imports),
+            references: uniqueSortedEdges(references),
+            routes,
+        },
+    };
 }

package/dist/extractors/pathPatterns.d.ts

@@ -1,9 +1,10 @@
 /**
  * Shared bootstrap heuristics for the extractor layer. These rules run before
  * richer graph/unit analysis exists, so they intentionally favor recall over
- * precision and always normalize case plus path separators first.
+ * precision and always normalize case, path separators, and simple camelCase
+ * boundaries first.
  */
-export declare const EXTRACTOR_HEURISTIC_NOTE = "Heuristic path classification normalizes case and path separators, then matches conservative keyword groups; confirm unusual repo layouts manually.";
+export declare const EXTRACTOR_HEURISTIC_NOTE = "Heuristic path classification normalizes case, path separators, and simple camelCase boundaries, then matches conservative keyword groups; confirm unusual repo layouts manually.";
 export declare function normalizeExtractorPath(path: string): string;
 export declare function pathTokens(normalized: string): string[];
 export declare function isNodeModulesOrGit(normalized: string): boolean;

package/dist/extractors/pathPatterns.js

@@ -1,9 +1,10 @@
 /**
  * Shared bootstrap heuristics for the extractor layer. These rules run before
  * richer graph/unit analysis exists, so they intentionally favor recall over
- * precision and always normalize case plus path separators first.
+ * precision and always normalize case, path separators, and simple camelCase
+ * boundaries first.
  */
-export const EXTRACTOR_HEURISTIC_NOTE = "Heuristic path classification normalizes case and path separators, then matches conservative keyword groups; confirm unusual repo layouts manually.";
+export const EXTRACTOR_HEURISTIC_NOTE = "Heuristic path classification normalizes case, path separators, and simple camelCase boundaries, then matches conservative keyword groups; confirm unusual repo layouts manually.";
 const BINARY_EXTENSIONS = [
     ".png",
     ".jpg",
@@ -20,15 +21,46 @@ const LOCKFILE_NAMES = [
     "composer.lock",
     "go.sum",
 ];
-const TEST_KEYWORDS = ["test", "spec", "__tests__"];
-const INTERFACE_KEYWORDS = ["route", "controller", "handler"];
-const DATA_LAYER_KEYWORDS = ["model", "schema", "migration", "seed"];
+const TEST_SEGMENTS = ["test", "tests", "spec", "specs", "__tests__"];
+const TEST_FILE_TOKENS = ["test", "spec"];
+const INTERFACE_KEYWORDS = [
+    "route",
+    "routes",
+    "controller",
+    "controllers",
+    "handler",
+    "handlers",
+    "endpoint",
+    "endpoints",
+];
+const DATA_LAYER_KEYWORDS = [
+    "model",
+    "models",
+    "schema",
+    "schemas",
+    "migration",
+    "migrations",
+    "seed",
+    "seeds",
+];
 const SECURITY_KEYWORDS = [
     "auth",
+    "authentication",
+    "authorization",
+    "credential",
+    "credentials",
+    "jwt",
+    "oauth",
+    "password",
+    "passwords",
     "secret",
+    "secrets",
     "token",
+    "tokens",
     "permission",
+    "permissions",
     "session",
+    "sessions",
 ];
 const CONCURRENCY_KEYWORDS = [
     "queue",
@@ -44,26 +76,49 @@ const CONCURRENCY_KEYWORDS = [
     "lock",
     "locks",
 ];
-const SCRIPT_KEYWORDS = ["script"];
+const SCRIPT_KEYWORDS = ["script", "scripts"];
 const DEPLOYMENT_KEYWORDS = [
     "docker",
     "terraform",
     "deploy",
+    "deployment",
+    "deployments",
     "workflow",
+    "workflows",
     "k8s",
 ];
-const SURFACE_KEYWORDS = ["route", "controller", "worker", "job", "command"];
+const SURFACE_KEYWORDS = [
+    "route",
+    "routes",
+    "controller",
+    "controllers",
+    "handler",
+    "handlers",
+    "worker",
+    "workers",
+    "job",
+    "jobs",
+    "command",
+    "commands",
+];
 const BILLING_KEYWORDS = [
     "billing",
     "invoice",
+    "invoices",
     "payment",
+    "payments",
     "ledger",
+    "ledgers",
     "subscription",
+    "subscriptions",
 ];
-const IDENTITY_KEYWORDS = ["user"];
-const ASYNC_TASK_KEYWORDS = ["task"];
+const IDENTITY_KEYWORDS = ["user", "users"];
+const ASYNC_TASK_KEYWORDS = ["task", "tasks"];
 export function normalizeExtractorPath(path) {
-    return path.replace(/\\/g, "/").toLowerCase();
+    return path
+        .replace(/\\/g, "/")
+        .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+        .toLowerCase();
 }
 function splitSegments(normalized) {
     return normalized.split("/").filter(Boolean);
@@ -95,7 +150,9 @@ export function isBuildOutput(normalized) {
     return hasSegment(normalized, "dist") || hasSegment(normalized, "build");
 }
 export function isVendorPath(normalized) {
-    return normalized.includes("vendor") || normalized.includes("third_party");
+    return (hasSegment(normalized, "vendor") ||
+        hasSegment(normalized, "vendors") ||
+        hasSegment(normalized, "third_party"));
 }
 export function isBinaryArtifact(normalized) {
     return endsWithAny(normalized, BINARY_EXTENSIONS);
@@ -120,10 +177,15 @@ export function isAuditArtifactPath(normalized) {
     return splitSegments(normalized).some((segment) => segment.startsWith(".audit-artifacts"));
 }
 export function isTestPath(normalized) {
-    return includesAny(normalized, TEST_KEYWORDS);
+    const segments = splitSegments(normalized);
+    if (segments.some((segment) => TEST_SEGMENTS.some((testSegment) => testSegment === segment))) {
+        return true;
+    }
+    const fileTokens = pathTokens(baseName(normalized));
+    return TEST_FILE_TOKENS.some((token) => fileTokens.includes(token));
 }
 export function isInterfacePath(normalized) {
-    return includesAny(normalized, INTERFACE_KEYWORDS) || hasSegment(normalized, "api");
+    return hasToken(normalized, INTERFACE_KEYWORDS) || hasSegment(normalized, "api");
 }
 export function isDataLayerPath(normalized) {
     return (hasToken(normalized, DATA_LAYER_KEYWORDS) ||
@@ -134,7 +196,7 @@ export function isDataLayerPath(normalized) {
         hasSegment(normalized, "db"));
 }
 export function isSecuritySensitivePath(normalized) {
-    return includesAny(normalized, SECURITY_KEYWORDS);
+    return hasToken(normalized, SECURITY_KEYWORDS);
 }
 export function isConcurrencyPath(normalized) {
     return hasToken(normalized, CONCURRENCY_KEYWORDS);
@@ -143,33 +205,44 @@ export function isExamplesOrFixturesPath(normalized) {
     return hasSegment(normalized, "examples") || hasSegment(normalized, "fixtures");
 }
 export function isScriptPath(normalized) {
-    return (includesAny(normalized, SCRIPT_KEYWORDS) ||
+    return (hasToken(normalized, SCRIPT_KEYWORDS) ||
         hasSegment(normalized, "scripts") ||
         hasSegment(normalized, "bin"));
 }
 export function isDeploymentConfigPath(normalized) {
-    return includesAny(normalized, DEPLOYMENT_KEYWORDS) || endsWithAny(normalized, [".yml", ".yaml"]);
+    return hasToken(normalized, DEPLOYMENT_KEYWORDS) || endsWithAny(normalized, [".yml", ".yaml"]);
 }
 export function isGeneratedPath(normalized) {
-    return normalized.includes("vendor") || normalized.includes("generated");
+    return isVendorPath(normalized) || hasToken(normalized, ["generated", "autogenerated"]);
 }
 export function isSurfacePath(normalized) {
     return (hasSegment(normalized, "api") ||
-        includesAny(normalized, SURFACE_KEYWORDS) ||
-        hasSegment(normalized, "cli"));
+        hasToken(normalized, SURFACE_KEYWORDS) ||
+        hasSegment(normalized, "cli") ||
+        hasToken(normalized, ["cli"]));
 }
 export function isBackgroundSurfacePath(normalized) {
-    return includesAny(normalized, ["worker", "job"]);
+    return hasToken(normalized, ["worker", "workers", "job", "jobs"]);
 }
 export function isNetworkSurfacePath(normalized) {
-    return hasSegment(normalized, "api") || includesAny(normalized, ["route", "controller"]);
+    return (hasSegment(normalized, "api") ||
+        hasToken(normalized, [
+            "route",
+            "routes",
+            "controller",
+            "controllers",
+            "handler",
+            "handlers",
+            "endpoint",
+            "endpoints",
+        ]));
 }
 export function isBillingPath(normalized) {
-    return includesAny(normalized, BILLING_KEYWORDS);
+    return hasToken(normalized, BILLING_KEYWORDS);
 }
 export function isIdentityPath(normalized) {
-    return isSecuritySensitivePath(normalized) || includesAny(normalized, IDENTITY_KEYWORDS);
+    return isSecuritySensitivePath(normalized) || hasToken(normalized, IDENTITY_KEYWORDS);
 }
 export function isAsyncTaskPath(normalized) {
-    return isConcurrencyPath(normalized) || includesAny(normalized, ASYNC_TASK_KEYWORDS);
+    return isConcurrencyPath(normalized) || hasToken(normalized, ASYNC_TASK_KEYWORDS);
 }

package/dist/io/artifacts.d.ts

@@ -7,6 +7,7 @@ import type { FlowCoverageManifest } from "../types/flowCoverage.js";
 import type { CriticalFlowManifest } from "../types/flows.js";
 import type { GraphBundle } from "../types/graph.js";
 import type { RiskRegister } from "../types/risk.js";
+import type { AuditPlanMetrics, ReviewPacket } from "../types/reviewPlanning.js";
 import type { RuntimeValidationReport, RuntimeValidationTaskManifest } from "../types/runtimeValidation.js";
 import type { SurfaceManifest } from "../types/surfaces.js";
 import type { ToolingManifest } from "../types/toolingManifest.js";
@@ -26,6 +27,8 @@ type ArtifactPayloadMap = {
     external_analyzer_results: ExternalAnalyzerResults;
     audit_results: AuditResult[];
     audit_tasks: AuditTask[];
+    audit_plan_metrics: AuditPlanMetrics;
+    review_packets: ReviewPacket[];
     requeue_tasks: AuditTask[];
     audit_report: string;
     audit_state: AuditState;
@@ -61,6 +64,8 @@ export declare const ARTIFACT_DEFINITIONS: {
     readonly external_analyzer_results: ArtifactDefinition<"external_analyzer_results">;
     readonly audit_results: ArtifactDefinition<"audit_results">;
     readonly audit_tasks: ArtifactDefinition<"audit_tasks">;
+    readonly audit_plan_metrics: ArtifactDefinition<"audit_plan_metrics">;
+    readonly review_packets: ArtifactDefinition<"review_packets">;
     readonly requeue_tasks: ArtifactDefinition<"requeue_tasks">;
     readonly audit_report: ArtifactDefinition<"audit_report">;
     readonly audit_state: ArtifactDefinition<"audit_state">;

package/dist/io/artifacts.js

@@ -42,6 +42,8 @@ export const ARTIFACT_DEFINITIONS = {
     external_analyzer_results: jsonArtifact("external_analyzer_results.json", "execution"),
     audit_results: ndjsonArtifact("audit_results.jsonl", "execution"),
     audit_tasks: jsonArtifact("audit_tasks.json", "execution"),
+    audit_plan_metrics: jsonArtifact("audit_plan_metrics.json", "execution"),
+    review_packets: jsonArtifact("review_packets.json", "execution"),
     requeue_tasks: jsonArtifact("requeue_tasks.json", "execution"),
     audit_report: textArtifact("audit-report.md", "reporting"),
     audit_state: jsonArtifact("audit_state.json", "supervisor"),

package/dist/orchestrator/advance.js

@@ -51,7 +51,7 @@ export async function advanceAudit(bundle, options = {}) {
                 run = await runIntakeExecutor(bundle, options.root);
                 break;
             case "structure_executor":
-                run = runStructureExecutor(bundle);
+                run = await runStructureExecutor(bundle, options.root);
                 break;
             case "planning_executor":
                 if (!options.root)

package/dist/orchestrator/dependencyMap.js

@@ -12,6 +12,8 @@ export const ARTIFACT_DEPENDENCY_MAP = {
         "coverage_matrix.json",
         "flow_coverage.json",
         "audit_tasks.json",
+        "audit_plan_metrics.json",
+        "review_packets.json",
         "requeue_tasks.json",
         "runtime_validation_tasks.json",
         "runtime_validation_report.json",
@@ -26,6 +28,8 @@ export const ARTIFACT_DEPENDENCY_MAP = {
         "coverage_matrix.json",
         "flow_coverage.json",
         "audit_tasks.json",
+        "audit_plan_metrics.json",
+        "review_packets.json",
         "requeue_tasks.json",
         "runtime_validation_tasks.json",
         "runtime_validation_report.json",
@@ -35,6 +39,8 @@ export const ARTIFACT_DEPENDENCY_MAP = {
         "risk_register.json",
         "coverage_matrix.json",
         "audit_tasks.json",
+        "audit_plan_metrics.json",
+        "review_packets.json",
         "runtime_validation_tasks.json",
         "requeue_tasks.json",
         "audit-report.md",
@@ -49,6 +55,8 @@ export const ARTIFACT_DEPENDENCY_MAP = {
         "flow_coverage.json",
         "risk_register.json",
         "audit_tasks.json",
+        "audit_plan_metrics.json",
+        "review_packets.json",
         "requeue_tasks.json",
         "runtime_validation_tasks.json",
         "runtime_validation_report.json",
@@ -58,12 +66,16 @@ export const ARTIFACT_DEPENDENCY_MAP = {
         "coverage_matrix.json",
         "flow_coverage.json",
         "requeue_tasks.json",
+        "audit_plan_metrics.json",
+        "review_packets.json",
         "runtime_validation_tasks.json",
         "runtime_validation_report.json",
         "audit-report.md",
     ],
     "coverage_matrix.json": [
         "flow_coverage.json",
+        "audit_plan_metrics.json",
+        "review_packets.json",
         "requeue_tasks.json",
         "runtime_validation_tasks.json",
         "runtime_validation_report.json",
@@ -75,6 +87,12 @@ export const ARTIFACT_DEPENDENCY_MAP = {
         "runtime_validation_report.json",
         "audit-report.md",
     ],
+    "audit_tasks.json": [
+        "audit_plan_metrics.json",
+        "review_packets.json",
+    ],
+    "audit_plan_metrics.json": [],
+    "review_packets.json": [],
     "runtime_validation_report.json": [
         "audit-report.md",
     ],

package/dist/orchestrator/fileAnchors.d.ts

@@ -0,0 +1,32 @@
+import type { ExternalAnalyzerResults } from "../types/externalAnalyzer.js";
+import type { GraphBundle } from "../types/graph.js";
+export type FileAnchorKind = "boundary" | "import" | "export" | "symbol" | "route" | "keyword" | "graph" | "analyzer_signal";
+export interface FileAnchor {
+    kind: FileAnchorKind;
+    name: string;
+    line?: number;
+    detail?: string;
+}
+export interface FileAnchorSummary {
+    contract_version: "audit-code-file-anchors/v1alpha1";
+    path: string;
+    total_lines: number;
+    review_mode: "isolated_large_file";
+    scope_basis: string[];
+    anchors: FileAnchor[];
+    omitted_anchor_count: number;
+    counts: {
+        symbols: number;
+        routes: number;
+        keywords: number;
+        graph_edges: number;
+        analyzer_signals: number;
+    };
+}
+export declare function buildFileAnchorSummary(params: {
+    path: string;
+    content: string;
+    totalLines: number;
+    graphBundle?: GraphBundle;
+    externalAnalyzerResults?: ExternalAnalyzerResults;
+}): FileAnchorSummary;