rea-agents 6.4.0 → 6.7.0

package/dist/application/javascript/JavaScriptSemanticGraphBuilder.js

@@ -1,4 +1,4 @@
-import { createJavaScriptSemanticGraph, createJavaScriptSemanticGraphUnknown, sealTransferredJavaScriptSemanticGraphSteps, } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { createJavaScriptSemanticGraph, 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";
@@ -7,14 +7,16 @@ import { projectSemanticBoundaries, projectSemanticConfiguration, projectSemanti
 import { projectSemanticResources } from "./JavaScriptSemanticGraphResourceProjection.js";
 import { projectSemanticObjects } from "./JavaScriptSemanticGraphObjectProjection.js";
 import { projectSemanticValues } from "./JavaScriptSemanticGraphValueProjection.js";
-import { inferredSemanticEvidenceAt } from "./JavaScriptSemanticGraphEvidence.js";
-import { observedSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { inferredSemanticEvidenceAt, observedSemanticEvidence, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticCoverageResourceLimits, semanticResourceLimitCoverage, } from "../../domain/javascript/javascriptSemanticCoverage.js";
+import { semanticResourceLimitReason } from "../../domain/javascript/javascriptSemanticResourceLimits.js";
 import { partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
-import { javaScriptAnalysisCoverageLimits } from "../../domain/javascript/javascriptAnalysisResourceControls.js";
+import { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_SEMANTIC_ITEM_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 { addSemanticFallbackRoot as addFallbackRoot, addSemanticGraphUnknown, recordSemanticUnknownOmission, 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.
  *
@@ -28,51 +30,71 @@ 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 = () => {
+export const createJavaScriptSemanticGraphProjection = (limits = {}) => {
+    const nodeCeiling = limits.totalNodes ?? SEMANTIC_GRAPH_NODE_CEILING;
+    const fileNodeCeiling = limits.fileNodes ?? SEMANTIC_GRAPH_FILE_NODE_CEILING;
+    const unknownCeiling = limits.totalUnknowns ??
+        JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticUnknowns;
+    const fileUnknownCeiling = limits.fileUnknowns ??
+        JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticUnknownsPerFile;
+    for (const value of [
+        nodeCeiling,
+        fileNodeCeiling,
+        unknownCeiling,
+        fileUnknownCeiling,
+    ])
+        if (!Number.isSafeInteger(value) ||
+            value < 1 ||
+            value > JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM)
+            throw new RangeError("Semantic graph requires valid retained capacities");
     const state = emptyState();
     const fingerprints = [];
     let truncatedFiles = 0;
     let unavailableFiles = 0;
     let resourceTruncatedFiles = 0;
     const executionLimits = new Map();
-    const projectSourceSteps = function* (file, ir) {
-        if (state.nodes.size >= SEMANTIC_GRAPH_NODE_CEILING) {
+    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(...(yield* projectFileSteps(file, ir, state)));
+        state.unknownCapacity = Math.min(unknownCeiling, state.unknowns.size + fileUnknownCeiling);
+        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.
         if (state.fileNodesDropped)
             truncatedFiles += 1;
         state.fileNodeBudget = null;
+        state.unknownCapacity = null;
     };
     const finishWith = (factory, rootArtifactSha256, applicationGraph) => {
         bindSemanticGraphApplicationNodes(state, applicationGraph);
@@ -80,6 +102,8 @@ export const createJavaScriptSemanticGraphProjection = () => {
             addFallbackRoot(rootArtifactSha256, state);
         const relations = [...state.relations.values()];
         const unknowns = [...state.unknowns.values()];
+        const unknownOmissions = [...state.unknownOmissions.values()];
+        const unknownsDropped = unknownOmissions.length > 0;
         const retainedByFamily = new Map();
         const unknownIdsByFamily = new Map();
         for (const relation of relations) {
@@ -105,17 +129,41 @@ export const createJavaScriptSemanticGraphProjection = () => {
             fingerprints: [...fingerprints],
             unknowns,
             coverage: {
-                status: truncatedFiles > 0 || unavailableFiles > 0 ? "partial" : "unknown",
-                truncated: truncatedFiles > 0 || resourceTruncatedFiles > 0,
+                status: truncatedFiles > 0 || unavailableFiles > 0 || unknownsDropped
+                    ? "partial"
+                    : "unknown",
+                truncated: truncatedFiles > 0 || resourceTruncatedFiles > 0 || unknownsDropped,
+                ...(unknownsDropped
+                    ? { omitted_unknown_occurrences: unknownOmissions }
+                    : {}),
                 omitted_nodes: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
                 omitted_relations: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
                 limits: [
                     ...executionLimits.values(),
+                    ...(unknownsDropped
+                        ? [
+                            {
+                                name: "semantic_graph_unknown_ceiling",
+                                value: unknownCeiling,
+                                unit: "items",
+                            },
+                            {
+                                name: "semantic_graph_file_unknown_ceiling",
+                                value: fileUnknownCeiling,
+                                unit: "items",
+                            },
+                        ]
+                        : []),
                     ...(truncatedFiles > 0
                         ? [
                             {
                                 name: "semantic_graph_node_ceiling",
-                                value: SEMANTIC_GRAPH_NODE_CEILING,
+                                value: nodeCeiling,
+                                unit: "items",
+                            },
+                            {
+                                name: "semantic_graph_file_node_ceiling",
+                                value: fileNodeCeiling,
                                 unit: "items",
                             },
                         ]
@@ -130,6 +178,11 @@ export const createJavaScriptSemanticGraphProjection = () => {
                 })),
             },
             limitations: [
+                ...(unknownsDropped
+                    ? [
+                        "Semantic unknown retention reached an effective capacity. Omission coverage counts examined emission occurrences by family and reason, including repeats; it does not count unexamined source frontiers or distinct discarded identities.",
+                    ]
+                    : []),
                 "The semantic graph contains static syntax observations and conservative relationship candidates; it does not claim runtime execution.",
                 "Local data flow does not claim control-flow-sensitive reaching definitions or arbitrary dynamic property resolution.",
                 "Promise ownership covers explicit unshadowed Promise construction, static factories, aggregation, chaining, and await syntax only.",
@@ -146,38 +199,52 @@ export const createJavaScriptSemanticGraphProjection = () => {
         state.nodes.clear();
         state.relations.clear();
         state.unknowns.clear();
+        state.unknownOmissions.clear();
         state.roots.clear();
         state.evidenceContexts.clear();
         fingerprints.length = 0;
         return graph;
     };
     return {
-        remainingFileNodeBudget: () => Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, Math.max(0, SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size)),
+        remainingFileCapacity: () => ({
+            nodes: Math.min(fileNodeCeiling, Math.max(0, nodeCeiling - state.nodes.size)),
+            unknowns: Math.min(fileUnknownCeiling, Math.max(0, unknownCeiling - state.unknowns.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))
+                Math.min(fileNodeCeiling, nodeCeiling - state.nodes.size))
                 throw new RangeError("Transferred semantic nodes exceed the offered tree capacity");
+            const newUnknowns = projection.unknowns.filter(({ unknown_id }) => !state.unknowns.has(unknown_id));
+            if (newUnknowns.length >
+                Math.min(fileUnknownCeiling, unknownCeiling - state.unknowns.size))
+                throw new RangeError("Transferred semantic unknowns exceed the offered tree capacity");
+            for (const omission of projection.omittedUnknownOccurrences ?? [])
+                recordSemanticUnknownOmission(state, omission);
             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)
+            for (const unknown of newUnknowns)
                 state.unknowns.set(unknown.unknown_id, unknown);
             for (const root of projection.roots)
                 state.roots.add(root);
             fingerprints.push(...projection.fingerprints);
-            if (projection.truncated)
+            if (projection.nodesTruncated)
                 truncatedFiles += 1;
         },
         recordUnavailableFile: (file, reason, limits, unknownReason) => {
+            // Both full and incremental construction enter here. Metadata/native
+            // processing gaps belong to the application graph, never JavaScript IR.
+            if (file.kind !== "javascript")
+                return;
             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));
+            state.fileNodeBudget = Math.min(fileNodeCeiling, Math.max(0, nodeCeiling - state.nodes.size));
             const module = retainNode(state, file, {
                 kind: "module",
                 roleKey: "module",
@@ -196,8 +263,9 @@ export const createJavaScriptSemanticGraphProjection = () => {
                 coverage: partialApplicationCoverage(retainedLimits, null),
                 limitations: [reason],
             };
+            state.unknownCapacity = Math.min(unknownCeiling, state.unknowns.size + fileUnknownCeiling);
             for (const family of JAVASCRIPT_SEMANTIC_RELATION_FAMILIES) {
-                const unknown = createJavaScriptSemanticGraphUnknown({
+                addSemanticGraphUnknown(state, {
                     node_id: module?.node_id ?? null,
                     family,
                     relation_kinds: JAVASCRIPT_SEMANTIC_RELATIONS.filter((relation) => JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation] === family),
@@ -205,15 +273,15 @@ export const createJavaScriptSemanticGraphProjection = () => {
                     detail: reason,
                     candidate_node_ids: [],
                     evidence,
-                }, state.evidenceContexts);
-                state.unknowns.set(unknown.unknown_id, unknown);
+                });
             }
+            state.unknownCapacity = null;
             unavailableFiles += 1;
             if (unknownReason === "resource-limit" && retainedLimits.length > 0)
                 resourceTruncatedFiles += 1;
         },
-        projectFile: (file, ir) => {
-            const steps = projectSourceSteps(file, ir);
+        projectFile: (file, ir, paths) => {
+            const steps = projectSourceSteps(file, ir, paths);
             while (steps.next().done !== true)
                 ;
         },
@@ -222,16 +290,17 @@ export const createJavaScriptSemanticGraphProjection = () => {
         finishImmutableSteps: (rootArtifactSha256, applicationGraph) => finishWith(sealTransferredJavaScriptSemanticGraphSteps, rootArtifactSha256, applicationGraph),
     };
 };
-/** 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");
+/** Project one source with the parent's remaining retained capacities, retaining no full IR. */
+export function* projectJavaScriptSemanticFileSteps(file, ir, capacity, paths = []) {
+    if ([capacity.nodes, capacity.unknowns].some((value) => !Number.isSafeInteger(value) ||
+        value < 0 ||
+        value > JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM))
+        throw new RangeError("File semantic projection requires valid offered retained capacities");
     const state = emptyState();
-    state.fileNodeBudget = nodeBudget;
+    state.fileNodeBudget = capacity.nodes;
+    state.unknownCapacity = capacity.unknowns;
     state.fileNodesDropped = false;
-    const fingerprints = yield* projectFileSteps(file, ir, state);
+    const fingerprints = yield* projectFileSteps(file, ir, state, paths);
     return {
         roots: [...state.roots],
         evidenceContexts: state.evidenceContexts.contexts,
@@ -239,10 +308,13 @@ export function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget) {
         relations: [...state.relations.values()],
         unknowns: [...state.unknowns.values()],
         fingerprints,
-        truncated: Boolean(state.fileNodesDropped),
+        ...(state.unknownOmissions.size > 0
+            ? { omittedUnknownOccurrences: [...state.unknownOmissions.values()] }
+            : {}),
+        nodesTruncated: Boolean(state.fileNodesDropped),
     };
 }
-function* projectFileSteps(file, ir, state) {
+function* projectFileSteps(file, ir, state, paths = []) {
     yield;
     const moduleNode = retainNode(state, file, {
         kind: "module",
@@ -254,6 +326,8 @@ function* projectFileSteps(file, ir, state) {
     if (moduleNode === null)
         return [];
     state.roots.add(moduleNode.node_id);
+    projectFileResourceLimits({ file, ir, state, moduleNode });
+    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();
@@ -327,6 +401,27 @@ function* projectFileSteps(file, ir, state) {
     yield;
     return projectSemanticFunctionFingerprints(file, ir, callableNodes, state.evidenceContexts);
 }
+const projectFileResourceLimits = (context) => {
+    // Getter limits describe query effects without tagged values; other limits
+    // already project from binding or return-site values and must not be duplicated.
+    for (const limit of semanticCoverageResourceLimits(context.ir.coverage)) {
+        if (limit !== "getter-expansion")
+            continue;
+        addSemanticGraphUnknown(context.state, {
+            node_id: context.moduleNode.node_id,
+            family: "data-flow",
+            relation_kinds: ["defines"],
+            reason: "resource-limit",
+            detail: semanticResourceLimitReason(limit),
+            candidate_node_ids: [],
+            evidence: {
+                ...unknownSemanticEvidence(context.file, null),
+                coverage: partialApplicationCoverage(semanticResourceLimitCoverage([limit]), null),
+                limitations: [semanticResourceLimitReason(limit)],
+            },
+        });
+    }
+};
 function* createReturnSiteNodes(file, ir, callables, state) {
     const result = new Map();
     for (const [index, callable] of ir.callables.entries()) {
@@ -418,7 +513,7 @@ function* projectDefinitionsAndReferences(context) {
                 resolution: "resolved",
                 evidence: inferredSemanticEvidenceAt(context.file, reference.location),
             });
-        else
+        else if (reference.role === "write")
             addRelation(context.state, {
                 source: expression,
                 target: binding,

package/dist/application/javascript/JavaScriptSemanticGraphChildProcessProjection.js

@@ -1,4 +1,3 @@
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 /** Project child creation, argv/env/stdio, listeners, and signals. */
@@ -73,6 +72,16 @@ const projectSpawn = (context, spawn, child) => {
         relation: "connects-stdio",
         resolution: spawn.stdioMode === "dynamic" ? "candidate" : "resolved",
     });
+    if (spawn.stdioMode === "dynamic")
+        addChildUnknown({
+            context,
+            node: child,
+            location: spawn.location,
+            relationKinds: ["connects-stdio"],
+            reason: "unknown-value",
+            detail: `Static ${spawn.method} stdio options remain unresolved.`,
+            candidateNodeIds: [],
+        });
     if (spawn.resolution !== "complete")
         addChildUnknown({
             context,
@@ -153,13 +162,13 @@ const addSignalNode = (context, interaction) => retainSemanticGraphNode(context.
 });
 const addChildUnknown = (input) => {
     const { context, node, location, relationKinds, detail, candidateNodeIds } = input;
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: node?.node_id ?? null,
         family: "child-process",
         relation_kinds: relationKinds,
-        reason: "ambiguous-target",
+        reason: input.reason ?? "ambiguous-target",
         detail,
         candidate_node_ids: candidateNodeIds,
         evidence: unknownSemanticEvidence(context.file, location),
-    }, context.state.evidenceContexts));
+    });
 };

package/dist/application/javascript/JavaScriptSemanticGraphConstruction.js

@@ -1,11 +1,13 @@
 import { javascriptDisplayText } from "../../domain/javascript/javascriptAstValues.js";
-import { createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphRelation, JavaScriptSemanticEvidenceContextRegistry, javaScriptSemanticNodeId, } from "../../domain/javascript/javascriptSemanticGraph.js";
+import { createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphUnknown, createJavaScriptSemanticGraphRelation, JavaScriptSemanticEvidenceContextRegistry, javaScriptSemanticNodeId, } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { inferredSemanticEvidence, observedSemanticEvidence, unavailableSemanticRootEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
 /** Create empty projection state; application-node links are bound at finish. */
 export const createSemanticGraphProjectionState = () => ({
     nodes: new Map(),
     relations: new Map(),
     unknowns: new Map(),
+    unknownCapacity: null,
+    unknownOmissions: new Map(),
     evidenceContexts: new JavaScriptSemanticEvidenceContextRegistry(),
     roots: new Set(),
 });
@@ -93,8 +95,26 @@ export const addSemanticGraphRelation = (state, input) => {
         return;
     state.relations.set(value.relation_id, value);
 };
-/** Retain one unresolved frontier. */
-export const addSemanticGraphUnknown = (state, unknown) => {
+/** Aggregate examined omissions without retaining unbounded discarded identities. */
+export const recordSemanticUnknownOmission = (state, omission) => {
+    const key = `${omission.family}:${omission.reason}`;
+    const occurrences = (state.unknownOmissions.get(key)?.occurrences ?? 0) + omission.occurrences;
+    if (!Number.isSafeInteger(occurrences))
+        throw new RangeError("Semantic unknown omission count overflow");
+    state.unknownOmissions.set(key, { ...omission, occurrences });
+};
+/** Admit unknown provenance only while its independent retained capacity allows it. */
+export const addSemanticGraphUnknown = (state, input) => {
+    if (state.unknownCapacity !== null &&
+        state.unknowns.size >= state.unknownCapacity) {
+        recordSemanticUnknownOmission(state, {
+            family: input.family,
+            reason: input.reason,
+            occurrences: 1,
+        });
+        return;
+    }
+    const unknown = createJavaScriptSemanticGraphUnknown(input, state.evidenceContexts);
     if (state.unknowns.has(unknown.unknown_id))
         return;
     state.unknowns.set(unknown.unknown_id, unknown);

package/dist/application/javascript/JavaScriptSemanticGraphDataProjection.js

@@ -1,6 +1,6 @@
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
+import { semanticResourceLimitReason } from "../../domain/javascript/javascriptSemanticResourceLimits.js";
 /** Project environment, argv, file, default, and precedence candidates. */
 export const projectSemanticConfiguration = (context) => {
     const configNodes = new Map(context.ir.configurationOperations.flatMap((operation) => {
@@ -35,7 +35,16 @@ export const projectSemanticConfiguration = (context) => {
                     ...(operation.kind === "default" ? ["overrides"] : []),
                 ],
                 location: operation.location,
-                detail: `Static ${operation.kind} configuration identity is partial.`,
+                ...(operation.valueResourceLimit === undefined
+                    ? {
+                        detail: operation.kind === "default"
+                            ? "Static default configuration value is partial."
+                            : `Static ${operation.kind} configuration identity is partial.`,
+                    }
+                    : {
+                        reason: "resource-limit",
+                        detail: semanticResourceLimitReason(operation.valueResourceLimit),
+                    }),
                 candidateNodeIds: [],
             });
     }
@@ -53,6 +62,9 @@ const addConfigurationNode = (context, operation) => retainSemanticGraphNode(con
         key: operation.key,
         source_kind: operation.kind,
         value: operation.value,
+        ...(operation.valueResourceLimit === undefined
+            ? {}
+            : { value_resource_limit: operation.valueResourceLimit }),
     },
 });
 const configurationRelation = (operation) => operation.kind === "environment"
@@ -195,6 +207,7 @@ const addBoundaryNode = (context, operation) => retainSemanticGraphNode(context.
             null),
     properties: {
         boundary_kind: operation.kind,
+        field: operation.method,
         method: operation.method,
     },
 });
@@ -204,13 +217,13 @@ const bindingOrOwner = (context, bindingId, callableId) => (bindingId === null ?
         : (context.callableNodes.get(callableId) ?? context.moduleNode));
 const addDataUnknown = (input) => {
     const { context, node, family, relationKinds, location, detail, candidateNodeIds, } = input;
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: node.node_id,
         family,
         relation_kinds: relationKinds,
-        reason: "ambiguous-target",
+        reason: input.reason ?? "ambiguous-target",
         detail,
         candidate_node_ids: candidateNodeIds,
         evidence: unknownSemanticEvidence(context.file, location),
-    }, context.state.evidenceContexts));
+    });
 };

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

@@ -1,4 +1,3 @@
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { sourceRangesEqual } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { inferredSemanticEvidenceAt, unknownSemanticEvidence, } from "./JavaScriptSemanticGraphEvidence.js";
@@ -108,7 +107,7 @@ const projectPromiseOwnership = (context, operation, promise) => {
 };
 const addPromiseUnknown = (context, operation, promise, promiseNodes) => {
     const relation = operation.kind === "aggregate" ? "aggregates" : "chains";
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: promise.node_id,
         family: "promise-ownership",
         relation_kinds: [relation],
@@ -119,7 +118,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) => {
@@ -166,7 +165,7 @@ export function* projectSemanticFrontiers(context) {
             : frontier.kind === "dynamic-scope"
                 ? ["reads", "writes"]
                 : ["reads-property", "writes-property"];
-        const unknown = createJavaScriptSemanticGraphUnknown({
+        addSemanticGraphUnknown(context.state, {
             node_id: frontier.callableId === null
                 ? context.moduleNode.node_id
                 : (context.callableNodes.get(frontier.callableId)?.node_id ??
@@ -177,7 +176,6 @@ export function* 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

@@ -1,5 +1,4 @@
 import { semanticSlotAtPath, semanticContainer, semanticPropertyPointer, } from "../../domain/javascript/javascriptSemanticSlots.js";
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 import { semanticPropertySlot } from "./JavaScriptSemanticGraphValueProjection.js";
@@ -100,7 +99,7 @@ const addObjectOccurrence = (context, operation) => retainSemanticGraphNode(cont
 });
 const addObjectUnknown = (context, operation, node, target) => {
     const relation = OBJECT_RELATIONS[operation.kind];
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: node?.node_id ?? null,
         family: "object-flow",
         relation_kinds: [relation],
@@ -108,5 +107,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/JavaScriptSemanticGraphResourceProjection.js

@@ -1,4 +1,3 @@
-import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
 /** Project built-in resource acquisition and exact local release handles. */
@@ -46,7 +45,7 @@ const projectRelease = (context, operation, resourceNodes) => {
         });
     if (operation.resolution === "complete")
         return;
-    addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+    addSemanticGraphUnknown(context.state, {
         node_id: callSite?.node_id ?? null,
         family: "resource-lifecycle",
         relation_kinds: ["releases"],
@@ -54,5 +53,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));
+    });
 };