rea-agents 6.2.0 → 6.4.0

package/dist/application/javascript/JavaScriptSemanticGraphBuilder.js

@@ -1,5 +1,5 @@
-import { createJavaScriptSemanticGraph, createImmutableJavaScriptSemanticGraphSteps, } from "../../domain/javascript/javascriptSemanticGraph.js";
-import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
+import { createJavaScriptSemanticGraph, createJavaScriptSemanticGraphUnknown, sealTransferredJavaScriptSemanticGraphSteps, } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, JAVASCRIPT_SEMANTIC_RELATIONS, } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
 import { sourceRangesEqual as rangesEqual } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { projectSemanticEvents, projectSemanticTimers, } from "./JavaScriptSemanticGraphAsyncProjection.js";
 import { projectSemanticChildProcesses } from "./JavaScriptSemanticGraphChildProcessProjection.js";
@@ -8,6 +8,9 @@ import { projectSemanticResources } from "./JavaScriptSemanticGraphResourceProje
 import { projectSemanticObjects } from "./JavaScriptSemanticGraphObjectProjection.js";
 import { projectSemanticValues } from "./JavaScriptSemanticGraphValueProjection.js";
 import { inferredSemanticEvidenceAt } from "./JavaScriptSemanticGraphEvidence.js";
+import { observedSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
+import { javaScriptAnalysisCoverageLimits } from "../../domain/javascript/javascriptAnalysisResourceControls.js";
 import { projectSemanticFunctionFingerprints } from "./JavaScriptSemanticGraphFingerprintProjection.js";
 import { projectSemanticClosureCaptures, projectSemanticFrontiers, projectSemanticPromises, projectSemanticReturnValues, } from "./JavaScriptSemanticGraphFlowProjection.js";
 import { createSemanticCallableOwnerLookup, createSemanticCallSiteLookup, createSemanticNodeRangeLookup, semanticFamilyStatus, } from "./JavaScriptSemanticGraphProjection.js";
@@ -45,14 +48,17 @@ export const buildJavaScriptSemanticGraph = ({ rootArtifactSha256, applicationGr
         if (analyzed.semantic !== null)
             projection.projectFile(analyzed.file, analyzed.semantic.ir);
     }
-    return projection.finish(rootArtifactSha256, applicationGraph, analysis);
+    return projection.finish(rootArtifactSha256, applicationGraph);
 };
 /** Accumulate semantic nodes while each source IR is still file-local. */
 export const createJavaScriptSemanticGraphProjection = () => {
-    const state = emptyState({ nodes: [] });
+    const state = emptyState();
     const fingerprints = [];
     let truncatedFiles = 0;
-    const projectSource = (file, ir) => {
+    let unavailableFiles = 0;
+    let resourceTruncatedFiles = 0;
+    const executionLimits = new Map();
+    const projectSourceSteps = function* (file, ir) {
         if (state.nodes.size >= SEMANTIC_GRAPH_NODE_CEILING) {
             truncatedFiles += 1;
             return;
@@ -60,7 +66,7 @@ export const createJavaScriptSemanticGraphProjection = () => {
         const remainingTreeBudget = SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size;
         state.fileNodeBudget = Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, remainingTreeBudget);
         state.fileNodesDropped = false;
-        fingerprints.push(...projectFile(file, ir, state));
+        fingerprints.push(...(yield* projectFileSteps(file, ir, state)));
         // Nodes were dropped only if the budget actually blocked creation. A file
         // that exactly fills its share ends with a zero budget without dropping
         // anything, so the remaining budget alone cannot decide truncation.
@@ -68,43 +74,59 @@ export const createJavaScriptSemanticGraphProjection = () => {
             truncatedFiles += 1;
         state.fileNodeBudget = null;
     };
-    const finishWith = (factory, rootArtifactSha256, applicationGraph, analysis) => {
+    const finishWith = (factory, rootArtifactSha256, applicationGraph) => {
         bindSemanticGraphApplicationNodes(state, applicationGraph);
         if (state.roots.size === 0)
             addFallbackRoot(rootArtifactSha256, state);
+        const relations = [...state.relations.values()];
         const unknowns = [...state.unknowns.values()];
+        const retainedByFamily = new Map();
+        const unknownIdsByFamily = new Map();
+        for (const relation of relations) {
+            const family = JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation.relation];
+            retainedByFamily.set(family, (retainedByFamily.get(family) ?? 0) + 1);
+        }
+        for (const unknown of unknowns) {
+            const identifiers = unknownIdsByFamily.get(unknown.family);
+            if (identifiers === undefined)
+                unknownIdsByFamily.set(unknown.family, [unknown.unknown_id]);
+            else
+                identifiers.push(unknown.unknown_id);
+        }
         const graph = factory({
             schema: "JavaScriptSemanticRelationGraph",
             root_artifact_sha256: rootArtifactSha256,
             application_graph_id: applicationGraph.graph_id,
             root_node_ids: [...state.roots],
+            evidence_contexts: state.evidenceContexts.contexts,
             nodes: [...state.nodes.values()],
-            relations: [...state.relations.values()],
-            fingerprints,
+            relations,
+            // The input is transferred to the factory; `fingerprints` is cleared below.
+            fingerprints: [...fingerprints],
             unknowns,
             coverage: {
-                status: truncatedFiles > 0 ? "partial" : "unknown",
-                truncated: truncatedFiles > 0,
-                omitted_nodes: truncatedFiles > 0 ? null : 0,
-                omitted_relations: truncatedFiles > 0 ? null : 0,
-                limits: truncatedFiles > 0
-                    ? [
-                        {
-                            name: "semantic_graph_node_ceiling",
-                            value: SEMANTIC_GRAPH_NODE_CEILING,
-                            unit: "items",
-                        },
-                    ]
-                    : [],
+                status: truncatedFiles > 0 || unavailableFiles > 0 ? "partial" : "unknown",
+                truncated: truncatedFiles > 0 || resourceTruncatedFiles > 0,
+                omitted_nodes: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
+                omitted_relations: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
+                limits: [
+                    ...executionLimits.values(),
+                    ...(truncatedFiles > 0
+                        ? [
+                            {
+                                name: "semantic_graph_node_ceiling",
+                                value: SEMANTIC_GRAPH_NODE_CEILING,
+                                unit: "items",
+                            },
+                        ]
+                        : []),
+                ],
                 families: JAVASCRIPT_SEMANTIC_RELATION_FAMILIES.map((family) => ({
                     family,
-                    status: semanticFamilyStatus(family, analysis),
-                    retained_relations: [...state.relations.values()].filter((relation) => JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation.relation] ===
-                        family).length,
-                    omitted_relations: truncatedFiles > 0 ? null : 0,
-                    unknown_ids: unknowns
-                        .filter((unknown) => unknown.family === family)
-                        .map(({ unknown_id: identifier }) => identifier),
+                    status: semanticFamilyStatus(family),
+                    retained_relations: retainedByFamily.get(family) ?? 0,
+                    omitted_relations: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
+                    unknown_ids: unknownIdsByFamily.get(family) ?? [],
                 })),
             },
             limitations: [
@@ -125,16 +147,103 @@ export const createJavaScriptSemanticGraphProjection = () => {
         state.relations.clear();
         state.unknowns.clear();
         state.roots.clear();
+        state.evidenceContexts.clear();
         fingerprints.length = 0;
         return graph;
     };
     return {
-        projectFile: projectSource,
-        finish: (rootArtifactSha256, applicationGraph, analysis) => finishWith(createJavaScriptSemanticGraph, rootArtifactSha256, applicationGraph, analysis),
-        finishImmutableSteps: (rootArtifactSha256, applicationGraph, analysis) => finishWith(createImmutableJavaScriptSemanticGraphSteps, rootArtifactSha256, applicationGraph, analysis),
+        remainingFileNodeBudget: () => Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, Math.max(0, SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size)),
+        adoptFileProjection: (projection) => {
+            const newNodes = projection.nodes.filter(({ node_id }) => !state.nodes.has(node_id));
+            if (newNodes.length >
+                Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size))
+                throw new RangeError("Transferred semantic nodes exceed the offered tree capacity");
+            for (const context of projection.evidenceContexts)
+                state.evidenceContexts.adopt(context);
+            for (const node of newNodes)
+                state.nodes.set(node.node_id, node);
+            for (const relation of projection.relations)
+                state.relations.set(relation.relation_id, relation);
+            for (const unknown of projection.unknowns)
+                state.unknowns.set(unknown.unknown_id, unknown);
+            for (const root of projection.roots)
+                state.roots.add(root);
+            fingerprints.push(...projection.fingerprints);
+            if (projection.truncated)
+                truncatedFiles += 1;
+        },
+        recordUnavailableFile: (file, reason, limits, unknownReason) => {
+            const retainedLimits = javaScriptAnalysisCoverageLimits(limits);
+            for (const limit of retainedLimits) {
+                executionLimits.set(JSON.stringify([limit.name, limit.value, limit.unit]), limit);
+            }
+            state.fileNodeBudget = Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, Math.max(0, SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size));
+            const module = retainNode(state, file, {
+                kind: "module",
+                roleKey: "module",
+                location: null,
+                label: file.path,
+                functionNodeId: null,
+            });
+            state.fileNodeBudget = null;
+            if (module !== null)
+                state.roots.add(module.node_id);
+            const evidence = {
+                ...observedSemanticEvidence(file, null),
+                authority: "unknown",
+                state: "unknown",
+                confidence: "unknown",
+                coverage: partialApplicationCoverage(retainedLimits, null),
+                limitations: [reason],
+            };
+            for (const family of JAVASCRIPT_SEMANTIC_RELATION_FAMILIES) {
+                const unknown = createJavaScriptSemanticGraphUnknown({
+                    node_id: module?.node_id ?? null,
+                    family,
+                    relation_kinds: JAVASCRIPT_SEMANTIC_RELATIONS.filter((relation) => JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation] === family),
+                    reason: unknownReason,
+                    detail: reason,
+                    candidate_node_ids: [],
+                    evidence,
+                }, state.evidenceContexts);
+                state.unknowns.set(unknown.unknown_id, unknown);
+            }
+            unavailableFiles += 1;
+            if (unknownReason === "resource-limit" && retainedLimits.length > 0)
+                resourceTruncatedFiles += 1;
+        },
+        projectFile: (file, ir) => {
+            const steps = projectSourceSteps(file, ir);
+            while (steps.next().done !== true)
+                ;
+        },
+        projectFileSteps: projectSourceSteps,
+        finish: (rootArtifactSha256, applicationGraph) => finishWith(createJavaScriptSemanticGraph, rootArtifactSha256, applicationGraph),
+        finishImmutableSteps: (rootArtifactSha256, applicationGraph) => finishWith(sealTransferredJavaScriptSemanticGraphSteps, rootArtifactSha256, applicationGraph),
     };
 };
-const projectFile = (file, ir, state) => {
+/** Project one source with the parent's remaining node capacity, retaining no full IR. */
+export function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget) {
+    if (!Number.isSafeInteger(nodeBudget) ||
+        nodeBudget < 0 ||
+        nodeBudget > SEMANTIC_GRAPH_FILE_NODE_CEILING)
+        throw new RangeError("File semantic projection requires a valid offered node capacity");
+    const state = emptyState();
+    state.fileNodeBudget = nodeBudget;
+    state.fileNodesDropped = false;
+    const fingerprints = yield* projectFileSteps(file, ir, state);
+    return {
+        roots: [...state.roots],
+        evidenceContexts: state.evidenceContexts.contexts,
+        nodes: [...state.nodes.values()],
+        relations: [...state.relations.values()],
+        unknowns: [...state.unknowns.values()],
+        fingerprints,
+        truncated: Boolean(state.fileNodesDropped),
+    };
+}
+function* projectFileSteps(file, ir, state) {
+    yield;
     const moduleNode = retainNode(state, file, {
         kind: "module",
         roleKey: "module",
@@ -145,7 +254,12 @@ const projectFile = (file, ir, state) => {
     if (moduleNode === null)
         return [];
     state.roots.add(moduleNode.node_id);
-    const callableNodes = new Map(ir.callables.flatMap((callable) => {
+    // Node creation keeps source order, which the per-file node budget relies
+    // on; yields between nodes do not change it.
+    const callableNodes = new Map();
+    for (const [index, callable] of ir.callables.entries()) {
+        if (index % 64 === 0)
+            yield;
         const node = retainNode(state, file, {
             kind: "function",
             roleKey: `callable:${callable.callableId}`,
@@ -155,10 +269,14 @@ const projectFile = (file, ir, state) => {
             // The label is display text; keep the exact name, which may be "".
             properties: { name: callable.name },
         });
-        return node === null ? [] : [[callable.callableId, node]];
-    }));
+        if (node !== null)
+            callableNodes.set(callable.callableId, node);
+    }
     const callableOwnerAt = createSemanticCallableOwnerLookup(ir, callableNodes);
-    const bindingNodes = new Map(ir.bindings.flatMap((binding) => {
+    const bindingNodes = new Map();
+    for (const [index, binding] of ir.bindings.entries()) {
+        if (index % 64 === 0)
+            yield;
         const location = binding.definitions[0]?.location ?? null;
         const kind = binding.kind === "parameter" ? "parameter" : "binding";
         const owner = callableOwnerAt(location);
@@ -169,10 +287,11 @@ const projectFile = (file, ir, state) => {
             label: binding.name,
             functionNodeId: owner?.node_id ?? null,
         });
-        return node === null ? [] : [[binding.bindingId, node]];
-    }));
-    const returnSiteNodes = createReturnSiteNodes(file, ir, callableNodes, state);
-    const callSiteNodes = createCallSiteNodes(file, ir, callableNodes, state);
+        if (node !== null)
+            bindingNodes.set(binding.bindingId, node);
+    }
+    const returnSiteNodes = yield* createReturnSiteNodes(file, ir, callableNodes, state);
+    const callSiteNodes = yield* createCallSiteNodes(file, ir, callableNodes, state);
     const definitions = {
         file,
         ir,
@@ -191,29 +310,28 @@ const projectFile = (file, ir, state) => {
         callableOwnerAt,
         callSiteAt: createSemanticCallSiteLookup(ir, callSiteNodes),
     };
-    projectDefinitionsAndReferences(definitions);
+    yield* projectDefinitionsAndReferences(definitions);
     const context = {
         ...definitions,
         referenceNodesWithin: createSemanticNodeRangeLookup(definitions.referenceNodes),
     };
-    projectSemanticValues(context);
-    projectSemanticObjects(context);
-    projectCalls(context);
-    projectSemanticPromises(context);
-    projectSemanticEvents(context);
-    projectSemanticTimers(context);
-    projectSemanticChildProcesses(context);
-    projectSemanticConfiguration(context);
-    projectSemanticRequests(context);
-    projectSemanticBoundaries(context);
-    projectSemanticResources(context);
-    projectSemanticClosureCaptures(context);
-    projectSemanticFrontiers(context);
-    return projectSemanticFunctionFingerprints(file, ir, callableNodes);
-};
-const createReturnSiteNodes = (file, ir, callables, state) => {
+    // Each pass completes before the next starts, so yielding between passes
+    // keeps projection order and results unchanged.
+    for (const project of FILE_PROJECTION_PASSES) {
+        yield;
+        const steps = project(context);
+        if (steps !== undefined)
+            while (steps.next().done !== true)
+                yield;
+    }
+    yield;
+    return projectSemanticFunctionFingerprints(file, ir, callableNodes, state.evidenceContexts);
+}
+function* createReturnSiteNodes(file, ir, callables, state) {
     const result = new Map();
-    for (const callable of ir.callables) {
+    for (const [index, callable] of ir.callables.entries()) {
+        if (index % 64 === 0)
+            yield;
         const owner = callables.get(callable.callableId);
         if (owner === undefined)
             continue;
@@ -231,10 +349,12 @@ const createReturnSiteNodes = (file, ir, callables, state) => {
         }
     }
     return result;
-};
-const createCallSiteNodes = (file, ir, callables, state) => {
+}
+function* createCallSiteNodes(file, ir, callables, state) {
     const result = new Map();
-    for (const call of ir.callSites) {
+    for (const [index, call] of ir.callSites.entries()) {
+        if (index % 64 === 0)
+            yield;
         const owner = call.callerCallableId === null
             ? null
             : (callables.get(call.callerCallableId)?.node_id ?? null);
@@ -249,9 +369,11 @@ const createCallSiteNodes = (file, ir, callables, state) => {
             result.set(call.callSiteId, node);
     }
     return result;
-};
-const projectDefinitionsAndReferences = (context) => {
-    for (const binding of context.ir.bindings) {
+}
+function* projectDefinitionsAndReferences(context) {
+    for (const [bindingIndex, binding] of context.ir.bindings.entries()) {
+        if (bindingIndex % 64 === 0)
+            yield;
         const bindingNode = context.bindingNodes.get(binding.bindingId);
         if (bindingNode === undefined)
             continue;
@@ -272,6 +394,8 @@ const projectDefinitionsAndReferences = (context) => {
         }
     }
     for (const [index, reference] of context.ir.references.entries()) {
+        if (index % 64 === 0)
+            yield;
         const expression = retainNode(context.state, context.file, {
             kind: "expression",
             roleKey: `reference:${String(index)}:${reference.role}:${reference.name}`,
@@ -302,7 +426,7 @@ const projectDefinitionsAndReferences = (context) => {
                 resolution: "resolved",
             });
     }
-};
+}
 const projectCalls = (context) => {
     for (const call of context.ir.callSites) {
         const callNode = context.callSiteNodes.get(call.callSiteId);
@@ -369,3 +493,19 @@ const createArgumentNode = (context, callNode, callSiteId, argument) => retainNo
         : `argument ${String(argument.index)}`,
     functionNodeId: callNode.function_node_id,
 });
+/** Per-file projection passes, run in this order with a yield between each. */
+const FILE_PROJECTION_PASSES = [
+    projectSemanticValues,
+    projectSemanticObjects,
+    projectCalls,
+    projectSemanticPromises,
+    projectSemanticEvents,
+    projectSemanticTimers,
+    projectSemanticChildProcesses,
+    projectSemanticConfiguration,
+    projectSemanticRequests,
+    projectSemanticBoundaries,
+    projectSemanticResources,
+    projectSemanticClosureCaptures,
+    projectSemanticFrontiers,
+];

package/dist/application/javascript/JavaScriptSemanticGraphChildProcessProjection.js

@@ -161,5 +161,5 @@ const addChildUnknown = (input) => {
         detail,
         candidate_node_ids: candidateNodeIds,
         evidence: unknownSemanticEvidence(context.file, location),
-    }));
+    }, context.state.evidenceContexts));
 };

package/dist/application/javascript/JavaScriptSemanticGraphConstruction.js

@@ -1,25 +1,22 @@
 import { javascriptDisplayText } from "../../domain/javascript/javascriptAstValues.js";
-import { createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphRelation, javaScriptSemanticNodeId, } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphRelation, JavaScriptSemanticEvidenceContextRegistry, javaScriptSemanticNodeId, } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { inferredSemanticEvidence, observedSemanticEvidence, unavailableSemanticRootEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
-/** Create empty projection state with structural application-node mappings. */
-export const createSemanticGraphProjectionState = (applicationGraph) => {
-    const index = indexApplicationNodes(applicationGraph.nodes);
-    return {
-        nodes: new Map(),
-        relations: new Map(),
-        unknowns: new Map(),
-        roots: new Set(),
-        applicationNodeIdsByLocation: index.identifiers,
-    };
-};
+/** Create empty projection state; application-node links are bound at finish. */
+export const createSemanticGraphProjectionState = () => ({
+    nodes: new Map(),
+    relations: new Map(),
+    unknowns: new Map(),
+    evidenceContexts: new JavaScriptSemanticEvidenceContextRegistry(),
+    roots: new Set(),
+});
 /** Bind retained semantic identities after all application observations exist. */
 export const bindSemanticGraphApplicationNodes = (state, applicationGraph) => {
-    const index = indexApplicationNodes(applicationGraph.nodes).identifiers;
+    const applicationNodeIdsByLocation = indexApplicationNodes(applicationGraph.nodes);
     for (const [identifier, node] of state.nodes) {
         state.nodes.set(identifier, {
             ...node,
             application_node_ids: [
-                ...(index.get(applicationLocationKey(node.identity.artifact_sha256, node.identity.module_path, node.identity.source_range)) ?? []),
+                ...(applicationNodeIdsByLocation.get(applicationLocationKey(node.identity.artifact_sha256, node.identity.module_path, node.identity.source_range)) ?? []),
             ],
         });
     }
@@ -34,11 +31,11 @@ export const constructSemanticGraphNode = (file, input, state) => createJavaScri
         role_key: input.roleKey,
     },
     function_node_id: input.functionNodeId,
-    application_node_ids: matchingApplicationNodeIds(file, input, state),
+    application_node_ids: [],
     label: input.label === null ? null : javascriptDisplayText(input.label),
     properties: input.properties ?? {},
     evidence: observedSemanticEvidence(file, input.location),
-});
+}, state.evidenceContexts);
 /** Reuse retained identities and reject exhausted budgets before allocation. */
 export const retainSemanticGraphNode = (state, file, input) => {
     const identifier = javaScriptSemanticNodeId({
@@ -89,8 +86,9 @@ export const addSemanticGraphRelation = (state, input) => {
         relation: input.relation,
         resolution: input.resolution ?? "candidate",
         properties: input.properties ?? {},
-        evidence: input.evidence ?? inferredSemanticEvidence(input.source),
-    });
+        evidence: input.evidence ??
+            inferredSemanticEvidence(state.evidenceContexts.resolve(input.source.evidence)),
+    }, state.evidenceContexts);
     if (state.relations.has(value.relation_id))
         return;
     state.relations.set(value.relation_id, value);
@@ -116,7 +114,7 @@ export const addSemanticFallbackRoot = (rootArtifactSha256, state) => {
         label: "unavailable semantic root",
         properties: {},
         evidence: unavailableSemanticRootEvidence(rootArtifactSha256),
-    }));
+    }, state.evidenceContexts));
     if (node !== null)
         state.roots.add(node.node_id);
 };
@@ -142,11 +140,8 @@ const indexApplicationNodes = (nodes) => {
         const sorted = [...values].sort();
         return [key, sorted];
     }));
-    return { identifiers: indexed };
+    return indexed;
 };
-const matchingApplicationNodeIds = (file, input, state) => [
-    ...(state.applicationNodeIdsByLocation.get(applicationLocationKey(file.sha256, file.path, input.location)) ?? []),
-];
 const addApplicationNodeIdentifier = (identifiers, key, nodeId) => {
     const values = identifiers.get(key) ?? new Set();
     values.add(nodeId);

package/dist/application/javascript/JavaScriptSemanticGraphDataProjection.js

@@ -97,7 +97,10 @@ const addRequestNode = (context, operation) => retainSemanticGraphNode(context.s
     kind: operation.kind === "request" ? "request" : "response",
     roleKey: operation.requestId,
     location: operation.location,
-    label: operation.endpoint ?? operation.method,
+    label: operation.endpoint !== null &&
+        operation.endpoint.length <= operation.method.length
+        ? operation.endpoint
+        : operation.method,
     functionNodeId: operation.ownerCallableId === null
         ? null
         : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??
@@ -209,5 +212,5 @@ const addDataUnknown = (input) => {
         detail,
         candidate_node_ids: candidateNodeIds,
         evidence: unknownSemanticEvidence(context.file, location),
-    }));
+    }, context.state.evidenceContexts));
 };

package/dist/application/javascript/JavaScriptSemanticGraphEvidence.js

@@ -32,7 +32,7 @@ export const observedSemanticEvidence = (file, location) => ({
 });
 /** Conservative static relationship evidence derived from one syntax node. */
 export const inferredSemanticEvidence = (source) => ({
-    ...source.evidence,
+    ...source,
     authority: "static-relationship-inference",
     state: "inferred",
     confidence: "high",

package/dist/application/javascript/JavaScriptSemanticGraphFingerprintProjection.js

@@ -1,7 +1,7 @@
 import { createJavaScriptSemanticFingerprint, } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { observedSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 /** Bind domain fingerprint components to exact semantic function nodes. */
-export const projectSemanticFunctionFingerprints = (file, ir, callableNodes) => ir.functionFingerprints.flatMap((fingerprint) => {
+export const projectSemanticFunctionFingerprints = (file, ir, callableNodes, evidenceContexts) => ir.functionFingerprints.flatMap((fingerprint) => {
     const callable = callableNodes.get(fingerprint.callableId);
     if (callable === undefined)
         return [];
@@ -20,6 +20,6 @@ export const projectSemanticFunctionFingerprints = (file, ir, callableNodes) =>
             },
             limitations: fingerprint.limitations,
             evidence: observedSemanticEvidence(file, callable.identity.source_range),
-        }),
+        }, evidenceContexts),
     ];
 });

package/dist/application/javascript/JavaScriptSemanticGraphFlowProjection.js

@@ -119,7 +119,7 @@ const addPromiseUnknown = (context, operation, promise, promiseNodes) => {
             return candidate === undefined ? [] : [candidate.node_id];
         }),
         evidence: unknownSemanticEvidence(context.file, operation.location),
-    }));
+    }, context.state.evidenceContexts));
 };
 /** Link direct return expressions to their retained semantic references. */
 export const projectSemanticReturnValues = (context) => {
@@ -151,8 +151,10 @@ export const projectSemanticClosureCaptures = (context) => {
         });
 };
 /** Retain bounded unresolved dynamic-call, dynamic-property and dynamic-scope frontiers. */
-export const projectSemanticFrontiers = (context) => {
-    for (const frontier of context.ir.frontiers) {
+export function* projectSemanticFrontiers(context) {
+    for (const [index, frontier] of context.ir.frontiers.entries()) {
+        if (index % 64 === 0)
+            yield;
         // Dynamic environments leave identifier reads and writes unresolved.
         const family = frontier.kind === "dynamic-call"
             ? "call-flow"
@@ -175,7 +177,7 @@ export const projectSemanticFrontiers = (context) => {
             detail: frontier.reason,
             candidate_node_ids: [],
             evidence: unknownSemanticEvidence(context.file, frontier.location),
-        });
+        }, context.state.evidenceContexts);
         addSemanticGraphUnknown(context.state, unknown);
     }
-};
+}

package/dist/application/javascript/JavaScriptSemanticGraphObjectProjection.js

@@ -4,9 +4,11 @@ import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnkn
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 import { semanticPropertySlot } from "./JavaScriptSemanticGraphValueProjection.js";
 /** Project static object reads, writes, spreads, and destructuring. */
-export const projectSemanticObjects = (context) => {
+export function* projectSemanticObjects(context) {
     const values = new Map(context.ir.bindings.map((binding) => [binding.bindingId, binding.value]));
-    for (const operation of context.ir.objectOperations) {
+    for (const [index, operation] of context.ir.objectOperations.entries()) {
+        if (index % 64 === 0)
+            yield;
         const occurrence = addObjectOccurrence(context, operation);
         const target = objectTarget(context, values, operation);
         const ends = objectRelationEnds(context, operation, occurrence, target);
@@ -22,7 +24,7 @@ export const projectSemanticObjects = (context) => {
         if (!resolved)
             addObjectUnknown(context, operation, target.slot ?? occurrence, target);
     }
-};
+}
 const OBJECT_RELATIONS = {
     read: "reads-property",
     write: "writes-property",
@@ -106,5 +108,5 @@ const addObjectUnknown = (context, operation, node, target) => {
         detail: `Static ${operation.kind} property ${operation.propertyPath === null ? "path is unresolved" : semanticPropertyPointer(operation.propertyPath)} has ${target.presence} presence; its receiver is ${target.receiverResolved ? "a retained container" : "unresolved or not a retained container"}; object identity is ${operation.resolution}.`,
         candidate_node_ids: [],
         evidence: unknownSemanticEvidence(context.file, operation.location),
-    }));
+    }, context.state.evidenceContexts));
 };

package/dist/application/javascript/JavaScriptSemanticGraphProjection.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../../domain/canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 import { JAVASCRIPT_SEMANTIC_RELATION_FAMILIES } from "../../domain/javascript/javascriptSemanticGraphSchemas.js";
 /** Index one immutable file IR; read retained callable membership at query time. */
 export const createSemanticCallableOwnerLookup = (ir, nodes) => {
@@ -29,7 +29,7 @@ export const createSemanticCallableOwnerLookup = (ir, nodes) => {
                 const node = nodes.get(candidate.callableId);
                 const rank = best === undefined
                     ? 1
-                    : compareCodePoints(candidate.priority, best.priority) ||
+                    : compareUnicodeCodePoints(candidate.priority, best.priority) ||
                         best.order - candidate.order;
                 if (node !== undefined && rank > 0) {
                     best = candidate;
@@ -120,7 +120,7 @@ export const createSemanticCallSiteLookup = (ir, nodes) => {
 };
 const rangeKey = (range) => `${range.start.line}:${range.start.column}-${range.end.line}:${range.end.column}`;
 /** Report extractor support without treating missing families as absence. */
-export const semanticFamilyStatus = (family, analysis) => {
+export const semanticFamilyStatus = (family) => {
     if (![
         "call-flow",
         "boundary",
@@ -136,7 +136,7 @@ export const semanticFamilyStatus = (family, analysis) => {
         "timer",
     ].includes(family))
         return "unsupported";
-    return analysis.truncated_scopes === 0 ? "partial" : "unknown";
+    return "partial";
 };
 const contains = (outer, inner) => pointCompare(outer.start, inner.start) <= 0 &&
     pointCompare(outer.end, inner.end) >= 0;

package/dist/application/javascript/JavaScriptSemanticGraphResourceProjection.js

@@ -54,5 +54,5 @@ const projectRelease = (context, operation, resourceNodes) => {
         detail: `Static ${operation.method} resource ownership is ambiguous.`,
         candidate_node_ids: resources.map(({ node_id: identifier }) => identifier),
         evidence: unknownSemanticEvidence(context.file, operation.location),
-    }));
+    }, context.state.evidenceContexts));
 };