rea-agents 6.4.0 → 6.5.0

package/dist/application/javascript/JavaScriptArtifactReconstruction.js

@@ -1,10 +1,12 @@
 import { constants } from "node:fs";
 import { access, lstat, realpath } from "node:fs/promises";
+import { setImmediate } from "node:timers/promises";
 import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
 import { AnalysisAccessDeniedError, AnalysisInputError, AnalysisUnsupportedTargetError, } from "../../domain/analysisErrorCore.js";
 import { createJavaScriptArtifactReader as createReader } from "../../artifacts/javascript/JavaScriptArtifactReader.js";
 import { parseOwnedJavaScriptApplicationAnalysisSteps } from "../../domain/javascript/javascriptApplicationAnalysis.js";
 import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { ArtifactOperationError } from "../../domain/artifactOperationError.js";
 import { analyzeAndAdoptJavaScriptArtifactFiles } from "./JavaScriptArtifactAnalysis.js";
 import { createJavaScriptSourceAnalysis } from "../../artifacts/javascript/JavaScriptSourceAnalysis.js";
 import { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS } from "../../domain/javascript/javascriptAnalysisResourceControls.js";
@@ -18,16 +20,14 @@ import { createJavaScriptSemanticGraphProjection } from "./JavaScriptSemanticGra
 import { checkpointJavaScriptAnalysis, completeJavaScriptAnalysisSteps, } from "./JavaScriptAnalysisControl.js";
 /** Reconstruct one local ASAR or extracted directory without executing code. */
 export const reconstructJavaScriptArtifact = async (rawInput, scope, signal, progress) => scope.run(async () => {
-    let effectiveSignal = signal;
-    let effectiveProgress = progress;
     const reportPhase = async (phase, message) => {
-        await effectiveProgress?.report({
+        await progress?.report({
             phase,
             completed: 0,
             total: 1,
             message,
         });
-        await checkpointJavaScriptAnalysis(effectiveSignal);
+        await checkpointJavaScriptAnalysis(signal);
     };
     const input = javascriptArtifactReconstructionInputSchema.parse(rawInput);
     abortIfNeeded(signal);
@@ -50,14 +50,21 @@ export const reconstructJavaScriptArtifact = async (rawInput, scope, signal, pro
     let reconstructionOutcome;
     try {
         await reportPhase("read_javascript_artifacts", "Reading inventoried JavaScript application sources");
-        const files = await readJavaScriptArtifactFiles(reader, snapshot, scope, signal);
+        const files = await readJavaScriptArtifactFiles(reader, snapshot, scope, signal, input.source_paths);
         // Release acquisition before analysis consumes these owned file facts.
         const earlyCleanup = await scope.release(readerOwner);
         readerOpen = false;
         if (earlyCleanup.kind === "failed")
             throw ArtifactReaderFailure.withCleanup(earlyCleanup.cause, ArtifactReaderFailure.cleanupObservation(earlyCleanup.cause, readerOwner.resource), { kind: "artifact-inventory", inventory: snapshot });
-        await reportPhase("parse_javascript_sources", `Parsing and projecting ${String(files.files.length)} application source files`);
-        const semanticProjection = createJavaScriptSemanticGraphProjection();
+        await reportPhase("parse_javascript_sources", `Parsing and projecting ${String(files.files.length - (files.source_selection?.unselected_files ?? 0))} selected application source files`);
+        const semanticProjection = createJavaScriptSemanticGraphProjection({
+            ...(input.max_semantic_nodes === undefined
+                ? {}
+                : { totalNodes: input.max_semantic_nodes }),
+            ...(input.max_semantic_nodes_per_file === undefined
+                ? {}
+                : { fileNodes: input.max_semantic_nodes_per_file }),
+        });
         const worker = createJavaScriptSourceAnalysis({
             heapMb: input.max_heap_mb ?? JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.heapMb,
             timeoutMs: input.analysis_timeout_ms ??
@@ -94,22 +101,29 @@ export const reconstructJavaScriptArtifact = async (rawInput, scope, signal, pro
             }
         }
         const analysis = outcome.analysis;
-        const interruption = cleanupFailure ?? outcome.interruption;
-        if (interruption !== null && interruption !== undefined) {
-            effectiveSignal = undefined;
-            effectiveProgress = undefined;
-        }
-        await checkpointJavaScriptAnalysis(effectiveSignal);
-        abortIfNeeded(effectiveSignal);
-        await reportPhase("build_javascript_application_graph", "Constructing application and Electron boundary relationships");
+        let interruption = cleanupFailure ?? outcome.interruption;
+        // Source facts are owned now. Finish their projection cooperatively so a
+        // later cancellation can retain Evidence instead of discarding those facts.
+        const checkpointCompletedAnalysis = async () => {
+            await setImmediate();
+            if (interruption == null && signal?.aborted === true)
+                interruption = new ArtifactOperationError(OPERATION, "cancelled");
+        };
+        const reportCompletedPhase = async (phase, message) => {
+            await checkpointCompletedAnalysis();
+            if (interruption == null)
+                await progress?.report({ phase, completed: 0, total: 1, message });
+            await checkpointCompletedAnalysis();
+        };
+        await reportCompletedPhase("build_javascript_application_graph", "Constructing application and Electron boundary relationships");
         const applicationGraphSteps = buildImmutableJavaScriptArtifactGraphSteps(snapshot, files, analysis);
-        await reportPhase("seal_javascript_application_graph", "Sealing the validated application graph");
-        const graph = await completeJavaScriptAnalysisSteps(applicationGraphSteps, effectiveSignal);
-        await reportPhase("build_javascript_semantic_graph", "Binding and validating static semantic relationships");
+        await reportCompletedPhase("seal_javascript_application_graph", "Sealing the validated application graph");
+        const graph = await completeJavaScriptAnalysisSteps(applicationGraphSteps);
+        await reportCompletedPhase("build_javascript_semantic_graph", "Binding and validating static semantic relationships");
         const semanticGraphSteps = semanticProjection.finishImmutableSteps(snapshot.manifest.root_sha256, graph);
-        await reportPhase("seal_javascript_semantic_graph", "Validating and sealing the semantic graph");
-        const semanticGraph = await completeJavaScriptAnalysisSteps(semanticGraphSteps, effectiveSignal);
-        await checkpointJavaScriptAnalysis(effectiveSignal);
+        await reportCompletedPhase("seal_javascript_semantic_graph", "Validating and sealing the semantic graph");
+        const semanticGraph = await completeJavaScriptAnalysisSteps(semanticGraphSteps);
+        await checkpointCompletedAnalysis();
         const completed = {
             input_path: path,
             format,
@@ -117,11 +131,16 @@ export const reconstructJavaScriptArtifact = async (rawInput, scope, signal, pro
             inventory_manifest_id: snapshot.manifest.manifest_id,
             inventory_graph_sha256: snapshot.manifest.graph_sha256,
             integrity_contradictions: snapshot.integrity_contradictions,
+            ...(files.source_selection === undefined
+                ? {}
+                : { source_selection: files.source_selection }),
             graph,
             semantic_graph: semanticGraph,
-            electron_summary: summarizeElectronBoundaries(analysis),
+            electron_summary: summarizeElectronBoundaries(analysis, new Set(snapshot.occurrences
+                .filter(({ entry_kind }) => entry_kind === "directory")
+                .map(({ logical_path }) => logical_path))),
             statistics: {
-                relevant_files: files.files.length,
+                relevant_files: files.files.length + files.unavailable_relevant_files.length,
                 nested_asar_containers: files.containers.length,
                 text_bytes_read: files.text_bytes_read,
                 invalid_utf8_files: files.invalid_utf8_files,
@@ -140,13 +159,7 @@ export const reconstructJavaScriptArtifact = async (rawInput, scope, signal, pro
                 summary,
                 limitations: completed.graph.limitations,
             }));
-            const { max_heap_mb, analysis_timeout_ms, ...coreInput } = input;
-            const parameters = {
-                ...coreInput,
-                ...(max_heap_mb === undefined ? {} : { max_heap_mb }),
-                ...(analysis_timeout_ms === undefined ? {} : { analysis_timeout_ms }),
-            };
-            const evidence = await createOwnedJavaScriptApplicationEvidenceCooperatively(parameters, partial);
+            const evidence = await createOwnedJavaScriptApplicationEvidenceCooperatively(input, partial);
             throw interruption.retainPartialObservation(evidence);
         }
         reconstructionOutcome = { kind: "completed", result: completed };

package/dist/application/javascript/JavaScriptArtifactReconstructionInput.js

@@ -1,10 +1,12 @@
 import { z } from "zod";
 import { artifactIntegrityPolicySchema } from "../../domain/artifactIntegrityPolicy.js";
 import { javaScriptAnalysisResourceControlsSchema } from "../../domain/javascript/javascriptAnalysisResourceControls.js";
+import { javaScriptSourcePathsSchema } from "../../domain/javascript/javascriptSourceSelection.js";
 /** Local ASAR/directory reconstruction request. */
 export const javascriptArtifactReconstructionInputSchema = z.strictObject({
     input_path: z.string().min(1),
     format: z.enum(["auto", "asar", "directory"]).default("auto"),
     integrity_policy: artifactIntegrityPolicySchema,
+    source_paths: javaScriptSourcePathsSchema.optional(),
     ...javaScriptAnalysisResourceControlsSchema.shape,
 });

package/dist/application/javascript/JavaScriptModuleRelationships.js

@@ -3,9 +3,10 @@ import { compareUnicodeCodePoints, compositeKey, } from "../../domain/unicodeCod
 import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { semanticCoverageResourceLimits, semanticResourceLimitCoverage, } from "../../domain/javascript/javascriptSemanticCoverage.js";
 import { semanticResourceLimitReason } from "../../domain/javascript/javascriptSemanticResourceLimits.js";
+import { moduleResolutionModeForJavaScriptReference } from "../../domain/javascript/javascriptModuleResolutionMode.js";
 import { addAstContainsEdge, artifactLocalIdentity, } from "./JavaScriptArtifactGraphContext.js";
 import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
-import { resolveArtifactPathByContext, } from "./JavaScriptArtifactPathResolution.js";
+import { artifactPathResolutionProperties, moduleResolutionModeProperties, resolveArtifactPathByContext, } from "./JavaScriptArtifactPathResolution.js";
 import { projectJavaScriptExportReturnShapes } from "../../domain/javascript/javascriptExportReturnShapeProjection.js";
 /** Create one path-scoped source-module identity for every analyzed source file. */
 export const addJavaScriptSourceModules = (context) => {
@@ -16,7 +17,10 @@ export const addJavaScriptSourceModules = (context) => {
         if (asset === undefined || semantic === null || program === undefined)
             continue;
         const exports = semantic.ir.moduleLinks
-            .flatMap(({ exportedName }) => exportedName === null ? [] : [exportedName])
+            .flatMap(({ exportedName, kind }) => exportedName === null || kind === "type-import" ? [] : [exportedName])
+            .sort(compareUnicodeCodePoints);
+        const typeExports = semantic.ir.moduleLinks
+            .flatMap(({ exportedName, kind }) => exportedName === null || kind !== "type-import" ? [] : [exportedName])
             .sort(compareUnicodeCodePoints);
         const retainedExports = [...new Set(exports)];
         const source = context.accumulator.addNode({
@@ -32,8 +36,10 @@ export const addJavaScriptSourceModules = (context) => {
                         logical_module_key: file.path,
                         module_format: moduleFormat(file.path, semantic.ir),
                         import_relationships: semantic.ir.moduleLinks.filter(({ kind }) => kind === "import" || kind === "require").length,
+                        type_relationships: semantic.ir.moduleLinks.filter(({ kind }) => kind === "type-import").length,
                         export_relationships: exports.length,
                         export_names: retainedExports,
+                        type_export_names: [...new Set(typeExports)],
                         omitted_export_names: 0,
                     },
                     evidence: astObservationEvidence({
@@ -69,6 +75,8 @@ export function* addJavaScriptModuleRelationshipsSteps(context) {
         for (const link of semantic.ir.moduleLinks) {
             // One module can export thousands of bindings, each with return shapes.
             yield;
+            if (link.kind === "type-import")
+                continue;
             const input = { context, file, semantic, source, link };
             if (isExportLink(link))
                 addExportRelationship(input, omissions);
@@ -173,17 +181,20 @@ const resolveModuleTarget = (input, specifier) => {
         sourcePath: input.file.path,
         context: "module-specifier",
         files: input.context.filesByPath,
-        moduleKind: input.link.kind === "require" || input.link.kind === "commonjs-export"
+        directoryPaths: input.context.directoryPaths,
+        unanalyzedFiles: input.context.unanalyzedFiles,
+        moduleKind: moduleResolutionModeForJavaScriptReference(input.file.path, input.link.kind === "require" || input.link.kind === "commonjs-export"
             ? "require"
-            : "import",
+            : "static-import", input.link.resolutionMode),
     });
     if (resolution.resolution_status !== "resolved")
         return {
-            node: unresolvedModuleNode(input, specifier, resolution.resolution_status),
+            node: unresolvedModuleNode(input, specifier, resolution),
             path: null,
             file: null,
             status: resolution.resolution_status,
             limitations: resolution.limitations,
+            resolution,
         };
     const path = resolution.resolved_path;
     const file = input.context.filesByPath.get(path);
@@ -197,18 +208,20 @@ const resolveModuleTarget = (input, specifier) => {
         file,
         status: "resolved",
         limitations: resolution.limitations,
+        resolution,
     };
 };
-const unresolvedModuleNode = (input, specifier, status) => input.context.accumulator.addNode({
+const unresolvedModuleNode = (input, specifier, resolution) => input.context.accumulator.addNode({
     kind: "javascript-module",
-    identity: artifactLocalIdentity(input.file.sha256, "unresolved-semantic-module", `${status}:${specifier}`),
+    identity: artifactLocalIdentity(input.file.sha256, "unresolved-semantic-module", `${resolution.resolution_status}:${specifier}`),
     observations: [
         {
             label: specifier,
             properties: {
                 semantic_role: "module-reference",
                 declared_specifier: specifier,
-                resolution_status: status,
+                resolution_status: resolution.resolution_status,
+                ...artifactPathResolutionProperties(resolution),
             },
             evidence: staticInferenceEvidence({
                 sha256: input.file.sha256,
@@ -225,6 +238,9 @@ const unresolvedModuleNode = (input, specifier, status) => input.context.accumul
 const moduleOriginForExport = (ir, link) => {
     if (link.specifier !== null)
         return {
+            ...(link.resolutionMode === undefined
+                ? {}
+                : { resolutionMode: link.resolutionMode }),
             specifier: link.specifier,
             importedPath: link.importedName === null ? [] : [link.importedName],
         };
@@ -239,6 +255,7 @@ const moduleOriginForExport = (ir, link) => {
 };
 const relationshipProperties = (link, target, origin) => ({
     module_link_kind: link.kind,
+    ...moduleResolutionModeProperties(link.resolutionMode),
     specifier: origin?.specifier ?? link.specifier,
     imported_name: origin?.importedPath.at(-1) ?? link.importedName,
     imported_path: origin?.importedPath ?? [],
@@ -246,8 +263,11 @@ const relationshipProperties = (link, target, origin) => ({
     exported_name: link.exportedName,
     resolved_path: target?.path ?? null,
     resolution_status: target?.status ?? null,
+    ...artifactPathResolutionProperties(target?.resolution),
     target_file_kind: target?.file?.kind ?? null,
-    target_json_status: target?.file?.kind === "json" ? jsonStatus(target.file) : null,
+    target_json_status: target?.file?.kind === "json" || target?.file?.kind === "package-json"
+        ? jsonStatus(target.file)
+        : null,
 });
 const relationshipEvidence = (input, operation, limitations, confidence = "high") => staticInferenceEvidence({
     sha256: input.file.sha256,
@@ -270,10 +290,12 @@ const semanticCoverage = (semantic) => {
 };
 const moduleFormat = (path, ir) => {
     const extension = posix.extname(path).toLowerCase();
-    if (extension === ".mjs")
+    if (extension === ".mjs" || extension === ".mts")
         return "esm";
-    if (extension === ".cjs")
+    if (extension === ".cjs" || extension === ".cts")
         return "commonjs";
+    if (extension === ".ts" || extension === ".tsx")
+        return "unknown";
     const esm = ir.moduleLinks.some(({ kind }) => ["import", "export", "re-export"].includes(kind));
     const commonJs = ir.moduleLinks.some(({ kind }) => ["require", "commonjs-export"].includes(kind));
     return esm && commonJs

package/dist/application/javascript/JavaScriptRecoveryService.js

@@ -1,8 +1,8 @@
-import { isAbsolute } from "node:path";
+import { isAbsolute, resolve } from "node:path";
 import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
 import { createEvidence } from "../../domain/evidence.js";
 import { javascriptRecoveryInputSchema, javascriptRecoveryResultSchema, } from "../../domain/javascript/javascriptRecovery.js";
-import { jsonObjectSchema } from "../../domain/jsonValue.js";
+import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { err, ok } from "../../domain/result.js";
 const OPERATION = "recover_javascript_sources";
@@ -25,12 +25,29 @@ export class JavaScriptRecoveryService {
                 cause: parsed.error,
             }));
         const invalidPaths = ["path", "output_directory"].filter((field) => !isAbsolute(parsed.data[field]));
-        if (invalidPaths.length > 0)
-            return err(new AnalysisInputError(OPERATION, undefined, invalidPaths.map((field) => ({
-                path: [field],
-                reason: "invalid_format",
-                message: `${field} must be an absolute filesystem path on this host.`,
-            }))));
+        const invalidAdditional = (parsed.data.additional_paths ?? []).filter((additional) => !isAbsolute(additional));
+        if (invalidPaths.length > 0 || invalidAdditional.length > 0)
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                ...invalidPaths.map((field) => ({
+                    path: [field],
+                    reason: "invalid_format",
+                    message: `${field} must be an absolute filesystem path on this host.`,
+                })),
+                ...invalidAdditional.map((additional) => ({
+                    path: ["additional_paths"],
+                    reason: "invalid_format",
+                    message: `additional_paths entries must be absolute filesystem paths on this host: ${additional}`,
+                })),
+            ]));
+        const selectedInputs = new Set([parsed.data.path, ...(parsed.data.additional_paths ?? [])].map((path) => resolve(path)));
+        if (selectedInputs.size !== 1 + (parsed.data.additional_paths ?? []).length)
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                {
+                    path: ["additional_paths"],
+                    reason: "invalid_format",
+                    message: "additional_paths must not repeat path or each other.",
+                },
+            ]));
         const execution = await this.provider.recover(parsed.data, options);
         if (!execution.ok)
             return execution;
@@ -38,6 +55,9 @@ export class JavaScriptRecoveryService {
         if (!result.success || execution.value.subject === null)
             return err(new AnalysisOutputError(OPERATION, "Recovery did not return a valid result bound to the original source"));
         if (result.data.source.path !== parsed.data.path ||
+            (result.data.additional_sources ?? []).length !==
+                (parsed.data.additional_paths ?? []).length ||
+            (parsed.data.additional_paths ?? []).some((path, index) => result.data.additional_sources?.[index]?.path !== path) ||
             execution.value.subject.path !== result.data.source.path ||
             execution.value.subject.sha256 !== result.data.source.sha256 ||
             execution.value.provider.id !== result.data.engine.id ||
@@ -46,7 +66,7 @@ export class JavaScriptRecoveryService {
         return ok(createEvidence(execution.value.subject, execution.value.provider, {
             operation: OPERATION,
             parameters: jsonObjectSchema.parse(parsed.data),
-            result: result.data,
+            result: jsonValueSchema.parse(result.data),
             rawResult: execution.value.rawResult,
             locations: execution.value.locations,
             limitations: execution.value.limitations,

package/dist/application/javascript/JavaScriptRuntimeObservationService.js

@@ -1,6 +1,5 @@
 import { createJavaScriptRuntimeObservationEvidence } from "./JavaScriptRuntimeObservationEvidence.js";
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../../domain/analysisErrorCore.js";
-import {} from "../../domain/analysisErrorBase.js";
 import { err, ok } from "../../domain/result.js";
 /** List targets exposed by the explicitly selected loopback Inspector. */
 export const listJavaScriptRuntimeTargets = async (provider, input, options = {}) => {
@@ -8,6 +7,8 @@ export const listJavaScriptRuntimeTargets = async (provider, input, options = {}
     if (!ready.ok)
         return ready;
     const result = await ready.value.listTargets(input, options);
+    if (result.ok && options.signal?.aborted === true)
+        return err(new AnalysisCancelledError("list_javascript_runtime_targets"));
     return result.ok
         ? ok(createJavaScriptRuntimeObservationEvidence("list_javascript_runtime_targets", input, result.value, ready.value.identity()))
         : result;

package/dist/application/javascript/JavaScriptRuntimeReconciliationService.js

@@ -1,7 +1,6 @@
 import { resolve } from "node:path";
 import { z } from "zod";
 import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
-import {} from "../../domain/analysisErrorBase.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { parseRuntimeReconciliationInput, reconcileJavaScriptRuntime, } from "../../domain/javascript/javascriptRuntimeReconciliation.js";
 import { reconcileJavaScriptRuntimeInputSchema } from "../../domain/javascript/javascriptRuntimeReconciliationSchemas.js";

package/dist/application/javascript/JavaScriptSemanticGraphBuilder.js

@@ -10,11 +10,12 @@ import { projectSemanticValues } from "./JavaScriptSemanticGraphValueProjection.
 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 { 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.
  *
@@ -28,45 +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 = () => {
+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;
     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)));
+        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.
@@ -115,7 +125,12 @@ export const createJavaScriptSemanticGraphProjection = () => {
                         ? [
                             {
                                 name: "semantic_graph_node_ceiling",
-                                value: SEMANTIC_GRAPH_NODE_CEILING,
+                                value: nodeCeiling,
+                                unit: "items",
+                            },
+                            {
+                                name: "semantic_graph_file_node_ceiling",
+                                value: fileNodeCeiling,
                                 unit: "items",
                             },
                         ]
@@ -152,11 +167,11 @@ export const createJavaScriptSemanticGraphProjection = () => {
         return graph;
     };
     return {
-        remainingFileNodeBudget: () => Math.min(SEMANTIC_GRAPH_FILE_NODE_CEILING, Math.max(0, SEMANTIC_GRAPH_NODE_CEILING - state.nodes.size)),
+        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(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");
             for (const context of projection.evidenceContexts)
                 state.evidenceContexts.adopt(context);
@@ -177,7 +192,7 @@ export const createJavaScriptSemanticGraphProjection = () => {
             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",
@@ -212,8 +227,8 @@ export const createJavaScriptSemanticGraphProjection = () => {
             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)
                 ;
         },
@@ -223,15 +238,15 @@ export const createJavaScriptSemanticGraphProjection = () => {
     };
 };
 /** Project one source with the parent's remaining node capacity, retaining no full IR. */
-export function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget) {
+export function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget, paths = []) {
     if (!Number.isSafeInteger(nodeBudget) ||
         nodeBudget < 0 ||
-        nodeBudget > SEMANTIC_GRAPH_FILE_NODE_CEILING)
+        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);
+    const fingerprints = yield* projectFileSteps(file, ir, state, paths);
     return {
         roots: [...state.roots],
         evidenceContexts: state.evidenceContexts.contexts,
@@ -242,7 +257,7 @@ export function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget) {
         truncated: Boolean(state.fileNodesDropped),
     };
 }
-function* projectFileSteps(file, ir, state) {
+function* projectFileSteps(file, ir, state, paths = []) {
     yield;
     const moduleNode = retainNode(state, file, {
         kind: "module",
@@ -254,6 +269,7 @@ function* projectFileSteps(file, ir, state) {
     if (moduleNode === null)
         return [];
     state.roots.add(moduleNode.node_id);
+    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();
@@ -418,7 +434,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/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/JavaScriptSemanticTraceService.js

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

package/dist/application/managed/ManagedApplicationGraphService.js

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