rea-agents 6.3.0 → 6.4.0

package/dist/application/javascript/JavaScriptArtifactAnalysis.js

@@ -1,48 +1,185 @@
 import { createHash } from "node:crypto";
 import { setImmediate } from "node:timers/promises";
 import { resolveJavaScriptSourceMapReference } from "../../domain/javascript/javascriptSourceMapPaths.js";
-import { analyzeParsedJavaScriptStaticSource } from "../../domain/javascript/javascriptStaticAnalysis.js";
-import { analyzeParsedJavaScriptSemantics, classifyParsedJavaScriptOpenReceivers, } from "../../domain/javascript/javascriptSemanticAnalysis.js";
+import { analyzeParsedJavaScriptStaticSourceSteps } from "../../domain/javascript/javascriptStaticAnalysis.js";
+import { analyzeParsedJavaScriptSemanticsSteps, classifyParsedJavaScriptOpenReceiversSteps, } from "../../domain/javascript/javascriptSemanticAnalysis.js";
+import { projectJavaScriptModuleSemantics } from "../../domain/javascript/javascriptModuleSemanticIr.js";
 import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";
 import { hasValidSourceMapContents } from "../../domain/sourceMapContents.js";
 import { flattenSourceMapLeaves } from "../../domain/sourceMapEnvelope.js";
 import { failedJavaScriptStaticAnalysis } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { analyzeJavaScriptJsonModule } from "./JavaScriptJsonModules.js";
+import { completeJavaScriptAnalysisSteps } from "./JavaScriptAnalysisControl.js";
 import { htmlArtifactReferences } from "../../domain/javascript/htmlArtifactReferences.js";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { projectAnalysisError } from "../../domain/analysisErrorProjection.js";
+import { AnalysisCancelledError, AnalysisResourceConstraintError, AnalysisTimeoutError, } from "../../domain/analysisErrorCore.js";
 /** Analyze every text source from the artifact without a result quota. */
-export const analyzeJavaScriptArtifactFiles = (fileSet) => analyzeArtifactFiles(fileSet, (_file, ir) => ir);
-/** Project each file's full IR immediately, retaining only later module facts. */
-export const analyzeAndProjectJavaScriptArtifactFiles = async (fileSet, projectSemantics, beforeFile) => {
+export const analyzeJavaScriptArtifactFiles = (fileSet) => analyzeArtifactFiles(fileSet, function* (_file, ir) {
+    // The full IR needs no projection; one step keeps the shared protocol.
+    yield;
+    return ir;
+});
+/**
+ * Project each file's full IR immediately, retaining only later module facts.
+ * Parsing, analysis and each projection pass run as separate steps, so control
+ * messages and cancellation are handled within one large file as well.
+ */
+export const analyzeAndProjectJavaScriptArtifactFiles = async (fileSet, projectSemantics, beforeFile, signal) => {
     const state = emptyArtifactAnalysis();
-    const projectFileSemantics = (file, ir) => {
-        projectSemantics(file, ir);
-        const programScopes = ir.scopes.filter(({ kind }) => kind === "program");
-        const programScopeId = programScopes[0]?.scopeId;
-        const localNames = new Set(ir.moduleLinks.map(({ localName }) => localName));
-        const callableIds = new Set(ir.moduleLinks.map(({ callableId }) => callableId));
-        return {
-            scopes: programScopes,
-            bindings: ir.bindings.filter(({ name, scopeId }) => scopeId === programScopeId && localNames.has(name)),
-            callables: ir.callables.filter(({ callableId }) => callableIds.has(callableId)),
-            moduleLinks: ir.moduleLinks,
-            coverage: ir.coverage,
-            limitations: ir.limitations,
-        };
+    const projectFileSemantics = function* (file, ir) {
+        const projection = projectSemantics(file, ir);
+        if (projection !== undefined)
+            while (projection.next().done !== true)
+                yield;
+        return projectJavaScriptModuleSemantics(ir);
     };
     const context = { state, projectSemantics: projectFileSemantics };
     for (const [index, file] of fileSet.files.entries()) {
         // Let progress, cancellation and garbage collection run between files.
         await setImmediate();
         await beforeFile?.(file, index, fileSet.files.length);
-        analyzeArtifactFile(file, context);
+        await completeJavaScriptAnalysisSteps(analyzeArtifactFileSteps(file, context), signal);
     }
     return finalizeArtifactAnalysis(state);
 };
+/** Analyze sources behind a hard heap boundary, retaining collected facts on interruption. */
+export const analyzeAndAdoptJavaScriptArtifactFiles = async (fileSet, worker, projection, beforeFile, signal) => {
+    const state = emptyArtifactAnalysis();
+    let interruption = null;
+    for (const [index, file] of fileSet.files.entries()) {
+        try {
+            await setImmediate();
+            await beforeFile(file, index, fileSet.files.length);
+            if (signal?.aborted === true)
+                throw new AnalysisCancelledError("analyze_javascript_application");
+            if (file.kind !== "javascript" || !file.text.included) {
+                const steps = analyzeArtifactFileSteps(file, {
+                    state,
+                    projectSemantics: function* (_file, ir) {
+                        yield;
+                        return projectJavaScriptModuleSemantics(ir);
+                    },
+                });
+                await completeJavaScriptAnalysisSteps(steps, signal);
+                continue;
+            }
+            const result = await worker.analyze(file, projection.remainingFileNodeBudget(), signal);
+            const facts = result.ok ? result.value : result.error;
+            const applicationProjectionFailure = facts.applicationProjectionFailure;
+            if (facts.projection !== null)
+                projection.adoptFileProjection(facts.projection);
+            const error = result.ok ? null : result.error.error;
+            const limits = error instanceof AnalysisResourceConstraintError
+                ? error.reportedLimits
+                : error instanceof AnalysisTimeoutError
+                    ? { worker_timeout_ms: error.timeoutMs }
+                    : null;
+            const failure = error === null
+                ? undefined
+                : {
+                    reason: `${file.path}: ${error.message}`,
+                    error: projectAnalysisError(error),
+                    limits,
+                };
+            state.files.push({
+                file,
+                javascript: facts.javascript,
+                semantic: facts.module === null ? null : { ir: facts.module },
+                ...(failure === undefined ? {} : { analysis_failure: failure }),
+                ...(applicationProjectionFailure === undefined
+                    ? {}
+                    : {
+                        application_projection_failure: {
+                            reason: applicationProjectionFailure.message,
+                            error: projectAnalysisError(applicationProjectionFailure),
+                            limits: applicationProjectionFailure.reportedLimits,
+                        },
+                    }),
+            });
+            if (failure !== undefined && facts.projection === null)
+                projection.recordUnavailableFile(file, failure.reason, failure.limits, error instanceof AnalysisResourceConstraintError ||
+                    error instanceof AnalysisTimeoutError
+                    ? "resource-limit"
+                    : "incomplete-module");
+            if (facts.javascript !== null) {
+                state.visitedNodes += facts.javascript.visited_ast_nodes;
+                state.findings +=
+                    findingCount(facts.javascript) +
+                        (facts.module?.moduleLinks.length ?? 0);
+                state.modules += facts.javascript.bundler_registrations.reduce((count, item) => count + item.modules.length, 0);
+                if (facts.javascript.parse_status === "failed")
+                    state.parseFailures += 1;
+            }
+            if (error !== null &&
+                (!(error instanceof AnalysisResourceConstraintError) ||
+                    error.reportedLimits?.parent_result_budget_exhausted === true)) {
+                interruption = error;
+                break;
+            }
+        }
+        catch (cause) {
+            if (signal?.aborted !== true && !(cause instanceof AnalysisError))
+                throw cause;
+            interruption =
+                signal?.aborted === true
+                    ? new AnalysisCancelledError("analyze_javascript_application")
+                    : cause instanceof AnalysisError
+                        ? cause
+                        : null;
+            if (interruption !== null) {
+                state.files.push({
+                    file,
+                    javascript: null,
+                    semantic: null,
+                    analysis_failure: {
+                        reason: `${file.path}: ${interruption.message}`,
+                        error: projectAnalysisError(interruption),
+                        limits: null,
+                    },
+                });
+                projection.recordUnavailableFile(file, interruption.message, null, "incomplete-module");
+            }
+            break;
+        }
+    }
+    if (interruption !== null) {
+        const analyzedPaths = new Set(state.files.map(({ file }) => file.path));
+        const failure = {
+            reason: `Source analysis was interrupted: ${interruption.message}`,
+            error: projectAnalysisError(interruption),
+            limits: interruption instanceof AnalysisResourceConstraintError
+                ? interruption.reportedLimits
+                : interruption instanceof AnalysisTimeoutError
+                    ? { worker_timeout_ms: interruption.timeoutMs }
+                    : null,
+        };
+        for (const file of fileSet.files) {
+            if (analyzedPaths.has(file.path))
+                continue;
+            state.files.push({
+                file,
+                javascript: null,
+                semantic: null,
+                analysis_failure: failure,
+            });
+            if (file.kind === "javascript")
+                projection.recordUnavailableFile(file, failure.reason, failure.limits, interruption instanceof AnalysisResourceConstraintError ||
+                    interruption instanceof AnalysisTimeoutError
+                    ? "resource-limit"
+                    : "incomplete-module");
+        }
+    }
+    return { analysis: finalizeArtifactAnalysis(state), interruption };
+};
 const analyzeArtifactFiles = (fileSet, projectSemantics) => {
     const state = emptyArtifactAnalysis();
     const context = { state, projectSemantics };
-    for (const file of fileSet.files)
-        analyzeArtifactFile(file, context);
+    for (const file of fileSet.files) {
+        const steps = analyzeArtifactFileSteps(file, context);
+        while (steps.next().done !== true)
+            ;
+    }
     return finalizeArtifactAnalysis(state);
 };
 const finalizeArtifactAnalysis = (state) => {
@@ -59,10 +196,11 @@ const finalizeArtifactAnalysis = (state) => {
         limitations: [
             "JavaScript and HTML were parsed as inert text; bundle bootstrap code was never executed.",
             "Static paths and relationships may remain unresolved when expressions are dynamic or obfuscated.",
+            ...state.files.flatMap(({ analysis_failure, application_projection_failure }) => [analysis_failure, application_projection_failure].flatMap((failure) => (failure === undefined ? [] : [failure.reason]))),
         ],
     };
 };
-const analyzeArtifactFile = (file, context) => {
+function* analyzeArtifactFileSteps(file, context) {
     const { state } = context;
     addStructuredObservations(file, state);
     if (file.kind === "html" && file.text.included)
@@ -74,31 +212,34 @@ const analyzeArtifactFile = (file, context) => {
         return;
     }
     const parsed = parseJavaScriptSource(file.text.value, file.path);
+    yield;
     if (parsed === null) {
         const analysis = failedJavaScriptStaticAnalysis();
         state.files.push({ file, javascript: analysis, semantic: null });
         state.parseFailures += 1;
         return;
     }
-    const openReceiverFacts = classifyParsedJavaScriptOpenReceivers(parsed);
-    const analysis = analyzeParsedJavaScriptStaticSource(file.text.value, parsed, openReceiverFacts);
+    const openReceiverFacts = yield* classifyParsedJavaScriptOpenReceiversSteps(parsed);
+    const analysis = yield* analyzeParsedJavaScriptStaticSourceSteps(file.text.value, parsed, openReceiverFacts);
     const staticFindings = findingCount(analysis);
+    yield;
     const semantics = analysis.parse_status === "complete" || analysis.parse_status === "partial"
-        ? analyzeParsedJavaScriptSemantics(parsed)
+        ? yield* analyzeParsedJavaScriptSemanticsSteps(parsed)
         : null;
+    const projected = semantics === null
+        ? null
+        : yield* context.projectSemantics(file, semantics);
     state.files.push({
         file,
         javascript: analysis,
-        semantic: semantics === null
-            ? null
-            : { ir: context.projectSemantics(file, semantics) },
+        semantic: projected === null ? null : { ir: projected },
     });
     state.visitedNodes += analysis.visited_ast_nodes;
     state.findings += staticFindings + (semantics?.moduleLinks.length ?? 0);
     state.modules += analysis.bundler_registrations.reduce((count, registration) => count + registration.modules.length, 0);
     if (analysis.parse_status === "failed")
         state.parseFailures += 1;
-};
+}
 const addSourceMap = (file, context) => {
     const sourceMap = parseSourceMap(file);
     context.state.sourceMaps.push(sourceMap);

package/dist/application/javascript/JavaScriptArtifactGraphAccumulator.js

@@ -3,7 +3,7 @@ import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } fro
 export class JavaScriptArtifactGraphAccumulator {
     #nodes = new Map();
     #edges = new Map();
-    /** Create or merge one canonical node. */
+    /** Create or merge one canonical node, retaining a stable live construction reference. */
     addNode(input) {
         const created = createJavaScriptApplicationNode(displayableNode(input));
         const existing = this.#nodes.get(created.node_id);
@@ -13,18 +13,20 @@ export class JavaScriptArtifactGraphAccumulator {
         }
         const bySemanticId = new Map([...existing.observations, ...created.observations].map((observation) => [
             observation.observation_id,
-            observationInput(observation),
+            observation,
         ]));
-        const observations = [...bySemanticId.entries()]
-            .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
-            .map(([, observation]) => observation);
-        const merged = createJavaScriptApplicationNode({
-            kind: existing.kind,
-            identity: existing.identity,
-            observations,
-        });
-        this.#nodes.set(merged.node_id, merged);
-        return merged;
+        const observations = [...bySemanticId.values()].sort((left, right) => left.observation_id < right.observation_id
+            ? -1
+            : left.observation_id > right.observation_id
+                ? 1
+                : 0);
+        // Both factories already validated and identified these observations.
+        // Replacing the node retained every previous observation array through
+        // path/chunk/IPC indexes when multiple paths shared an entity identity.
+        existing.observations.length = 0;
+        for (const observation of observations)
+            existing.observations.push(observation);
+        return existing;
     }
     /** Create or replace one canonical edge by semantic identifier. */
     addEdge(input) {
@@ -41,10 +43,6 @@ export class JavaScriptArtifactGraphAccumulator {
         return [...this.#edges.values()];
     }
 }
-const observationInput = (observation) => {
-    const { observation_id: _observationId, identifier_strategy: _strategy, ...input } = observation;
-    return input;
-};
 /**
  * Static findings can carry legal empty strings, such as `fetch("")`,
  * `require("")`, or a source map's `sources: [""]`. Labels must be nonempty,

package/dist/application/javascript/JavaScriptArtifactGraphBuilder.js

@@ -1,9 +1,10 @@
-import { createJavaScriptApplicationGraph, createImmutableJavaScriptApplicationGraphSteps, } from "../../domain/javascript/javascriptApplicationGraph.js";
+import { ELECTRON_IDENTITY_LIMITATION } from "../../domain/javascript/javascriptElectronMemberWrites.js";
+import { createJavaScriptApplicationGraph, sealTransferredJavaScriptApplicationGraphSteps, } from "../../domain/javascript/javascriptApplicationGraph.js";
 import { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
 import { selfReferenceOmissions, } from "./JavaScriptArtifactGraphContext.js";
 import { addJavaScriptHtmlRoles, addJavaScriptSourceMapOriginals, } from "./JavaScriptArtifactGraphDocuments.js";
-import { addJavaScriptStaticFindings } from "./JavaScriptArtifactGraphFindings.js";
-import { addJavaScriptModuleRelationships, addJavaScriptSourceModules, } from "./JavaScriptModuleRelationships.js";
+import { addJavaScriptStaticFindingsSteps } from "./JavaScriptArtifactGraphFindings.js";
+import { addJavaScriptModuleRelationshipsSteps, addJavaScriptSourceModules, } from "./JavaScriptModuleRelationships.js";
 import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { semanticCoverageResourceLimits, semanticResourceLimitCoverage, } from "../../domain/javascript/javascriptSemanticCoverage.js";
 import { semanticResourceLimitReason } from "../../domain/javascript/javascriptSemanticResourceLimits.js";
@@ -12,10 +13,25 @@ import { addJavaScriptBundlerNodes } from "./JavaScriptArtifactGraphBundlers.js"
 import { addElectronBoundaries } from "./ElectronBoundaryGraph.js";
 import { classifyElectronIpcPairings, collectElectronIpcRecords, } from "./ElectronBoundaryAnalysis.js";
 /** Project artifact and AST facts into JavaScript Application Graph. */
-export const buildJavaScriptArtifactGraph = (snapshot, fileSet, analysis) => createJavaScriptApplicationGraph(buildJavaScriptArtifactGraphInput(snapshot, fileSet, analysis));
-/** Build a validated application graph with cooperative immutable ownership. */
-export const buildImmutableJavaScriptArtifactGraphSteps = (snapshot, fileSet, analysis) => createImmutableJavaScriptApplicationGraphSteps(buildJavaScriptArtifactGraphInput(snapshot, fileSet, analysis));
-const buildJavaScriptArtifactGraphInput = (snapshot, fileSet, analysis) => {
+export const buildJavaScriptArtifactGraph = (snapshot, fileSet, analysis) => createJavaScriptApplicationGraph(completeSynchronously(buildJavaScriptArtifactGraphInputSteps(snapshot, fileSet, analysis)));
+/**
+ * Build a validated application graph with cooperative immutable ownership.
+ * Constructing the graph input also runs in steps: projecting every module
+ * relationship and finding at once held the event loop for seconds.
+ */
+export function* buildImmutableJavaScriptArtifactGraphSteps(snapshot, fileSet, analysis) {
+    const input = yield* buildJavaScriptArtifactGraphInputSteps(snapshot, fileSet, analysis);
+    // The input was built here and is not retained, so it can be transferred.
+    return yield* sealTransferredJavaScriptApplicationGraphSteps(input);
+}
+const completeSynchronously = (steps) => {
+    for (;;) {
+        const step = steps.next();
+        if (step.done === true)
+            return step.value;
+    }
+};
+function* buildJavaScriptArtifactGraphInputSteps(snapshot, fileSet, analysis) {
     const accumulator = new JavaScriptArtifactGraphAccumulator();
     const root = createJavaScriptArtifactRootNode(accumulator, snapshot);
     const context = {
@@ -33,15 +49,33 @@ const buildJavaScriptArtifactGraphInput = (snapshot, fileSet, analysis) => {
         containerNodes: new Map([[snapshot.manifest.root_sha256, root]]),
     };
     addJavaScriptArtifactContainers(context);
+    yield;
     addJavaScriptArtifactFiles(context);
-    const packageRoots = addJavaScriptPackageNodes(context);
-    addJavaScriptSourceModules(context);
-    const bundlerLimitations = addJavaScriptBundlerNodes(context);
-    const relationshipOmissions = addJavaScriptModuleRelationships(context);
-    const findingLimitations = addJavaScriptStaticFindings(context);
-    addElectronBoundaries(context);
-    addJavaScriptHtmlRoles(context);
-    addJavaScriptSourceMapOriginals(context);
+    yield;
+    // Raw observations remain on the file nodes. Only admitted expansions feed
+    // the relationship builders, including their Electron and bundler callers.
+    const projectionContext = {
+        ...context,
+        analysis: {
+            ...analysis,
+            files: analysis.files.map((file) => file.application_projection_failure === undefined
+                ? file
+                : { ...file, javascript: null, semantic: null }),
+        },
+    };
+    const packageRoots = addJavaScriptPackageNodes(projectionContext);
+    yield;
+    addJavaScriptSourceModules(projectionContext);
+    yield;
+    const bundlerLimitations = addJavaScriptBundlerNodes(projectionContext);
+    const relationshipOmissions = yield* addJavaScriptModuleRelationshipsSteps(projectionContext);
+    const findingLimitations = yield* addJavaScriptStaticFindingsSteps(projectionContext);
+    addElectronBoundaries(projectionContext);
+    yield;
+    addJavaScriptHtmlRoles(projectionContext);
+    yield;
+    addJavaScriptSourceMapOriginals(projectionContext);
+    yield;
     const coverage = graphCoverage(context);
     return {
         schema: "JavaScriptApplicationGraph",
@@ -57,7 +91,7 @@ const buildJavaScriptArtifactGraphInput = (snapshot, fileSet, analysis) => {
             ...graphLimitations(context, coverage.status, relationshipOmissions),
         ],
     };
-};
+}
 const graphCoverage = (context) => {
     const resourceLimits = semanticResourceLimits(context);
     const sourceMapPolicyGap = context.analysis.source_maps.some(({ status }) => status === "invalid");
@@ -65,13 +99,23 @@ const graphCoverage = (context) => {
         context.analysis.json_modules.some(({ status }) => status !== "included") ||
         context.analysis.source_maps.some(({ status }) => status === "invalid");
     const partialJavaScript = context.analysis.files.some(({ javascript }) => javascript !== null && javascript.parse_status === "partial");
-    const unknownGap = context.analysis.parse_failures > 0 ||
+    const unknownGap = context.analysis.files.some(({ analysis_failure, application_projection_failure }) => analysis_failure !== undefined ||
+        application_projection_failure !== undefined) ||
+        context.analysis.parse_failures > 0 ||
         context.fileSet.invalid_utf8_files > 0 ||
         sourceMapPolicyGap ||
         malformedStructuredData ||
         partialJavaScript;
-    if (resourceLimits.length > 0)
-        return partialApplicationCoverage(semanticResourceLimitCoverage(resourceLimits), null);
+    const executionLimits = context.analysis.files.flatMap(({ analysis_failure, application_projection_failure }) => [analysis_failure, application_projection_failure].flatMap((failure) => failure === undefined
+        ? []
+        : javaScriptAnalysisCoverageLimits(failure.limits)));
+    if (resourceLimits.length > 0 || executionLimits.length > 0)
+        return partialApplicationCoverage([
+            ...new Map([
+                ...semanticResourceLimitCoverage(resourceLimits),
+                ...executionLimits,
+            ].map((limit) => [JSON.stringify(limit), limit])).values(),
+        ], null);
     if (unknownGap)
         return partialApplicationCoverage([], null);
     if (context.snapshot.integrity_contradictions.length > 0) {
@@ -104,6 +148,9 @@ const graphLimitations = (context, coverage, relationshipOmissions) => {
         "CommonJS and ESM binding relationships were recovered from inert syntax and resolved only within the inventoried artifact container.",
         "Webpack/Rspack factories were recovered from AST literals; REA did not invoke push handlers or bundle bootstrap code.",
         "Static imports, entrypoints, workers, endpoints, and storage relationships do not prove runtime execution.",
+        ...(context.analysis.files.some(({ javascript }) => javascript?.limitations.includes(ELECTRON_IDENTITY_LIMITATION))
+            ? [ELECTRON_IDENTITY_LIMITATION]
+            : []),
         ...(electronFindings === 0
             ? []
             : [
@@ -137,3 +184,4 @@ const graphLimitations = (context, coverage, relationshipOmissions) => {
             ]),
     ];
 };
+import { javaScriptAnalysisCoverageLimits } from "../../domain/javascript/javascriptAnalysisResourceControls.js";

package/dist/application/javascript/JavaScriptArtifactGraphBundlers.js

@@ -1,3 +1,4 @@
+import { compositeKey } from "../../domain/unicodeCodePointOrder.js";
 import { addAstContainsEdge, artifactLocalIdentity, chunkLookupKey, javascriptAnalysisCoverage, moduleLookupKey, selfReferenceOmissions, } from "./JavaScriptArtifactGraphContext.js";
 import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 /** Project Webpack/Rspack AST literals and disclose unrepresentable relationships. */
@@ -41,7 +42,7 @@ const createBundlerChunkNode = (context, input) => {
     const chunkKey = `${registration.runtime}:${registration.chunk_keys.join(",")}`;
     return context.accumulator.addNode({
         kind: "javascript-chunk",
-        identity: artifactLocalIdentity(file.sha256, "bundler-chunk", chunkKey),
+        identity: artifactLocalIdentity(file.sha256, "bundler-chunk", compositeKey([registration.runtime, registration.chunk_keys])),
         observations: [
             {
                 label: chunkKey,
@@ -104,7 +105,7 @@ const addBundlerModuleNodes = (context, input) => {
                 },
             ],
         });
-        context.moduleNodes.set(moduleLookupKey(file.path, moduleValue.module_key), module);
+        context.moduleNodes.set(moduleLookupKey(file.path, registration.runtime, moduleValue.module_key), module);
         addAstContainsEdge(context, {
             source: chunk,
             target: module,
@@ -124,7 +125,7 @@ const addBundlerRuntimeEdges = (context, record) => {
     let selfAsyncChunks = 0;
     const { file, registration, chunk, coverage } = record;
     for (const moduleKey of registration.entry_module_keys) {
-        const resolved = context.moduleNodes.get(moduleLookupKey(file.path, moduleKey));
+        const resolved = context.moduleNodes.get(moduleLookupKey(file.path, registration.runtime, moduleKey));
         const target = resolved ?? unresolvedBundlerModuleNode(context, record, moduleKey);
         context.accumulator.addEdge({
             source_node_id: chunk.node_id,

package/dist/application/javascript/JavaScriptArtifactGraphContext.js

@@ -1,3 +1,4 @@
+import { compositeKey } from "../../domain/unicodeCodePointOrder.js";
 import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
 import { artifactObservationEvidence, astObservationEvidence, staticInferenceEvidence, unavailableAstEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
@@ -63,12 +64,15 @@ export const addUnavailableStaticParseScope = (context, input) => {
                     path: input.file.path,
                     operation: input.operation,
                     limitation: input.limitation,
+                    ...(input.failure === undefined
+                        ? {}
+                        : { analysis_failure: input.failure }),
                 },
                 evidence: unavailableAstEvidence({
                     sha256: input.file.sha256,
                     path: input.file.path,
                     operation: input.operation,
-                    coverage: partialApplicationCoverage([], null),
+                    coverage: partialApplicationCoverage(input.limits ?? [], null),
                     limitation: input.limitation,
                 }),
             },
@@ -171,9 +175,9 @@ export const selfReferenceOmissions = (count, noun, owner) => count === 0
         `${String(count)} ${count === 1 ? noun[0] : noun[1]} resolved back to ${owner} itself and ${count === 1 ? "was" : "were"} omitted; application graph edges cannot be self-referential.`,
     ];
 /** Deterministic key for one recovered module inside a bundle asset. */
-export const moduleLookupKey = (path, moduleKey) => `${path}\0${moduleKey}`;
+export const moduleLookupKey = (path, runtime, moduleKey) => compositeKey([path, runtime, moduleKey]);
 /** Deterministic key for one recovered bundler chunk inside a bundle asset. */
-export const chunkLookupKey = (path, runtime, chunkKey) => `${path}\0${runtime}\0${chunkKey}`;
+export const chunkLookupKey = (path, runtime, chunkKey) => compositeKey([path, runtime, chunkKey]);
 /** Resolve a relative static specifier without escaping the artifact root. */
 export const resolveArtifactPath = (specifier, sourcePath, files, moduleKind) => resolveArtifactPathByContext({
     declaredPath: specifier,
@@ -183,6 +187,8 @@ export const resolveArtifactPath = (specifier, sourcePath, files, moduleKind) =>
     ...(moduleKind === undefined ? {} : { moduleKind }),
 }).resolved_path;
 /** Locate the recovered module that owns a static finding. */
-export const sourceNodeFor = (context, path, moduleKey) => moduleKey === null
+export const sourceNodeFor = (context, path, moduleKey, runtime) => moduleKey === null
     ? context.sourceModuleNodes.get(path)
-    : context.moduleNodes.get(moduleLookupKey(path, moduleKey));
+    : runtime === undefined
+        ? undefined
+        : context.moduleNodes.get(moduleLookupKey(path, runtime, moduleKey));

package/dist/application/javascript/JavaScriptArtifactGraphFindings.js

@@ -1,11 +1,13 @@
 import { createHash } from "node:crypto";
+import { compactStringIdentityKey } from "../../domain/compactStringIdentity.js";
 import { addStaticInferenceEdge, artifactLocalIdentity, chunkLookupKey, createElectronRoleNode, javascriptAnalysisCoverage, linkElectronRoleToAsset, moduleLookupKey, resolveArtifactPath, selfReferenceOmissions, sourceNodeFor, } from "./JavaScriptArtifactGraphContext.js";
 import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
 /** Project imports, workers, roles, endpoints, storage, and source-map links. */
-export const addJavaScriptStaticFindings = (context) => {
+export function* addJavaScriptStaticFindingsSteps(context) {
     const omissions = { selfReferences: 0 };
     for (const analyzed of context.analysis.files) {
+        yield;
         const { file, javascript } = analyzed;
         const asset = context.assetNodes.get(file.path);
         if (javascript === null || asset === undefined)
@@ -23,10 +25,9 @@ export const addJavaScriptStaticFindings = (context) => {
             addSourceMapEdge(context, { file, asset, value, coverage });
     }
     return selfReferenceOmissions(omissions.selfReferences, ["static reference", "static references"], "the referencing module");
-};
+}
 const addReference = (context, input, omissions) => {
-    const source = sourceNodeFor(context, input.file.path, input.value.module_key) ??
-        input.asset;
+    const source = sourceNodeFor(context, input.file.path, input.value.module_key, input.value.module_runtime) ?? input.asset;
     const resolved = input.value.specifier === null
         ? null
         : resolveReference(context, input.file.path, input.value);
@@ -98,14 +99,15 @@ const addReference = (context, input, omissions) => {
     });
 };
 const addEndpoint = (context, input) => {
-    const source = sourceNodeFor(context, input.file.path, input.value.module_key) ??
-        input.asset;
+    const source = sourceNodeFor(context, input.file.path, input.value.module_key, input.value.module_runtime) ?? input.asset;
+    const key = compactStringIdentityKey(input.value.value);
+    const label = `${input.value.kind} endpoint`;
     const node = context.accumulator.addNode({
         kind: "endpoint",
-        identity: artifactLocalIdentity(input.file.sha256, input.value.kind, input.value.value),
+        identity: artifactLocalIdentity(input.file.sha256, input.value.kind, key),
         observations: [
             {
-                label: input.value.value,
+                label: input.value.value.length <= label.length ? input.value.value : label,
                 properties: {
                     endpoint_kind: input.value.kind,
                     value: input.value.value,
@@ -132,8 +134,7 @@ const addEndpoint = (context, input) => {
     });
 };
 const addStorage = (context, input) => {
-    const source = sourceNodeFor(context, input.file.path, input.value.module_key) ??
-        input.asset;
+    const source = sourceNodeFor(context, input.file.path, input.value.module_key, input.value.module_runtime) ?? input.asset;
     const node = context.accumulator.addNode({
         kind: "storage",
         identity: artifactLocalIdentity(input.file.sha256, input.value.kind, input.value.name ?? input.value.mechanism),
@@ -180,8 +181,7 @@ const addDiscoveredRole = (context, input) => {
         range: input.value.location,
         coverage: input.coverage,
     });
-    const source = sourceNodeFor(context, input.file.path, input.value.module_key) ??
-        input.asset;
+    const source = sourceNodeFor(context, input.file.path, input.value.module_key, input.value.module_runtime) ?? input.asset;
     addStaticInferenceEdge(context, {
         source,
         target: role,
@@ -262,7 +262,9 @@ const resolveReference = (context, sourcePath, reference) => {
     const chunk = resolveBundlerChunkReference(context, sourcePath, reference);
     if (chunk !== null)
         return chunk;
-    const module = context.moduleNodes.get(moduleLookupKey(sourcePath, specifier));
+    const module = reference.module_runtime === undefined
+        ? undefined
+        : context.moduleNodes.get(moduleLookupKey(sourcePath, reference.module_runtime, specifier));
     if (module !== undefined) {
         const file = context.filesByPath.get(sourcePath);
         return file === undefined
@@ -300,9 +302,10 @@ const resolveBundlerChunkReference = (context, sourcePath, reference) => {
         return null;
     const registrations = context.analysis.files
         .find(({ file: analyzedFile }) => analyzedFile.path === sourcePath)
-        ?.javascript?.bundler_registrations.filter(({ modules }) => reference.module_key === null
-        ? true
-        : modules.some(({ module_key: moduleKey }) => moduleKey === reference.module_key));
+        ?.javascript?.bundler_registrations.filter(({ runtime, modules }) => reference.module_runtime === undefined
+        ? reference.module_key === null
+        : runtime === reference.module_runtime &&
+            modules.some(({ module_key: moduleKey }) => moduleKey === reference.module_key));
     if (registrations === undefined)
         return null;
     const candidates = registrations.flatMap(({ runtime }) => {