rea-agents 6.2.0 → 6.4.0

package/dist/application/javascript/JavaScriptApplicationService.js

@@ -1,9 +1,9 @@
 import { z } from "zod";
 import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
 import { analyzeJavaScriptApplicationInputSchema, parseOwnedJavaScriptApplicationAnalysisSteps, } from "../../domain/javascript/javascriptApplicationAnalysis.js";
-import { AnalysisAccessDeniedError, AnalysisInputError, AnalysisOutputError, AnalysisUnsupportedTargetError, } from "../../domain/analysisErrorCore.js";
+import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
 import { ArtifactOperationError } from "../../domain/artifactOperationError.js";
-import {} from "../../domain/analysisErrorBase.js";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { err, ok } from "../../domain/result.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
@@ -13,14 +13,14 @@ import { reconstructJavaScriptArtifact } from "./JavaScriptArtifactReconstructio
 import { JAVASCRIPT_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
 const OPERATION = "analyze_javascript_application";
 /** Statically analyze one local JavaScript/Electron application. */
-export const analyzeJavaScriptApplication = async (rawInput, options = {}) => {
+export const analyzeJavaScriptApplication = async (rawInput, scope, options = {}) => {
     const parsed = analyzeJavaScriptApplicationInputSchema.safeParse(rawInput);
     if (!parsed.success)
         return err(analysisInputErrorFromIssues(OPERATION, parsed.error.issues, rawInput));
-    return analyzeJavaScriptApplicationValidated(parsed.data, options);
+    return analyzeJavaScriptApplicationValidated(parsed.data, scope, options);
 };
 /** Analyze input already parsed by a trusted adapter boundary. */
-export const analyzeJavaScriptApplicationValidated = async (input, options = {}) => {
+export const analyzeJavaScriptApplicationValidated = async (input, scope, options = {}) => {
     try {
         assertJavaScriptAnalysisActive(options.signal);
         await options.progress?.report({
@@ -33,7 +33,14 @@ export const analyzeJavaScriptApplicationValidated = async (input, options = {})
         const reconstructed = await reconstructJavaScriptArtifact({
             input_path: input.input_path,
             format: input.format,
-        }, options.signal, options.progress);
+            integrity_policy: input.integrity_policy,
+            ...(input.max_heap_mb === undefined
+                ? {}
+                : { max_heap_mb: input.max_heap_mb }),
+            ...(input.analysis_timeout_ms === undefined
+                ? {}
+                : { analysis_timeout_ms: input.analysis_timeout_ms }),
+        }, scope, options.signal, options.progress);
         const { electron_summary: summary, ...application } = reconstructed;
         await options.progress?.report({
             phase: "validate_javascript_application_result",
@@ -67,13 +74,11 @@ export const analyzeJavaScriptApplicationValidated = async (input, options = {})
         return ok(evidence);
     }
     catch (cause) {
-        // Input selection failures are already typed by their cause.
-        if (cause instanceof AnalysisInputError ||
-            cause instanceof AnalysisUnsupportedTargetError ||
-            cause instanceof AnalysisAccessDeniedError)
+        // Preserve execution constraints and their completed partial Evidence.
+        if (cause instanceof AnalysisError)
             return err(cause);
         if (cause instanceof ArtifactReaderFailure)
-            return err(new ArtifactOperationError(OPERATION, cause.reason, cause.details, cause.message));
+            return err(artifactFailureToOperationError(cause));
         if (cause instanceof z.ZodError)
             return err(new AnalysisOutputError(OPERATION, describeResultSchemaFailure(cause), {
                 cause,
@@ -97,6 +102,13 @@ export const analyzeJavaScriptApplicationValidated = async (input, options = {})
         }));
     }
 };
+const artifactFailureToOperationError = (cause) => new ArtifactOperationError(OPERATION, cause.reason, cause.details, cause.message, {
+    cause,
+    ...(cause.cleanup === undefined ? {} : { cleanup: cause.cleanup }),
+    ...(cause.partialObservation === undefined
+        ? {}
+        : { partialObservation: cause.partialObservation }),
+});
 const describeResultSchemaFailure = (cause) => {
     const issue = cause.issues[0];
     if (issue === undefined)

package/dist/application/javascript/JavaScriptApplicationWorkflowEvidence.js

@@ -1,12 +1,11 @@
 import { createEvidence, } from "../../domain/evidence.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
 /** Create derived Evidence for one bounded application-graph feature trace. */
 export const createApplicationFeatureTraceEvidence = (parameters, result) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
     predicateType: "rea.application-feature-trace",
     operation: "trace_application_feature",
     parameters,
-    result: jsonValueSchema.parse(result),
+    result,
     rawResult: null,
     confidence: "inferred",
     authority: "analyst-inference",
@@ -19,7 +18,7 @@ export const createJavaScriptSemanticTraceEvidence = (parameters, result) => cre
     predicateType: "rea.javascript-semantic-trace",
     operation: "trace_javascript_semantics",
     parameters,
-    result: jsonValueSchema.parse(result),
+    result,
     rawResult: null,
     confidence: "inferred",
     authority: "analyst-inference",
@@ -32,7 +31,7 @@ export const createApplicationVersionComparisonEvidence = (parameters, result) =
     predicateType: "rea.application-version-comparison",
     operation: "compare_application_versions",
     parameters,
-    result: jsonValueSchema.parse(result),
+    result,
     rawResult: null,
     confidence: "inferred",
     authority: "analyst-inference",
@@ -45,7 +44,7 @@ export const createSourceToBundleComparisonEvidence = (parameters, result) => cr
     predicateType: "rea.source-to-bundle-comparison",
     operation: "compare_source_to_bundle",
     parameters,
-    result: jsonValueSchema.parse(result),
+    result,
     rawResult: null,
     confidence: "inferred",
     authority: "analyst-inference",
@@ -58,7 +57,7 @@ export const createJavaScriptExportShapeComparisonEvidence = (parameters, result
     predicateType: "rea.javascript-export-shape-comparison",
     operation: "compare_javascript_export_shapes",
     parameters,
-    result: jsonValueSchema.parse(result),
+    result,
     rawResult: null,
     confidence: "inferred",
     authority: "analyst-inference",

package/dist/application/javascript/JavaScriptApplicationWorkflowService.js

@@ -1,17 +1,17 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import { AnalysisProtocolError } from "../../domain/analysisErrorCore.js";
 import {} from "../../domain/analysisErrorBase.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { compareJavaScriptApplicationVersions } from "../../domain/javascript/javascriptApplicationVersionComparison.js";
-import { compareApplicationVersionsInputSchema } from "../../domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
+import { compareApplicationVersionsInputSchema, applicationVersionIdentitiesSchema, } from "../../domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
 import { compareJavaScriptExportShapes } from "../../domain/javascript/javascriptExportShapeComparison.js";
-import { compareJavaScriptExportShapesInputSchema } from "../../domain/javascript/javascriptExportShapeComparisonSchemas.js";
+import { compareJavaScriptExportShapesInputSchema, javaScriptExportShapeIdentitiesSchema, } from "../../domain/javascript/javascriptExportShapeComparisonSchemas.js";
 import { traceApplicationFeature } from "../../domain/javascript/javascriptFeatureTrace.js";
-import { traceApplicationFeatureInputSchema } from "../../domain/javascript/javascriptFeatureTraceSchemas.js";
+import { traceApplicationFeatureInputSchema, applicationTraceIdentitiesSchema, } from "../../domain/javascript/javascriptFeatureTraceSchemas.js";
 import { err, ok } from "../../domain/result.js";
 import { compareSourceToBundle } from "../../domain/javascript/sourceToBundleComparison.js";
 import { compareSourceToBundleInputSchema } from "../../domain/javascript/sourceToBundleComparisonSchemas.js";
-import { parseApplicationGraphEvidence, parseNativeApplicationEvidence, } from "./JavaScriptApplicationEvidenceGraph.js";
+import { applicationGraphEvidenceInputError, parseApplicationGraphEvidence, parseNativeApplicationEvidence, } from "./JavaScriptApplicationEvidenceGraph.js";
 import { createApplicationFeatureTraceEvidence, createApplicationVersionComparisonEvidence, createJavaScriptExportShapeComparisonEvidence, createSourceToBundleComparisonEvidence, } from "./JavaScriptApplicationWorkflowEvidence.js";
 /** Authenticate Evidence and derive one bounded cross-layer feature trace. */
 export const traceApplicationFeatureEvidence = (rawInput) => {
@@ -24,9 +24,20 @@ export const traceApplicationFeatureEvidence = (rawInput) => {
 /** Derive one feature trace from input parsed by a trusted adapter. */
 export const traceApplicationFeatureEvidenceValidated = (input) => {
     const operation = "trace_application_feature";
+    const identities = applicationTraceIdentitiesSchema.safeParse(input);
+    if (!identities.success)
+        return err(analysisInputErrorFromIssues(operation, identities.error.issues, input));
+    const sourceResult = parseApplicationGraphEvidence(input.application, [
+        "application",
+    ]);
+    if (!sourceResult.ok)
+        return err(applicationGraphEvidenceInputError(operation, sourceResult.error));
+    const nativeResult = parseNativeApplicationEvidence(input.native_observations, ["native_observations"]);
+    if (!nativeResult.ok)
+        return err(applicationGraphEvidenceInputError(operation, nativeResult.error));
     try {
-        const source = parseApplicationGraphEvidence(input.application);
-        const nativeEvidence = parseNativeApplicationEvidence(input.native_observations);
+        const source = sourceResult.value;
+        const nativeEvidence = nativeResult.value;
         const result = traceApplicationFeature({
             sourceEvidenceId: source.evidence.evidence_id,
             graph: source.graph,
@@ -42,7 +53,7 @@ export const traceApplicationFeatureEvidenceValidated = (input) => {
         }, result));
     }
     catch (cause) {
-        return workflowFailure(operation, cause, input);
+        return workflowFailure(operation, cause);
     }
 };
 /** Authenticate both graphs and derive a tiered cross-version change graph. */
@@ -56,11 +67,26 @@ export const compareApplicationVersionsEvidence = (rawInput) => {
 /** Compare versions from input parsed by a trusted adapter. */
 export const compareApplicationVersionsEvidenceValidated = (input) => {
     const operation = "compare_application_versions";
+    const identities = applicationVersionIdentitiesSchema.safeParse(input);
+    if (!identities.success)
+        return err(analysisInputErrorFromIssues(operation, identities.error.issues, input));
+    const leftResult = parseApplicationGraphEvidence(input.left, ["left"]);
+    if (!leftResult.ok)
+        return err(applicationGraphEvidenceInputError(operation, leftResult.error));
+    const rightResult = parseApplicationGraphEvidence(input.right, ["right"]);
+    if (!rightResult.ok)
+        return err(applicationGraphEvidenceInputError(operation, rightResult.error));
+    const leftNativeResult = parseNativeApplicationEvidence(input.left_native_observations, ["left_native_observations"]);
+    if (!leftNativeResult.ok)
+        return err(applicationGraphEvidenceInputError(operation, leftNativeResult.error));
+    const rightNativeResult = parseNativeApplicationEvidence(input.right_native_observations, ["right_native_observations"]);
+    if (!rightNativeResult.ok)
+        return err(applicationGraphEvidenceInputError(operation, rightNativeResult.error));
     try {
-        const left = parseApplicationGraphEvidence(input.left);
-        const right = parseApplicationGraphEvidence(input.right);
-        const leftNative = parseNativeApplicationEvidence(input.left_native_observations);
-        const rightNative = parseNativeApplicationEvidence(input.right_native_observations);
+        const left = leftResult.value;
+        const right = rightResult.value;
+        const leftNative = leftNativeResult.value;
+        const rightNative = rightNativeResult.value;
         const result = compareJavaScriptApplicationVersions({
             left: {
                 evidenceId: left.evidence.evidence_id,
@@ -83,14 +109,19 @@ export const compareApplicationVersionsEvidenceValidated = (input) => {
         }, result));
     }
     catch (cause) {
-        return workflowFailure(operation, cause, input);
+        return workflowFailure(operation, cause);
     }
 };
 /** Compare source and bundle inputs already parsed by a trusted adapter. */
 export const compareSourceToBundleEvidenceValidated = (input) => {
     const operation = "compare_source_to_bundle";
+    const applicationResult = parseApplicationGraphEvidence(input.application, [
+        "application",
+    ]);
+    if (!applicationResult.ok)
+        return err(applicationGraphEvidenceInputError(operation, applicationResult.error));
     try {
-        const application = parseApplicationGraphEvidence(input.application);
+        const application = applicationResult.value;
         const result = compareSourceToBundle({
             reference: input.reference,
             application: {
@@ -105,7 +136,7 @@ export const compareSourceToBundleEvidenceValidated = (input) => {
         }, result));
     }
     catch (cause) {
-        return workflowFailure(operation, cause, input);
+        return workflowFailure(operation, cause);
     }
 };
 /**
@@ -122,9 +153,18 @@ export const compareJavaScriptExportShapesEvidence = (rawInput) => {
 /** Compare exact export shapes from input parsed by a trusted adapter. */
 export const compareJavaScriptExportShapesEvidenceValidated = (input) => {
     const operation = "compare_javascript_export_shapes";
+    const identities = javaScriptExportShapeIdentitiesSchema.safeParse(input);
+    if (!identities.success)
+        return err(analysisInputErrorFromIssues(operation, identities.error.issues, input));
+    const leftResult = parseApplicationGraphEvidence(input.left, ["left"]);
+    if (!leftResult.ok)
+        return err(applicationGraphEvidenceInputError(operation, leftResult.error));
+    const rightResult = parseApplicationGraphEvidence(input.right, ["right"]);
+    if (!rightResult.ok)
+        return err(applicationGraphEvidenceInputError(operation, rightResult.error));
     try {
-        const left = parseApplicationGraphEvidence(input.left);
-        const right = parseApplicationGraphEvidence(input.right);
+        const left = leftResult.value;
+        const right = rightResult.value;
         const result = compareJavaScriptExportShapes({
             left: {
                 evidenceId: left.evidence.evidence_id,
@@ -149,33 +189,7 @@ export const compareJavaScriptExportShapesEvidenceValidated = (input) => {
         }, result));
     }
     catch (cause) {
-        return workflowFailure(operation, cause, input);
+        return workflowFailure(operation, cause);
     }
 };
-const workflowFailure = (operation, cause, input) => cause instanceof z.ZodError
-    ? err(analysisInputErrorFromIssues(operation, cause.issues, input))
-    : cause instanceof TypeError &&
-        SAFE_APPLICATION_INPUT_CONSTRAINTS.has(cause.message)
-        ? err(new AnalysisInputError(operation, undefined, [
-            { path: [], reason: "invalid_value", message: cause.message },
-        ]))
-        : err(new AnalysisProtocolError("JavaScript application workflow produced an invalid result", { cause }));
-const SAFE_APPLICATION_INPUT_CONSTRAINTS = new Set([
-    "Evidence semantic identifier does not match its record",
-    "Application workflow requires authenticated analyze_javascript_application, reconcile_javascript_runtime, or project_managed_application_graph Evidence",
-    "JavaScript application Evidence authority or confidence is invalid",
-    "JavaScript application Evidence predicate does not match its result shape",
-    "JavaScript application Evidence subject does not match its result",
-    "Runtime reconciliation Evidence authority or confidence is invalid",
-    "Runtime reconciliation result references Evidence outside its envelope",
-    "Runtime reconciliation application layer is missing",
-    "Managed application graph Evidence authority or confidence is invalid",
-    "Managed application graph result references Evidence outside its envelope",
-    "Native handoff Evidence requires an artifact subject",
-    "Native handoff Evidence must be unique",
-    ...[
-        "analyze_javascript_application",
-        "reconcile_javascript_runtime",
-        "project_managed_application_graph",
-    ].map((operation) => `Evidence does not match the supported ${operation} contract`),
-]);
+const workflowFailure = (operation, cause) => err(new AnalysisProtocolError(`JavaScript application workflow failed while producing ${operation}`, { cause }));

package/dist/application/javascript/JavaScriptArtifactAnalysis.js

@@ -1,52 +1,188 @@
 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) => {
-    const truncatedScopes = state.truncatedScopes;
     return {
         files: state.files,
         packages: state.packages,
@@ -57,17 +193,14 @@ const finalizeArtifactAnalysis = (state) => {
         findings: state.findings + state.htmlScripts.length,
         modules: state.modules,
         parse_failures: state.parseFailures,
-        truncated_scopes: truncatedScopes,
         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.",
-            ...(truncatedScopes === 0
-                ? []
-                : ["Some static-analysis scopes were truncated."]),
+            ...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)
@@ -79,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);
@@ -118,7 +254,6 @@ const emptyArtifactAnalysis = () => ({
     findings: 0,
     modules: 0,
     parseFailures: 0,
-    truncatedScopes: 0,
 });
 const addStructuredObservations = (file, state) => {
     if (file.kind === "package-json")

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,