rea-agents 6.2.0 → 6.4.0

package/dist/application/javascript/JavaScriptArtifactReconstruction.js

@@ -3,60 +3,120 @@ 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, { signal });
+    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, analysis);
+        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,
             inventory_manifest_id: snapshot.manifest.manifest_id,
             inventory_graph_sha256: snapshot.manifest.graph_sha256,
+            integrity_contradictions: snapshot.integrity_contradictions,
             graph,
             semantic_graph: semanticGraph,
             electron_summary: summarizeElectronBoundaries(analysis),
@@ -70,15 +130,47 @@ export const reconstructJavaScriptArtifact = async (rawInput, signal, progress)
                 findings: analysis.findings,
                 modules: analysis.modules,
                 parse_failures: analysis.parse_failures,
-                truncated_scopes: analysis.truncated_scopes,
             },
             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,6 +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: artifactIntegrityPolicySchema,
+    ...javaScriptAnalysisResourceControlsSchema.shape,
 });

package/dist/application/javascript/JavaScriptJsonModules.js

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "../../domain/canonicalOrdering.js";
+import { compareUnicodeCodePoints } from "../../domain/unicodeCodePointOrder.js";
 /** Parse one approved JSON module without evaluating JavaScript or resolving imports. */
 export const analyzeJavaScriptJsonModule = (file) => {
     if (!file.text.included)
@@ -26,7 +26,7 @@ export const analyzeJavaScriptJsonModule = (file) => {
         };
     }
     const keys = typeof value === "object" && value !== null && !Array.isArray(value)
-        ? Object.keys(value).sort(compareCodePoints)
+        ? Object.keys(value).sort(compareUnicodeCodePoints)
         : [];
     const retained = keys;
     return {

package/dist/application/javascript/JavaScriptModuleRelationships.js

@@ -1,8 +1,8 @@
 import { posix } from "node:path";
-import { compareCodePoints } from "../../domain/canonicalOrdering.js";
+import { compareUnicodeCodePoints, compositeKey, } from "../../domain/unicodeCodePointOrder.js";
 import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
-import { semanticCoverageResourceLimits } from "../../domain/javascript/javascriptSemanticCoverage.js";
-import { SEMANTIC_EXPRESSION_DEPTH_LIMIT, SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT, SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT, semanticResourceLimitReason, } from "../../domain/javascript/javascriptSemanticResourceLimits.js";
+import { semanticCoverageResourceLimits, semanticResourceLimitCoverage, } from "../../domain/javascript/javascriptSemanticCoverage.js";
+import { semanticResourceLimitReason } from "../../domain/javascript/javascriptSemanticResourceLimits.js";
 import { addAstContainsEdge, artifactLocalIdentity, } from "./JavaScriptArtifactGraphContext.js";
 import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { resolveArtifactPathByContext, } from "./JavaScriptArtifactPathResolution.js";
@@ -17,7 +17,7 @@ export const addJavaScriptSourceModules = (context) => {
             continue;
         const exports = semantic.ir.moduleLinks
             .flatMap(({ exportedName }) => exportedName === null ? [] : [exportedName])
-            .sort(compareCodePoints);
+            .sort(compareUnicodeCodePoints);
         const retainedExports = [...new Set(exports)];
         const source = context.accumulator.addNode({
             kind: "javascript-module",
@@ -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}`,
@@ -264,19 +266,7 @@ const semanticCoverage = (semantic) => {
     const resourceLimits = semanticCoverageResourceLimits(semantic.ir.coverage);
     if (semantic.ir.coverage.status === "complete" && resourceLimits.length === 0)
         return completeApplicationCoverage();
-    return partialApplicationCoverage(resourceLimits.map((resourceLimit) => ({
-        name: `javascript_semantic_${resourceLimit.replaceAll("-", "_")}`,
-        value: resourceLimit === "primitive-candidates"
-            ? SEMANTIC_PRIMITIVE_CANDIDATE_LIMIT
-            : resourceLimit === "primitive-bytes"
-                ? SEMANTIC_PRIMITIVE_JSON_BYTES_LIMIT
-                : SEMANTIC_EXPRESSION_DEPTH_LIMIT,
-        unit: resourceLimit === "expression-depth"
-            ? "depth"
-            : resourceLimit === "primitive-bytes"
-                ? "bytes"
-                : "items",
-    })), semantic.ir.coverage.omittedCount);
+    return partialApplicationCoverage(semanticResourceLimitCoverage(resourceLimits), semantic.ir.coverage.omittedCount);
 };
 const moduleFormat = (path, ir) => {
     const extension = posix.extname(path).toLowerCase();

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/JavaScriptRuntimeReconciliationService.js

@@ -1,9 +1,9 @@
 import { resolve } from "node:path";
 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 { reconcileJavaScriptRuntime } from "../../domain/javascript/javascriptRuntimeReconciliation.js";
+import { parseRuntimeReconciliationInput, reconcileJavaScriptRuntime, } from "../../domain/javascript/javascriptRuntimeReconciliation.js";
 import { reconcileJavaScriptRuntimeInputSchema } from "../../domain/javascript/javascriptRuntimeReconciliationSchemas.js";
 import { err, ok } from "../../domain/result.js";
 import { createJavaScriptRuntimeReconciliationEvidence } from "./JavaScriptRuntimeReconciliationEvidence.js";
@@ -17,19 +17,20 @@ export const reconcileJavaScriptRuntimeEvidence = (rawInput) => {
 };
 /** Reconcile input already parsed by a trusted adapter boundary. */
 export const reconcileJavaScriptRuntimeEvidenceValidated = (parsedInput) => {
+    let parsed;
     try {
-        const input = reconcileJavaScriptRuntimeInputSchema.parse(normalizeRuntimeMappingRoots(parsedInput));
-        const result = reconcileJavaScriptRuntime(input);
-        return ok(createJavaScriptRuntimeReconciliationEvidence(input, result));
+        parsed = parseRuntimeReconciliationInput(normalizeRuntimeMappingRoots(parsedInput));
     }
     catch (cause) {
         if (cause instanceof z.ZodError)
             return err(analysisInputErrorFromIssues(OPERATION, cause.issues, parsedInput));
-        if (cause instanceof TypeError &&
-            SAFE_RECONCILIATION_INPUT_CONSTRAINTS.has(cause.message))
-            return err(new AnalysisInputError(OPERATION, undefined, [
-                { path: [], reason: "invalid_value", message: cause.message },
-            ]));
+        return err(new AnalysisProtocolError("JavaScript runtime reconciliation input parsing failed", { cause }));
+    }
+    try {
+        const result = reconcileJavaScriptRuntime(parsed);
+        return ok(createJavaScriptRuntimeReconciliationEvidence(parsed.input, result));
+    }
+    catch (cause) {
         return err(new AnalysisProtocolError("JavaScript runtime reconciliation produced an invalid result", { cause }));
     }
 };
@@ -50,20 +51,3 @@ const normalizeRuntimeMappingRoots = (input) => ({
 const isPortableAbsolutePath = (path) => path.startsWith("/") ||
     /^[a-z]:[\\/]/iu.test(path) ||
     /^(?:\\\\|\/\/)[^\\/]+[\\/][^\\/]+(?:[\\/]|$)/u.test(path);
-const SAFE_RECONCILIATION_INPUT_CONSTRAINTS = new Set([
-    "Evidence semantic identifier does not match its record",
-    "JavaScript application Evidence subject disagrees with its result",
-    "Runtime reconciliation requires inspect_web_page, inspect_electron_page, observe_javascript_runtime, or capture_electron_scenario Evidence",
-    "Runtime Evidence target or declared role disagrees with its result",
-    "Runtime Evidence contains an invalid builtin location",
-    "Runtime Evidence target disagrees with its captured result",
-    "Browser Evidence target is outside its recorded origin scope",
-    "Runtime Evidence contains source without source-capture selection",
-    "Active Electron Evidence application path disagrees with its configured root",
-    ...[
-        "inspect_web_page",
-        "inspect_electron_page",
-        "observe_javascript_runtime",
-        "capture_electron_scenario",
-    ].map((operation) => `Evidence does not match the supported ${operation} contract`),
-]);

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 ??
@@ -84,7 +90,7 @@ const addEventUnknown = (context, operation, event, relation) => {
             : `Static ${operation.method} emitter identity is partial.`,
         candidate_node_ids: [],
         evidence: unknownSemanticEvidence(context.file, operation.location),
-    }));
+    }, context.state.evidenceContexts));
 };
 /** Project Node timer scheduling and exact local handle cancellation. */
 export const projectSemanticTimers = (context) => {
@@ -153,5 +159,5 @@ const projectTimerCancellation = (context, operation, timerNodes) => {
         detail: `Static ${operation.method} handle resolution was ${operation.resolution}.`,
         candidate_node_ids: [],
         evidence: unknownSemanticEvidence(context.file, operation.location),
-    }));
+    }, context.state.evidenceContexts));
 };