rea-agents 6.3.0 → 6.5.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,10 +8,14 @@ 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 { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_SEMANTIC_NODE_MAXIMUM, 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";
 import { addSemanticFallbackRoot as addFallbackRoot, retainSemanticGraphNode as retainNode, addSemanticGraphRelation as addRelation, createSemanticGraphProjectionState as emptyState, bindSemanticGraphApplicationNodes, } from "./JavaScriptSemanticGraphConstruction.js";
+import { projectElectronSemanticCallPaths } from "./JavaScriptSemanticGraphElectronProjection.js";
 /**
  * Resource-safety ceiling on retained semantic nodes.
  *
@@ -25,42 +29,54 @@ import { addSemanticFallbackRoot as addFallbackRoot, retainSemanticGraphNode as
  * (`truncated`, `omitted_nodes`, `omitted_relations`, `limits`) rather than
  * silently dropping data.
  *
- * Sizing: a retained semantic node costs roughly 3 KB once serialized, and V8
- * additionally caps a single string at 512 MB. The result is serialized after the
- * object graph is built and validated, so both phases must fit together. A single
- * minified vendor bundle can account for most of a tree's nodes, so a whole-tree
- * ceiling without a per-file ceiling does not bound the work. Both are applied.
+ * Defaults bound work even when ample heap is available. Callers may raise the
+ * capacities explicitly; isolated worker heap, bounded record transport and
+ * parent result admission independently constrain actual retained memory. The
+ * result uses incremental serialization rather than a single JSON string.
  */
-export const SEMANTIC_GRAPH_NODE_CEILING = 100_000;
+export const SEMANTIC_GRAPH_NODE_CEILING = JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticNodes;
 /**
  * Per-file share of the semantic node budget.
  *
  * Bound each source file independently so one large bundled library cannot
  * consume the whole tree's budget and starve the application's own modules.
  */
-export const SEMANTIC_GRAPH_FILE_NODE_CEILING = 20_000;
+export const SEMANTIC_GRAPH_FILE_NODE_CEILING = JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticNodesPerFile;
 export const buildJavaScriptSemanticGraph = ({ rootArtifactSha256, applicationGraph, analysis, }) => {
     const projection = createJavaScriptSemanticGraphProjection();
     for (const analyzed of analysis.files) {
         if (analyzed.semantic !== null)
-            projection.projectFile(analyzed.file, analyzed.semantic.ir);
+            projection.projectFile(analyzed.file, analyzed.semantic.ir, analyzed.javascript?.electron.call_paths);
+        else if (!analyzed.file.text.included &&
+            analyzed.file.text.reason === "outside-analysis-scope")
+            projection.recordUnavailableFile(analyzed.file, "Source was not analyzed because it is outside the caller-selected source_paths.", null, "incomplete-module");
     }
     return projection.finish(rootArtifactSha256, applicationGraph);
 };
 /** Accumulate semantic nodes while each source IR is still file-local. */
-export const createJavaScriptSemanticGraphProjection = () => {
-    const state = emptyState({ nodes: [] });
+export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
+    const nodeCeiling = limits.totalNodes ?? SEMANTIC_GRAPH_NODE_CEILING;
+    const fileNodeCeiling = limits.fileNodes ?? SEMANTIC_GRAPH_FILE_NODE_CEILING;
+    for (const value of [nodeCeiling, fileNodeCeiling])
+        if (!Number.isSafeInteger(value) ||
+            value < 1 ||
+            value > JAVASCRIPT_SEMANTIC_NODE_MAXIMUM)
+            throw new RangeError("Semantic graph requires valid node capacities");
+    const state = emptyState();
     const fingerprints = [];
     let truncatedFiles = 0;
-    const projectSource = (file, ir) => {
-        if (state.nodes.size >= SEMANTIC_GRAPH_NODE_CEILING) {
+    let unavailableFiles = 0;
+    let resourceTruncatedFiles = 0;
+    const executionLimits = new Map();
+    const projectSourceSteps = function* (file, ir, paths = []) {
+        if (state.nodes.size >= nodeCeiling) {
             truncatedFiles += 1;
             return;
         }
-        const remainingTreeBudget = SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size;
-        state.fileNodeBudget = Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, remainingTreeBudget);
+        const remainingTreeBudget = nodeCeiling - state.nodes.size;
+        state.fileNodeBudget = Math.min(fileNodeCeiling, remainingTreeBudget);
         state.fileNodesDropped = false;
-        fingerprints.push(...projectFile(file, ir, state));
+        fingerprints.push(...(yield* projectFileSteps(file, ir, state, paths)));
         // 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.
@@ -72,7 +88,21 @@ export const createJavaScriptSemanticGraphProjection = () => {
         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,
@@ -80,32 +110,38 @@ export const createJavaScriptSemanticGraphProjection = () => {
             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: nodeCeiling,
+                                unit: "items",
+                            },
+                            {
+                                name: "semantic_graph_file_node_ceiling",
+                                value: fileNodeCeiling,
+                                unit: "items",
+                            },
+                        ]
+                        : []),
+                ],
                 families: JAVASCRIPT_SEMANTIC_RELATION_FAMILIES.map((family) => ({
                     family,
                     status: semanticFamilyStatus(family),
-                    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),
+                    retained_relations: retainedByFamily.get(family) ?? 0,
+                    omitted_relations: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
+                    unknown_ids: unknownIdsByFamily.get(family) ?? [],
                 })),
             },
             limitations: [
@@ -131,12 +167,98 @@ export const createJavaScriptSemanticGraphProjection = () => {
         return graph;
     };
     return {
-        projectFile: projectSource,
+        remainingFileNodeBudget: () => Math.min(fileNodeCeiling, Math.max(0, nodeCeiling - state.nodes.size)),
+        adoptFileProjection: (projection) => {
+            const newNodes = projection.nodes.filter(({ node_id }) => !state.nodes.has(node_id));
+            if (newNodes.length >
+                Math.min(fileNodeCeiling, nodeCeiling - 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(fileNodeCeiling, Math.max(0, nodeCeiling - 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, paths) => {
+            const steps = projectSourceSteps(file, ir, paths);
+            while (steps.next().done !== true)
+                ;
+        },
+        projectFileSteps: projectSourceSteps,
         finish: (rootArtifactSha256, applicationGraph) => finishWith(createJavaScriptSemanticGraph, rootArtifactSha256, applicationGraph),
-        finishImmutableSteps: (rootArtifactSha256, applicationGraph) => finishWith(createImmutableJavaScriptSemanticGraphSteps, 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, paths = []) {
+    if (!Number.isSafeInteger(nodeBudget) ||
+        nodeBudget < 0 ||
+        nodeBudget > JAVASCRIPT_SEMANTIC_NODE_MAXIMUM)
+        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, paths);
+    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, paths = []) {
+    yield;
     const moduleNode = retainNode(state, file, {
         kind: "module",
         roleKey: "module",
@@ -147,7 +269,13 @@ const projectFile = (file, ir, state) => {
     if (moduleNode === null)
         return [];
     state.roots.add(moduleNode.node_id);
-    const callableNodes = new Map(ir.callables.flatMap((callable) => {
+    yield* projectElectronSemanticCallPaths(file, paths, state);
+    // 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}`,
@@ -157,10 +285,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);
@@ -171,10 +303,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,
@@ -193,29 +326,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);
+    // 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);
-};
-const createReturnSiteNodes = (file, ir, callables, state) => {
+}
+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;
@@ -233,10 +365,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);
@@ -251,9 +385,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;
@@ -274,6 +410,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}`,
@@ -296,7 +434,7 @@ const projectDefinitionsAndReferences = (context) => {
                 resolution: "resolved",
                 evidence: inferredSemanticEvidenceAt(context.file, reference.location),
             });
-        else
+        else if (reference.role === "write")
             addRelation(context.state, {
                 source: expression,
                 target: binding,
@@ -304,7 +442,7 @@ const projectDefinitionsAndReferences = (context) => {
                 resolution: "resolved",
             });
     }
-};
+}
 const projectCalls = (context) => {
     for (const call of context.ir.callSites) {
         const callNode = context.callSiteNodes.get(call.callSiteId);
@@ -371,3 +509,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/JavaScriptSemanticGraphConstruction.js

@@ -1,26 +1,22 @@
 import { javascriptDisplayText } from "../../domain/javascript/javascriptAstValues.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(),
-        evidenceContexts: new JavaScriptSemanticEvidenceContextRegistry(),
-        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)) ?? []),
             ],
         });
     }
@@ -35,7 +31,7 @@ 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),
@@ -144,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 ??

package/dist/application/javascript/JavaScriptSemanticGraphElectronProjection.js

@@ -0,0 +1,67 @@
+import { sha256Text } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
+import { addSemanticGraphRelation, retainSemanticGraphNode, } from "./JavaScriptSemanticGraphConstruction.js";
+import { inferredSemanticEvidenceAt } from "./JavaScriptSemanticGraphEvidence.js";
+/** Give discovered process-boundary paths budget before bulk library definitions. */
+export function* projectElectronSemanticCallPaths(file, paths, state) {
+    for (const path of paths) {
+        yield;
+        const pathId = sha256Text(JSON.stringify(path));
+        let previous = null;
+        let previousKind;
+        for (const [index, step] of path.steps.entries()) {
+            const node = retainSemanticGraphNode(state, file, {
+                kind: step.kind === "function"
+                    ? "function"
+                    : step.kind === "exposure"
+                        ? "boundary"
+                        : "call-site",
+                roleKey: `electron-path:${pathId}:${String(index)}`,
+                location: step.location,
+                label: step.label,
+                functionNodeId: null,
+                properties: {
+                    path_id: pathId,
+                    entry: path.entry,
+                    ...(path.entry_path === undefined
+                        ? {}
+                        : { entry_path: [...path.entry_path] }),
+                    channel: path.channel,
+                    terminal: path.terminal,
+                    step_kind: step.kind,
+                    resolution: "candidate",
+                    conditions: path.conditions.map((c) => ({
+                        expression: c.expression,
+                        location: {
+                            start: { ...c.location.start },
+                            end: { ...c.location.end },
+                        },
+                    })),
+                },
+            });
+            if (index === 0 && node !== null)
+                state.roots.add(node.node_id);
+            addSemanticGraphRelation(state, {
+                source: previous,
+                target: node,
+                relation: previousKind === "ipc"
+                    ? "registers-listener"
+                    : previousKind === "exposure" || previousKind === "factory"
+                        ? "aliases"
+                        : "calls",
+                resolution: "candidate",
+                evidence: inferredSemanticEvidenceAt(file, step.location),
+                properties: {
+                    path_id: pathId,
+                    entry: path.entry,
+                    ...(path.entry_path === undefined
+                        ? {}
+                        : { entry_path: [...path.entry_path] }),
+                    channel: path.channel,
+                    basis: "lexical-wrapper-substitution",
+                },
+            });
+            previous = node;
+            previousKind = step.kind;
+        }
+    }
+}

package/dist/application/javascript/JavaScriptSemanticGraphFlowProjection.js

@@ -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"
@@ -178,4 +180,4 @@ export const projectSemanticFrontiers = (context) => {
         }, 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",