rea-agents 4.1.0 → 5.0.0

package/dist/application/{BinarySessionRecords.js → binary/BinarySessionRecords.js}

@@ -1,43 +1,46 @@
-import { createEvidence } from "../domain/evidence.js";
-import { evidenceBundleForTarget } from "../domain/evidenceBundle.js";
-import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
-import {} from "../domain/analysisErrorBase.js";
-import {} from "../domain/unknownRegistryError.js";
-import { err, ok } from "../domain/result.js";
+import { evidenceBundleForTarget } from "../../domain/evidenceBundle.js";
+import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
+import {} from "../../domain/analysisErrorBase.js";
+import {} from "../../domain/unknownRegistryError.js";
+import { err, ok } from "../../domain/result.js";
 import { AnalysisSnapshotCache } from "./AnalysisSnapshotCache.js";
-import { EvidenceLedger } from "./EvidenceLedger.js";
-import { UNKNOWN_REGISTRY_PROVIDER, unknownEvidenceLinks, unknownMutationEvidence, } from "./UnknownEvidence.js";
-/** Owns session evidence, snapshots, and residual unknowns. */
+import { InvestigationRecords } from "../investigation/InvestigationRecords.js";
+/** Binary snapshot owner and compatibility facade for composed investigation records. */
 export class BinarySessionRecords {
-    #evidence = new EvidenceLedger();
+    #records;
     #snapshot = new AnalysisSnapshotCache();
     #snapshotInvalidated = false;
     #snapshotListeners = new Set();
+    constructor(records = new InvestigationRecords()) {
+        this.#records = records;
+    }
     /** Observe changes to the mutable current analysis snapshot resource. */
     onAnalysisSnapshotChanged(listener) {
         this.#snapshotListeners.add(listener);
         return () => this.#snapshotListeners.delete(listener);
     }
     recordEvidence(evidence) {
-        const recorded = this.#evidence.record(evidence);
+        const recorded = this.#records.recordEvidence(evidence);
         if (recorded.ok && recorded.value === "added")
             this.#emitSnapshotChanged();
         return recorded;
     }
     hasEvidence(evidenceId) {
-        return this.#evidence.has(evidenceId);
+        return this.#records.hasEvidence(evidenceId);
     }
     evidenceById(evidenceId) {
-        return this.#evidence.get(evidenceId);
+        return this.#records.evidenceById(evidenceId);
     }
     exportEvidenceBundle() {
-        return this.#evidence.export();
+        return this.#records.exportEvidenceBundle();
     }
     importEvidenceBundle(bundle) {
-        const imported = this.#evidence.import(bundle);
+        const imported = this.#records.mergeEvidenceBundle(bundle);
         if (!imported.ok)
             return imported;
-        if (imported.value.changed)
+        if (imported.value.metadataChanged)
+            this.invalidateSnapshot();
+        else if (imported.value.changed)
             this.#emitSnapshotChanged();
         return ok(imported.value.recordsAdded);
     }
@@ -50,8 +53,8 @@ export class BinarySessionRecords {
         if (target !== undefined && profile === undefined)
             return err(new EvidenceIntegrityError("Analysis snapshots require a concrete provider analysis profile"));
         return this.#snapshot.export(target, profile, target === undefined
-            ? this.#evidence.export()
-            : evidenceBundleForTarget(this.#evidence.export(), target.sha256));
+            ? this.#records.exportEvidenceBundle()
+            : evidenceBundleForTarget(this.#records.exportEvidenceBundle(), target.sha256));
     }
     importAnalysisSnapshot(snapshot) {
         const active = this.activeAnalysisBinding();
@@ -60,7 +63,7 @@ export class BinarySessionRecords {
         const imported = this.#snapshot.import(snapshot, active === undefined
             ? undefined
             : { target: active.target, profile: active.profile }, (bundle) => {
-            const imported = this.#evidence.import(bundle);
+            const imported = this.#records.mergeEvidenceBundle(bundle);
             return imported.ok ? ok(imported.value.recordsAdded) : imported;
         });
         if (imported.ok)
@@ -97,7 +100,7 @@ export class BinarySessionRecords {
         this.#emitSnapshotChanged();
     }
     clearSessionRecords() {
-        this.#evidence.clear();
+        this.#records.clear();
         this.#snapshot.clear();
         this.#snapshotInvalidated = false;
         this.#emitSnapshotChanged();
@@ -121,43 +124,28 @@ export class BinarySessionRecords {
     }
     recordUnknown(input) {
         const target = this.activeAnalysisBinding()?.target;
-        const recorded = this.#evidence.recordUnknown(input, unknownMutationEvidence(target, input));
+        const recorded = this.#records.recordUnknown(input, target);
         if (recorded.ok)
             this.#emitSnapshotChanged();
         return recorded;
     }
     recordEvidenceWithUnknown(evidence, input) {
-        const recorded = this.#evidence.recordWithUnknown(evidence, input, unknownMutationEvidence(undefined, input));
+        const recorded = this.#records.recordEvidenceWithUnknown(evidence, input);
         if (recorded.ok)
             this.#emitSnapshotChanged();
         return recorded;
     }
     updateUnknown(input) {
         const target = this.activeAnalysisBinding()?.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);
+        const updated = this.#records.updateUnknown(input, target);
         if (updated.ok)
             this.#emitSnapshotChanged();
         return updated;
     }
     listUnknowns(filters = {}) {
-        return this.#evidence.listUnknowns(filters);
+        return this.#records.listUnknowns(filters);
     }
     verifyUnknownResolution(unknownId) {
-        return this.#evidence.verifyUnknownResolution(unknownId);
+        return this.#records.verifyUnknownResolution(unknownId);
     }
 }

package/dist/application/{CompositeProvider.js → binary/CompositeProvider.js}

@@ -1,5 +1,5 @@
-import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
-import { err, ok } from "../domain/result.js";
+import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.js";
+import { err, ok } from "../../domain/result.js";
 import { closeAnalysisClient } from "./AnalysisClientCleanup.js";
 /** Synthetic compatibility identity for a deterministic provider set. */
 export const compositeProviderIdentity = (identities) => ({

package/dist/application/{LazyAnalysisProvider.js → binary/LazyAnalysisProvider.js}

@@ -1,7 +1,7 @@
-import { AnalysisCancelledError } from "../domain/analysisErrorCore.js";
-import { AnalysisError } from "../domain/analysisErrorBase.js";
-import { ProviderAdapterError } from "../domain/providerAdapterError.js";
-import { err } from "../domain/result.js";
+import { AnalysisCancelledError } from "../../domain/analysisErrorCore.js";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { err } from "../../domain/result.js";
 import { ABORTED, waitForAbortable } from "./AbortablePromise.js";
 const isAborted = (signal) => signal?.aborted === true;
 /**
@@ -18,11 +18,11 @@ export class LazyAnalysisProvider {
         this.#capabilityDescriptors = options.capabilities;
         this.#loadProvider = options.load;
     }
-    /** Return generated provider identity without loading its implementation. */
+    /** Return source-declared provider identity without loading its implementation. */
     identity() {
         return this.#providerIdentity;
     }
-    /** Return generated capability metadata without loading its implementation. */
+    /** Return source-declared capability metadata without loading its implementation. */
     capabilities() {
         return this.#capabilityDescriptors;
     }

package/dist/application/{SessionProviderRouter.js → binary/SessionProviderRouter.js}

@@ -1,10 +1,10 @@
-import { analysisProfileSchema, } from "../domain/analysisProfile.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../domain/analysisErrorCore.js";
-import { ProviderAdapterError } from "../domain/providerAdapterError.js";
-import { ProviderSelectionError } from "../domain/providerSelectionError.js";
-import {} from "../domain/analysisErrorBase.js";
-import { jsonObjectSchema } from "../domain/jsonValue.js";
-import { err, ok } from "../domain/result.js";
+import { analysisProfileSchema, } from "../../domain/analysisProfile.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../../domain/analysisErrorCore.js";
+import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { ProviderSelectionError } from "../../domain/providerSelectionError.js";
+import {} from "../../domain/analysisErrorBase.js";
+import { jsonObjectSchema } from "../../domain/jsonValue.js";
+import { err, ok } from "../../domain/result.js";
 import { AnalysisProviderRegistry, } from "./AnalysisProviderRegistry.js";
 import { ABORTED, waitForAbortable } from "./AbortablePromise.js";
 import { CompositeProvider, compositeProviderIdentity, } from "./CompositeProvider.js";

package/dist/application/{FirmwareAnalysisService.js → firmware/FirmwareAnalysisService.js}

@@ -1,8 +1,8 @@
-import { firmwareRequestSchema, } from "../domain/firmwareAnalysis.js";
-import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../domain/analysisErrorCore.js";
-import { createEvidence } from "../domain/evidence.js";
-import { jsonObjectSchema } from "../domain/jsonValue.js";
-import { err, ok } from "../domain/result.js";
+import { firmwareRequestSchema, } from "../../domain/firmware/firmwareAnalysis.js";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { jsonObjectSchema } from "../../domain/jsonValue.js";
+import { err, ok } from "../../domain/result.js";
 /** Shared CLI/MCP validation and Evidence composition for arbitrary firmware files. */
 export class FirmwareAnalysisService {
     provider;

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

@@ -1,10 +1,10 @@
 import canonicalize from "canonicalize";
-import { createEvidenceBundle, parseEvidenceBundle, validateResidualUnknownAddition, } from "../domain/evidenceBundle.js";
-import { EvidenceIntegrityError } from "../domain/evidenceErrors.js";
-import { UnknownRegistryError } from "../domain/unknownRegistryError.js";
-import { parseEvidence } from "../domain/evidence.js";
-import { createResidualUnknown, updateResidualUnknown, } from "../domain/residualUnknown.js";
-import { err, ok } from "../domain/result.js";
+import { createEvidenceBundle, parseEvidenceBundle, validateResidualUnknownAddition, } from "../../domain/evidenceBundle.js";
+import { EvidenceIntegrityError } from "../../domain/evidenceErrors.js";
+import { UnknownRegistryError } from "../../domain/unknownRegistryError.js";
+import { parseEvidence } from "../../domain/evidence.js";
+import { createResidualUnknown, updateResidualUnknown, } from "../../domain/residualUnknown.js";
+import { err, ok } from "../../domain/result.js";
 /** Session-owned set of immutable evidence records. */
 export class EvidenceLedger {
     #records = new Map();
@@ -41,11 +41,47 @@ export class EvidenceLedger {
                 cause,
             }));
         }
+        // A record-only bundle cannot change the already-valid unknown graph. The
+        // bundle parser has validated every incoming record and its manifests, so
+        // checking ID conflicts and committing only the additions preserves the
+        // atomic merge without rebuilding and reparsing the entire ledger.
+        if (bundle.unknowns.length === 0) {
+            const additions = new Map();
+            const replacements = new Map();
+            let metadataChanged = false;
+            for (const evidence of bundle.records) {
+                const existing = this.#records.get(evidence.evidence_id);
+                if (existing !== undefined) {
+                    if (!recordsAgree(existing, evidence))
+                        return err(new EvidenceIntegrityError("Conflicting evidence record"));
+                    if (canonicalize(existing) !== canonicalize(evidence)) {
+                        replacements.set(evidence.evidence_id, evidence);
+                        metadataChanged = true;
+                    }
+                    continue;
+                }
+                additions.set(evidence.evidence_id, evidence);
+            }
+            for (const [id, evidence] of replacements)
+                this.#records.set(id, evidence);
+            for (const [id, evidence] of additions)
+                this.#records.set(id, evidence);
+            return ok({
+                recordsAdded: additions.size,
+                unknownsAdded: 0,
+                changed: additions.size > 0 || metadataChanged,
+                metadataChanged,
+            });
+        }
         const pending = new Map(this.#records);
+        let metadataChanged = false;
         for (const evidence of bundle.records) {
             const existing = pending.get(evidence.evidence_id);
             if (existing !== undefined && !recordsAgree(existing, evidence))
                 return err(new EvidenceIntegrityError("Conflicting evidence record"));
+            if (existing !== undefined &&
+                canonicalize(existing) !== canonicalize(evidence))
+                metadataChanged = true;
             pending.set(evidence.evidence_id, evidence);
         }
         const pendingUnknowns = new Map(this.#unknownRevisions);
@@ -73,7 +109,8 @@ export class EvidenceLedger {
         return ok({
             recordsAdded: added,
             unknownsAdded,
-            changed: added > 0 || unknownsAdded > 0,
+            changed: added > 0 || unknownsAdded > 0 || metadataChanged,
+            metadataChanged,
         });
     }
     /** Export records in deterministic, semantically irrelevant ID order. */

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 { canonicalDigest } from "../domain/comparisonSemantics.js";
-import { createEvidence } from "../domain/evidence.js";
-import { jsonValueSchema } from "../domain/jsonValue.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",

package/dist/application/javascript/ElectronActiveObservationPort.js

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

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

@@ -1,8 +1,8 @@
 import { dirname } from "node:path";
 import { realpath } from "node:fs/promises";
-import { AnalysisCapabilityUnavailableError, AnalysisInputError, } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.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,4 +1,4 @@
-import { compareCodePoints } from "../domain/canonicalOrdering.js";
+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

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,6 +1,6 @@
-import { AnalysisCapabilityUnavailableError } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.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/{JavaScriptApplicationService.js → javascript/JavaScriptApplicationService.js}

@@ -1,15 +1,15 @@
 import { z } from "zod";
-import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
-import { analyzeJavaScriptApplicationInputSchema, javascriptApplicationAnalysisResultSchema, } from "../domain/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 { 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";
+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 = {}) => {
@@ -48,7 +48,7 @@ export const analyzeJavaScriptApplicationValidated = async (input, options = {})
     }
     catch (cause) {
         if (cause instanceof ArtifactReaderFailure)
-            return err(new ArtifactOperationError(OPERATION, cause.reason, cause.details));
+            return err(new ArtifactOperationError(OPERATION, cause.reason, cause.details, cause.message));
         if (cause instanceof z.ZodError)
             return err(new AnalysisOutputError(OPERATION, describeResultSchemaFailure(cause), {
                 cause,

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,16 +1,16 @@
 import { z } from "zod";
-import { AnalysisInputError, AnalysisProtocolError, } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.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) => {
@@ -215,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,
+    })),
+});