rea-agents 6.5.0 → 6.7.0

package/dist/application/binaryDiagnostics/RecordedCrashService.js

@@ -4,6 +4,7 @@ import { createEvidence } from "../../domain/evidence.js";
 import { inspectRecordedCrashInputSchema, RECORDED_LINUX_CORE_PROFILES, recordedCrashSchema, } from "../../domain/native/recordedCrash.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { err, ok } from "../../domain/result.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 const OPERATION = "inspect_recorded_crash";
 /** Shared CLI/MCP validation and Evidence composition for recorded crash inspection. */
 export class RecordedCrashService {
@@ -45,8 +46,6 @@ export class RecordedCrashService {
         const outputOptions = diagnostics.success
             ? { capturedOutput: diagnostics.data }
             : undefined;
-        if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(OPERATION, outputOptions));
         const report = recordedCrashSchema.safeParse(inspected.value);
         if (!report.success ||
             report.data.artifact.path !== input.data.path ||
@@ -54,7 +53,7 @@ export class RecordedCrashService {
                 input.data.include_debugger_context)
             return err(new AnalysisOutputError(OPERATION, "Recorded crash provider returned malformed evidence or changed the selected artifact identity.", outputOptions));
         const value = report.data;
-        return ok(createEvidence({
+        return completeProviderEvidence(createEvidence({
             path: value.artifact.path,
             format: "elf",
             architecture: RECORDED_LINUX_CORE_PROFILES[value.architecture]
@@ -69,6 +68,6 @@ export class RecordedCrashService {
             confidence: value.debugger.status === "available" ? "derived" : "observed",
             limitations: value.limitations,
             locations: [{ kind: "artifact-path", path: value.artifact.path }],
-        }));
+        }), options?.signal, outputOptions?.capturedOutput);
     }
 }

package/dist/application/captures/PacketCaptureService.js

@@ -17,7 +17,7 @@ export class PacketCaptureService {
     async inspect(raw, options) {
         const operation = "inspect_packet_capture";
         if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(operation));
+            return err(new AnalysisCancelledError(operation, { cause: options.signal.reason }));
         const input = inspectPacketCaptureInputSchema.safeParse(raw);
         if (!input.success)
             return err(analysisInputErrorFromIssues(operation, input.error.issues, raw, {
@@ -47,7 +47,7 @@ export class PacketCaptureService {
     async inspectFields(raw, options) {
         const operation = "inspect_packet_fields";
         if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(operation));
+            return err(new AnalysisCancelledError(operation, { cause: options.signal.reason }));
         const input = inspectPacketFieldsInputSchema.safeParse(raw);
         if (!input.success)
             return err(analysisInputErrorFromIssues(operation, input.error.issues, raw, {
@@ -76,6 +76,7 @@ export class PacketCaptureService {
         });
         return options?.signal?.aborted
             ? err(new AnalysisCancelledError(operation, {
+                cause: options.signal.reason,
                 partialObservation: evidence,
             }))
             : ok(evidence);

package/dist/application/closeOwnedWebResources.js

@@ -1,7 +1,37 @@
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
+import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
 /** Attempt every web workflow cleanup owner and report all failures. */
 export const closeOwnedWebResources = async (close, message) => {
     const results = await Promise.allSettled(close.flatMap((owner) => owner === undefined ? [] : [Promise.resolve().then(owner)]));
     const failures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
-    if (failures.length > 0)
-        throw new AggregateError(failures, message);
+    if (failures.length === 1) {
+        const [failure] = failures;
+        if (failure instanceof AnalysisError)
+            throw failure;
+        throw new ProviderCleanupError("web-workflow", [], { reason: failure instanceof Error ? failure.message : String(failure) }, { cause: failure, operation: "close_web_workflow" });
+    }
+    if (failures.length > 1) {
+        const normalized = failures.map((cause) => ({
+            cause,
+            projection: cause instanceof AnalysisError
+                ? projectAnalysisError(cause)
+                : undefined,
+            resources: cause instanceof AnalysisError ? cause.cleanupResources : [],
+        }));
+        const recoveryActions = [
+            ...new Set(normalized.flatMap(({ projection }) => projection === undefined ? [] : [projection.remediation.action])),
+        ];
+        throw new ProviderCleanupError("web-workflow", [...new Set(normalized.flatMap(({ resources }) => resources))], {
+            failures: normalized.map(({ cause, projection }) => projection ?? {
+                message: cause instanceof Error ? cause.message : String(cause),
+            }),
+        }, {
+            cause: new AggregateError(normalized.map(({ cause }) => cause), message),
+            operation: "close_web_workflow",
+            ...(recoveryActions.length === 0
+                ? {}
+                : { remediationAction: recoveryActions.join("; ") }),
+        });
+    }
 };

package/dist/application/electron/ElectronFuseService.js

@@ -1,10 +1,10 @@
 import { isAbsolute } from "node:path";
 import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
-import { BINARY_ARCHITECTURES } from "../../domain/binaryTargetTypes.js";
 import { electronFuseReportSchema, inspectElectronFusesInputSchema, } from "../../domain/electron/electronFuses.js";
-import { createEvidence } from "../../domain/evidence.js";
+import { createElectronFuseEvidence } from "../../domain/electron/electronFuseEvidence.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { err, ok } from "../../domain/result.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 const OPERATION = "inspect_electron_fuses";
 /** Shared exact input validation and artifact-bound Evidence for CLI and MCP. */
 export class ElectronFuseService {
@@ -12,10 +12,14 @@ export class ElectronFuseService {
     constructor(provider) {
         this.provider = provider;
     }
+    /** Await and retry the reader's exact retained descriptor owners. */
+    async close() {
+        await this.provider.close?.();
+    }
     /** Read fuse wires for one explicitly selected path without launching it. */
     async inspect(rawInput, options) {
         if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(OPERATION));
+            return err(new AnalysisCancelledError(OPERATION, { cause: options.signal.reason }));
         const input = inspectElectronFusesInputSchema.safeParse(rawInput);
         if (!input.success)
             return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
@@ -32,49 +36,10 @@ export class ElectronFuseService {
         const inspected = await this.provider.inspect(input.data, options);
         if (!inspected.ok)
             return inspected;
-        if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(OPERATION));
         const report = electronFuseReportSchema.safeParse(inspected.value);
         if (!report.success ||
             report.data.artifact.selected_path !== input.data.path)
             return err(new AnalysisOutputError(OPERATION, "Electron fuse reader returned a malformed report or changed the selected artifact identity."));
-        const value = report.data;
-        const architecture = subjectArchitecture(value);
-        return ok(createEvidence({
-            path: value.artifact.resolved_path,
-            sha256: value.artifact.sha256,
-            format: value.artifact.format,
-            ...(architecture === undefined ? {} : { architecture }),
-        }, this.provider.identity, {
-            operation: OPERATION,
-            parameters: input.data,
-            result: value,
-            confidence: "observed",
-            limitations: value.limitations,
-            locations: locationsFor(value),
-        }));
+        return completeProviderEvidence(createElectronFuseEvidence(input.data, report.data, this.provider.identity), options?.signal);
     }
 }
-const subjectArchitecture = (report) => {
-    if (report.artifact.format === "mach-o-universal")
-        return undefined;
-    if (report.slices.length !== 1)
-        return undefined;
-    const name = report.slices[0]?.architecture;
-    return BINARY_ARCHITECTURES.find((supported) => supported === name);
-};
-const locationsFor = (report) => [
-    { kind: "artifact-path", path: report.artifact.selected_path },
-    ...(report.artifact.resolved_path === report.artifact.selected_path
-        ? []
-        : [
-            {
-                kind: "artifact-path",
-                path: report.artifact.resolved_path,
-            },
-        ]),
-    ...report.slices.flatMap((slice) => slice.sentinels.map((sentinel) => ({
-        kind: "file-offset",
-        offset: sentinel.sentinel_offset,
-    }))),
-];

package/dist/application/evm/EvmInterfaceEvidence.js

@@ -0,0 +1,11 @@
+import { createEvidence } from "../../domain/evidence.js";
+/** Preserve the same validated inference and provenance on success and failed finalization. */
+export const evmInterfaceEvidence = (input, execution) => createEvidence(execution.subject, execution.provider, {
+    operation: "inspect_evm_interface",
+    parameters: input,
+    result: execution.result,
+    ...(execution.rawResult === null ? {} : { rawResult: execution.rawResult }),
+    confidence: "inferred",
+    locations: execution.locations,
+    limitations: execution.limitations,
+});

package/dist/application/evm/EvmInterfaceService.js

@@ -1,10 +1,11 @@
 import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
-import { createEvidence } from "../../domain/evidence.js";
+import { evmInterfaceEvidence } from "./EvmInterfaceEvidence.js";
 import { inspectEvmInterfaceInputSchema, evmInterfaceSchema, } from "../../domain/evm/evmInterface.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { err, ok } from "../../domain/result.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 const OPERATION = "inspect_evm_interface";
 const diagnosticsSchema = z.object({
     diagnostics: evmInterfaceSchema.shape.diagnostics,
@@ -21,7 +22,7 @@ export class EvmInterfaceService {
     /** Preserve selected byte identity while clearly labeling recovered ABI candidates as inferences. */
     async inspect(rawInput, options) {
         if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(OPERATION));
+            return err(new AnalysisCancelledError(OPERATION, { cause: options.signal.reason }));
         const input = inspectEvmInterfaceInputSchema.safeParse(rawInput);
         if (!input.success)
             return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
@@ -42,8 +43,6 @@ export class EvmInterfaceService {
         const outputOptions = diagnostics.success
             ? { capturedOutput: diagnostics.data.diagnostics }
             : undefined;
-        if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(OPERATION, outputOptions));
         const execution = inspected.value;
         const report = evmInterfaceSchema.safeParse(execution.result);
         if (!report.success ||
@@ -53,16 +52,6 @@ export class EvmInterfaceService {
             execution.subject?.path !== input.data.path ||
             execution.subject.sha256 !== report.data.artifact.sha256)
             return err(new AnalysisOutputError(OPERATION, "Interface adapter returned malformed data or changed the selected carrier identity/encoding.", outputOptions));
-        return ok(createEvidence(execution.subject, execution.provider, {
-            operation: OPERATION,
-            parameters: input.data,
-            result: report.data,
-            ...(execution.rawResult === null
-                ? {}
-                : { rawResult: execution.rawResult }),
-            confidence: "inferred",
-            locations: execution.locations,
-            limitations: execution.limitations,
-        }));
+        return completeProviderEvidence(evmInterfaceEvidence(input.data, execution), options?.signal, outputOptions?.capturedOutput);
     }
 }

package/dist/application/firmware/FirmwareAnalysisService.js

@@ -2,7 +2,8 @@ import { firmwareRequestSchema, } from "../../domain/firmware/firmwareAnalysis.j
 import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
 import { createEvidence } from "../../domain/evidence.js";
 import { jsonObjectSchema } from "../../domain/jsonValue.js";
-import { err, ok } from "../../domain/result.js";
+import { err } from "../../domain/result.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 /** Shared CLI/MCP validation and Evidence composition for arbitrary firmware files. */
 export class FirmwareAnalysisService {
     provider;
@@ -25,7 +26,7 @@ export class FirmwareAnalysisService {
         const execution = executed.value;
         if (execution.subject === null)
             return err(new AnalysisOutputError(operation, "Firmware execution did not bind its source artifact"));
-        return ok(createEvidence(execution.subject, execution.provider, {
+        return completeProviderEvidence(createEvidence(execution.subject, execution.provider, {
             operation,
             parameters: jsonObjectSchema.parse(parsed.data.input),
             result: execution.result,
@@ -33,6 +34,6 @@ export class FirmwareAnalysisService {
             locations: execution.locations,
             limitations: execution.limitations,
             confidence: "observed",
-        }));
+        }), options?.signal);
     }
 }

package/dist/application/go/GoBinaryService.js

@@ -5,6 +5,7 @@ import { BINARY_ARCHITECTURES } from "../../domain/binaryTargetTypes.js";
 import { goBinarySchema, inspectGoBinaryInputSchema, } from "../../domain/go/goBinary.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { err, ok } from "../../domain/result.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 const OPERATION = "inspect_go_binary";
 const architectureForSubject = (architecture) => {
     switch (architecture) {
@@ -28,7 +29,7 @@ export class GoBinaryService {
     /** Inspect one explicitly selected file without acquiring a binary session. */
     async inspect(rawInput, options) {
         if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(OPERATION));
+            return err(new AnalysisCancelledError(OPERATION, { cause: options.signal.reason }));
         const input = inspectGoBinaryInputSchema.safeParse(rawInput);
         if (!input.success)
             return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
@@ -45,14 +46,12 @@ export class GoBinaryService {
         const inspected = await this.provider.inspect(input.data, options);
         if (!inspected.ok)
             return inspected;
-        if (options?.signal?.aborted)
-            return err(new AnalysisCancelledError(OPERATION));
         const report = goBinarySchema.safeParse(inspected.value);
         if (!report.success || report.data.artifact.path !== input.data.path)
             return err(new AnalysisOutputError(OPERATION, "Go build-information reader returned malformed metadata or changed the selected artifact identity."));
         const value = report.data;
         const architecture = architectureForSubject(value.architecture);
-        return ok(createEvidence({
+        return completeProviderEvidence(createEvidence({
             path: value.artifact.path,
             sha256: value.artifact.sha256,
             format: value.format === "macho" ? "mach-o" : value.format,
@@ -75,6 +74,6 @@ export class GoBinaryService {
                         },
                     ]),
             ],
-        }));
+        }), options?.signal);
     }
 }

package/dist/application/investigation/EvidenceLedger.js

@@ -194,10 +194,9 @@ export class EvidenceLedger {
         catch (cause) {
             return err(new UnknownRegistryError("invalid-transition", { cause }));
         }
-        const existingUnknown = this.#unknownHeads.get(unknown.unknown_id);
-        if (existingUnknown !== undefined) {
-            if (existingUnknown.revision !== 1 ||
-                existingUnknown.revision_digest !== unknown.revision_digest)
+        const creationUnknown = this.#unknownRevisions.get(unknownRevisionKey(unknown));
+        if (creationUnknown !== undefined) {
+            if (creationUnknown.revision_digest !== unknown.revision_digest)
                 return err(new UnknownRegistryError("already-exists"));
             const checked = this.#appendIncremental([evidence]);
             if (!checked.ok)

package/dist/application/javascript/ElectronBoundaryGraphWindows.js

@@ -41,13 +41,25 @@ const addBrowserWindow = (input) => {
                     web_preferences: value.web_preferences,
                     preload_path: value.preload_path,
                     preload_resolution_context: value.preload_resolution_context,
+                    ...(value.resolution_sources === undefined
+                        ? {}
+                        : {
+                            resolution_sources: value.resolution_sources.map((location) => ({
+                                source: file.path,
+                                ...location,
+                            })),
+                        }),
                     absence_means_default: false,
                 },
-                evidence: astObservationEvidence({
+                evidence: (value.resolution_sources === undefined
+                    ? astObservationEvidence
+                    : staticInferenceEvidence)({
                     sha256: file.sha256,
                     path: file.path,
                     range: value.location,
-                    operation: "observe-browser-window-construction",
+                    operation: value.resolution_sources === undefined
+                        ? "observe-browser-window-construction"
+                        : "resolve-browser-window-constant-options",
                     coverage,
                     limitations: [
                         "Only explicitly present webPreferences are reported; omitted properties are not interpreted as Electron defaults.",

package/dist/application/javascript/ElectronEvidence.js

@@ -1,5 +1,4 @@
 import { createEvidence, } from "../../domain/evidence.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
 /** Create Evidence for one Electron observation. */
 export const createElectronEvidence = (operation, input, result, provider) => createEvidence(undefined, provider, {
     predicateType: operation === "list_electron_targets"
@@ -7,7 +6,7 @@ export const createElectronEvidence = (operation, input, result, provider) => cr
         : "rea.electron-page-inspection",
     operation,
     parameters: parameters(input),
-    result: jsonValueSchema.parse(result),
+    result,
     confidence: "observed",
     authority: "external-service",
     environment: "target" in result

package/dist/application/javascript/ElectronObservationService.js

@@ -1,25 +1,59 @@
-import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
 import { err, ok } from "../../domain/result.js";
 import { createElectronEvidence } from "./ElectronEvidence.js";
+import { electronPageInspectionSchema, electronTargetListSchema, } from "../../domain/javascript/electronObservation.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 /** List local file pages exposed by the explicitly selected endpoint. */
 export const listElectronTargets = async (provider, input, options = {}) => {
     const ready = requireProvider(provider, "list_electron_targets");
     if (!ready.ok)
         return ready;
+    if (options.signal?.aborted)
+        return err(new AnalysisCancelledError("list_electron_targets"));
     const result = await ready.value.listTargets(input, options);
-    return result.ok
-        ? ok(createElectronEvidence("list_electron_targets", input, result.value, ready.value.identity()))
-        : result;
+    if (!result.ok)
+        return result;
+    const report = electronTargetListSchema.safeParse(result.value);
+    if (!report.success)
+        return err(new AnalysisOutputError("list_electron_targets", "Electron provider returned a malformed target list.", { cause: report.error }));
+    return completeProviderEvidence(createElectronEvidence("list_electron_targets", input, report.data, ready.value.identity()), options.signal);
 };
 /** Inspect one local file page from the explicitly selected endpoint. */
 export const inspectElectronPage = async (provider, input, options = {}) => {
     const ready = requireProvider(provider, "inspect_electron_page");
     if (!ready.ok)
         return ready;
+    if (options.signal?.aborted)
+        return err(new AnalysisCancelledError("inspect_electron_page"));
     const result = await ready.value.inspectPage(input, options);
-    return result.ok
-        ? ok(createElectronEvidence("inspect_electron_page", input, result.value, ready.value.identity()))
-        : result;
+    if (!result.ok) {
+        const partial = result.error.partialObservation;
+        if (partial !== undefined &&
+            "kind" in partial &&
+            partial.kind === "electron-page-observation") {
+            const report = electronPageInspectionSchema.safeParse(partial.inspection);
+            if (!report.success) {
+                if (result.error instanceof AnalysisCancelledError)
+                    return err(new AnalysisOutputError("inspect_electron_page", "Electron provider retained a malformed completed page inspection.", { cause: report.error }));
+                return result;
+            }
+            const inspection = {
+                ...report.data,
+                limitations: [
+                    ...report.data.limitations,
+                    partial.cleanup === "transport-closed"
+                        ? "REA closed its CDP transport; this does not imply target shutdown."
+                        : "CDP transport cleanup remains incomplete.",
+                ],
+            };
+            result.error.partialObservation = createElectronEvidence("inspect_electron_page", input, inspection, ready.value.identity());
+        }
+        return result;
+    }
+    const report = electronPageInspectionSchema.safeParse(result.value);
+    if (!report.success)
+        return err(new AnalysisOutputError("inspect_electron_page", "Electron provider returned a malformed page inspection.", { cause: report.error }));
+    return completeProviderEvidence(createElectronEvidence("inspect_electron_page", input, report.data, ready.value.identity()), options.signal);
 };
 const requireProvider = (provider, operation) => provider === undefined
     ? err(new AnalysisCapabilityUnavailableError("rea-cdp-electron", operation, "Electron observation provider is not configured"))

package/dist/application/javascript/JavaScriptApplicationEvidence.js

@@ -43,6 +43,12 @@ const parameters = (input) => ({
     ...(input.max_semantic_nodes_per_file === undefined
         ? {}
         : { max_semantic_nodes_per_file: input.max_semantic_nodes_per_file }),
+    ...(input.max_semantic_unknowns === undefined
+        ? {}
+        : { max_semantic_unknowns: input.max_semantic_unknowns }),
+    ...(input.max_semantic_unknowns_per_file === undefined
+        ? {}
+        : { max_semantic_unknowns_per_file: input.max_semantic_unknowns_per_file }),
     ...(input.source_paths === undefined
         ? {}
         : { source_paths: input.source_paths }),

package/dist/application/javascript/JavaScriptArtifactAnalysis.js

@@ -3,12 +3,13 @@ import { moduleResolutionModeForJavaScriptReference } from "../../domain/javascr
 import { setImmediate } from "node:timers/promises";
 import { resolveJavaScriptSourceMapReferences } from "../../domain/javascript/javascriptSourceMapPaths.js";
 import { analyzeParsedJavaScriptStaticSourceSteps } from "../../domain/javascript/javascriptStaticAnalysis.js";
-import { analyzeParsedJavaScriptSemanticsSteps, classifyParsedJavaScriptOpenReceiversSteps, } from "../../domain/javascript/javascriptSemanticAnalysis.js";
+import { analyzeParsedJavaScriptSemanticsSteps } 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, sourceMapJsonText, } from "../../domain/sourceMapEnvelope.js";
 import { failedJavaScriptStaticAnalysis } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
+import { javascriptArtifactAnalysisScopes } from "./JavaScriptArtifactAnalysisTypes.js";
 import { analyzeJavaScriptJsonModule } from "./JavaScriptJsonModules.js";
 import { completeJavaScriptAnalysisSteps } from "./JavaScriptAnalysisControl.js";
 import { htmlArtifactReferences } from "../../domain/javascript/htmlArtifactReferences.js";
@@ -51,6 +52,7 @@ export const analyzeAndAdoptJavaScriptArtifactFiles = async (fileSet, worker, pr
     const selectedFileCount = fileSet.files.length - (fileSet.source_selection?.unselected_files ?? 0);
     let selectedFileIndex = 0;
     for (const file of fileSet.files) {
+        let analysisStarted = false;
         try {
             await setImmediate();
             if (classifyOutsideAnalysisScope(file, state, projection)) {
@@ -63,6 +65,7 @@ export const analyzeAndAdoptJavaScriptArtifactFiles = async (fileSet, worker, pr
             if (signal?.aborted === true)
                 throw new AnalysisCancelledError("analyze_javascript_application");
             await beforeFile(file, selectedFileIndex++, selectedFileCount);
+            analysisStarted = true;
             if (file.kind !== "javascript" || !file.text.included) {
                 const steps = analyzeArtifactFileSteps(file, {
                     state,
@@ -74,7 +77,7 @@ export const analyzeAndAdoptJavaScriptArtifactFiles = async (fileSet, worker, pr
                 await completeJavaScriptAnalysisSteps(steps, signal);
                 continue;
             }
-            const result = await worker.analyze(file, projection.remainingFileNodeBudget(), signal);
+            const result = await worker.analyze(file, projection.remainingFileCapacity(), signal);
             const facts = result.ok ? result.value : result.error;
             const applicationProjectionFailure = facts.applicationProjectionFailure;
             if (facts.projection !== null)
@@ -88,6 +91,8 @@ export const analyzeAndAdoptJavaScriptArtifactFiles = async (fileSet, worker, pr
             const failure = error === null
                 ? undefined
                 : {
+                    scope: javascriptArtifactAnalysisScopes.javascript,
+                    status: "interrupted",
                     reason: `${file.path}: ${error.message}`,
                     error: projectAnalysisError(error),
                     limits,
@@ -138,15 +143,22 @@ export const analyzeAndAdoptJavaScriptArtifactFiles = async (fileSet, worker, pr
                         ? cause
                         : null;
             if (interruption !== null) {
+                const scope = javascriptArtifactAnalysisScopes[file.kind];
                 state.files.push({
                     file,
                     javascript: null,
                     semantic: null,
-                    analysis_failure: {
-                        reason: `${file.path}: ${interruption.message}`,
-                        error: projectAnalysisError(interruption),
-                        limits: null,
-                    },
+                    ...(scope === null
+                        ? {}
+                        : {
+                            analysis_failure: {
+                                scope,
+                                status: analysisStarted ? "interrupted" : "not-started",
+                                reason: `${file.path}: ${interruption.message}`,
+                                error: projectAnalysisError(interruption),
+                                limits: null,
+                            },
+                        }),
                 });
                 projection.recordUnavailableFile(file, interruption.message, null, "incomplete-module");
             }
@@ -164,22 +176,30 @@ export const analyzeAndAdoptJavaScriptArtifactFiles = async (fileSet, worker, pr
                     ? { worker_timeout_ms: interruption.timeoutMs }
                     : null,
         };
+        // This interruption has one cause. Share its immutable failure per phase
+        // rather than copying it for every unvisited source in a large bundle.
+        const failures = new Map();
         for (const file of fileSet.files) {
             if (analyzedPaths.has(file.path))
                 continue;
             if (classifyOutsideAnalysisScope(file, state, projection))
                 continue;
+            const scope = javascriptArtifactAnalysisScopes[file.kind];
+            let unavailable = scope === null ? undefined : failures.get(scope);
+            if (scope !== null && unavailable === undefined) {
+                unavailable = { ...failure, scope, status: "not-started" };
+                failures.set(scope, unavailable);
+            }
             state.files.push({
                 file,
                 javascript: null,
                 semantic: null,
-                analysis_failure: failure,
+                ...(unavailable === undefined ? {} : { analysis_failure: unavailable }),
             });
-            if (file.kind === "javascript")
-                projection.recordUnavailableFile(file, failure.reason, failure.limits, interruption instanceof AnalysisResourceConstraintError ||
-                    interruption instanceof AnalysisTimeoutError
-                    ? "resource-limit"
-                    : "incomplete-module");
+            projection.recordUnavailableFile(file, failure.reason, failure.limits, interruption instanceof AnalysisResourceConstraintError ||
+                interruption instanceof AnalysisTimeoutError
+                ? "resource-limit"
+                : "incomplete-module");
         }
     }
     return { analysis: finalizeArtifactAnalysis(state), interruption };
@@ -243,8 +263,7 @@ function* analyzeArtifactFileSteps(file, context) {
         state.parseFailures += 1;
         return;
     }
-    const openReceiverFacts = yield* classifyParsedJavaScriptOpenReceiversSteps(parsed);
-    const analysis = yield* analyzeParsedJavaScriptStaticSourceSteps(file.text.value, parsed, openReceiverFacts);
+    const analysis = yield* analyzeParsedJavaScriptStaticSourceSteps(file.text.value, parsed);
     const staticFindings = findingCount(analysis);
     yield;
     const semantics = analysis.parse_status === "complete" || analysis.parse_status === "partial"
@@ -268,8 +287,7 @@ const classifyOutsideAnalysisScope = (file, state, projection) => {
     if (file.text.included || file.text.reason !== "outside-analysis-scope")
         return false;
     state.files.push({ file, javascript: null, semantic: null });
-    if (file.kind === "javascript")
-        projection?.recordUnavailableFile(file, "Source was not analyzed because it is outside the caller-selected source_paths.", null, "incomplete-module");
+    projection?.recordUnavailableFile(file, "Source was not analyzed because it is outside the caller-selected source_paths.", null, "incomplete-module");
     return true;
 };
 const addSourceMap = (file, context) => {

package/dist/application/javascript/JavaScriptArtifactAnalysisTypes.js

@@ -1 +1,30 @@
-export {};
+/** Applicable processing of inventoried files; native bytes remain metadata-only. */
+export const javascriptArtifactAnalysisScopes = {
+    javascript: {
+        operation: "analyze-javascript-source",
+        authority: "ast-static-analysis",
+    },
+    "package-json": {
+        operation: "parse-package-json",
+        authority: "artifact-bytes",
+    },
+    json: { operation: "parse-json-module", authority: "artifact-bytes" },
+    html: {
+        operation: "parse-html-script-references",
+        authority: "artifact-bytes",
+    },
+    "source-map": {
+        operation: "parse-local-source-map",
+        authority: "artifact-bytes",
+    },
+    "native-addon": null,
+};
+/**
+ * A JavaScript source selected for analysis whose worker produced no facts.
+ * The analysis failure carries the reason; the null parse status alone reads
+ * as "nothing there" instead of "not analyzed".
+ */
+export const isSkippedJavaScriptAnalysis = (entry) => entry.file.kind === "javascript" &&
+    entry.file.text.included &&
+    entry.javascript === null &&
+    entry.analysis_failure !== undefined;

package/dist/application/javascript/JavaScriptArtifactGraphContext.js

@@ -2,7 +2,7 @@ import { compositeKey } from "../../domain/unicodeCodePointOrder.js";
 import { completeApplicationCoverage, partialApplicationCoverage, truncatedApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { HTML_INLINE_SCRIPT_LOCATION_LIMIT } from "../../domain/javascript/htmlArtifactReferences.js";
 import { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
-import { artifactObservationEvidence, astObservationEvidence, staticInferenceEvidence, unavailableAstEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
+import { artifactObservationEvidence, astObservationEvidence, staticInferenceEvidence, unavailableStaticEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { artifactPathResolutionProperties, resolveArtifactPathByContext, } from "./JavaScriptArtifactPathResolution.js";
 /** The per-file bound on retained inline HTML script locations. */
 export const HTML_INLINE_SCRIPT_LOCATION_COVERAGE_LIMIT = {
@@ -85,7 +85,8 @@ export const addUnavailableStaticParseScope = (context, input) => {
                         ? {}
                         : { analysis_failure: input.failure }),
                 },
-                evidence: unavailableAstEvidence({
+                evidence: unavailableStaticEvidence({
+                    authority: input.authority,
                     sha256: input.file.sha256,
                     path: input.file.path,
                     operation: input.operation,