rea-agents 2.2.0 → 2.4.0

package/dist/application/ProcessHarness.js

@@ -8,79 +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 scheduleScenarioEvents = (options) => {
-    const { scenario, getTerminal, timers, interactions, renderer, started } = options;
-    for (const [eventIndex, event] of scenario.events.entries()) {
-        const timer = setTimeout(() => {
-            options.dispatchedEventIndexes.add(eventIndex);
-            const terminal = getTerminal();
-            const dispatchedAt = Math.max(0, Date.now() - started);
-            let outcome = "dispatched";
-            if (terminal === undefined)
-                outcome = "target_exited";
-            else {
-                try {
-                    if (event.type === "input")
-                        terminal.write(event.data);
-                    else if (event.type === "resize") {
-                        terminal.resize(event.columns, event.rows);
-                        renderer.resize(event.columns, event.rows, dispatchedAt);
-                    }
-                    else
-                        terminal.kill(event.signal);
-                }
-                catch {
-                    outcome = "failed";
-                }
-            }
-            interactions.push({
-                sequence: interactions.length,
-                scheduled_at_ms: event.at_ms,
-                dispatched_at_ms: dispatchedAt,
-                type: event.type,
-                data: event.type === "input"
-                    ? event.sensitive
-                        ? `<redacted-input:${String(Buffer.byteLength(event.data))}-bytes>`
-                        : normalizeProcessText(event.data, scenario, "<no-temporary-root>", -1)
-                    : event.type === "resize"
-                        ? `${String(event.columns)}x${String(event.rows)}`
-                        : event.signal,
-                outcome,
-            });
-        }, event.at_ms);
-        timers.add(timer);
-    }
-};
 const cleanupFailedStartup = async (options) => {
     options.terminal?.kill("SIGKILL");
     const cleanupFailure = await releaseProcessResources({
@@ -94,13 +29,19 @@ const cleanupFailedStartup = async (options) => {
         });
     throw options.cause;
 };
-const createTerminalRenderer = (scenario, temporaryRoot, terminalPid) => new TerminalRenderer({
+const createTerminalRenderer = (scenario, temporaryRoot, terminalPid, recordEvent) => new TerminalRenderer({
     columns: scenario.terminal.columns,
     rows: scenario.terminal.rows,
     scrollback: scenario.terminal.scrollback,
     maxFrames: scenario.limits.frames,
     maxBytes: scenario.limits.output_bytes,
     normalize: (value) => normalizeProcessText(value, scenario, temporaryRoot, terminalPid()),
+    recordEvent,
+});
+const reactiveCapture = (options, protocolEvents) => ({
+    ...options,
+    processSamples: options.samples,
+    protocolEvents,
 });
 const startCaptureRuntime = async (options) => {
     const { scenario } = options;
@@ -109,18 +50,22 @@ const startCaptureRuntime = async (options) => {
     let checkpoints;
     let shimReplay;
     let terminal;
+    let reactive;
     try {
         const { spawn } = await import("@lydell/node-pty");
-        replay = await startLoopbackReplay(scenario);
+        replay = await startLoopbackReplay(scenario, options.recordEvent);
         const startedAt = new Date();
         const started = Date.now();
         let lastOutput = started;
-        renderer = createTerminalRenderer(scenario, options.temporaryRoot, () => terminal?.pid ?? -1);
-        checkpoints = new ProcessCheckpoints(scenario, started, options.before, options.signal);
-        shimReplay = await startCommandShimReplay(scenario, options.temporaryRoot, started);
+        renderer = createTerminalRenderer(scenario, options.temporaryRoot, () => terminal?.pid ?? -1, options.recordEvent);
+        checkpoints = new ProcessCheckpoints(scenario, started, options.before, {
+            signal: options.signal,
+            recordEvent: options.recordEvent,
+        });
+        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",
@@ -133,7 +78,16 @@ const startCaptureRuntime = async (options) => {
             renderer,
             checkpoints,
         });
-        scheduleScenarioEvents({
+        reactive = startProcessReactiveHarness({
+            capture: reactiveCapture(options, () => replay?.events ?? []),
+            scenario,
+            terminal: () => terminal,
+            renderer,
+            checkpoints,
+            shimReplay,
+            started,
+        });
+        scheduleScenarioInteractions({
             ...options,
             getTerminal: () => terminal,
             renderer,
@@ -145,6 +99,7 @@ const startCaptureRuntime = async (options) => {
             started,
             limit: scenario.limits.processes,
             samples: options.samples,
+            recordEvent: options.recordEvent,
         });
         return {
             replay,
@@ -157,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,
@@ -173,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,
@@ -193,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"
@@ -216,15 +177,25 @@ 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();
-    const settlement = await observeSettlement(options.runId, selectCapturedProcessGroupIds(runtime.terminal.pid, options.samples), scenario.settle_ms);
+    }
+    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;
     assertNotCancelled(options.signal);
     const after = await snapshotRoots(scenario, options.signal);
     const renderedFrames = await runtime.renderer.frames();
     const checkpoints = await runtime.checkpoints.finish(after);
+    await runtime.replay.close();
     const manifest = await createRunManifest(scenario, runtime.startedAt, new Date());
     const truncated = options.initiallyTruncated ||
         after.truncated ||
@@ -239,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,
@@ -251,13 +223,17 @@ const completeCapture = async (options) => {
         shimEvents: normalizedShimEvents(runtime, scenario, options.temporaryRoot),
         settlement: { ...settlement, cleanup_outcome: "not_required" },
         manifest,
+        eventJournal: options.eventJournal,
     });
 };
 /** 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 journal = createProcessCaptureJournal();
+    const { entries: eventJournal, recordEvent } = journal;
     let runtime;
     const timers = new Set();
     let capture;
@@ -277,6 +253,8 @@ const runProcessScenario = async (scenario, policy, signal) => {
             interactions,
             timers,
             dispatchedEventIndexes,
+            recordEvent,
+            journal,
             ...(signal === undefined ? {} : { signal }),
         });
         stopSampler = runtime.stopSampler;
@@ -289,6 +267,7 @@ const runProcessScenario = async (scenario, policy, signal) => {
             timers,
             interactions,
             dispatchedEventIndexes,
+            recordEvent,
         });
         capture = await completeCapture({
             scenario,
@@ -301,6 +280,8 @@ const runProcessScenario = async (scenario, policy, signal) => {
             interactions,
             exit,
             initiallyTruncated: before.truncated,
+            eventJournal,
+            recordEvent,
             ...(signal === undefined ? {} : { signal }),
         });
     }

package/dist/application/ProcessNormalization.js

@@ -1,3 +1,5 @@
+/** Bucket one elapsed process-capture timestamp under scenario normalization. */
+export const normalizeProcessElapsedTime = (elapsedMs, timeBucketMs) => Math.floor(elapsedMs / timeBucketMs) * timeBucketMs;
 /** Normalize and redact one terminal/protocol payload under scenario rules. */
 export const normalizeProcessText = (value, scenario, temporaryRoot, pid) => {
     let normalized = value;
@@ -42,8 +44,7 @@ export const normalizeProcessSamples = (samples, scenario, rootPid) => {
             : normalized;
     };
     return samples.map((sample) => ({
-        at_ms: Math.floor(sample.at_ms / scenario.normalization.time_bucket_ms) *
-            scenario.normalization.time_bucket_ms,
+        at_ms: normalizeProcessElapsedTime(sample.at_ms, scenario.normalization.time_bucket_ms),
         pid: mapping.get(sample.pid) ?? 1,
         parent_pid: mapping.get(sample.parent_pid) ?? 0,
         process_group_id: sample.process_group_id === null
@@ -53,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

@@ -0,0 +1,225 @@
+import { commitProcessReactiveProposal, createProcessReactiveSnapshot, reduceProcessReactiveScenario, } from "../domain/processReactiveRuntime.js";
+const systemTimerHost = {
+    schedule: (callback, delayMs) => {
+        const timer = setTimeout(callback, delayMs);
+        return { cancel: () => clearTimeout(timer) };
+    },
+};
+/**
+ * Serializes live observations, deadlines, and effect commits for one run.
+ * Producer callbacks enqueue work without awaiting it, preventing reentrancy.
+ */
+export class ProcessReactiveCoordinator {
+    #scenario;
+    #executor;
+    #timerHost;
+    #now;
+    #scenarioDeadlineAt;
+    #onDecision;
+    #snapshot;
+    #pendingInputs = [];
+    #tail = Promise.resolve();
+    #running = false;
+    #failure;
+    #stateTimer;
+    #scenarioTimer;
+    #stateDeadlineAt = 0;
+    #effectAbort;
+    #accepting = true;
+    #closed = false;
+    constructor(options) {
+        this.#scenario = options.scenario;
+        this.#executor = options.executor;
+        this.#timerHost = options.timerHost ?? systemTimerHost;
+        this.#now = options.now ?? Date.now;
+        this.#scenarioDeadlineAt = this.#now() + options.scenario.deadline_ms;
+        this.#onDecision = options.onDecision;
+        this.#snapshot = createProcessReactiveSnapshot(options.scenario);
+        this.#scheduleScenarioDeadline();
+        this.#scheduleStateDeadline();
+    }
+    /** Current immutable reducer snapshot after all completed turns. */
+    get snapshot() {
+        return this.#snapshot;
+    }
+    /** Enqueue producer work without creating a floating promise. */
+    enqueue(input) {
+        if (!this.#accepting)
+            return;
+        if (this.#interruptsEffects(input))
+            this.#effectAbort?.abort();
+        this.#enqueueOwned(input);
+    }
+    /** Submit one input and wait until every turn queued before it completes. */
+    async submit(input) {
+        this.enqueue(input);
+        await this.drain();
+        return this.#snapshot;
+    }
+    /** Wait for currently queued reducer/effect work and surface host failures. */
+    async drain() {
+        for (;;) {
+            const observedTail = this.#tail;
+            await observedTail;
+            if (observedTail === this.#tail)
+                break;
+        }
+        if (this.#failure !== undefined)
+            throw this.#failure;
+    }
+    /** Stop owned deadlines after queued work settles. */
+    async close() {
+        this.#accepting = false;
+        this.#clearTimers();
+        await this.drain();
+        this.#closed = true;
+    }
+    #enqueueOwned(input) {
+        if (this.#closed || this.#failure !== undefined)
+            return;
+        this.#pendingInputs.push(input);
+        this.#startWorker();
+    }
+    #startWorker() {
+        if (this.#running || this.#pendingInputs.length === 0)
+            return;
+        this.#running = true;
+        this.#tail = this.#runQueue()
+            .catch((cause) => this.#fail(cause))
+            .finally(() => {
+            this.#running = false;
+            if (this.#pendingInputs.length > 0)
+                this.#startWorker();
+        });
+    }
+    async #runQueue() {
+        for (;;) {
+            const input = this.#nextInput();
+            if (input === undefined)
+                return;
+            await this.#advance(input);
+        }
+    }
+    #nextInput() {
+        const terminalIndex = this.#pendingInputs.findIndex(({ kind }) => kind === "cancelled" || kind === "cleanup_failed");
+        if (terminalIndex >= 0)
+            return this.#pendingInputs.splice(terminalIndex, 1)[0];
+        let observationIndex = -1;
+        let captureOrder = Number.POSITIVE_INFINITY;
+        for (const [index, input] of this.#pendingInputs.entries())
+            if (input.kind === "observation" &&
+                input.observation.capture_order < captureOrder) {
+                observationIndex = index;
+                captureOrder = input.observation.capture_order;
+            }
+        return observationIndex >= 0
+            ? this.#pendingInputs.splice(observationIndex, 1)[0]
+            : this.#pendingInputs.shift();
+    }
+    #fail(cause) {
+        this.#failure ??= cause;
+        this.#accepting = false;
+        this.#closed = true;
+        this.#effectAbort?.abort();
+        this.#pendingInputs.length = 0;
+        this.#clearTimers();
+    }
+    async #advance(input) {
+        const before = this.#snapshot;
+        let decision = reduceProcessReactiveScenario(this.#scenario, before, input);
+        let effectResults = [];
+        if (decision.kind === "proposal") {
+            const effectAbort = new AbortController();
+            this.#effectAbort = effectAbort;
+            try {
+                effectResults = await this.#executor.execute(decision.effects, effectAbort.signal);
+            }
+            catch (cause) {
+                if (effectAbort.signal.aborted)
+                    return;
+                throw cause;
+            }
+            finally {
+                if (this.#effectAbort === effectAbort)
+                    this.#effectAbort = undefined;
+            }
+            if (effectAbort.signal.aborted)
+                return;
+            const expired = this.#expiredDeadlineInput();
+            if (expired !== undefined) {
+                this.#enqueueOwned(expired);
+                return;
+            }
+            decision = commitProcessReactiveProposal(this.#scenario, decision, effectResults);
+        }
+        this.#snapshot = decision.snapshot;
+        this.#onDecision?.(decision, input);
+        if (this.#snapshot.status === "finished")
+            this.#clearTimers();
+        else if (this.#accepting &&
+            (before.active_state !== this.#snapshot.active_state ||
+                before.state_entry_capture_order !==
+                    this.#snapshot.state_entry_capture_order))
+            this.#scheduleStateDeadline();
+        for (const result of effectResults)
+            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 === "target_lost")
+            return true;
+        return (input.kind === "state_deadline" &&
+            input.state_id === this.#snapshot.active_state &&
+            input.state_entry_capture_order ===
+                this.#snapshot.state_entry_capture_order);
+    }
+    #expiredDeadlineInput() {
+        const now = this.#now();
+        if (now >= this.#scenarioDeadlineAt)
+            return { kind: "scenario_deadline" };
+        if (now < this.#stateDeadlineAt)
+            return undefined;
+        return {
+            kind: "state_deadline",
+            state_id: this.#snapshot.active_state,
+            state_entry_capture_order: this.#snapshot.state_entry_capture_order,
+        };
+    }
+    #scheduleScenarioDeadline() {
+        if (!this.#accepting)
+            return;
+        this.#scenarioTimer = this.#timerHost.schedule(() => this.enqueue({ kind: "scenario_deadline" }), this.#scenario.deadline_ms);
+    }
+    #scheduleStateDeadline() {
+        if (!this.#accepting)
+            return;
+        this.#stateTimer?.cancel();
+        const state = this.#scenario.states.find(({ id }) => id === this.#snapshot.active_state);
+        if (state === undefined)
+            return;
+        this.#stateDeadlineAt = this.#now() + state.deadline_ms;
+        const identity = {
+            state_id: state.id,
+            state_entry_capture_order: this.#snapshot.state_entry_capture_order,
+        };
+        this.#stateTimer = this.#timerHost.schedule(() => this.enqueue({ kind: "state_deadline", ...identity }), state.deadline_ms);
+    }
+    #clearTimers() {
+        this.#stateTimer?.cancel();
+        this.#scenarioTimer?.cancel();
+        this.#stateTimer = undefined;
+        this.#scenarioTimer = undefined;
+    }
+}

package/dist/application/ProcessReactiveEffects.js

@@ -0,0 +1,141 @@
+import { createProcessObservation } from "../domain/processObservation.js";
+const elapsed = (host) => Math.max(0, host.now() - host.startedAtMs);
+const interactionData = (action) => {
+    if (action.type === "send_input")
+        return action.sensitive
+            ? `<redacted-input:${String(Buffer.byteLength(action.data))}-bytes>`
+            : action.data;
+    if (action.type === "resize")
+        return `${String(action.columns)}x${String(action.rows)}`;
+    return action.signal;
+};
+const interactionType = (action) => {
+    if (action.type === "send_input")
+        return "input";
+    if (action.type === "resize")
+        return "resize";
+    return "signal";
+};
+const performTerminalAction = (terminal, renderer, action, atMs) => {
+    if (action.type === "send_input")
+        terminal.write(action.data);
+    else if (action.type === "resize") {
+        terminal.resize(action.columns, action.rows);
+        renderer.resize(action.columns, action.rows, atMs);
+    }
+    else
+        terminal.kill(action.signal);
+};
+const recordInteraction = (host, action, atMs, outcome) => {
+    const index = host.interactions.length;
+    const event = {
+        sequence: index,
+        scheduled_at_ms: atMs,
+        dispatched_at_ms: atMs,
+        type: interactionType(action),
+        data: interactionData(action),
+        outcome,
+    };
+    host.interactions.push(event);
+    const location = host.journal.record("interaction_events", index);
+    if (outcome !== "dispatched")
+        return { status: "rejected" };
+    return {
+        status: "succeeded",
+        observation: createProcessObservation({
+            source: "interaction",
+            source_sequence: index,
+            captured_at_ms: atMs,
+            subject_id: null,
+            location,
+            payload: event,
+        }),
+    };
+};
+const executeTerminalAction = (host, action) => {
+    if (action.type === "send_signal" && action.target.kind !== "root")
+        return { status: "rejected" };
+    const terminal = host.terminal();
+    if (terminal === undefined)
+        return { status: "target_lost" };
+    const atMs = elapsed(host);
+    let outcome = "dispatched";
+    try {
+        performTerminalAction(terminal, host.renderer, action, atMs);
+    }
+    catch {
+        outcome = "failed";
+    }
+    return recordInteraction(host, action, atMs, outcome);
+};
+const executeCheckpoint = async (host, action, signal) => {
+    try {
+        const { index, checkpoint } = await host.checkpoints.captureAndRead(action.name, signal);
+        const location = host.journal.entries.findLast((entry) => entry.collection === "filesystem_checkpoints" && entry.index === index);
+        if (location === undefined)
+            return { status: "rejected" };
+        return {
+            status: "succeeded",
+            observation: createProcessObservation({
+                source: "filesystem",
+                source_sequence: index,
+                captured_at_ms: checkpoint.at_ms,
+                subject_id: `checkpoint:${checkpoint.name}`,
+                location,
+                payload: checkpoint,
+            }),
+        };
+    }
+    catch {
+        return { status: "rejected" };
+    }
+};
+/** Execute proposed effects in order and stop after the first failure. */
+export const executeProcessReactiveEffects = async (host, actions, signal) => {
+    const results = [];
+    for (const action of actions) {
+        if (signal.aborted)
+            return results;
+        const result = action.type === "checkpoint"
+            ? await executeCheckpoint(host, action, signal)
+            : executeTerminalAction(host, action);
+        results.push(result);
+        if (result.status !== "succeeded")
+            break;
+    }
+    return results;
+};
+const triggerSources = (trigger) => {
+    if (trigger.kind === "terminal_text")
+        return [];
+    if (trigger.kind === "event")
+        return [
+            "terminal_raw",
+            "interaction",
+            "process",
+            "filesystem",
+            "http",
+            "websocket",
+            "shim",
+        ].includes(trigger.source)
+            ? []
+            : [trigger.source];
+    return trigger.kind === "repeat"
+        ? triggerSources(trigger.trigger)
+        : trigger.triggers.flatMap(triggerSources);
+};
+/** Return unsupported sources, selectors, and checkpoint collisions pre-launch. */
+export const unsupportedProcessReactiveFeatures = (scenario, reservedCheckpointNames = new Set([
+    "before",
+    "after_settlement",
+])) => [
+    ...scenario.states.flatMap((state) => state.on.flatMap((transition) => triggerSources(transition.when).map((source) => `${transition.id}:source:${source}`))),
+    ...scenario.states.flatMap((state) => state.on.flatMap((transition) => transition.actions.flatMap((action) => {
+        if (action.type === "send_signal" && action.target.kind !== "root")
+            return [`${transition.id}:target:${action.target.kind}`];
+        if (action.type === "checkpoint" &&
+            reservedCheckpointNames.has(action.name))
+            return [`${transition.id}:checkpoint:${action.name}`];
+        return [];
+    }))),
+];