rea-agents 5.0.0 → 6.0.0

package/dist/application/binaryDiagnostics/BinaryLayoutService.js

@@ -0,0 +1,57 @@
+import { isAbsolute } from "node:path";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { inspectBinaryLayoutInputSchema, binaryLayoutSchema, } from "../../domain/native/binaryLayout.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+const OPERATION = "inspect_binary_layout";
+/** Shared CLI/MCP validation and Evidence composition for offline layout inspection. */
+export class BinaryLayoutService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Bind complete observations to the caller-selected artifact before creating Evidence. */
+    async inspect(rawInput, options) {
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const input = inspectBinaryLayoutInputSchema.safeParse(rawInput);
+        if (!input.success)
+            return err(new AnalysisInputError(OPERATION, { cause: input.error }, projectInputIssues(input.error.issues, rawInput)));
+        if (!isAbsolute(input.data.path))
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                {
+                    path: ["path"],
+                    reason: "invalid_format",
+                    message: "Expected an absolute filesystem path on this host.",
+                },
+            ]));
+        const inspected = await this.provider.inspect(input.data, options);
+        if (!inspected.ok)
+            return inspected;
+        const diagnostics = binaryLayoutSchema.shape.diagnostics.safeParse(inspected.value.diagnostics);
+        const outputOptions = diagnostics.success
+            ? { capturedOutput: diagnostics.data }
+            : undefined;
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION, outputOptions));
+        const report = binaryLayoutSchema.safeParse(inspected.value);
+        if (!report.success || report.data.artifact.path !== input.data.path)
+            return err(new AnalysisOutputError(OPERATION, "Binary layout provider returned malformed evidence or changed the selected artifact identity.", outputOptions));
+        const value = report.data;
+        return ok(createEvidence({
+            path: value.artifact.path,
+            format: "elf",
+            architecture: "x86_64",
+            sha256: value.artifact.sha256,
+        }, this.provider.identity, {
+            operation: OPERATION,
+            parameters: input.data,
+            result: value,
+            rawResult: value,
+            confidence: "observed",
+            limitations: value.limitations,
+            locations: [{ kind: "artifact-path", path: value.artifact.path }],
+        }));
+    }
+}

package/dist/application/binaryDiagnostics/RecordedCrashPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/binaryDiagnostics/RecordedCrashService.js

@@ -0,0 +1,60 @@
+import { isAbsolute } from "node:path";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { inspectRecordedCrashInputSchema, recordedCrashSchema, } from "../../domain/native/recordedCrash.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+const OPERATION = "inspect_recorded_crash";
+/** Shared CLI/MCP validation and Evidence composition for recorded crash inspection. */
+export class RecordedCrashService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Bind complete observations to the caller-selected artifact before creating Evidence. */
+    async inspect(rawInput, options) {
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const input = inspectRecordedCrashInputSchema.safeParse(rawInput);
+        if (!input.success)
+            return err(new AnalysisInputError(OPERATION, { cause: input.error }, projectInputIssues(input.error.issues, rawInput)));
+        if (!isAbsolute(input.data.path))
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                {
+                    path: ["path"],
+                    reason: "invalid_format",
+                    message: "Expected an absolute filesystem path on this host.",
+                },
+            ]));
+        const inspected = await this.provider.inspect(input.data, options);
+        if (!inspected.ok)
+            return inspected;
+        const diagnostics = recordedCrashSchema.shape.diagnostics.safeParse(inspected.value.diagnostics);
+        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 ||
+            (report.data.debugger.status === "available") !==
+                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({
+            path: value.artifact.path,
+            format: "elf",
+            architecture: "x86_64",
+            sha256: value.artifact.sha256,
+        }, this.provider.identity, {
+            operation: OPERATION,
+            parameters: input.data,
+            result: value,
+            rawResult: value,
+            confidence: value.debugger.status === "available" ? "derived" : "observed",
+            limitations: value.limitations,
+            locations: [{ kind: "artifact-path", path: value.artifact.path }],
+        }));
+    }
+}

package/dist/application/evm/EvmInterfacePort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/evm/EvmInterfaceService.js

@@ -0,0 +1,62 @@
+import { isAbsolute } from "node:path";
+import { z } from "zod";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { inspectEvmInterfaceInputSchema, evmInterfaceSchema, } from "../../domain/evm/evmInterface.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+const OPERATION = "inspect_evm_interface";
+const diagnosticsSchema = z.object({
+    diagnostics: evmInterfaceSchema.shape.diagnostics,
+});
+/** Shared carrier validation and typed inline Evidence for CLI/MCP. */
+export class EvmInterfaceService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** 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));
+        const input = inspectEvmInterfaceInputSchema.safeParse(rawInput);
+        if (!input.success)
+            return err(new AnalysisInputError(OPERATION, { cause: input.error }, projectInputIssues(input.error.issues, rawInput)));
+        if (!isAbsolute(input.data.path))
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                {
+                    path: ["path"],
+                    reason: "invalid_format",
+                    message: "Expected an absolute filesystem path on this host.",
+                },
+            ]));
+        const inspected = await this.provider.inspect(input.data, options);
+        if (!inspected.ok)
+            return inspected;
+        const diagnostics = diagnosticsSchema.safeParse(inspected.value.result);
+        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 ||
+            report.data.artifact.path !== input.data.path ||
+            report.data.artifact.encoding !== input.data.encoding ||
+            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,
+        }));
+    }
+}

package/dist/application/javascript/JavaScriptApplicationEvidence.js

@@ -1,5 +1,4 @@
 import { createEvidence, } from "../../domain/evidence.js";
-import { jsonValueSchema } from "../../domain/jsonValue.js";
 import { JAVASCRIPT_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
 /** Create Evidence for one deterministic local JavaScript application graph. */
 export const createJavaScriptApplicationEvidence = (input, result) => createEvidence({
@@ -10,7 +9,7 @@ export const createJavaScriptApplicationEvidence = (input, result) => createEvid
     predicateType: "rea.javascript-application-analysis",
     operation: "analyze_javascript_application",
     parameters: parameters(input),
-    result: jsonValueSchema.parse(result),
+    result,
     rawResult: null,
     confidence: "derived",
     authority: "shipped-artifact",

package/dist/application/javascript/JavaScriptApplicationService.js

@@ -30,13 +30,26 @@ export const analyzeJavaScriptApplicationValidated = async (input, options = {})
         const reconstructed = await reconstructJavaScriptArtifact({
             input_path: input.input_path,
             format: input.format,
-        }, options.signal);
+        }, options.signal, options.progress);
         const { electron_summary: summary, ...application } = reconstructed;
+        await options.progress?.report({
+            phase: "validate_javascript_application_result",
+            completed: 0,
+            total: 1,
+            message: "Validating the application analysis result",
+        });
         const result = javascriptApplicationAnalysisResultSchema.parse({
             ...application,
             summary,
             limitations: reconstructed.graph.limitations,
         });
+        await options.progress?.report({
+            phase: "create_javascript_application_evidence",
+            completed: 0,
+            total: 1,
+            message: "Creating and hashing application analysis Evidence",
+        });
+        const evidence = createJavaScriptApplicationEvidence(input, result);
         await options.progress?.report({
             phase: "analyze_javascript_application",
             completed: 1,
@@ -44,7 +57,7 @@ export const analyzeJavaScriptApplicationValidated = async (input, options = {})
             message: "Application graph and Electron boundaries reconstructed",
             terminal: true,
         });
-        return ok(createJavaScriptApplicationEvidence(input, result));
+        return ok(evidence);
     }
     catch (cause) {
         if (cause instanceof ArtifactReaderFailure)

package/dist/application/javascript/JavaScriptArtifactAnalysis.js

@@ -1,4 +1,5 @@
 import { createHash } from "node:crypto";
+import { setImmediate } from "node:timers/promises";
 import { analyzeParsedJavaScriptStaticSource } from "../../domain/javascript/javascriptStaticAnalysis.js";
 import { analyzeParsedJavaScriptSemantics } from "../../domain/javascript/javascriptSemanticAnalysis.js";
 import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";
@@ -6,10 +7,39 @@ 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 { htmlArtifactReferences } from "../../domain/javascript/htmlArtifactReferences.js";
 /** Analyze every text source from the artifact without a result quota. */
-export const analyzeJavaScriptArtifactFiles = (fileSet) => {
+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) => {
     const state = emptyArtifactAnalysis();
-    const context = { state };
+    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 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);
+    }
+    return finalizeArtifactAnalysis(state);
+};
+const analyzeArtifactFiles = (fileSet, projectSemantics) => {
+    const state = emptyArtifactAnalysis();
+    const context = { state, projectSemantics };
     for (const file of fileSet.files)
         analyzeArtifactFile(file, context);
     return finalizeArtifactAnalysis(state);
@@ -62,7 +92,9 @@ const analyzeArtifactFile = (file, context) => {
     state.files.push({
         file,
         javascript: analysis,
-        semantic: semantics === null ? null : { ir: semantics },
+        semantic: semantics === null
+            ? null
+            : { ir: context.projectSemantics(file, semantics) },
     });
     state.visitedNodes += analysis.visited_ast_nodes;
     state.findings += staticFindings + (semantics?.moduleLinks.length ?? 0);
@@ -137,26 +169,13 @@ const unavailablePackage = (file, limitation) => ({
     limitation,
 });
 const parseHtmlScripts = (path, text) => {
-    const scripts = [];
-    const baseHref = htmlBaseHref(text);
-    const pattern = /<script\b[^>]*\bsrc\s*=\s*(["'])([^"']+)\1[^>]*>/giu;
-    for (const match of text.matchAll(pattern)) {
-        const script = match[2];
-        if (script === undefined)
-            continue;
-        const start = match.index;
-        scripts.push({
-            html_path: path,
-            script_path: script,
-            base_href: baseHref,
-            location: rangeForOffsets(text, start, start + match[0].length),
-        });
-    }
-    return scripts;
-};
-const htmlBaseHref = (text) => {
-    const match = /<base\b[^>]*\bhref\s*=\s*(["'])([^"']+)\1[^>]*>/iu.exec(text);
-    return match?.[2] ?? null;
+    const { scripts, baseHref } = htmlArtifactReferences(text);
+    return scripts.map(({ scriptPath, startOffset, endOffset }) => ({
+        html_path: path,
+        script_path: scriptPath,
+        base_href: baseHref,
+        location: rangeForOffsets(text, startOffset, endOffset),
+    }));
 };
 const parseSourceMap = (file) => {
     if (!file.text.included)

package/dist/application/javascript/JavaScriptArtifactGraphDocuments.js

@@ -1,5 +1,5 @@
 import { addArtifactContainsEdge, addStaticInferenceEdge, createElectronRoleNode, linkElectronRoleToAsset, } from "./JavaScriptArtifactGraphContext.js";
-import { artifactObservationEvidence } from "./JavaScriptArtifactGraphEvidence.js";
+import { artifactObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { completeApplicationCoverage } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
 /** Project HTML renderer entrypoints and their local script assets. */
@@ -46,8 +46,32 @@ export const addJavaScriptHtmlRoles = (context) => {
                 htmlBaseHref: script.base_href,
             });
             const resolvedPath = resolution.resolved_path;
-            if (resolvedPath === null)
+            if (resolvedPath === null) {
+                context.accumulator.addNode({
+                    kind: role.kind,
+                    identity: role.identity,
+                    observations: [
+                        {
+                            label: script.script_path,
+                            properties: {
+                                mechanism: "html-script-reference",
+                                script_path: script.script_path,
+                                base_href: script.base_href,
+                                ...resolution,
+                            },
+                            evidence: staticInferenceEvidence({
+                                sha256: html.sha256,
+                                path: html.path,
+                                range: script.location,
+                                operation: "resolve-html-script-reference",
+                                coverage: completeApplicationCoverage(),
+                                limitations: resolution.limitations,
+                            }),
+                        },
+                    ],
+                });
                 continue;
+            }
             const resolved = context.fileNodes.get(resolvedPath);
             if (resolved === undefined)
                 continue;

package/dist/application/javascript/JavaScriptArtifactPathResolution.js

@@ -14,16 +14,24 @@ const EXTENSIONS = [
 const NODE_BUILTINS = new Set(builtinModules.map((name) => name.replace(/^node:/u, "")));
 /** Resolve one declaration under its exact syntax/metadata context. */
 export const resolveArtifactPathByContext = (input) => resolvePackagePath(input, new Set());
-const resolvePackagePath = (input, packageChain, mode = "full") => {
+const resolvePackagePath = (input, packageChain, mode = "full", exportsTargetUrl = false) => {
     const rejected = rejectDeclaration(input);
     if (rejected !== null)
         return rejected;
-    const candidate = contextualCandidate(input);
+    const candidate = contextualCandidate(input, exportsTargetUrl);
     if (typeof candidate !== "string")
         return candidate;
     const confined = confineCandidate(input, candidate);
     if (typeof confined !== "string")
         return confined;
+    if (input.context === "html-reference")
+        return outcome(input, resolveFileCandidates(input, [confined]) ?? {
+            resolvedPath: null,
+            status: "not-found",
+            limitations: [
+                `The exact HTML resource ${confined} was not found among the selected application files.`,
+            ],
+        });
     const resolved = mode === "files-and-index"
         ? (resolveFileCandidates(input, [
             ...fileCandidates(confined),
@@ -48,10 +56,11 @@ const rejectDeclaration = (input) => {
         ]);
     return null;
 };
-const contextualCandidate = (input) => {
+const contextualCandidate = (input, exportsTargetUrl) => {
     const { context } = input;
-    const declared = context === "html-reference" ||
+    let declared = context === "html-reference" ||
         context === "url-reference" ||
+        exportsTargetUrl ||
         (context === "module-specifier" && input.moduleKind !== "require")
         ? stripQueryAndFragment(input.declaredPath)
         : input.declaredPath;
@@ -72,6 +81,23 @@ const contextualCandidate = (input) => {
         return unresolvedOutcome(input, "external", [
             "URL schemes and protocol-relative URLs are outside this local artifact path context.",
         ]);
+    // Exports targets use URL paths for both loaders; legacy main fields remain literal.
+    if (exportsTargetUrl ||
+        (context === "module-specifier" && input.moduleKind !== "require")) {
+        try {
+            declared = decodeURIComponent(declared);
+        }
+        catch (cause) {
+            void cause;
+            return unresolvedOutcome(input, "rejected", [
+                "The module URL path contains malformed percent encoding.",
+            ]);
+        }
+        if (declared.includes("\0"))
+            return unresolvedOutcome(input, "rejected", [
+                "The decoded module URL path contains NUL.",
+            ]);
+    }
     const relative = declared.startsWith("/") ? declared.slice(1) : declared;
     return declared.startsWith("/")
         ? relative
@@ -206,6 +232,12 @@ const resolveCandidate = (input, candidate, packageChain) => {
                 `Directory package metadata ${packagePath} is not valid package JSON.`,
             ],
         };
+    if (main.status === "rejected")
+        return {
+            resolvedPath: null,
+            status: "rejected",
+            limitations: [`Package metadata ${packagePath}: ${main.limitation}`],
+        };
     if (main.status === "unmatched")
         return {
             resolvedPath: null,
@@ -242,7 +274,7 @@ const resolveCandidate = (input, candidate, packageChain) => {
             return index;
     }
     // Preserve recursive artifact package lookup only after legacy file/index fallbacks.
-    return candidateOutcome(resolvePackagePath(entryInput, chain));
+    return candidateOutcome(resolvePackagePath(entryInput, chain, "full", main.source === "exports"));
 };
 const candidateOutcome = (nested) => nested.resolution_status === "resolved"
     ? {
@@ -299,23 +331,35 @@ const packageEntry = (text, moduleKind, useExports) => {
     }
 };
 const packageExport = (value, moduleKind) => {
-    if (typeof value === "string")
-        return packagePathValue(value);
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        return { status: "invalid" };
-    const root = Reflect.get(value, ".") ?? value;
-    if (typeof root === "string")
-        return packagePathValue(root);
-    if (typeof root !== "object" || root === null || Array.isArray(root))
-        return { status: "invalid" };
+    const root = typeof value === "object" && value !== null && Object.hasOwn(value, ".")
+        ? Reflect.get(value, ".")
+        : value;
     const flattened = exportTargets(root, packageExportConditions(moduleKind));
     if (flattened.kind === "invalid")
-        return { status: "invalid" };
+        return { status: "rejected", limitation: flattened.limitation };
     const first = flattened.kind === "unmatched" ? undefined : flattened.values[0];
     return first === undefined
-        ? { status: "unmatched", declared: Object.keys(root) }
+        ? {
+            status: "unmatched",
+            declared: typeof root === "object" && root !== null ? Object.keys(root) : [],
+        }
         : { status: "value", value: first };
 };
+const invalidExportTarget = (value, reason) => ({
+    kind: "invalid",
+    limitation: `The package exports target ${JSON.stringify(value) ?? String(value)} ${reason}.`,
+});
+// Node checks raw target segments before URL normalization. Compare encoded
+// segment names here; full URL decoding follows array target selection.
+const forbiddenExportSegment = (value) => value
+    .slice(2)
+    .split(/[\\/]/u)
+    .find((raw) => {
+    const segment = raw.replace(/%[0-9a-f]{2}/giu, (encoded) => String.fromCharCode(Number.parseInt(encoded.slice(1), 16)));
+    return (segment === "." ||
+        segment === ".." ||
+        segment.toLowerCase() === "node_modules");
+});
 /**
  * Resolve a target in Node's declared order. Explicit null blocks an active
  * condition, whereas an unmatched nested object permits the next condition.
@@ -323,30 +367,36 @@ const packageExport = (value, moduleKind) => {
  * preserves the final invalid-versus-null refusal if no string is selected.
  */
 const exportTargets = (value, conditions) => {
-    if (typeof value === "string")
-        return value.startsWith("./")
+    if (typeof value === "string") {
+        if (!value.startsWith("./"))
+            return invalidExportTarget(value, 'must start with "./"');
+        const forbidden = forbiddenExportSegment(value);
+        return forbidden === undefined
             ? { kind: "targets", values: [value] }
-            : { kind: "invalid" };
+            : invalidExportTarget(value, `contains forbidden path segment ${JSON.stringify(forbidden)} before URL normalization`);
+    }
     if (value === null)
         return { kind: "targets", values: [] };
     if (Array.isArray(value)) {
-        let invalid = false;
+        let invalid = null;
         for (const entry of value) {
             const nested = exportTargets(entry, conditions);
             if (nested.kind === "invalid") {
-                invalid = true;
+                invalid = nested.limitation;
                 continue;
             }
             if (nested.kind === "unmatched")
                 continue;
-            invalid = false;
+            invalid = null;
             if (nested.values.length > 0)
                 return nested;
         }
-        return invalid ? { kind: "invalid" } : { kind: "targets", values: [] };
+        return invalid === null
+            ? { kind: "targets", values: [] }
+            : { kind: "invalid", limitation: invalid };
     }
     if (typeof value !== "object")
-        return { kind: "invalid" };
+        return invalidExportTarget(value, "must be a relative string, object, array, or null");
     for (const [condition, target] of Object.entries(value)) {
         if (!conditions.has(condition))
             continue;

package/dist/application/javascript/JavaScriptArtifactReconstruction.js

@@ -1,15 +1,18 @@
 import { lstat, realpath } from "node:fs/promises";
 import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
 import { createJavaScriptArtifactReader as createReader } from "../../artifacts/javascript/JavaScriptArtifactReader.js";
-import { analyzeJavaScriptArtifactFiles } from "./JavaScriptArtifactAnalysis.js";
+import { analyzeAndProjectJavaScriptArtifactFiles } from "./JavaScriptArtifactAnalysis.js";
 import { readJavaScriptArtifactFiles } from "../../artifacts/javascript/JavaScriptArtifactFiles.js";
 import { buildJavaScriptArtifactGraph } from "./JavaScriptArtifactGraphBuilder.js";
 import { javascriptArtifactReconstructionInputSchema, } from "./JavaScriptArtifactReconstructionInput.js";
-import { scanCanonicalArtifactInventory } from "../ArtifactInventory.js";
+import { scanCanonicalArtifactInventory } from "../../artifacts/inventory/ArtifactInventory.js";
 import { summarizeElectronBoundaries } from "./ElectronBoundaryAnalysis.js";
-import { buildJavaScriptSemanticGraph } from "./JavaScriptSemanticGraphBuilder.js";
+import { createJavaScriptSemanticGraphProjection } from "./JavaScriptSemanticGraphBuilder.js";
 /** Reconstruct one local ASAR or extracted directory without executing code. */
-export const reconstructJavaScriptArtifact = async (rawInput, signal) => {
+export const reconstructJavaScriptArtifact = async (rawInput, signal, progress) => {
+    const reportPhase = async (phase, message) => {
+        await progress?.report({ phase, completed: 0, total: 1, message });
+    };
     const input = javascriptArtifactReconstructionInputSchema.parse(rawInput);
     abortIfNeeded(signal);
     const path = await realpath(input.input_path);
@@ -19,15 +22,25 @@ export const reconstructJavaScriptArtifact = async (rawInput, signal) => {
         throw new ArtifactReaderFailure("format", `Artifact inventory classified ${path} as ${snapshot.manifest.root_format}, not ${format}`);
     const reader = createReader(path, format);
     try {
+        await reportPhase("read_javascript_artifacts", "Reading inventoried JavaScript application sources");
         const files = await readJavaScriptArtifactFiles(reader, snapshot, signal);
-        const analysis = analyzeJavaScriptArtifactFiles(files);
+        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);
+        });
         abortIfNeeded(signal);
+        await reportPhase("build_javascript_application_graph", "Constructing application and Electron boundary relationships");
         const graph = buildJavaScriptArtifactGraph(snapshot, files, analysis);
-        const semanticGraph = buildJavaScriptSemanticGraph({
-            rootArtifactSha256: snapshot.manifest.root_sha256,
-            applicationGraph: graph,
-            analysis,
-        });
+        await reportPhase("build_javascript_semantic_graph", "Binding and validating static semantic relationships");
+        const semanticGraph = semanticProjection.finish(snapshot.manifest.root_sha256, graph, analysis);
         return {
             input_path: path,
             format,