rea-agents 6.4.0 → 6.7.0

package/dist/application/javascript/JavaScriptSemanticGraphValueProjection.js

@@ -1,6 +1,5 @@
 import { semanticContainer, semanticPropertyPointer, } from "../../domain/javascript/javascriptSemanticSlots.js";
 import { digestCanonicalValue } from "../../domain/canonicalDigest.js";
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { observedSemanticEvidence, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
 /** Project bounded literal values and object slots for exact query seeds. */
@@ -65,7 +64,7 @@ const projectValue = (input) => {
                 });
         }
         if (container.coverage.status === "partial")
-            addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+            addSemanticGraphUnknown(context.state, {
                 node_id: target.node_id,
                 family: "object-flow",
                 relation_kinds: ["writes-property"],
@@ -73,20 +72,18 @@ const projectValue = (input) => {
                 detail: `Initializer container has unknown ${value.status === "object" ? "properties" : "items"}${container.coverage.omitted === null ? " with an unknown omitted count" : `; ${container.coverage.omitted} omitted`}.`,
                 candidate_node_ids: [target.node_id],
                 evidence: unknownSemanticEvidence(context.file, binding.definitions[0]?.location ?? null),
-            }, context.state.evidenceContexts));
+            });
     }
     else if (value.status === "unknown" ||
         value.status === "ambiguous" ||
         value.status === "cycle") {
         const location = binding.definitions[0]?.location ?? null;
         const evidence = observedSemanticEvidence(context.file, location);
-        addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+        addSemanticGraphUnknown(context.state, {
             node_id: target.node_id,
             family: "data-flow",
             relation_kinds: ["defines"],
-            reason: value.resourceLimit === undefined
-                ? "unknown-value"
-                : "resource-limit",
+            reason: value.resourceLimit === undefined ? "unknown-value" : "resource-limit",
             detail: `${value.reason} Unknown value at ${role}.`,
             candidate_node_ids: [target.node_id],
             evidence: {
@@ -96,7 +93,7 @@ const projectValue = (input) => {
                 confidence: "unknown",
                 limitations: [value.reason],
             },
-        }, context.state.evidenceContexts));
+        });
     }
 };
 const addLiteralNode = (context, binding, value, role) => {

package/dist/application/javascript/JavaScriptSemanticTraceService.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
-import {} from "../../domain/analysisErrorBase.js";
 import { applicationGraphEvidenceInputError, parseApplicationGraphEvidence, } from "./JavaScriptApplicationEvidenceGraph.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { queryJavaScriptSemanticGraph } from "../../domain/javascript/javascriptSemanticQuery.js";

package/dist/application/managed/ManagedApplicationGraphService.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
-import {} from "../../domain/analysisErrorBase.js";
 import { createEvidence, } from "../../domain/evidence.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { managedApplicationGraphResultSchema, projectManagedApplicationGraph, projectManagedApplicationGraphInputSchema, } from "../../domain/managed/managedApplicationGraph.js";

package/dist/application/managed/ManagedMemberComparisonService.js

@@ -1,16 +1,15 @@
-import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
 import { z } from "zod";
 import { compareManagedMembers, managedMemberComparisonResultSchema, } from "../../domain/managed/managedMemberComparison.js";
 import { parseManagedMemberEvidence } from "../../domain/managed/managedMemberComparisonMatch.js";
 import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
 import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
-import {} from "../../domain/analysisErrorBase.js";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
 import { createEvidence } from "../../domain/evidence.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
-import { parseBinaryTarget } from "../BinaryTargetResolver.js";
+import { classifyBinaryTargetFilesystemFailure, parseBinaryTarget, } from "../BinaryTargetResolver.js";
 import { err, ok } from "../../domain/result.js";
 import { inspectManagedMembersBytes } from "../../dotnet/ManagedMemberInspector.js";
+import { readManagedSnapshot } from "../../dotnet/ManagedSnapshot.js";
 import { MANAGED_STATIC_PROVIDER, MANAGED_WORKFLOW_PROVIDER, } from "../InvestigationProviders.js";
 import { workflowInputError } from "../workflowInputError.js";
 /** Compare managed members from input parsed by a trusted adapter. */
@@ -26,17 +25,16 @@ export const compareManagedMembersEvidenceValidated = (input) => {
         return workflowFailure(operation, cause);
     }
 };
-const DEFAULT_PATH_DEPENDENCIES = {
-    resolveTarget: parseBinaryTarget,
-    readBytes: readFile,
-};
 /** Inspect two local PE artifacts and return one derived comparison Evidence. */
-export const compareManagedMemberPaths = async (input, dependencies = DEFAULT_PATH_DEPENDENCIES) => {
+export const compareManagedMemberPaths = async (input, dependencies = {}, resources) => {
     const operation = "compare_managed_members";
+    const resolveTarget = dependencies.resolveTarget ?? parseBinaryTarget;
+    const readSnapshot = dependencies.readSnapshot ?? readManagedSnapshot;
+    let partialEvidence;
     try {
         const [leftTarget, rightTarget] = await Promise.all([
-            dependencies.resolveTarget(input.leftPath),
-            dependencies.resolveTarget(input.rightPath),
+            resolveTarget(input.leftPath),
+            resolveTarget(input.rightPath),
         ]);
         // Report an unopenable path like every other path-based command does,
         // with the failed path and constraint, rather than a bare input error.
@@ -44,59 +42,66 @@ export const compareManagedMemberPaths = async (input, dependencies = DEFAULT_PA
             return err(leftTarget.error);
         if (!rightTarget.ok)
             return err(rightTarget.error);
-        const [leftBytes, rightBytes] = await Promise.all([
-            dependencies.readBytes(leftTarget.value.path),
-            dependencies.readBytes(rightTarget.value.path),
-        ]);
-        for (const [target, bytes] of [
-            [leftTarget.value, leftBytes],
-            [rightTarget.value, rightBytes],
-        ]) {
-            const observedSha256 = createHash("sha256").update(bytes).digest("hex");
-            if (observedSha256 !== target.sha256)
-                return err(new EvidenceIntegrityError(`Managed artifact digest changed after open: expected ${target.sha256}, observed ${observedSha256} at ${target.path}`));
-        }
-        const leftInspection = inspectManagedMembersBytes(leftBytes, leftTarget.value);
-        const rightInspection = inspectManagedMembersBytes(rightBytes, rightTarget.value);
-        const leftEvidence = createEvidence(leftTarget.value, MANAGED_STATIC_PROVIDER, {
-            operation: "inspect_managed_members",
-            parameters: {},
-            result: jsonValueSchema.parse(leftInspection),
-            rawResult: null,
-            limitations: leftInspection.limitations,
-            locations: [{ kind: "artifact-path", path: leftTarget.value.path }],
-        });
-        const rightEvidence = createEvidence(rightTarget.value, MANAGED_STATIC_PROVIDER, {
-            operation: "inspect_managed_members",
-            parameters: {},
-            result: jsonValueSchema.parse(rightInspection),
-            rawResult: null,
-            limitations: rightInspection.limitations,
-            locations: [{ kind: "artifact-path", path: rightTarget.value.path }],
-        });
+        const inspectTarget = async (target, selectedPath) => {
+            const { path } = target;
+            let snapshot;
+            try {
+                snapshot = await readSnapshot(path, operation, resources === undefined ? {} : { resources });
+            }
+            catch (cause) {
+                const failure = classifyBinaryTargetFilesystemFailure(path, cause);
+                if (failure !== undefined)
+                    throw failure;
+                throw cause;
+            }
+            if (snapshot.sha256 !== target.sha256)
+                throw new EvidenceIntegrityError(`Managed artifact digest changed after open: expected ${target.sha256}, observed ${snapshot.sha256} at ${target.path}`);
+            // Member comparison never reads literals, so it does not spend the
+            // decode budget on them.
+            const inspection = inspectManagedMembersBytes(snapshot.bytes, target, {
+                userStrings: false,
+            });
+            const evidence = createEvidence(target, MANAGED_STATIC_PROVIDER, {
+                operation: "inspect_managed_members",
+                parameters: {},
+                result: jsonValueSchema.parse(inspection),
+                rawResult: null,
+                limitations: inspection.limitations,
+                locations: [{ kind: "artifact-path", path: selectedPath }],
+            });
+            return { inspection, evidence };
+        };
+        const left = await inspectTarget(leftTarget.value, input.leftPath);
+        partialEvidence = left.evidence;
+        const right = await inspectTarget(rightTarget.value, input.rightPath);
         const result = compareManagedMembers({
-            evidenceId: leftEvidence.evidence_id,
-            result: leftInspection,
+            evidenceId: left.evidence.evidence_id,
+            result: left.inspection,
         }, {
-            evidenceId: rightEvidence.evidence_id,
-            result: rightInspection,
+            evidenceId: right.evidence.evidence_id,
+            result: right.inspection,
         });
         return ok(createManagedMemberComparisonEvidence({
-            left: leftEvidence,
-            right: rightEvidence,
-        }, result));
+            left: left.evidence,
+            right: right.evidence,
+        }, result, { leftPath: input.leftPath, rightPath: input.rightPath }));
     }
     catch (cause) {
-        return workflowFailure(operation, cause);
+        return workflowFailure(operation, cause, partialEvidence);
     }
 };
-/** ECMA-335 representable limits for path-based member comparison. */
-const createManagedMemberComparisonEvidence = (parameters, result) => createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
+const createManagedMemberComparisonEvidence = (parameters, result, sourcePaths) => createEvidence(undefined, MANAGED_WORKFLOW_PROVIDER, {
     predicateType: "rea.managed-member-comparison",
     operation: "compare_managed_members",
     parameters: {
         left_evidence_id: parameters.left.evidence_id,
         right_evidence_id: parameters.right.evidence_id,
+        ...(sourcePaths === undefined
+            ? {}
+            : {
+                left_path: sourcePaths.leftPath,
+                right_path: sourcePaths.rightPath,
+            }),
     },
     result: jsonValueSchema.parse(result),
     rawResult: null,
@@ -104,8 +109,21 @@ const createManagedMemberComparisonEvidence = (parameters, result) => createEvid
     authority: "analyst-inference",
     environment: null,
     limitations: result.limitations,
+    locations: sourcePaths === undefined
+        ? []
+        : [
+            { kind: "artifact-path", path: sourcePaths.leftPath },
+            { kind: "artifact-path", path: sourcePaths.rightPath },
+        ],
     evidenceLinks: result.evidence_links,
 });
-const workflowFailure = (operation, cause) => err(cause instanceof z.ZodError || cause instanceof TypeError
-    ? workflowInputError(operation, cause)
-    : new AnalysisProtocolError("Managed member comparison produced an invalid result", { cause }));
+const workflowFailure = (operation, cause, partialEvidence) => {
+    const failure = cause instanceof AnalysisError
+        ? cause
+        : cause instanceof z.ZodError || cause instanceof TypeError
+            ? workflowInputError(operation, cause)
+            : new AnalysisProtocolError("Managed member comparison produced an invalid result", { cause });
+    return err(partialEvidence === undefined
+        ? failure
+        : failure.retainPartialObservation(partialEvidence));
+};

package/dist/application/managed/ManagedNativeVerificationService.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
-import {} from "../../domain/analysisErrorBase.js";
 import { createEvidence } from "../../domain/evidence.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { managedNativeVerificationInputSchema, } from "../../domain/managed/managedNativeVerificationSchemas.js";

package/dist/application/managed/ManagedReconstructionService.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
-import {} from "../../domain/analysisErrorBase.js";
 import { createEvidence } from "../../domain/evidence.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { importManagedReconstruction, managedReconstructionImportInputSchema, } from "../../domain/managed/managedReconstruction.js";

package/dist/application/native/NativeCallRoutes.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { parseRelatedAddresses, referenceKindSchema, } from "../../domain/hopperValues.js";
-import { err, ok } from "../../domain/result.js";
 import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
+const limitationsFrom = (operation, provider, limitations) => limitations.map((limitation) => ({ provider, operation, limitation }));
 const referencesSchema = z.object({
     reference_kinds_available: z.boolean(),
     references: z.array(z.object({
@@ -12,59 +12,96 @@ const referencesSchema = z.object({
     })),
     unresolved_calls: z.array(z.object({ address: z.string(), reason: z.string() })),
 });
+const typedCallRoutes = (references) => {
+    const calls = references.filter(({ kind }) => kind.available && kind.call);
+    const countBySite = new Map();
+    for (const call of calls) {
+        const targets = countBySite.get(call.source_address) ?? new Set();
+        targets.add(call.target_address);
+        countBySite.set(call.source_address, targets);
+    }
+    return calls.map((call) => ({
+        address: call.target_procedure?.address ?? call.target_address,
+        site: call.source_address,
+        relation: call.kind.available && (call.kind.computed || call.kind.indirect)
+            ? "indirect_call"
+            : "direct_call",
+        resolution: (countBySite.get(call.source_address)?.size ?? 0) > 1
+            ? "ambiguous"
+            : call.kind.available && (call.kind.computed || call.kind.indirect)
+                ? "resolved"
+                : "observed",
+    }));
+};
 /** Prefer typed static call references, preserving computed targets and targetless sites. */
-export const readNativeCallRoutes = async (analysis, procedure, signal) => {
-    const options = signal === undefined ? {} : { signal };
+export const readNativeCallRoutes = async (analysis, procedure, signal, selectorOrigin) => {
+    const options = {
+        ...(signal === undefined ? {} : { signal }),
+        ...(selectorOrigin === undefined ? {} : { selectorOrigin }),
+    };
     const execution = await analysis.execute("procedure_references", { procedure, direction: "outgoing" }, options);
+    let unknowns = [];
+    let limitations = [];
     if (execution.ok) {
+        limitations = limitationsFrom("procedure_references", execution.value.provider, execution.value.limitations);
         const parsed = referencesSchema.safeParse(execution.value.result);
         if (!parsed.success)
-            return err(new AnalysisOutputError("procedure_references", "Invalid typed call references"));
+            return {
+                ok: false,
+                error: new AnalysisOutputError("procedure_references", "Invalid typed call references"),
+                unknowns,
+                limitations,
+            };
+        // Missing detailed reference flags do not invalidate observed targetless
+        // calls. Keep their producing provider even if another provider supplies
+        // the fallback callee inventory.
+        unknowns = parsed.data.unresolved_calls.map((call) => ({
+            ...call,
+            provider: execution.value.provider,
+        }));
         const references = parsed.data.references;
         if (parsed.data.reference_kinds_available === true ||
             (references.length > 0 && references.every(({ kind }) => kind.available))) {
-            const calls = references.filter(({ kind }) => kind.available && kind.call);
-            const countBySite = new Map();
-            for (const call of calls) {
-                const targets = countBySite.get(call.source_address) ?? new Set();
-                targets.add(call.target_address);
-                countBySite.set(call.source_address, targets);
-            }
-            return ok({
-                provider: execution.value.provider,
-                routes: calls.map((call) => ({
-                    address: call.target_procedure?.address ?? call.target_address,
-                    site: call.source_address,
-                    relation: call.kind.available && (call.kind.computed || call.kind.indirect)
-                        ? "indirect_call"
-                        : "direct_call",
-                    resolution: (countBySite.get(call.source_address)?.size ?? 0) > 1
-                        ? "ambiguous"
-                        : call.kind.available &&
-                            (call.kind.computed || call.kind.indirect)
-                            ? "resolved"
-                            : "observed",
-                })),
-                unknowns: parsed.data.unresolved_calls,
-            });
+            return {
+                ok: true,
+                value: {
+                    provider: execution.value.provider,
+                    routes: typedCallRoutes(references),
+                    unknowns,
+                    limitations,
+                },
+            };
         }
     }
     else if (execution.error._tag !== "AnalysisCapabilityUnavailableError")
-        return err(execution.error);
+        return {
+            ok: false,
+            error: execution.error,
+            unknowns,
+            limitations,
+        };
     const callees = await analysis.execute("procedure_callees", { procedure }, options);
     if (!callees.ok)
-        return callees;
+        return { ok: false, error: callees.error, unknowns, limitations };
+    limitations = [
+        ...limitations,
+        ...limitationsFrom("procedure_callees", callees.value.provider, callees.value.limitations),
+    ];
     const parsed = parseRelatedAddresses(callees.value.result, "callees");
     return parsed.ok
-        ? ok({
-            provider: callees.value.provider,
-            routes: parsed.value.map((address) => ({
-                address,
-                site: procedure,
-                relation: "provider_call",
-                resolution: "inferred",
-            })),
-            unknowns: [],
-        })
-        : parsed;
+        ? {
+            ok: true,
+            value: {
+                provider: callees.value.provider,
+                routes: parsed.value.map((address) => ({
+                    address,
+                    site: procedure,
+                    relation: "provider_call",
+                    resolution: "inferred",
+                })),
+                unknowns,
+                limitations,
+            },
+        }
+        : { ok: false, error: parsed.error, unknowns, limitations };
 };

package/dist/application/native/NativeDispatchMetadataInspection.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { addressedValue } from "../../contracts/toolOutputSchemaPrimitives.js";
 import { nativeDispatchMetadataResultSchema, inspectNativeDispatchMetadata, } from "../../domain/native/objcSwiftMetadata.js";
 import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
@@ -15,8 +16,11 @@ export const inspectNativeDispatch = async (analysis, maxRecords, signal) => {
         return err(execution.error);
     const names = z
         .array(z.union([
-        z.strictObject({ address: z.string(), value: z.string() }),
-        z.strictObject({ address: z.string(), name: z.string() }),
+        addressedValue.strict(),
+        addressedValue
+            .omit({ value: true })
+            .extend({ name: z.string() })
+            .strict(),
     ]))
         .safeParse(execution.value.result);
     if (!names.success)

package/dist/application/native/NativeUiActionTrace.js

@@ -5,6 +5,7 @@ import { nativeDispatchMetadataResultSchema } from "../../domain/native/objcSwif
 import { inspectNativeDispatch } from "./NativeDispatchMetadataInspection.js";
 import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { readNativeCallRoutes } from "./NativeCallRoutes.js";
+import { renderSourceLimitations, } from "../SourceLimitations.js";
 import { err, ok } from "../../domain/result.js";
 import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
 import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
@@ -78,6 +79,9 @@ export const traceNativeUiAction = async (analysis, input, signal) => {
         const native = await analysis.execute("procedure_address", { procedure: input.action }, signal === undefined ? {} : { signal });
         if (!native.ok && native.error._tag === "AnalysisCancelledError")
             return err(native.error);
+        if (!native.ok &&
+            native.error._tag !== "AnalysisCapabilityUnavailableError")
+            return err(native.error);
         if (native.ok) {
             const address = z.string().safeParse(native.value.result);
             if (!address.success || native.value.subject?.sha256 !== targetSha256)
@@ -179,6 +183,10 @@ export const traceNativeUiAction = async (analysis, input, signal) => {
             : graph.truncated && trace.reason === null
                 ? "native_trace_output_bound_reached"
                 : trace.reason,
+        limitations: [
+            ...trace.limitations,
+            ...renderSourceLimitations(expanded.limitations),
+        ],
     })));
 };
 const emptyGraph = (targetSha256, provider) => nativeInvestigationGraphSchema.parse({
@@ -274,6 +282,7 @@ const addDirectCallees = async (input) => {
     let examined = 0;
     let omitted = 0;
     let truncated = false;
+    const sourceLimitations = [];
     while (queueIndex < queue.length) {
         const current = queue[queueIndex++];
         if (current === undefined || visited.has(current.address))
@@ -289,30 +298,18 @@ const addDirectCallees = async (input) => {
             omitted += queue.length - queueIndex + 1;
             break;
         }
-        const execution = await readNativeCallRoutes(input.analysis, current.address, input.signal);
+        const execution = await readNativeCallRoutes(input.analysis, current.address, input.signal, "provider");
         examined += 1;
-        if (!execution.ok) {
-            if (execution.error._tag === "AnalysisCancelledError")
-                return { error: execution.error };
-            const id = `unknown-callees:${current.address}`;
-            edges.set(id, {
-                id,
-                from: current.node.id,
-                to: null,
-                relation: "direct_call",
-                resolution: "unresolved",
-                reason: projectAnalysisError(execution.error).message,
-                evidence: [],
-                limitations: [
-                    "The provider could not enumerate resolved direct callees.",
-                ],
-            });
-            continue;
-        }
-        for (const unknown of execution.value.unknowns) {
+        sourceLimitations.push(...(execution.ok ? execution.value.limitations : execution.limitations));
+        if (!execution.ok && execution.error._tag === "AnalysisCancelledError")
+            return { error: execution.error };
+        const unknowns = execution.ok
+            ? execution.value.unknowns
+            : execution.unknowns;
+        for (const [index, unknown] of unknowns.entries()) {
             if (edges.size >= input.input.max_edges) {
                 truncated = true;
-                omitted++;
+                omitted += unknowns.length - index;
                 break;
             }
             const id = `unknown-dispatch:${current.address}:${unknown.address}`;
@@ -326,7 +323,8 @@ const addDirectCallees = async (input) => {
                 evidence: [
                     {
                         kind: "reference",
-                        description: unknown.reason,
+                        provider: unknown.provider,
+                        description: `${unknown.provider.name} reported an unresolved call: ${unknown.reason}`,
                         location: { address: unknown.address, file_offset: null },
                         artifact_path: null,
                         artifact_sha256: input.targetSha256,
@@ -335,6 +333,27 @@ const addDirectCallees = async (input) => {
                 limitations: [],
             });
         }
+        if (!execution.ok) {
+            if (edges.size >= input.input.max_edges) {
+                truncated = true;
+                omitted += 1;
+                continue;
+            }
+            const id = `unknown-callees:${current.address}`;
+            edges.set(id, {
+                id,
+                from: current.node.id,
+                to: null,
+                relation: "direct_call",
+                resolution: "unresolved",
+                reason: projectAnalysisError(execution.error).message,
+                evidence: [],
+                limitations: [
+                    "The provider could not enumerate resolved direct callees.",
+                ],
+            });
+            continue;
+        }
         for (const [index, route] of execution.value.routes.entries()) {
             const address = route.address;
             if (edges.size >= input.input.max_edges) {
@@ -346,6 +365,7 @@ const addDirectCallees = async (input) => {
             const evidence = [
                 {
                     kind: "reference",
+                    provider: execution.value.provider,
                     description: `${execution.value.provider.name} reported ${route.relation} from ${current.address} to ${address}`,
                     location: { address: route.site, file_offset: null },
                     artifact_path: null,
@@ -401,6 +421,7 @@ const addDirectCallees = async (input) => {
         examined,
         omitted,
         truncated,
+        limitations: sourceLimitations,
     };
 };
 const graphNodeDepths = (start, nodes, edges) => {