rea-agents 6.0.0 → 6.2.0

package/dist/application/binary/CompositeProvider.js

@@ -1,8 +1,8 @@
 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) => ({
+/** Synthetic identity for a deterministic provider set. */
+const compositeProviderIdentity = (identities) => ({
     id: `composite:${identities
         .map(({ id }) => id)
         .sort()
@@ -16,15 +16,10 @@ export class CompositeProvider {
     #identity;
     #capabilities;
     #providerByOperation;
-    #profileProvider;
     constructor(providers) {
         this.providers = providers;
         if (providers.length === 0)
             throw new RangeError("CompositeProvider requires at least one provider");
-        const profileProviders = providers.filter(({ resolveAnalysisProfile }) => resolveAnalysisProfile !== undefined);
-        if (profileProviders.length > 1)
-            throw new TypeError("CompositeProvider supports at most one target-bound analysis profile");
-        this.#profileProvider = profileProviders[0];
         this.#identity = Object.freeze(compositeProviderIdentity(providers.map((provider) => provider.identity())));
         const routes = new Map();
         const capabilities = [];
@@ -46,12 +41,6 @@ export class CompositeProvider {
     capabilities() {
         return this.#capabilities;
     }
-    resolveAnalysisProfile(target, options) {
-        const resolve = this.#profileProvider?.resolveAnalysisProfile;
-        return resolve === undefined
-            ? Promise.resolve(ok({ profile: null, compatibility: {} }))
-            : resolve.call(this.#profileProvider, target, options);
-    }
     createClient(target, profile, context) {
         const clients = new Map();
         const clientFor = (provider) => {
@@ -62,7 +51,7 @@ export class CompositeProvider {
             clients.set(provider, created);
             return created;
         };
-        const closeWithOutcome = async (options) => {
+        const close = async (options) => {
             const outcomes = await Promise.all([...clients.entries()].map(([provider, client]) => closeAnalysisClient(client, provider.identity().id, options)));
             return outcomes.find((outcome) => !outcome.ok) ?? ok(null);
         };
@@ -88,10 +77,20 @@ export class CompositeProvider {
             requestActivitySnapshots: () => [...clients.values()]
                 .flatMap((client) => client.requestActivitySnapshots?.() ?? [])
                 .sort((left, right) => left.provider.id.localeCompare(right.provider.id)),
-            closeWithOutcome,
-            close: async () => {
-                await closeWithOutcome();
+            operationHealthSnapshot: () => {
+                for (const client of clients.values()) {
+                    const snapshot = client.operationHealthSnapshot?.();
+                    if (snapshot !== undefined && snapshot.state !== "idle")
+                        return snapshot;
+                }
+                for (const client of clients.values()) {
+                    const snapshot = client.operationHealthSnapshot?.();
+                    if (snapshot !== undefined)
+                        return snapshot;
+                }
+                return undefined;
             },
+            close,
         };
     }
 }

package/dist/application/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 { err, ok } from "../../domain/result.js";
 import { ABORTED, waitForAbortable } from "./AbortablePromise.js";
 const isAborted = (signal) => signal?.aborted === true;
 /**
@@ -74,13 +74,16 @@ class LazyAnalysisClient {
     requestActivitySnapshots() {
         return this.#client?.requestActivitySnapshots?.() ?? [];
     }
-    async close() {
+    operationHealthSnapshot() {
+        return this.#client?.operationHealthSnapshot?.();
+    }
+    close = async (options) => {
         this.#closed = true;
         if (this.#loading === undefined)
-            return;
+            return ok(null);
         const client = await this.#loading;
-        await client.close();
-    }
+        return client.close(options);
+    };
     async #load(operation) {
         if (this.#closed)
             throw new ProviderAdapterError(this.#providerId, operation, {

package/dist/application/binary/SessionProviderRouter.js

@@ -1,40 +1,18 @@
-import { analysisProfileSchema, } from "../../domain/analysisProfile.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, } from "../../domain/analysisErrorCore.js";
-import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
+import { AnalysisCapabilityUnavailableError } from "../../domain/analysisErrorCore.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";
-/** Resolve either the compatibility single-provider seam or a selectable set. */
+import { CompositeProvider } from "./CompositeProvider.js";
+/** Resolve one registry-selected deep provider and disjoint auxiliary families. */
 export class SessionProviderRouter {
-    runtime;
-    constructor(runtime) {
-        this.runtime = runtime;
-    }
-    /** Create routing for an embedding backed by one fixed provider or factory. */
-    static single(provider, options = {}) {
-        const identity = typeof provider === "function"
-            ? { id: "unidentified", name: "Unidentified provider", version: null }
-            : provider.identity();
-        const capabilities = typeof provider === "function"
-            ? undefined
-            : capabilityMap(provider.capabilities());
-        const resolveProfile = options.resolveAnalysisProfile ??
-            (typeof provider === "function" ||
-                provider.resolveAnalysisProfile === undefined
-                ? () => Promise.resolve(ok({ profile: null, compatibility: {} }))
-                : (target, resolutionOptions) => provider.resolveAnalysisProfile?.(target, resolutionOptions) ??
-                    Promise.resolve(ok({ profile: null, compatibility: {} })));
-        return new SessionProviderRouter({
-            kind: "single",
-            provider,
-            identity,
-            capabilities,
-            resolveProfile,
-        });
+    registry;
+    auxiliaryProviders;
+    route;
+    constructor(registry, auxiliaryProviders, route) {
+        this.registry = registry;
+        this.auxiliaryProviders = auxiliaryProviders;
+        this.route = route;
     }
     /** Create selection-aware routing while keeping auxiliary families disjoint. */
     static selectable(registry, auxiliaryProviders) {
@@ -48,99 +26,31 @@ export class SessionProviderRouter {
             if (auxiliaryOperations.has(operation))
                 throw new TypeError(`Deep and auxiliary providers both declare operation ${operation}`);
         const initialRoute = selectableRoute(auxiliaryProviders, undefined);
-        return new SessionProviderRouter({
-            kind: "selectable",
-            registry,
-            auxiliaryProviders: [...auxiliaryProviders],
-            identity: identities.length === 0
-                ? emptyProviderIdentity()
-                : compositeProviderIdentity(identities),
-            initialRoute,
-        });
-    }
-    /** Compatibility identity covering every configured provider. */
-    configuredIdentity() {
-        return structuredClone(this.runtime.identity);
-    }
-    /** Provider identities exposed through the flat 1.x compatibility field. */
-    providerIdentities(route) {
-        if (this.runtime.kind === "single") {
-            if (route.capabilities === undefined)
-                return [route.identity];
-            return uniqueProviderIdentities([...route.capabilities.values()].map(({ provider }) => provider));
-        }
-        const selected = route.binding?.identity;
-        return uniqueProviderIdentities([
-            ...this.runtime.auxiliaryProviders.map((provider) => provider.identity()),
-            ...this.runtime.registry
-                .identities()
-                .map((identity) => identity.id === selected?.id ? selected : identity),
-        ]);
+        return new SessionProviderRouter(registry, [...auxiliaryProviders], initialRoute);
     }
     /** Target-free routes and discovery metadata. */
     initialRoute() {
-        if (this.runtime.kind === "selectable")
-            return this.runtime.initialRoute;
-        const runtime = this.runtime;
-        return {
-            identity: structuredClone(runtime.identity),
-            capabilities: runtime.capabilities,
-            profile: null,
-            compatibility: {},
-            binding: null,
-            selection: undefined,
-            createClient: (target, context) => createSingleProviderClient(runtime, target, undefined, context),
-        };
+        return this.route;
     }
     /** Resolve target routes before any provider client is created. */
     async resolve(target, providerId, signal) {
         const resolutionOptions = signal === undefined ? undefined : { signal };
-        if (this.runtime.kind === "selectable") {
-            const selected = await this.runtime.registry.select(target, providerId, resolutionOptions);
-            return selected.ok
-                ? ok(selectableRoute(this.runtime.auxiliaryProviders, selected.value))
-                : selected;
-        }
-        const runtime = this.runtime;
-        if (providerId !== undefined &&
-            providerId !== "auto" &&
-            providerId !== runtime.identity.id)
-            return err(new ProviderSelectionError({
-                reason: "unknown_provider",
-                requestedProviderId: providerId,
-                candidateIds: [runtime.identity.id],
-            }));
-        const resolved = await waitForAbortable(runtime.resolveProfile(target, resolutionOptions), signal);
-        if (resolved === ABORTED)
-            return err(new AnalysisCancelledError("open_binary"));
-        if (!resolved.ok)
-            return resolved;
-        const normalized = normalizeProfileResolution(resolved.value, runtime.identity.id);
-        if (!normalized.ok)
-            return normalized;
-        return ok({
-            identity: structuredClone(runtime.identity),
-            capabilities: runtime.capabilities,
-            profile: normalized.value.profile,
-            compatibility: normalized.value.compatibility,
-            binding: null,
-            selection: undefined,
-            createClient: (openedTarget, context) => createSingleProviderClient(runtime, openedTarget, normalized.value.profile ?? undefined, context),
-        });
+        const selected = await this.registry.select(target, providerId, resolutionOptions);
+        return selected.ok
+            ? ok(selectableRoute(this.auxiliaryProviders, selected.value))
+            : selected;
     }
     /** Candidate status authoritative for the active or target-free route. */
     candidateStatuses(route) {
-        if (this.runtime.kind === "single")
-            return [];
-        return route.selection?.candidates ?? this.runtime.registry.candidates();
+        return route.selection?.candidates ?? this.registry.candidates();
     }
     /** Produce exact candidate rejections for an intentionally unbound route. */
     unboundOperationError(operation, route) {
-        if (this.runtime.kind !== "selectable" ||
-            route.binding !== null ||
-            route.selection === undefined)
+        if (route.binding !== null ||
+            route.selection === undefined ||
+            !this.registry.declaredOperations().includes(operation))
             return undefined;
-        return this.runtime.registry.unboundOperationError(operation, route.selection);
+        return this.registry.unboundOperationError(operation, route.selection);
     }
 }
 const selectableRoute = (auxiliaryProviders, selection) => {
@@ -149,23 +59,23 @@ const selectableRoute = (auxiliaryProviders, selection) => {
         ...auxiliaryProviders,
         ...(binding === null ? [] : [binding.provider]),
     ];
-    const provider = providers.length === 0 ? undefined : new CompositeProvider(providers);
+    const provider = binding === null && providers.length === 1
+        ? providers[0]
+        : providers.length === 0
+            ? undefined
+            : new CompositeProvider(providers);
     const identity = provider?.identity() ?? emptyProviderIdentity();
     const capabilities = capabilityMap(provider?.capabilities() ?? []);
     return {
         identity,
         capabilities,
         profile: binding?.profile ?? null,
-        compatibility: structuredClone(binding?.compatibility ?? {}),
         binding,
         selection,
         createClient: (target, context) => provider?.createClient(target, binding?.profile, context) ??
             emptyClient(identity),
     };
 };
-const createSingleProviderClient = (runtime, target, profile, context) => typeof runtime.provider === "function"
-    ? runtime.provider(target, profile, context)
-    : runtime.provider.createClient(target, profile, context);
 const emptyClient = (identity) => ({
     execute: (operation) => operation === "health"
         ? Promise.resolve(ok({
@@ -177,7 +87,7 @@ const emptyClient = (identity) => ({
             subject: null,
         }))
         : Promise.resolve(err(new AnalysisCapabilityUnavailableError(identity.id, operation, "operation is not declared by this provider set"))),
-    close: () => Promise.resolve(),
+    close: () => Promise.resolve(ok(null)),
 });
 const emptyProviderIdentity = () => ({
     id: "composite:none",
@@ -185,9 +95,6 @@ const emptyProviderIdentity = () => ({
     version: null,
 });
 const capabilityMap = (capabilities) => new Map(capabilities.map((descriptor) => [descriptor.operation, descriptor]));
-const uniqueProviderIdentities = (identities) => [...new Map(identities.map((identity) => [identity.id, identity])).values()]
-    .sort((left, right) => left.id.localeCompare(right.id))
-    .map((identity) => structuredClone(identity));
 const assertDisjoint = (providers) => {
     const routes = new Set();
     for (const provider of providers)
@@ -206,18 +113,3 @@ const assertUniqueProviderIds = (identities) => {
         ids.add(identity.id);
     }
 };
-const normalizeProfileResolution = (resolution, providerId) => {
-    try {
-        return ok({
-            profile: resolution.profile === null
-                ? null
-                : analysisProfileSchema.parse(resolution.profile),
-            compatibility: jsonObjectSchema.parse(resolution.compatibility),
-        });
-    }
-    catch (cause) {
-        return err(new ProviderAdapterError(providerId, "resolve_analysis_profile", {
-            cause,
-        }));
-    }
-};

package/dist/application/binaryDiagnostics/BinaryLayoutService.js

@@ -2,7 +2,7 @@ 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 { analysisInputErrorFromIssues } 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. */
@@ -17,7 +17,9 @@ export class BinaryLayoutService {
             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)));
+            return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
+                cause: input.error,
+            }));
         if (!isAbsolute(input.data.path))
             return err(new AnalysisInputError(OPERATION, undefined, [
                 {

package/dist/application/binaryDiagnostics/RecordedCrashService.js

@@ -2,7 +2,7 @@ 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 { analysisInputErrorFromIssues } 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. */
@@ -17,7 +17,9 @@ export class RecordedCrashService {
             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)));
+            return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
+                cause: input.error,
+            }));
         if (!isAbsolute(input.data.path))
             return err(new AnalysisInputError(OPERATION, undefined, [
                 {

package/dist/application/evm/EvmInterfaceService.js

@@ -3,7 +3,7 @@ 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 { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
 import { err, ok } from "../../domain/result.js";
 const OPERATION = "inspect_evm_interface";
 const diagnosticsSchema = z.object({
@@ -21,7 +21,9 @@ export class EvmInterfaceService {
             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)));
+            return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
+                cause: input.error,
+            }));
         if (!isAbsolute(input.data.path))
             return err(new AnalysisInputError(OPERATION, undefined, [
                 {

package/dist/application/homebrew.js

@@ -1,3 +1,6 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
 /** Standard executable names and locations used to discover Homebrew. */
 const HOMEBREW_COMMANDS = [
     "brew",
@@ -17,3 +20,48 @@ export const probeHomebrew = async (probe) => {
     }
     return undefined;
 };
+const caskDirectoriesSchema = z
+    .object({ appdir: z.string().min(1).optional() })
+    .loose();
+const caskConfigSchema = z
+    .object({
+    default: caskDirectoriesSchema.optional(),
+    env: caskDirectoriesSchema.optional(),
+    explicit: caskDirectoriesSchema.optional(),
+})
+    .loose();
+/**
+ * Read the application directory Homebrew recorded when it installed a cask,
+ * in Homebrew's precedence: explicit option, then environment, then default.
+ * Reading the Caskroom avoids `brew` cask commands, which refresh Homebrew's
+ * API and bootsnap caches.
+ */
+export const installedCaskAppdir = async (caskroom, token, home) => {
+    let text;
+    try {
+        text = await readFile(join(caskroom, token, ".metadata", "config.json"), "utf8");
+    }
+    catch (cause) {
+        // An absent or unreadable receipt means the cask is not installed here.
+        void cause;
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (cause) {
+        // A malformed receipt does not identify an application directory.
+        void cause;
+        return undefined;
+    }
+    const config = caskConfigSchema.safeParse(parsed);
+    if (!config.success)
+        return undefined;
+    const appdir = config.data.explicit?.appdir ??
+        config.data.env?.appdir ??
+        config.data.default?.appdir;
+    if (appdir === undefined)
+        return undefined;
+    return appdir.startsWith("~/") ? join(home, appdir.slice(2)) : appdir;
+};

package/dist/application/investigation/EvidenceLedger.js

@@ -1,8 +1,8 @@
 import canonicalize from "canonicalize";
-import { createEvidenceBundle, parseEvidenceBundle, validateResidualUnknownAddition, } from "../../domain/evidenceBundle.js";
+import { createEvidenceBundle, createImmutableEvidenceBundle, describeEvidenceBundleFailure, 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 { immutableEvidence, 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. */
@@ -14,7 +14,7 @@ export class EvidenceLedger {
     record(input) {
         let evidence;
         try {
-            evidence = parseEvidence(input);
+            evidence = immutableEvidence(input);
         }
         catch (cause) {
             return err(new EvidenceIntegrityError("Evidence record validation failed", {
@@ -23,6 +23,11 @@ export class EvidenceLedger {
         }
         const existing = this.#records.get(evidence.evidence_id);
         if (existing !== undefined) {
+            // A borrowed record is already authenticated and deeply immutable. Its
+            // identity cannot change between reads, so comparing document-sized
+            // canonical strings again would add no integrity check.
+            if (existing === evidence)
+                return ok("duplicate");
             return recordsAgree(existing, evidence)
                 ? ok("duplicate")
                 : err(new EvidenceIntegrityError("Conflicting evidence record"));
@@ -39,6 +44,7 @@ export class EvidenceLedger {
         catch (cause) {
             return err(new EvidenceIntegrityError("Evidence bundle validation failed", {
                 cause,
+                userMessage: describeEvidenceBundleFailure(input, cause),
             }));
         }
         // A record-only bundle cannot change the already-valid unknown graph. The
@@ -63,9 +69,9 @@ export class EvidenceLedger {
                 additions.set(evidence.evidence_id, evidence);
             }
             for (const [id, evidence] of replacements)
-                this.#records.set(id, evidence);
+                this.#records.set(id, immutableEvidence(evidence));
             for (const [id, evidence] of additions)
-                this.#records.set(id, evidence);
+                this.#records.set(id, immutableEvidence(evidence));
             return ok({
                 recordsAdded: additions.size,
                 unknownsAdded: 0,
@@ -117,6 +123,10 @@ export class EvidenceLedger {
     export() {
         return structuredClone(createEvidenceBundle([...this.#records.values()], [...this.#unknownRevisions.values()]));
     }
+    /** Borrow a sealed canonical bundle for serialization without copying its records. */
+    forSerialization() {
+        return createImmutableEvidenceBundle([...this.#records.values()], [...this.#unknownRevisions.values()]);
+    }
     /** Check whether one immutable Evidence ID is present in this ledger. */
     has(evidenceId) {
         return this.#records.has(evidenceId);
@@ -126,6 +136,10 @@ export class EvidenceLedger {
         const evidence = this.#records.get(evidenceId);
         return evidence === undefined ? undefined : structuredClone(evidence);
     }
+    /** Borrow authenticated immutable Evidence for read-only analysis without a full clone. */
+    forAnalysis(evidenceId) {
+        return this.#records.get(evidenceId);
+    }
     /** Create one approved unknown and atomically append its mutation evidence. */
     recordUnknown(input, mutationEvidence) {
         let parsedMutation;
@@ -271,7 +285,7 @@ export class EvidenceLedger {
                 return err(new UnknownRegistryError("integrity", { cause }));
             }
         for (const [id, evidence] of additions)
-            this.#records.set(id, evidence);
+            this.#records.set(id, immutableEvidence(evidence));
         if (unknown !== undefined && unknownKey !== undefined) {
             this.#unknownRevisions.set(unknownKey, unknown);
             this.#unknownHeads.set(unknown.unknown_id, unknown);
@@ -290,7 +304,7 @@ export class EvidenceLedger {
     #commit(records, unknowns) {
         this.#records.clear();
         for (const [id, evidence] of records)
-            this.#records.set(id, evidence);
+            this.#records.set(id, immutableEvidence(evidence));
         this.#unknownRevisions.clear();
         this.#unknownHeads.clear();
         for (const [key, unknown] of unknowns) {

package/dist/application/investigation/InvestigationRecords.js

@@ -16,10 +16,18 @@ export class InvestigationRecords {
     evidenceById(evidenceId) {
         return this.#evidence.get(evidenceId);
     }
+    /** Borrow an immutable authenticated record for a read-only application workflow. */
+    evidenceForAnalysis(evidenceId) {
+        return this.#evidence.forAnalysis(evidenceId);
+    }
     /** Export a detached deterministic bundle of Evidence and Unknown revisions. */
     exportEvidenceBundle() {
         return this.#evidence.export();
     }
+    /** Borrow a sealed bundle snapshot for complete JSON serialization. */
+    evidenceBundleForSerialization() {
+        return this.#evidence.forSerialization();
+    }
     /** Atomically merge a bundle and report changes for the owner's post-commit observers. */
     mergeEvidenceBundle(bundle) {
         return this.#evidence.import(bundle);

package/dist/application/javascript/ElectronActiveEvidence.js

@@ -1,7 +1,7 @@
 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. */
+import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
+/** Commit the selected Electron experiment and its observed result. */
 export const createElectronActiveEvidence = (input, result, provider) => createEvidence(undefined, provider, {
     predicateType: "rea.electron-active-scenario",
     operation: "capture_electron_scenario",
@@ -20,14 +20,10 @@ export const createElectronActiveEvidence = (input, result, provider) => createE
         "Application host platform and architecture were not observed.",
     ],
 });
-const scenarioProjection = (input) => ({
-    executable_path: input.executable_path,
-    application_path: input.application_path,
-    application_root: input.application_root,
-    args: [...input.args],
-    actions: input.actions.map(({ step_id, kind }) => ({ step_id, kind })),
-});
-const parameters = (input) => ({
-    ...scenarioProjection(input),
-    scenario_sha256: canonicalDigest(scenarioProjection(input), "Browser scenario"),
-});
+const parameters = (input) => {
+    const scenario = jsonObjectSchema.parse(input);
+    return {
+        ...scenario,
+        scenario_sha256: canonicalDigest(scenario, "Electron scenario"),
+    };
+};

package/dist/application/javascript/JavaScriptAnalysisControl.js

@@ -0,0 +1,34 @@
+import { setImmediate } from "node:timers/promises";
+import { ArtifactReaderFailure } from "../../artifacts/ArtifactReader.js";
+/** Reject cancelled application work before computing or publishing more results. */
+export const assertJavaScriptAnalysisActive = (signal) => {
+    if (signal?.aborted === true)
+        throw new ArtifactReaderFailure("cancelled", "JavaScript application analysis cancelled");
+};
+/** Let request control messages run, then recheck the current analysis intent. */
+export const checkpointJavaScriptAnalysis = async (signal) => {
+    assertJavaScriptAnalysisActive(signal);
+    await setImmediate();
+    assertJavaScriptAnalysisActive(signal);
+};
+/** Drive bounded owned-domain steps while permitting cancellation and control I/O. */
+export const completeJavaScriptAnalysisSteps = async (steps, signal) => {
+    let deadline = performance.now() + 8;
+    try {
+        for (;;) {
+            assertJavaScriptAnalysisActive(signal);
+            const step = steps.next();
+            if (step.done) {
+                assertJavaScriptAnalysisActive(signal);
+                return step.value;
+            }
+            if (performance.now() >= deadline) {
+                await checkpointJavaScriptAnalysis(signal);
+                deadline = performance.now() + 8;
+            }
+        }
+    }
+    finally {
+        steps.return?.();
+    }
+};