rea-agents 4.0.1 → 5.0.0

package/dist/application/investigation/InvestigationRecords.js

@@ -0,0 +1,69 @@
+import { createEvidence } from "../../domain/evidence.js";
+import { EvidenceLedger } from "./EvidenceLedger.js";
+import { UNKNOWN_REGISTRY_PROVIDER, unknownEvidenceLinks, unknownMutationEvidence, } from "./UnknownEvidence.js";
+/** One investigation's validated record owner, independent of binary execution. */
+export class InvestigationRecords {
+    #evidence = new EvidenceLedger();
+    /** Record immutable Evidence idempotently; reject conflicting content. */
+    recordEvidence(evidence) {
+        return this.#evidence.record(evidence);
+    }
+    /** Check one semantic Evidence ID without exposing stored values. */
+    hasEvidence(evidenceId) {
+        return this.#evidence.has(evidenceId);
+    }
+    /** Return a detached Evidence value for one semantic ID. */
+    evidenceById(evidenceId) {
+        return this.#evidence.get(evidenceId);
+    }
+    /** Export a detached deterministic bundle of Evidence and Unknown revisions. */
+    exportEvidenceBundle() {
+        return this.#evidence.export();
+    }
+    /** Atomically merge a bundle and report changes for the owner's post-commit observers. */
+    mergeEvidenceBundle(bundle) {
+        return this.#evidence.import(bundle);
+    }
+    /** Clear records when the owning runtime applies its existing lifecycle policy. */
+    clear() {
+        this.#evidence.clear();
+    }
+    /** Record an Unknown with an explicitly supplied Evidence subject, if any. */
+    recordUnknown(input, target) {
+        const recorded = this.#evidence.recordUnknown(input, unknownMutationEvidence(target, input));
+        return recorded;
+    }
+    /** Commit derived Evidence and its Unknown atomically without an implicit subject. */
+    recordEvidenceWithUnknown(evidence, input) {
+        const recorded = this.#evidence.recordWithUnknown(evidence, input, unknownMutationEvidence(undefined, input));
+        return recorded;
+    }
+    /** Update an optimistic revision with an explicitly supplied Evidence subject. */
+    updateUnknown(input, target) {
+        const evidence = createEvidence(target, UNKNOWN_REGISTRY_PROVIDER, {
+            predicateType: "rea.residual-unknown-mutation",
+            operation: "update_unknown",
+            parameters: {
+                unknown_id: input.unknown_id,
+                expected_revision: input.expected_revision,
+            },
+            result: { action: "update", status: input.status },
+            confidence: "derived",
+            authority: "analyst-inference",
+            evidenceLinks: unknownEvidenceLinks(input),
+            limitations: [
+                "Registry mutation evidence records analyst intent, not proof of the answer.",
+            ],
+        });
+        const updated = this.#evidence.updateUnknown(input, evidence);
+        return updated;
+    }
+    /** Return detached current Unknown revisions matching the selected filters. */
+    listUnknowns(filters = {}) {
+        return this.#evidence.listUnknowns(filters);
+    }
+    /** Verify registry consistency without asserting the answer is true. */
+    verifyUnknownResolution(unknownId) {
+        return this.#evidence.verifyUnknownResolution(unknownId);
+    }
+}

package/dist/application/{UnknownEvidence.js → investigation/UnknownEvidence.js}

@@ -1,4 +1,4 @@
-import { createEvidence } from "../domain/evidence.js";
+import { createEvidence } from "../../domain/evidence.js";
 /** Provider identity for analyst-authored residual-unknown mutations. */
 export const UNKNOWN_REGISTRY_PROVIDER = {
     id: "rea-unknown-registry",

package/dist/application/{ElectronActiveEvidence.js → javascript/ElectronActiveEvidence.js}

@@ -1,6 +1,6 @@
-import { createEvidence } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { digestCanonicalJson } from "../domain/browserScenarioNormalization.js";
+import { canonicalDigest } from "../../domain/comparisonSemantics.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
 /** Create Evidence without retaining arbitrary runtime argument values. */
 export const createElectronActiveEvidence = (input, result, provider) => createEvidence(undefined, provider, {
     predicateType: "rea.electron-active-scenario",
@@ -29,5 +29,5 @@ const scenarioProjection = (input) => ({
 });
 const parameters = (input) => ({
     ...scenarioProjection(input),
-    scenario_sha256: digestCanonicalJson(scenarioProjection(input)),
+    scenario_sha256: canonicalDigest(scenarioProjection(input), "Browser scenario"),
 });

package/dist/application/javascript/ElectronActiveObservationPort.js

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

package/dist/application/{ElectronActiveObservationService.js → javascript/ElectronActiveObservationService.js}

@@ -1,7 +1,8 @@
 import { dirname } from "node:path";
 import { realpath } from "node:fs/promises";
-import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../domain/errors.js";
-import { err } from "../domain/result.js";
+import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { err } from "../../domain/result.js";
 import { createElectronActiveEvidence } from "./ElectronActiveEvidence.js";
 const OPERATION = "capture_electron_scenario";
 const PROVIDER_ID = "rea-playwright-electron-active";

package/dist/application/{ElectronBoundaryAnalysis.js → javascript/ElectronBoundaryAnalysis.js}

@@ -1,3 +1,4 @@
+import { compareCodePoints } from "../../domain/canonicalOrdering.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
 /** Flatten all per-file IPC facts into deterministic application records. */
 export const collectElectronIpcRecords = (analysis) => analysis.files
@@ -110,4 +111,3 @@ const resolvesToFile = (input) => {
         (input.kind === undefined || input.files.get(resolved)?.kind === input.kind));
 };
 const ipcRecordKey = (path, finding) => `${path}\0${String(finding.location.start.line)}:${String(finding.location.start.column)}\0${finding.side}\0${finding.operation}`;
-const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;

package/dist/application/{ElectronBoundaryGraphContext.js → javascript/ElectronBoundaryGraphContext.js}

@@ -1,4 +1,4 @@
-import { sha256Text } from "../domain/javascriptStaticAnalysisHelpers.js";
+import { sha256Text } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { astObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 /** Resolve the file or recovered bundle module that owns one finding. */
 export const electronFindingSourceNode = (context, file, moduleKey) => moduleKey === null

package/dist/application/{ElectronEvidence.js → javascript/ElectronEvidence.js}

@@ -1,5 +1,5 @@
-import { createEvidence, } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
+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"

package/dist/application/javascript/ElectronObservationPort.js

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

package/dist/application/{ElectronObservationService.js → javascript/ElectronObservationService.js}

@@ -1,5 +1,6 @@
-import { AnalysisCapabilityUnavailableError, } from "../domain/errors.js";
-import { err, ok } from "../domain/result.js";
+import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { err, ok } from "../../domain/result.js";
 import { createElectronEvidence } from "./ElectronEvidence.js";
 /** List local file pages exposed by the explicitly selected endpoint. */
 export const listElectronTargets = async (provider, input, options = {}) => {

package/dist/application/{JavaScriptApplicationEvidence.js → javascript/JavaScriptApplicationEvidence.js}

@@ -1,6 +1,6 @@
-import { createEvidence, } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { JAVASCRIPT_APPLICATION_PROVIDER } from "./InvestigationProviders.js";
+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({
     path: result.input_path,

package/dist/application/{JavaScriptApplicationEvidenceGraph.js → javascript/JavaScriptApplicationEvidenceGraph.js}

@@ -1,8 +1,8 @@
-import { JAVASCRIPT_APPLICATION_PROVIDER, JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER, MANAGED_WORKFLOW_PROVIDER, } from "./InvestigationProviders.js";
-import { parseEvidence } from "../domain/evidence.js";
-import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../domain/javascriptApplicationAnalysis.js";
-import { javascriptRuntimeReconciliationResultSchema } from "../domain/javascriptRuntimeReconciliationSchemas.js";
-import { managedApplicationGraphResultSchema } from "../domain/managedApplicationGraph.js";
+import { JAVASCRIPT_APPLICATION_PROVIDER, JAVASCRIPT_RUNTIME_RECONCILIATION_PROVIDER, MANAGED_WORKFLOW_PROVIDER, } from "../InvestigationProviders.js";
+import { parseEvidence } from "../../domain/evidence.js";
+import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../../domain/javascript/javascriptApplicationAnalysis.js";
+import { javascriptRuntimeReconciliationResultSchema } from "../../domain/javascript/javascriptRuntimeReconciliationSchemas.js";
+import { managedApplicationGraphResultSchema } from "../../domain/managed/managedApplicationGraph.js";
 /** Parse and authenticate one REA-produced JavaScript Application Graph Evidence. */
 export const parseApplicationGraphEvidence = (input) => {
     const evidence = parseEvidence(input);

package/dist/application/javascript/JavaScriptApplicationService.js

@@ -0,0 +1,99 @@
+import { z } from "zod";
+import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../../domain/javascript/javascriptApplicationAnalysis.js";
+import { AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { ArtifactOperationError } from "../../domain/artifactOperationError.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { createJavaScriptApplicationEvidence } from "./JavaScriptApplicationEvidence.js";
+import { reconstructJavaScriptArtifact } from "./JavaScriptArtifactReconstruction.js";
+import { JAVASCRIPT_APPLICATION_PROVIDER } from "../InvestigationProviders.js";
+const OPERATION = "analyze_javascript_application";
+/** Statically analyze one local JavaScript/Electron application. */
+export const analyzeJavaScriptApplication = async (rawInput, options = {}) => {
+    const parsed = analyzeJavaScriptApplicationInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(new AnalysisInputError(OPERATION, undefined, projectInputIssues(parsed.error.issues, rawInput)));
+    return analyzeJavaScriptApplicationValidated(parsed.data, options);
+};
+/** Analyze input already parsed by a trusted adapter boundary. */
+export const analyzeJavaScriptApplicationValidated = async (input, options = {}) => {
+    await options.progress?.report({
+        phase: "analyze_javascript_application",
+        completed: 0,
+        total: 1,
+        message: "Inventorying and parsing application artifacts",
+    });
+    try {
+        const reconstructed = await reconstructJavaScriptArtifact({
+            input_path: input.input_path,
+            format: input.format,
+        }, options.signal);
+        const { electron_summary: summary, ...application } = reconstructed;
+        const result = javascriptApplicationAnalysisResultSchema.parse({
+            ...application,
+            summary,
+            limitations: reconstructed.graph.limitations,
+        });
+        await options.progress?.report({
+            phase: "analyze_javascript_application",
+            completed: 1,
+            total: 1,
+            message: "Application graph and Electron boundaries reconstructed",
+            terminal: true,
+        });
+        return ok(createJavaScriptApplicationEvidence(input, result));
+    }
+    catch (cause) {
+        if (cause instanceof ArtifactReaderFailure)
+            return err(new ArtifactOperationError(OPERATION, cause.reason, cause.details, cause.message));
+        if (cause instanceof z.ZodError)
+            return err(new AnalysisOutputError(OPERATION, describeResultSchemaFailure(cause), {
+                cause,
+            }));
+        if (cause instanceof Error &&
+            "code" in cause &&
+            typeof cause.code === "string" &&
+            FILESYSTEM_ERROR_CODES.has(cause.code))
+            return err(new ArtifactOperationError(OPERATION, "io"));
+        return err(new ProviderAdapterError(JAVASCRIPT_APPLICATION_PROVIDER.id, OPERATION, {
+            cause,
+            diagnostics: {
+                input_path: input.input_path,
+                error_name: cause instanceof Error ? cause.name : "UnknownError",
+                error_message: cause instanceof Error
+                    ? cause.message
+                    : typeof cause === "string"
+                        ? cause
+                        : "JavaScript analysis failed with a non-Error value",
+            },
+        }));
+    }
+};
+const describeResultSchemaFailure = (cause) => {
+    const issue = cause.issues[0];
+    if (issue === undefined)
+        return "Result schema rejected an unknown issue";
+    const path = issue.path.flatMap((part) => typeof part === "string" || typeof part === "number" ? [part] : []);
+    const pointer = path.length === 0
+        ? "/"
+        : `/${path.map((part) => escapePointerPart(String(part))).join("/")}`;
+    return `Result schema rejected ${String(cause.issues.length)} ${cause.issues.length === 1 ? "issue" : "issues"} at ${pointer} (${issue.code})`;
+};
+const escapePointerPart = (part) => part.replaceAll("~", "~0").replaceAll("/", "~1");
+const FILESYSTEM_ERROR_CODES = new Set([
+    "ENOENT",
+    "EACCES",
+    "EPERM",
+    "ENOTDIR",
+    "EISDIR",
+    "EIO",
+    "ELOOP",
+    "ENAMETOOLONG",
+    "EMFILE",
+    "ENFILE",
+    "ENOSPC",
+    "EROFS",
+]);

package/dist/application/{JavaScriptApplicationWorkflowEvidence.js → javascript/JavaScriptApplicationWorkflowEvidence.js}

@@ -1,6 +1,6 @@
-import { createEvidence, } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
+import { createEvidence, } from "../../domain/evidence.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "../InvestigationProviders.js";
 /** Create derived Evidence for one bounded application-graph feature trace. */
 export const createApplicationFeatureTraceEvidence = (parameters, result) => createEvidence(undefined, JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER, {
     predicateType: "rea.application-feature-trace",

package/dist/application/{JavaScriptApplicationWorkflowService.js → javascript/JavaScriptApplicationWorkflowService.js}

@@ -1,15 +1,16 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/errors.js";
-import { projectInputIssues } from "../domain/inputIssueProjection.js";
-import { compareJavaScriptApplicationVersions } from "../domain/javascriptApplicationVersionComparison.js";
-import { compareApplicationVersionsInputSchema } from "../domain/javascriptApplicationVersionComparisonSchemas.js";
-import { compareJavaScriptExportShapes } from "../domain/javascriptExportShapeComparison.js";
-import { compareJavaScriptExportShapesInputSchema } from "../domain/javascriptExportShapeComparisonSchemas.js";
-import { traceApplicationFeature } from "../domain/javascriptFeatureTrace.js";
-import { traceApplicationFeatureInputSchema } from "../domain/javascriptFeatureTraceSchemas.js";
-import { err, ok } from "../domain/result.js";
-import { compareSourceToBundle } from "../domain/sourceToBundleComparison.js";
-import { compareSourceToBundleInputSchema } from "../domain/sourceToBundleComparisonSchemas.js";
+import { AnalysisInputError, AnalysisProtocolError, } from "../../domain/analysisErrorCore.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { projectInputIssues } from "../../domain/inputIssueProjection.js";
+import { compareJavaScriptApplicationVersions } from "../../domain/javascript/javascriptApplicationVersionComparison.js";
+import { compareApplicationVersionsInputSchema } from "../../domain/javascript/javascriptApplicationVersionComparisonSchemas.js";
+import { compareJavaScriptExportShapes } from "../../domain/javascript/javascriptExportShapeComparison.js";
+import { compareJavaScriptExportShapesInputSchema } from "../../domain/javascript/javascriptExportShapeComparisonSchemas.js";
+import { traceApplicationFeature } from "../../domain/javascript/javascriptFeatureTrace.js";
+import { traceApplicationFeatureInputSchema } from "../../domain/javascript/javascriptFeatureTraceSchemas.js";
+import { err, ok } from "../../domain/result.js";
+import { compareSourceToBundle } from "../../domain/javascript/sourceToBundleComparison.js";
+import { compareSourceToBundleInputSchema } from "../../domain/javascript/sourceToBundleComparisonSchemas.js";
 import { parseApplicationGraphEvidence, parseNativeApplicationEvidence, } from "./JavaScriptApplicationEvidenceGraph.js";
 import { createApplicationFeatureTraceEvidence, createApplicationVersionComparisonEvidence, createJavaScriptExportShapeComparisonEvidence, createSourceToBundleComparisonEvidence, } from "./JavaScriptApplicationWorkflowEvidence.js";
 /** Authenticate Evidence and derive one bounded cross-layer feature trace. */

package/dist/application/{JavaScriptArtifactAnalysis.js → javascript/JavaScriptArtifactAnalysis.js}

@@ -1,9 +1,10 @@
 import { createHash } from "node:crypto";
-import { analyzeParsedJavaScriptStaticSource } from "../domain/javascriptStaticAnalysis.js";
-import { analyzeParsedJavaScriptSemantics } from "../domain/javascriptSemanticAnalysis.js";
-import { parseJavaScriptSource } from "../domain/javascriptSourceParser.js";
-import { hasValidSourceMapContents } from "../domain/sourceMapContents.js";
-import { failedJavaScriptStaticAnalysis } from "../domain/javascriptStaticAnalysisHelpers.js";
+import { analyzeParsedJavaScriptStaticSource } from "../../domain/javascript/javascriptStaticAnalysis.js";
+import { analyzeParsedJavaScriptSemantics } from "../../domain/javascript/javascriptSemanticAnalysis.js";
+import { parseJavaScriptSource } from "../../domain/javascript/javascriptSourceParser.js";
+import { hasValidSourceMapContents } from "../../domain/sourceMapContents.js";
+import { flattenSourceMapLeaves } from "../../domain/sourceMapEnvelope.js";
+import { failedJavaScriptStaticAnalysis } from "../../domain/javascript/javascriptStaticAnalysisHelpers.js";
 import { analyzeJavaScriptJsonModule } from "./JavaScriptJsonModules.js";
 /** Analyze every text source from the artifact without a result quota. */
 export const analyzeJavaScriptArtifactFiles = (fileSet) => {
@@ -102,7 +103,8 @@ const parsePackage = (file) => {
     try {
         value = JSON.parse(file.text.value);
     }
-    catch {
+    catch (cause) {
+        void cause;
         return invalidPackage(file, "package.json is not valid JSON.");
     }
     if (!isRecord(value))
@@ -163,7 +165,8 @@ const parseSourceMap = (file) => {
     try {
         value = JSON.parse(file.text.value);
     }
-    catch {
+    catch (cause) {
+        void cause;
         return invalidSourceMap(file, "Source map is not valid JSON.");
     }
     const maps = flattenSourceMaps(value);
@@ -213,25 +216,8 @@ const unavailableSourceMap = (file) => {
     };
 };
 const flattenSourceMaps = (root) => {
-    if (!isRecord(root) || root.version !== 3)
-        return undefined;
-    const maps = [];
-    const pending = [root];
-    while (pending.length > 0) {
-        const map = pending.pop();
-        if (map === undefined || map.version !== 3)
-            return undefined;
-        if (Array.isArray(map.sections)) {
-            for (const section of map.sections) {
-                if (!isRecord(section) || !isRecord(section.map))
-                    return undefined;
-                pending.push(section.map);
-            }
-        }
-        else
-            maps.push(map);
-    }
-    return maps;
+    const leaves = flattenSourceMapLeaves(root);
+    return leaves === undefined ? undefined : [...leaves];
 };
 const invalidSourceMap = (file, limitation) => ({
     path: file.path,

package/dist/application/javascript/JavaScriptArtifactAnalysisTypes.js

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

package/dist/application/{JavaScriptArtifactGraphAccumulator.js → javascript/JavaScriptArtifactGraphAccumulator.js}

@@ -1,11 +1,11 @@
-import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } from "../domain/javascriptApplicationGraph.js";
+import { createJavaScriptApplicationEdge, createJavaScriptApplicationNode, } from "../../domain/javascript/javascriptApplicationGraph.js";
 /** Deduplicate graph entities while retaining distinct evidence observations. */
 export class JavaScriptArtifactGraphAccumulator {
     #nodes = new Map();
     #edges = new Map();
     /** Create or merge one canonical node. */
     addNode(input) {
-        const created = createJavaScriptApplicationNode(input);
+        const created = createJavaScriptApplicationNode(displayableNode(input));
         const existing = this.#nodes.get(created.node_id);
         if (existing === undefined) {
             this.#nodes.set(created.node_id, created);
@@ -45,3 +45,17 @@ const observationInput = (observation) => {
     const { observation_id: _observationId, identifier_strategy: _strategy, ...input } = observation;
     return input;
 };
+/**
+ * Static findings can carry legal empty strings, such as `fetch("")`,
+ * `require("")`, or a source map's `sources: [""]`. Labels must be nonempty,
+ * so an empty value has no label rather than synthetic text that a real value
+ * could share; literal feature seeds match labels. Identities and observation
+ * properties keep the exact value.
+ */
+const displayableNode = (input) => ({
+    ...input,
+    observations: input.observations.map((observation) => ({
+        ...observation,
+        label: observation.label === "" ? null : observation.label,
+    })),
+});

package/dist/application/{JavaScriptArtifactGraphBuilder.js → javascript/JavaScriptArtifactGraphBuilder.js}

@@ -1,9 +1,9 @@
-import { createJavaScriptApplicationGraph, } from "../domain/javascriptApplicationGraph.js";
+import { createJavaScriptApplicationGraph, } from "../../domain/javascript/javascriptApplicationGraph.js";
 import { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
 import { addJavaScriptHtmlRoles, addJavaScriptSourceMapOriginals, } from "./JavaScriptArtifactGraphDocuments.js";
 import { addJavaScriptStaticFindings } from "./JavaScriptArtifactGraphFindings.js";
 import { addJavaScriptModuleRelationships, addJavaScriptSourceModules, } from "./JavaScriptModuleRelationships.js";
-import { completeApplicationCoverage, partialApplicationCoverage, } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { addJavaScriptArtifactContainers, addJavaScriptArtifactFiles, addJavaScriptBundlerNodes, addJavaScriptPackageNodes, createJavaScriptArtifactRootNode, } from "./JavaScriptArtifactGraphStructure.js";
 import { addElectronBoundaries } from "./ElectronBoundaryGraph.js";
 import { classifyElectronIpcPairings, collectElectronIpcRecords, } from "./ElectronBoundaryAnalysis.js";

package/dist/application/{JavaScriptArtifactGraphContext.js → javascript/JavaScriptArtifactGraphContext.js}

@@ -1,4 +1,4 @@
-import { completeApplicationCoverage, partialApplicationCoverage, } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { completeApplicationCoverage, partialApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { JavaScriptArtifactGraphAccumulator } from "./JavaScriptArtifactGraphAccumulator.js";
 import { artifactObservationEvidence, astObservationEvidence, staticInferenceEvidence, unavailableAstEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { resolveArtifactPathByContext, } from "./JavaScriptArtifactPathResolution.js";

package/dist/application/{JavaScriptArtifactGraphDocuments.js → javascript/JavaScriptArtifactGraphDocuments.js}

@@ -1,6 +1,6 @@
 import { addArtifactContainsEdge, addStaticInferenceEdge, createElectronRoleNode, linkElectronRoleToAsset, } from "./JavaScriptArtifactGraphContext.js";
 import { artifactObservationEvidence } from "./JavaScriptArtifactGraphEvidence.js";
-import { completeApplicationCoverage } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { completeApplicationCoverage } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";
 /** Project HTML renderer entrypoints and their local script assets. */
 export const addJavaScriptHtmlRoles = (context) => {

package/dist/application/{JavaScriptArtifactGraphFindings.js → javascript/JavaScriptArtifactGraphFindings.js}

@@ -190,7 +190,12 @@ const addDiscoveredRole = (context, input) => {
     });
 };
 const addSourceMapEdge = (context, input) => {
-    const resolvedPath = resolveArtifactPath(input.value.declared_url, input.file.path, context.filesByPath);
+    const resolvedPath = resolveArtifactPathByContext({
+        declaredPath: input.value.declared_url,
+        sourcePath: input.file.path,
+        context: "url-reference",
+        files: context.filesByPath,
+    }).resolved_path;
     const resolvedFile = resolvedPath === null ? undefined : context.filesByPath.get(resolvedPath);
     const resolvedNode = resolvedPath === null ? undefined : context.fileNodes.get(resolvedPath);
     const target = resolvedFile?.kind === "source-map" && resolvedNode !== undefined
@@ -247,12 +252,20 @@ const resolveReference = (context, sourcePath, reference) => {
             ? null
             : { path: `${sourcePath}#module:${specifier}`, file, node: module };
     }
-    const path = resolveArtifactPath(specifier, sourcePath, context.filesByPath, reference.kind === "require"
-        ? "require"
-        : reference.kind === "static-import" ||
-            reference.kind === "dynamic-import"
-            ? "import"
-            : undefined);
+    // Worker scripts are URLs relative to the script, not module specifiers.
+    const path = reference.kind === "worker" || reference.kind === "service-worker"
+        ? resolveArtifactPathByContext({
+            declaredPath: specifier,
+            sourcePath,
+            context: "url-reference",
+            files: context.filesByPath,
+        }).resolved_path
+        : resolveArtifactPath(specifier, sourcePath, context.filesByPath, reference.kind === "require"
+            ? "require"
+            : reference.kind === "static-import" ||
+                reference.kind === "dynamic-import"
+                ? "import"
+                : undefined);
     if (path === null)
         return null;
     const file = context.filesByPath.get(path);

package/dist/application/{JavaScriptArtifactGraphStructure.js → javascript/JavaScriptArtifactGraphStructure.js}

@@ -1,4 +1,4 @@
-import { completeApplicationCoverage } from "../domain/javascriptApplicationEvidenceSchemas.js";
+import { completeApplicationCoverage } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
 import { addArtifactContainsEdge, addUnavailableStaticParseScope, artifactFileNodeKind, artifactLocalIdentity, createElectronRoleNode, linkElectronRoleToAsset, } from "./JavaScriptArtifactGraphContext.js";
 import { artifactObservationEvidence, staticInferenceEvidence, } from "./JavaScriptArtifactGraphEvidence.js";
 import { resolveArtifactPathByContext } from "./JavaScriptArtifactPathResolution.js";

package/dist/application/{JavaScriptArtifactPathResolution.js → javascript/JavaScriptArtifactPathResolution.js}

@@ -1,5 +1,6 @@
 import { builtinModules } from "node:module";
 import { posix } from "node:path";
+import { admitsCanonicalPathSyntax, hasScheme, looksExternal, stripQueryAndFragment, } from "../../domain/artifactPathSyntax.js";
 const EXTENSIONS = [
     ".js",
     ".cjs",
@@ -47,13 +48,10 @@ const rejectDeclaration = (input) => {
         ]);
     return null;
 };
-/** Path syntax admitted for a canonical artifact path. */
-const admitsCanonicalPathSyntax = (value) => !value.includes("\0") &&
-    !value.includes("\\") &&
-    !/%(?:2e|2f|5c)/iu.test(value);
 const contextualCandidate = (input) => {
     const { context } = input;
     const declared = context === "html-reference" ||
+        context === "url-reference" ||
         (context === "module-specifier" && input.moduleKind !== "require")
         ? stripQueryAndFragment(input.declaredPath)
         : input.declaredPath;
@@ -70,9 +68,9 @@ const contextualCandidate = (input) => {
         if (!declared.startsWith(".") && !declared.startsWith("/"))
             return bareModuleCandidate(input, declared);
     }
-    else if (hasScheme(declared))
+    else if (looksExternal(declared))
         return unresolvedOutcome(input, "external", [
-            "URL schemes are outside this local artifact path context.",
+            "URL schemes and protocol-relative URLs are outside this local artifact path context.",
         ]);
     const relative = declared.startsWith("/") ? declared.slice(1) : declared;
     return declared.startsWith("/")
@@ -125,7 +123,7 @@ const hasContainerCandidate = (files, candidate, containerSha256) => [
 });
 const htmlCandidate = (input) => {
     const declared = stripQueryAndFragment(input.declaredPath);
-    if (hasScheme(declared) || declared.startsWith("//"))
+    if (looksExternal(declared))
         return unresolvedOutcome(input, "external", [
             "External HTML references are not mapped to local artifact assets.",
         ]);
@@ -133,9 +131,7 @@ const htmlCandidate = (input) => {
     const base = rawBase === undefined || rawBase === null
         ? rawBase
         : stripQueryAndFragment(rawBase);
-    if (base !== undefined &&
-        base !== null &&
-        (hasScheme(base) || base.startsWith("//")))
+    if (base !== undefined && base !== null && looksExternal(base))
         return unresolvedOutcome(input, "external", [
             "The document base href is external, so its script reference is not a local artifact path.",
         ]);
@@ -296,7 +292,9 @@ const packageEntry = (text, moduleKind, useExports) => {
         const legacy = packagePathValue(entry);
         return legacy.status === "value" ? { ...legacy, source: "legacy" } : legacy;
     }
-    catch {
+    catch (cause) {
+        // Reflect-based manifest reads fail closed as invalid.
+        void cause;
         return { status: "invalid" };
     }
 };
@@ -380,7 +378,6 @@ const notFoundCandidate = () => ({
         "No extension, directory package, or index candidate exists in the inventoried artifact container.",
     ],
 });
-const hasScheme = (value) => /^[A-Za-z][A-Za-z+.-]*:/u.test(value);
 const fileUrlPath = (value) => {
     if (!value.startsWith("file://"))
         return undefined;
@@ -390,11 +387,12 @@ const fileUrlPath = (value) => {
             return undefined;
         return decodeURIComponent(url.pathname).replace(/^\/+/, "");
     }
-    catch {
+    catch (cause) {
+        // Unparseable file URLs have no path to resolve.
+        void cause;
         return undefined;
     }
 };
-const stripQueryAndFragment = (value) => value.split("#", 1)[0]?.split("?", 1)[0] ?? "";
 const outcome = (input, resolution) => resolution.status === "resolved"
     ? {
         declared_path: input.declaredPath,

package/dist/application/{JavaScriptArtifactReconstruction.js → javascript/JavaScriptArtifactReconstruction.js}

@@ -1,12 +1,11 @@
 import { lstat, realpath } from "node:fs/promises";
-import { AsarArtifactReader } from "../artifacts/AsarArtifactReader.js";
-import { ArtifactReaderFailure, } from "../artifacts/ArtifactReader.js";
-import { DirectoryArtifactReader } from "../artifacts/DirectoryArtifactReader.js";
+import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+import { createJavaScriptArtifactReader as createReader } from "../../artifacts/javascript/JavaScriptArtifactReader.js";
 import { analyzeJavaScriptArtifactFiles } from "./JavaScriptArtifactAnalysis.js";
-import { readJavaScriptArtifactFiles } from "./JavaScriptArtifactFiles.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 "../ArtifactInventory.js";
 import { summarizeElectronBoundaries } from "./ElectronBoundaryAnalysis.js";
 import { buildJavaScriptSemanticGraph } from "./JavaScriptSemanticGraphBuilder.js";
 /** Reconstruct one local ASAR or extracted directory without executing code. */
@@ -70,9 +69,6 @@ const resolveFormat = async (path, input) => {
         throw new ArtifactReaderFailure("format", `Requested ${input.format} input but observed ${observed}: ${path}`);
     return observed;
 };
-const createReader = (path, format) => format === "asar"
-    ? new AsarArtifactReader(path)
-    : new DirectoryArtifactReader(path);
 const abortIfNeeded = (signal) => {
     if (signal?.aborted === true)
         throw new ArtifactReaderFailure("cancelled", "JavaScript artifact reconstruction cancelled");