rea-agents 2.3.0 → 2.4.0

package/README.md

@@ -376,7 +376,7 @@ REA handles the app analysis in steps 1–5. The agent performs step 6 with its
 | Native inspection         |    33 | procedures, pseudocode, assembly, strings, names, segments, callers, callees, xrefs, annotations                                                                                                                                          |
 | Investigation workflows   |    10 | `binary_overview`, `analyze_function`, `batch_decompile`, `trace_feature`, call graphs, Swift and Objective-C discovery                                                                                                                   |
 | Native macOS utilities    |     5 | Mach-O metadata, code signatures, plists, architectures, Swift demangling; Hopper-free and provenance-bearing                                                                                                                             |
-| Artifact graph            |     2 | deterministic directory, ZIP/APK/IPA, and ASAR inventory; explicitly selected extraction into an absent owned tree                                                                                                                        |
+| Artifact graph            |     2 | deterministic directory, ZIP/APK/IPA/MSIX/AppX, and ASAR inventory; explicitly selected extraction into an absent owned tree                                                                                                              |
 | Managed PE/CLI            |     8 | PE/CLI identity, metadata members, CIL hashes, P/Invoke/native-boundary declarations and verification, application-graph projection, decompiler reconstruction import, token remapping, runtime-correlation plans, and version comparison |
 | Browser observation       |     8 | exact-origin CDP capture, bundle and source-map analysis, WebMCP discovery, session timelines, capture diff, and visual evidence                                                                                                          |
 | Electron analysis         |     4 | passive root-confined observation, bounded static application mapping, and evidence-backed static/runtime reconciliation                                                                                                                  |
@@ -479,7 +479,7 @@ Setup detects Claude Code, Claude Desktop, Codex, Cursor, Gemini CLI, Windsurf,
   "mcpServers": {
     "rea": {
       "command": "npx",
-      "args": ["-y", "rea-agents@2.3.0", "mcp"]
+      "args": ["-y", "rea-agents@2.4.0", "mcp"]
     }
   }
 }

package/dist/application/ArtifactExtraction.js

@@ -140,7 +140,11 @@ const createReader = async (path, format) => {
         return new DirectoryArtifactReader(path);
     if (format === "asar")
         return new AsarArtifactReader(path);
-    if (format === "ipa" || format === "apk" || format === "zip")
+    if (format === "ipa" ||
+        format === "apk" ||
+        format === "msix" ||
+        format === "appx" ||
+        format === "zip")
         return new ZipArtifactReader(path, format);
     if (format === "mach-o")
         return new MachOSliceArtifactReader(path);

package/dist/application/ArtifactGraphConstruction.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
-import { extname } from "node:path";
 import canonicalize from "canonicalize";
+import { zipPackageFormatForPath } from "../domain/zipPackageFormat.js";
 /** Index the first occurrence for each canonical logical path. */
 export const indexOccurrencesByPath = (occurrences) => {
     const byPath = new Map();
@@ -74,7 +74,7 @@ export const createRootNode = (input) => createArtifactNode({
         }),
     size: input.digest?.bytes ?? 0,
     kind: input.directory ||
-        ["zip", "ipa", "apk", "asar", "dmg", "pkg"].includes(input.format)
+        ["zip", "ipa", "apk", "msix", "appx", "asar", "dmg", "pkg"].includes(input.format)
         ? "container"
         : classifyArtifactPath(input.path).kind,
     format: input.format,
@@ -174,7 +174,7 @@ export const classifyArtifactPath = (path) => {
         return { kind: "javascript", format: "javascript-bundle" };
     if (lower.endsWith(".asar"))
         return { kind: "container", format: "asar" };
-    const archiveFormat = archiveFormatForExtension(extname(lower));
+    const archiveFormat = zipPackageFormatForPath(lower);
     if (archiveFormat !== undefined)
         return { kind: "container", format: archiveFormat };
     if (/\.framework(?:\/|$)/u.test(lower))
@@ -251,16 +251,4 @@ const relationFor = (path) => {
         return "embeds";
     return "contains";
 };
-const archiveFormatForExtension = (extension) => {
-    switch (extension) {
-        case ".zip":
-            return "zip";
-        case ".ipa":
-            return "ipa";
-        case ".apk":
-            return "apk";
-        default:
-            return undefined;
-    }
-};
 const depth = (path) => path.split("/").length;

package/dist/application/ArtifactInventory/classify.js

@@ -1,8 +1,12 @@
 import { open } from "node:fs/promises";
 import { classifyArtifactPath } from "../ArtifactGraphConstruction.js";
+import { zipPackageFormatForPath } from "../../domain/zipPackageFormat.js";
 const classifyContainerExtension = (path) => {
     const lower = path.toLowerCase();
-    for (const format of ["asar", "ipa", "apk", "zip", "dmg", "pkg"])
+    const zipPackage = zipPackageFormatForPath(lower);
+    if (zipPackage !== undefined)
+        return zipPackage;
+    for (const format of ["asar", "dmg", "pkg"])
         if (lower.endsWith(`.${format}`))
             return format;
     return undefined;

package/dist/application/ArtifactInventory/reader.js

@@ -11,6 +11,8 @@ export const createReader = async (path, format, nativeMount, signal) => {
         case "zip":
         case "ipa":
         case "apk":
+        case "msix":
+        case "appx":
             return new ZipArtifactReader(path, format);
         case "asar":
             return new AsarArtifactReader(path);

package/dist/application/BinarySessionStatus.js

@@ -91,6 +91,7 @@ const capabilityStatus = (descriptor) => ({
     operation: descriptor.operation,
     available: descriptor.available,
     reason: descriptor.reason,
+    availability_code: descriptor.availabilityCode ?? null,
     input_contract_version: descriptor.inputContractVersion,
     output_contract_version: descriptor.outputContractVersion,
     pagination: descriptor.pagination,

package/dist/application/CapabilityInventory.js

@@ -8,6 +8,7 @@ const statusSchema = z.object({
         operation: z.string(),
         available: z.boolean(),
         reason: z.string().nullable(),
+        availability_code: z.string().nullable().optional(),
     })),
 });
 const ENHANCED_REQUIREMENTS = {
@@ -35,7 +36,14 @@ const ENHANCED_REQUIREMENTS = {
 /** Build stable per-operation availability without hiding familiar tools. */
 export const buildCapabilityInventory = (sessionStatus, policy) => {
     const status = statusSchema.parse(sessionStatus);
-    const descriptors = new Map(status.capabilities.map((descriptor) => [descriptor.operation, descriptor]));
+    const descriptors = new Map(status.capabilities.map((descriptor) => [
+        descriptor.operation,
+        {
+            available: descriptor.available,
+            reason: descriptor.reason,
+            availability_code: descriptor.availability_code ?? null,
+        },
+    ]));
     return TOOL_CONTRACTS.map((contract) => {
         const availability = availabilityFor({
             name: contract.name,
@@ -157,7 +165,7 @@ const providerAvailability = ({ descriptors, kind, name, }) => {
             remediation: "Install or configure a provider that declares this operation.",
         };
     if (!descriptor.available &&
-        descriptor.reason?.toLowerCase().includes("require macos") === true)
+        descriptor.availability_code === "unsupported_host")
         return {
             reason: "unsupported_host",
             remediation: descriptor.reason,
@@ -187,7 +195,7 @@ const composedAvailability = (name, descriptors) => {
         .find((descriptor) => descriptor?.available === false);
     if (unavailable !== undefined)
         return {
-            reason: unavailable.reason?.toLowerCase().includes("require macos") === true
+            reason: unavailable.availability_code === "unsupported_host"
                 ? "unsupported_host"
                 : "provider_unavailable",
             remediation: unavailable.reason ?? "Choose another target or configured provider.",

package/dist/application/ProcessCaptureEnvironment.js

@@ -0,0 +1,26 @@
+/** Build the explicitly admitted environment for a captured process. */
+export const makeProcessCaptureEnvironment = (options) => {
+    const { scenario, home, replay, shimReplay, runId } = options;
+    const environment = {
+        ...scenario.environment,
+        HOME: home,
+        TERM: "xterm-256color",
+        REA_PROCESS_RUN_ID: runId,
+    };
+    for (const name of scenario.inherit_environment) {
+        const value = process.env[name];
+        if (value !== undefined)
+            environment[name] = value;
+    }
+    environment.REA_REPLAY_HTTP_URL = replay.httpUrl;
+    environment.REA_REPLAY_WEBSOCKET_URL = replay.websocketUrl;
+    environment.REA_SHIM_LEDGER_URL = shimReplay.url;
+    // PATH is evidence-producing input. Inheriting the host PATH here would let
+    // the authority and reconstruction probe different tools without recording
+    // that difference. Scenarios must opt in through environment or
+    // inherit_environment; deterministic shims always take precedence.
+    environment.PATH = [shimReplay.binPath, environment.PATH ?? ""]
+        .filter((part) => part.length > 0)
+        .join(":");
+    return environment;
+};

package/dist/application/ProcessCaptureLifecycle.js

@@ -33,6 +33,7 @@ export const buildCaptureResult = (options) => ({
     shim_events: options.shimEvents,
     protocol_events: redactProtocolEvents(options.replay.events, options.scenario),
     replay_transitions: options.replay.transitions,
+    reactive_run: options.reactiveRun,
     event_journal: options.eventJournal,
     files_before: options.before.files,
     files_after: options.after.files,

package/dist/application/ProcessCheckpoints.js

@@ -79,6 +79,11 @@ export class ProcessCheckpoints {
     capture(name) {
         this.#scheduleCapture(name, this.#signal);
     }
+    /** Read one committed checkpoint for synchronous journal projection. */
+    at(index) {
+        const checkpoint = this.#captures[index];
+        return checkpoint === undefined ? undefined : structuredClone(checkpoint);
+    }
     #scheduleCapture(name, signal) {
         if (this.#captured.has(name))
             return;

package/dist/application/ProcessHarness.js

@@ -8,37 +8,14 @@ import { snapshotRoots } from "./FilesystemSnapshot.js";
 import { ProcessCheckpoints } from "./ProcessCheckpoints.js";
 import { TerminalRenderer } from "./TerminalRenderer.js";
 import { startCommandShimReplay, } from "./CommandShimReplay.js";
-import { normalizeProcessText } from "./ProcessNormalization.js";
+import { normalizeProcessShimEvent, normalizeProcessText, } from "./ProcessNormalization.js";
 import { selectCapturedProcessGroupIds } from "../process/ProcessOwnership.js";
 import { awaitTerminalExit, buildCaptureResult, captureTerminalFrames, createRunManifest, observeSettlement, prepareProcessCapture, releaseProcessResources, resolveProcessResult, } from "./ProcessCaptureLifecycle.js";
 import { assertNotCancelled } from "./ProcessCaptureAuthority.js";
 import { createProcessCaptureJournal, scheduleScenarioInteractions, } from "./ProcessCaptureJournal.js";
+import { assertSupportedReactiveScenario, projectProcessReactiveRun, startProcessReactiveHarness, } from "./ProcessReactiveHarness.js";
+import { makeProcessCaptureEnvironment } from "./ProcessCaptureEnvironment.js";
 export { probeProcessCaptureCapability } from "./ProcessCaptureCapability.js";
-const makeEnvironment = (options) => {
-    const { scenario, home, replay, shimReplay, runId } = options;
-    const environment = {
-        ...scenario.environment,
-        HOME: home,
-        TERM: "xterm-256color",
-        REA_PROCESS_RUN_ID: runId,
-    };
-    for (const name of scenario.inherit_environment) {
-        const value = process.env[name];
-        if (value !== undefined)
-            environment[name] = value;
-    }
-    environment.REA_REPLAY_HTTP_URL = replay.httpUrl;
-    environment.REA_REPLAY_WEBSOCKET_URL = replay.websocketUrl;
-    environment.REA_SHIM_LEDGER_URL = shimReplay.url;
-    // PATH is evidence-producing input. Inheriting the host PATH here would let
-    // the authority and reconstruction probe different tools without recording
-    // that difference. Scenarios must opt in through environment or
-    // inherit_environment; deterministic shims always take precedence.
-    environment.PATH = [shimReplay.binPath, environment.PATH ?? ""]
-        .filter((part) => part.length > 0)
-        .join(":");
-    return environment;
-};
 const cleanupFailedStartup = async (options) => {
     options.terminal?.kill("SIGKILL");
     const cleanupFailure = await releaseProcessResources({
@@ -61,6 +38,11 @@ const createTerminalRenderer = (scenario, temporaryRoot, terminalPid, recordEven
     normalize: (value) => normalizeProcessText(value, scenario, temporaryRoot, terminalPid()),
     recordEvent,
 });
+const reactiveCapture = (options, protocolEvents) => ({
+    ...options,
+    processSamples: options.samples,
+    protocolEvents,
+});
 const startCaptureRuntime = async (options) => {
     const { scenario } = options;
     let replay;
@@ -68,6 +50,7 @@ const startCaptureRuntime = async (options) => {
     let checkpoints;
     let shimReplay;
     let terminal;
+    let reactive;
     try {
         const { spawn } = await import("@lydell/node-pty");
         replay = await startLoopbackReplay(scenario, options.recordEvent);
@@ -82,7 +65,7 @@ const startCaptureRuntime = async (options) => {
         shimReplay = await startCommandShimReplay(scenario, options.temporaryRoot, started, options.recordEvent);
         terminal = spawn(scenario.executable, [...scenario.arguments], {
             cwd: scenario.working_directory,
-            env: makeEnvironment({ ...options, replay, shimReplay }),
+            env: makeProcessCaptureEnvironment({ ...options, replay, shimReplay }),
             cols: scenario.terminal.columns,
             rows: scenario.terminal.rows,
             name: "xterm-256color",
@@ -95,6 +78,15 @@ const startCaptureRuntime = async (options) => {
             renderer,
             checkpoints,
         });
+        reactive = startProcessReactiveHarness({
+            capture: reactiveCapture(options, () => replay?.events ?? []),
+            scenario,
+            terminal: () => terminal,
+            renderer,
+            checkpoints,
+            shimReplay,
+            started,
+        });
         scheduleScenarioInteractions({
             ...options,
             getTerminal: () => terminal,
@@ -120,9 +112,12 @@ const startCaptureRuntime = async (options) => {
             lastOutput: () => lastOutput,
             framesTruncated,
             stopSampler,
+            reactive,
         };
     }
     catch (cause) {
+        reactive?.unsubscribe();
+        await reactive?.coordinator.close();
         return cleanupFailedStartup({
             cause,
             timers: options.timers,
@@ -136,12 +131,9 @@ const startCaptureRuntime = async (options) => {
         });
     }
 };
-const normalizedShimEvents = (runtime, scenario, temporaryRoot) => runtime.shimReplay.events.map((event) => ({
-    ...event,
-    arguments: event.arguments.map((argument) => normalizeProcessText(argument, scenario, temporaryRoot, runtime.terminal.pid)),
-    working_directory: normalizeProcessText(event.working_directory, scenario, temporaryRoot, runtime.terminal.pid),
-}));
+const normalizedShimEvents = (runtime, scenario, temporaryRoot) => runtime.shimReplay.events.map((event) => normalizeProcessShimEvent(event, scenario, temporaryRoot, runtime.terminal.pid));
 const finishProcessRun = async (options) => {
+    options.runtime?.reactive?.unsubscribe();
     await options.stopSampler();
     const cleanupFailure = await releaseProcessResources({
         timers: options.timers,
@@ -156,10 +148,16 @@ const finishProcessRun = async (options) => {
             ? []
             : selectCapturedProcessGroupIds(options.runtime.terminal.pid, options.samples),
     });
+    if (cleanupFailure !== undefined)
+        await options.runtime?.reactive?.coordinator.submit({
+            kind: "cleanup_failed",
+        });
+    await options.runtime?.reactive?.coordinator.close();
     let { capture, executionFailure } = options;
     if (capture !== undefined) {
         capture = {
             ...capture,
+            reactive_run: projectProcessReactiveRun(options.runtime?.reactive),
             settlement: {
                 ...capture.settlement,
                 cleanup_outcome: capture.settlement.state === "quiesced"
@@ -179,8 +177,17 @@ const completeCapture = async (options) => {
     const { runtime, scenario } = options;
     runtime.checkpoints.trigger("root_exit");
     const { reason } = options.exit;
-    if (reason === "cancelled")
+    if (reason === "cancelled") {
+        if (runtime.reactive !== undefined) {
+            await runtime.reactive.coordinator.submit({ kind: "cancelled" });
+            runtime.reactive.unsubscribe();
+        }
         throw processCaptureCancelled();
+    }
+    if (runtime.reactive !== undefined) {
+        await runtime.reactive.coordinator.submit({ kind: "target_lost" });
+        runtime.reactive.unsubscribe();
+    }
     const settlement = await observeSettlement(options.runId, selectCapturedProcessGroupIds(runtime.terminal.pid, options.samples), scenario.settle_ms, options.recordEvent);
     runtime.checkpoints.trigger("settled");
     const samplingPartial = (await runtime.stopSampler()).partial;
@@ -203,6 +210,7 @@ const completeCapture = async (options) => {
         exit: { ...options.exit, reason },
         samples: options.samples,
         replay: runtime.replay,
+        reactiveRun: projectProcessReactiveRun(runtime.reactive),
         before: options.before,
         after,
         truncated,
@@ -220,10 +228,12 @@ const completeCapture = async (options) => {
 };
 /** Execute one authorized scenario and return bounded observations. */
 const runProcessScenario = async (scenario, policy, signal) => {
+    assertSupportedReactiveScenario(scenario);
     const { temporaryRoot, runId, home, before } = await prepareProcessCapture(scenario, policy, signal);
     const frames = [];
     const samples = [];
-    const { entries: eventJournal, recordEvent } = createProcessCaptureJournal();
+    const journal = createProcessCaptureJournal();
+    const { entries: eventJournal, recordEvent } = journal;
     let runtime;
     const timers = new Set();
     let capture;
@@ -244,6 +254,7 @@ const runProcessScenario = async (scenario, policy, signal) => {
             timers,
             dispatchedEventIndexes,
             recordEvent,
+            journal,
             ...(signal === undefined ? {} : { signal }),
         });
         stopSampler = runtime.stopSampler;

package/dist/application/ProcessNormalization.js

@@ -54,6 +54,12 @@ export const normalizeProcessSamples = (samples, scenario, rootPid) => {
         command: normalizeCommand(sample.command),
     }));
 };
+/** Normalize one shim observation identically for live matching and capture. */
+export const normalizeProcessShimEvent = (event, scenario, temporaryRoot, rootPid) => ({
+    ...event,
+    arguments: event.arguments.map((argument) => normalizeProcessText(argument, scenario, temporaryRoot, rootPid)),
+    working_directory: normalizeProcessText(event.working_directory, scenario, temporaryRoot, rootPid),
+});
 const normalizePidTokens = (value, identifiers) => {
     const tokens = [...new Set(identifiers)]
         .filter((identifier) => Number.isSafeInteger(identifier) && identifier > 0)

package/dist/application/ProcessReactiveCoordinator.js

@@ -153,7 +153,7 @@ export class ProcessReactiveCoordinator {
             decision = commitProcessReactiveProposal(this.#scenario, decision, effectResults);
         }
         this.#snapshot = decision.snapshot;
-        this.#onDecision?.(decision);
+        this.#onDecision?.(decision, input);
         if (this.#snapshot.status === "finished")
             this.#clearTimers();
         else if (this.#accepting &&
@@ -162,16 +162,23 @@ export class ProcessReactiveCoordinator {
                     this.#snapshot.state_entry_capture_order))
             this.#scheduleStateDeadline();
         for (const result of effectResults)
-            if (result.status === "succeeded")
+            if (result.status === "succeeded" &&
+                !this.#hasObservation(result.observation.event_id))
                 this.#enqueueOwned({
                     kind: "observation",
                     observation: result.observation,
                 });
     }
+    #hasObservation(eventId) {
+        return (this.#snapshot.observations.some((observation) => observation.event_id === eventId) ||
+            this.#pendingInputs.some((input) => input.kind === "observation" &&
+                input.observation.event_id === eventId));
+    }
     #interruptsEffects(input) {
         if (input.kind === "cancelled" ||
             input.kind === "cleanup_failed" ||
-            input.kind === "scenario_deadline")
+            input.kind === "scenario_deadline" ||
+            input.kind === "target_lost")
             return true;
         return (input.kind === "state_deadline" &&
             input.state_id === this.#snapshot.active_state &&

package/dist/application/ProcessReactiveEffects.js

@@ -109,7 +109,15 @@ const triggerSources = (trigger) => {
     if (trigger.kind === "terminal_text")
         return [];
     if (trigger.kind === "event")
-        return ["terminal_raw", "interaction", "filesystem"].includes(trigger.source)
+        return [
+            "terminal_raw",
+            "interaction",
+            "process",
+            "filesystem",
+            "http",
+            "websocket",
+            "shim",
+        ].includes(trigger.source)
             ? []
             : [trigger.source];
     return trigger.kind === "repeat"

package/dist/application/ProcessReactiveHarness.js

@@ -0,0 +1,85 @@
+import { ProcessCaptureError } from "./ProcessCaptureError.js";
+import { ProcessReactiveCoordinator } from "./ProcessReactiveCoordinator.js";
+import { executeProcessReactiveEffects, unsupportedProcessReactiveFeatures, } from "./ProcessReactiveEffects.js";
+import { subscribeProcessReactiveObservations } from "./ProcessReactiveObservations.js";
+import { normalizeProcessSamples, normalizeProcessShimEvent, redactProtocolEvents, } from "./ProcessNormalization.js";
+const controlKind = (input) => input.kind === "observation" ? undefined : input.kind;
+/** Reject reactive declarations the current process adapter cannot execute. */
+export const assertSupportedReactiveScenario = (scenario) => {
+    if (scenario.reactive === null)
+        return;
+    const unsupported = unsupportedProcessReactiveFeatures(scenario.reactive);
+    if (unsupported.length === 0)
+        return;
+    throw new ProcessCaptureError(`reactive scenario requests unsupported features: ${unsupported.join(", ")}`);
+};
+/**
+ * Attach the serialized reactive runtime once the target PID is available.
+ *
+ * Subscription replays journal entries admitted during launcher startup before
+ * observing new records, so PID-dependent normalization cannot drop them.
+ */
+export const startProcessReactiveHarness = (options) => {
+    if (options.scenario.reactive === null)
+        return undefined;
+    const controls = [];
+    const coordinator = new ProcessReactiveCoordinator({
+        scenario: options.scenario.reactive,
+        executor: {
+            execute: (actions, signal) => executeProcessReactiveEffects({
+                terminal: options.terminal,
+                renderer: options.renderer,
+                checkpoints: options.checkpoints,
+                interactions: options.capture.interactions,
+                journal: options.capture.journal,
+                startedAtMs: options.started,
+                now: Date.now,
+            }, actions, signal),
+        },
+        onDecision: (decision, input) => {
+            const kind = controlKind(input);
+            if (kind === undefined || decision.kind !== "finished")
+                return;
+            controls.push({
+                sequence: controls.length,
+                kind,
+                after_capture_order: decision.snapshot.observations.at(-1)?.capture_order ?? -1,
+            });
+        },
+    });
+    return {
+        coordinator,
+        controls,
+        unsubscribe: subscribeProcessReactiveObservations({
+            journal: options.capture.journal,
+            frames: options.capture.frames,
+            interactions: options.capture.interactions,
+            checkpointAt: (index) => options.checkpoints.at(index),
+            processSampleAt: (index) => {
+                const rootPid = options.terminal()?.pid;
+                return rootPid === undefined
+                    ? undefined
+                    : normalizeProcessSamples(options.capture.processSamples, options.scenario, rootPid)[index];
+            },
+            protocolEventAt: (index) => redactProtocolEvents(options.capture.protocolEvents().slice(index, index + 1), options.scenario)[0],
+            shimEventAt: (index) => {
+                const event = options.shimReplay.events[index];
+                const rootPid = options.terminal()?.pid;
+                return event === undefined || rootPid === undefined
+                    ? undefined
+                    : normalizeProcessShimEvent(event, options.scenario, options.capture.temporaryRoot, rootPid);
+            },
+            sink: coordinator,
+        }),
+    };
+};
+/** Project internal reducer state into the stable Process Capture shape. */
+export const projectProcessReactiveRun = (harness) => harness === undefined
+    ? null
+    : {
+        status: harness.coordinator.snapshot.status,
+        outcome: harness.coordinator.snapshot.outcome,
+        active_state: harness.coordinator.snapshot.active_state,
+        transitions: harness.coordinator.snapshot.transitions,
+        controls: harness.controls,
+    };

package/dist/application/ProcessReactiveObservations.js

@@ -1,20 +1,105 @@
-import { createProcessObservation } from "../domain/processObservation.js";
-/** Subscribe a reactive coordinator to normalized raw PTY journal records. */
-export const subscribeProcessReactiveTerminalObservations = (options) => options.journal.subscribe((entry) => {
-    if (entry.collection !== "frames")
-        return;
-    const frame = options.frames[entry.index];
-    if (frame === undefined)
-        return;
-    options.sink.enqueue({
-        kind: "observation",
-        observation: createProcessObservation({
+import { createProcessObservation, processObservationSubject, } from "../domain/processObservation.js";
+const terminalObservation = (options, entry) => {
+    const value = options.frames[entry.index];
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
             source: "terminal_raw",
-            source_sequence: frame.sequence,
-            captured_at_ms: frame.at_ms,
+            source_sequence: value.sequence,
+            captured_at_ms: value.at_ms,
             subject_id: null,
             location: entry,
-            payload: frame,
-        }),
+            payload: value,
+        });
+};
+const interactionObservation = (options, entry) => {
+    const value = options.interactions[entry.index];
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
+            source: "interaction",
+            source_sequence: value.sequence,
+            captured_at_ms: value.dispatched_at_ms,
+            subject_id: null,
+            location: entry,
+            payload: value,
+        });
+};
+const filesystemObservation = (options, entry) => {
+    const value = options.checkpointAt(entry.index);
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
+            source: "filesystem",
+            source_sequence: entry.index,
+            captured_at_ms: value.at_ms,
+            subject_id: processObservationSubject("filesystem", value),
+            location: entry,
+            payload: value,
+        });
+};
+const processObservation = (options, entry) => {
+    const value = options.processSampleAt(entry.index);
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
+            source: "process",
+            source_sequence: entry.index,
+            captured_at_ms: value.at_ms,
+            subject_id: processObservationSubject("process", value),
+            location: entry,
+            payload: value,
+        });
+};
+const protocolObservation = (options, entry) => {
+    const value = options.protocolEventAt(entry.index);
+    return value === undefined
+        ? undefined
+        : createProcessObservation({
+            source: value.protocol,
+            source_sequence: value.sequence,
+            captured_at_ms: value.at_ms,
+            subject_id: processObservationSubject(value.protocol, value),
+            location: entry,
+            payload: value,
+        });
+};
+const shimObservation = (options, entry) => {
+    const normalized = options.shimEventAt(entry.index);
+    if (normalized === undefined)
+        return undefined;
+    return createProcessObservation({
+        source: "shim",
+        source_sequence: normalized.sequence,
+        captured_at_ms: normalized.at_ms,
+        subject_id: processObservationSubject("shim", normalized),
+        location: entry,
+        payload: normalized,
     });
-});
+};
+const observationFor = (options, entry) => {
+    if (entry.collection === "frames")
+        return terminalObservation(options, entry);
+    if (entry.collection === "interaction_events")
+        return interactionObservation(options, entry);
+    if (entry.collection === "filesystem_checkpoints")
+        return filesystemObservation(options, entry);
+    if (entry.collection === "process_samples")
+        return processObservation(options, entry);
+    if (entry.collection === "protocol_events")
+        return protocolObservation(options, entry);
+    if (entry.collection === "shim_events")
+        return shimObservation(options, entry);
+    return undefined;
+};
+/** Subscribe the reactive coordinator to admitted normalized journal records. */
+export const subscribeProcessReactiveObservations = (options) => {
+    const enqueue = (entry) => {
+        const observation = observationFor(options, entry);
+        if (observation !== undefined)
+            options.sink.enqueue({ kind: "observation", observation });
+    };
+    for (const entry of options.journal.entries)
+        enqueue(entry);
+    return options.journal.subscribe(enqueue);
+};