rea-agents 6.3.0 → 6.4.0

package/dist/application/javascript/JavaScriptArtifactReconstruction.js

@@ -3,58 +3,114 @@ import { access, lstat, realpath } from "node:fs/promises";
 import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
 import { AnalysisAccessDeniedError, AnalysisInputError, AnalysisUnsupportedTargetError, } from "../../domain/analysisErrorCore.js";
 import { createJavaScriptArtifactReader as createReader } from "../../artifacts/javascript/JavaScriptArtifactReader.js";
-import { analyzeAndProjectJavaScriptArtifactFiles } from "./JavaScriptArtifactAnalysis.js";
+import { parseOwnedJavaScriptApplicationAnalysisSteps } from "../../domain/javascript/javascriptApplicationAnalysis.js";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { analyzeAndAdoptJavaScriptArtifactFiles } from "./JavaScriptArtifactAnalysis.js";
+import { createJavaScriptSourceAnalysis } from "../../artifacts/javascript/JavaScriptSourceAnalysis.js";
+import { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS } from "../../domain/javascript/javascriptAnalysisResourceControls.js";
+import { createOwnedJavaScriptApplicationEvidenceCooperatively } from "./JavaScriptApplicationEvidence.js";
 import { readJavaScriptArtifactFiles } from "../../artifacts/javascript/JavaScriptArtifactFiles.js";
 import { buildImmutableJavaScriptArtifactGraphSteps } from "./JavaScriptArtifactGraphBuilder.js";
 import { javascriptArtifactReconstructionInputSchema, } from "./JavaScriptArtifactReconstructionInput.js";
-import { scanCanonicalArtifactInventory } from "../../artifacts/inventory/scanCanonical.js";
+import { scanCanonicalArtifactInventoryInScope } from "../../artifacts/inventory/scanCanonical.js";
 import { summarizeElectronBoundaries } from "./ElectronBoundaryAnalysis.js";
 import { createJavaScriptSemanticGraphProjection } from "./JavaScriptSemanticGraphBuilder.js";
 import { checkpointJavaScriptAnalysis, completeJavaScriptAnalysisSteps, } from "./JavaScriptAnalysisControl.js";
 /** Reconstruct one local ASAR or extracted directory without executing code. */
-export const reconstructJavaScriptArtifact = async (rawInput, signal, progress) => {
+export const reconstructJavaScriptArtifact = async (rawInput, scope, signal, progress) => scope.run(async () => {
+    let effectiveSignal = signal;
+    let effectiveProgress = progress;
     const reportPhase = async (phase, message) => {
-        await progress?.report({ phase, completed: 0, total: 1, message });
-        await checkpointJavaScriptAnalysis(signal);
+        await effectiveProgress?.report({
+            phase,
+            completed: 0,
+            total: 1,
+            message,
+        });
+        await checkpointJavaScriptAnalysis(effectiveSignal);
     };
     const input = javascriptArtifactReconstructionInputSchema.parse(rawInput);
     abortIfNeeded(signal);
     const path = await resolveSelectedInput(input.input_path);
     const format = await resolveFormat(path, input);
-    const snapshot = await scanCanonicalArtifactInventory(path, {
+    const snapshot = await scanCanonicalArtifactInventoryInScope(path, {
+        resourceScope: scope,
         signal,
         integrity: { mode: input.integrity_policy },
     });
     if (snapshot.manifest.root_format !== format)
         throw new ArtifactReaderFailure("format", `Artifact inventory classified ${path} as ${snapshot.manifest.root_format}, not ${format}`);
     const reader = createReader(path, format);
+    const readerOwner = {
+        kind: "reader",
+        reader,
+        resource: `JavaScript artifact reader for ${path}`,
+    };
+    let readerOpen = true;
+    let reconstructionOutcome;
     try {
         await reportPhase("read_javascript_artifacts", "Reading inventoried JavaScript application sources");
-        const files = await readJavaScriptArtifactFiles(reader, snapshot, signal);
+        const files = await readJavaScriptArtifactFiles(reader, snapshot, scope, signal);
+        // Release acquisition before analysis consumes these owned file facts.
+        const earlyCleanup = await scope.release(readerOwner);
+        readerOpen = false;
+        if (earlyCleanup.kind === "failed")
+            throw ArtifactReaderFailure.withCleanup(earlyCleanup.cause, ArtifactReaderFailure.cleanupObservation(earlyCleanup.cause, readerOwner.resource), { kind: "artifact-inventory", inventory: snapshot });
         await reportPhase("parse_javascript_sources", `Parsing and projecting ${String(files.files.length)} application source files`);
         const semanticProjection = createJavaScriptSemanticGraphProjection();
-        const analysis = await analyzeAndProjectJavaScriptArtifactFiles(files, semanticProjection.projectFile, async (file, completed, total) => {
-            abortIfNeeded(signal);
-            await progress?.report({
-                phase: "parse_javascript_source",
-                completed: 0,
-                total: 1,
-                message: `Parsing and projecting ${file.path} (${String(completed + 1)}/${String(total)})`,
-            });
-            abortIfNeeded(signal);
-        });
-        await checkpointJavaScriptAnalysis(signal);
-        abortIfNeeded(signal);
+        const worker = createJavaScriptSourceAnalysis({
+            heapMb: input.max_heap_mb ?? JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.heapMb,
+            timeoutMs: input.analysis_timeout_ms ??
+                JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.timeoutMs,
+        }, files.files.filter((file) => file.kind === "javascript" && file.text.included).length);
+        let outcome;
+        let cleanupFailure;
+        try {
+            outcome = await analyzeAndAdoptJavaScriptArtifactFiles(files, worker, semanticProjection, async (file, completed, total) => {
+                abortIfNeeded(signal);
+                await progress?.report({
+                    phase: "parse_javascript_source",
+                    completed: 0,
+                    total: 1,
+                    message: `Parsing and projecting ${file.path} (${String(completed + 1)}/${String(total)})`,
+                });
+                abortIfNeeded(signal);
+            }, signal);
+        }
+        finally {
+            try {
+                const cleanup = await scope.release({
+                    kind: "javascript-source-analysis",
+                    analysis: worker,
+                    resource: `JavaScript source analyzer for ${path}`,
+                });
+                if (cleanup.kind === "failed")
+                    throw cleanup.cause;
+            }
+            catch (cause) {
+                if (!(cause instanceof AnalysisError))
+                    throw cause;
+                cleanupFailure = cause;
+            }
+        }
+        const analysis = outcome.analysis;
+        const interruption = cleanupFailure ?? outcome.interruption;
+        if (interruption !== null && interruption !== undefined) {
+            effectiveSignal = undefined;
+            effectiveProgress = undefined;
+        }
+        await checkpointJavaScriptAnalysis(effectiveSignal);
+        abortIfNeeded(effectiveSignal);
         await reportPhase("build_javascript_application_graph", "Constructing application and Electron boundary relationships");
         const applicationGraphSteps = buildImmutableJavaScriptArtifactGraphSteps(snapshot, files, analysis);
         await reportPhase("seal_javascript_application_graph", "Sealing the validated application graph");
-        const graph = await completeJavaScriptAnalysisSteps(applicationGraphSteps, signal);
+        const graph = await completeJavaScriptAnalysisSteps(applicationGraphSteps, effectiveSignal);
         await reportPhase("build_javascript_semantic_graph", "Binding and validating static semantic relationships");
         const semanticGraphSteps = semanticProjection.finishImmutableSteps(snapshot.manifest.root_sha256, graph);
         await reportPhase("seal_javascript_semantic_graph", "Validating and sealing the semantic graph");
-        const semanticGraph = await completeJavaScriptAnalysisSteps(semanticGraphSteps, signal);
-        await checkpointJavaScriptAnalysis(signal);
-        return {
+        const semanticGraph = await completeJavaScriptAnalysisSteps(semanticGraphSteps, effectiveSignal);
+        await checkpointJavaScriptAnalysis(effectiveSignal);
+        const completed = {
             input_path: path,
             format,
             root_artifact_sha256: snapshot.manifest.root_sha256,
@@ -77,11 +133,44 @@ export const reconstructJavaScriptArtifact = async (rawInput, signal, progress)
             },
             limitations: analysis.limitations,
         };
+        if (interruption !== null && interruption !== undefined) {
+            const { electron_summary: summary, ...application } = completed;
+            const partial = await completeJavaScriptAnalysisSteps(parseOwnedJavaScriptApplicationAnalysisSteps({
+                ...application,
+                summary,
+                limitations: completed.graph.limitations,
+            }));
+            const { max_heap_mb, analysis_timeout_ms, ...coreInput } = input;
+            const parameters = {
+                ...coreInput,
+                ...(max_heap_mb === undefined ? {} : { max_heap_mb }),
+                ...(analysis_timeout_ms === undefined ? {} : { analysis_timeout_ms }),
+            };
+            const evidence = await createOwnedJavaScriptApplicationEvidenceCooperatively(parameters, partial);
+            throw interruption.retainPartialObservation(evidence);
+        }
+        reconstructionOutcome = { kind: "completed", result: completed };
     }
-    finally {
-        await reader.close();
+    catch (cause) {
+        reconstructionOutcome = { kind: "failed", cause };
     }
-};
+    if (readerOpen) {
+        const cleanupAttempt = await scope.release(readerOwner);
+        if (cleanupAttempt.kind === "failed") {
+            const cleanup = ArtifactReaderFailure.cleanupObservation(cleanupAttempt.cause, readerOwner.resource);
+            const partialObservation = {
+                kind: "artifact-inventory",
+                inventory: snapshot,
+            };
+            throw ArtifactReaderFailure.withCleanup(reconstructionOutcome.kind === "failed"
+                ? reconstructionOutcome.cause
+                : cleanupAttempt.cause, cleanup, partialObservation);
+        }
+    }
+    if (reconstructionOutcome.kind === "failed")
+        throw reconstructionOutcome.cause;
+    return reconstructionOutcome.result;
+});
 const OPERATION = "analyze_javascript_application";
 /**
  * Resolve the caller-selected input. A missing or unreadable selection is a

package/dist/application/javascript/JavaScriptArtifactReconstructionInput.js

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

package/dist/application/javascript/JavaScriptModuleRelationships.js

@@ -1,5 +1,5 @@
 import { posix } from "node:path";
-import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
+import { compareUnicodeCodePoints, compositeKey, } from "../../domain/unicodeCodePointOrder.js";
 import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { semanticCoverageResourceLimits, semanticResourceLimitCoverage, } from "../../domain/javascript/javascriptSemanticCoverage.js";
 import { semanticResourceLimitReason } from "../../domain/javascript/javascriptSemanticResourceLimits.js";
@@ -59,7 +59,7 @@ export const addJavaScriptSourceModules = (context) => {
     }
 };
 /** Compose bounded CommonJS and ESM binding relationships across artifact files. */
-export const addJavaScriptModuleRelationships = (context) => {
+export function* addJavaScriptModuleRelationshipsSteps(context) {
     const omissions = { selfImports: 0 };
     for (const analyzed of context.analysis.files) {
         const { file, semantic } = analyzed;
@@ -67,6 +67,8 @@ export const addJavaScriptModuleRelationships = (context) => {
         if (semantic === null || source === undefined)
             continue;
         for (const link of semantic.ir.moduleLinks) {
+            // One module can export thousands of bindings, each with return shapes.
+            yield;
             const input = { context, file, semantic, source, link };
             if (isExportLink(link))
                 addExportRelationship(input, omissions);
@@ -78,7 +80,7 @@ export const addJavaScriptModuleRelationships = (context) => {
         }
     }
     return omissions;
-};
+}
 const addExportRelationship = (input, omissions) => {
     const { context, file, semantic, source, link } = input;
     if (link.exportedName === null)
@@ -92,7 +94,7 @@ const addExportRelationship = (input, omissions) => {
     });
     const exported = context.accumulator.addNode({
         kind: "javascript-module",
-        identity: artifactLocalIdentity(file.sha256, "module-export", `${file.container_sha256}:${file.path}:${link.exportedName}`),
+        identity: artifactLocalIdentity(file.sha256, "module-export", compositeKey([file.container_sha256, file.path, link.exportedName])),
         observations: [
             {
                 label: `${file.path}:${link.exportedName}`,

package/dist/application/javascript/JavaScriptRecoveryService.js

@@ -12,6 +12,9 @@ export class JavaScriptRecoveryService {
     constructor(provider) {
         this.provider = provider;
     }
+    close() {
+        return this.provider.close?.() ?? Promise.resolve();
+    }
     /** Recover sources and bind the result to its original immutable input. */
     async recover(input, options) {
         if (options?.signal?.aborted === true)

package/dist/application/javascript/JavaScriptSemanticGraphAsyncProjection.js

@@ -1,3 +1,4 @@
+import { compactStringIdentityKey } from "../../domain/compactStringIdentity.js";
 import { createJavaScriptSemanticGraphUnknown } from "../../domain/javascript/javascriptSemanticGraph.js";
 import { retainSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, } from "./JavaScriptSemanticGraphConstruction.js";
 import { unknownSemanticEvidence } from "./JavaScriptSemanticGraphEvidence.js";
@@ -7,7 +8,7 @@ export const projectSemanticEvents = (context) => {
     for (const operation of context.ir.eventOperations) {
         const eventKey = operation.eventName === null
             ? operation.eventId
-            : `${operation.emitterKey}\u0000${operation.eventName}`;
+            : `${operation.emitterKey}\u0000${compactStringIdentityKey(operation.eventName)}`;
         const event = eventNodes.get(eventKey) ?? addEventNode(context, operation, eventKey);
         if (event === null)
             continue;
@@ -37,7 +38,10 @@ const addEventNode = (context, operation, eventKey) => retainSemanticGraphNode(c
     kind: "event",
     roleKey: `event:${eventKey}`,
     location: operation.eventName === null ? operation.location : null,
-    label: operation.eventName,
+    label: operation.eventName === null ||
+        operation.eventName.length <= "event".length
+        ? operation.eventName
+        : "event",
     functionNodeId: null,
     properties: {
         emitter_key: operation.emitterKey,
@@ -50,7 +54,9 @@ const addListenerNode = (context, operation) => retainSemanticGraphNode(context.
     location: operation.listenerLocation ?? operation.location,
     label: operation.eventName === null
         ? operation.method
-        : `${operation.method}:${operation.eventName}`,
+        : operation.eventName.length <= "listener".length
+            ? `${operation.method}:${operation.eventName}`
+            : `${operation.method}:listener`,
     functionNodeId: operation.ownerCallableId === null
         ? null
         : (context.callableNodes.get(operation.ownerCallableId)?.node_id ??