rea-agents 2.1.0 → 2.3.0

package/dist/domain/processReactiveScenario.js

@@ -0,0 +1,361 @@
+import { z } from "zod";
+import { jsonValueSchema } from "./jsonValue.js";
+import { processObservationSourceSchema } from "./processObservation.js";
+import { definitelyAvailableCheckpoints } from "./processReactiveCheckpointDataflow.js";
+import { preflightProcessReactiveScenario } from "./processReactiveScenarioPreflight.js";
+/** Fixed public bounds for Process Reactive Scenario v1. */
+export const PROCESS_REACTIVE_LIMITS = {
+    states: 32,
+    transitions: 128,
+    triggerDepth: 6,
+    predicates: 64,
+    actions: 256,
+    actionsPerTransition: 16,
+    childrenPerComposite: 16,
+    stateVisits: 256,
+    transitionUses: 256,
+    repeat: 64,
+    retainedObservations: 256,
+    terminalMatchBytes: 65_536,
+    evaluationWork: 8_192,
+    jsonDepth: 20,
+    jsonNodes: 1_024,
+    runtimeMs: 300_000,
+};
+const identifierSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]{0,63}$/u);
+const checkpointNameSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/u);
+const positiveRuntime = z
+    .number()
+    .int()
+    .positive()
+    .max(PROCESS_REACTIVE_LIMITS.runtimeMs);
+const frontierSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("scenario_start") }),
+    z.strictObject({ kind: z.literal("state_entry") }),
+    z.strictObject({ kind: z.literal("checkpoint"), name: checkpointNameSchema }),
+    z.strictObject({ kind: z.literal("event_id"), event_id: identifierSchema }),
+]);
+const ignoredFieldSchema = z.enum([
+    "sequence",
+    "at_ms",
+    "scheduled_at_ms",
+    "dispatched_at_ms",
+    "elapsed_ms",
+]);
+const processReactiveTriggerSchema = z.lazy(() => z.discriminatedUnion("kind", [
+    z.strictObject({
+        kind: z.literal("event"),
+        source: processObservationSourceSchema,
+        exact: jsonValueSchema,
+        ignore_fields: z
+            .array(ignoredFieldSchema)
+            .max(5)
+            .refine((values) => new Set(values).size === values.length, {
+            message: "ignored event fields must be unique",
+        }),
+        since: frontierSchema,
+        consume: z.boolean(),
+        cardinality: z
+            .strictObject({
+            min: z.number().int().positive().max(256),
+            max: z.number().int().positive().max(256),
+        })
+            .refine(({ min, max }) => min <= max, {
+            message: "cardinality min must not exceed max",
+        }),
+    }),
+    z.strictObject({
+        kind: z.literal("terminal_text"),
+        view: z.literal("decoded"),
+        encoding: z.literal("utf8"),
+        literal: z.string().min(1).max(10_000),
+        case_sensitive: z.literal(true),
+        control_sequences: z.literal("include"),
+        occurrence: z.number().int().positive().max(1_000),
+        since: frontierSchema,
+        consume: z.boolean(),
+    }),
+    z.strictObject({
+        kind: z.literal("all"),
+        triggers: z
+            .array(processReactiveTriggerSchema)
+            .min(2)
+            .max(PROCESS_REACTIVE_LIMITS.childrenPerComposite),
+    }),
+    z.strictObject({
+        kind: z.literal("any"),
+        triggers: z
+            .array(processReactiveTriggerSchema)
+            .min(2)
+            .max(PROCESS_REACTIVE_LIMITS.childrenPerComposite),
+    }),
+    z.strictObject({
+        kind: z.literal("sequence"),
+        triggers: z
+            .array(processReactiveTriggerSchema)
+            .min(1)
+            .max(PROCESS_REACTIVE_LIMITS.childrenPerComposite),
+    }),
+    z
+        .strictObject({
+        kind: z.literal("repeat"),
+        trigger: processReactiveTriggerSchema,
+        min: z.number().int().positive().max(PROCESS_REACTIVE_LIMITS.repeat),
+        max: z.number().int().positive().max(PROCESS_REACTIVE_LIMITS.repeat),
+    })
+        .refine(({ min, max }) => min <= max, {
+        message: "repeat min must not exceed max",
+    }),
+]));
+const signalTargetSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("root") }),
+    z.strictObject({ kind: z.literal("process_group") }),
+    z.strictObject({
+        kind: z.literal("subject_id"),
+        subject_id: identifierSchema,
+    }),
+]);
+const processReactiveActionSchema = z.discriminatedUnion("type", [
+    z.strictObject({
+        type: z.literal("send_input"),
+        data: z.string().max(1_000_000),
+        sensitive: z.boolean(),
+    }),
+    z.strictObject({
+        type: z.literal("resize"),
+        columns: z.number().int().min(1).max(1_000),
+        rows: z.number().int().min(1).max(1_000),
+    }),
+    z.strictObject({
+        type: z.literal("send_signal"),
+        target: signalTargetSchema,
+        signal: z.enum(["SIGINT", "SIGTERM", "SIGKILL"]),
+    }),
+    z.strictObject({ type: z.literal("checkpoint"), name: checkpointNameSchema }),
+]);
+const transitionTargetSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("goto"), state: identifierSchema }),
+    z.strictObject({ kind: z.literal("finish"), outcome: z.literal("passed") }),
+]);
+const transitionSchema = z.strictObject({
+    id: identifierSchema,
+    priority: z.number().int().min(0).max(1_000),
+    max_uses: z
+        .number()
+        .int()
+        .positive()
+        .max(PROCESS_REACTIVE_LIMITS.transitionUses),
+    when: processReactiveTriggerSchema,
+    actions: z
+        .array(processReactiveActionSchema)
+        .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),
+    target: transitionTargetSchema,
+});
+const stateSchema = z.strictObject({
+    id: identifierSchema,
+    max_visits: z
+        .number()
+        .int()
+        .positive()
+        .max(PROCESS_REACTIVE_LIMITS.stateVisits),
+    deadline_ms: positiveRuntime,
+    on: z.array(transitionSchema).min(1).max(128),
+});
+const scenarioShapeSchema = z.strictObject({
+    version: z.literal(1),
+    initial_state: identifierSchema,
+    deadline_ms: positiveRuntime,
+    states: z.array(stateSchema).min(1).max(PROCESS_REACTIVE_LIMITS.states),
+});
+const measureTrigger = (trigger) => {
+    if (trigger.kind === "event" || trigger.kind === "terminal_text")
+        return { depth: 1, predicates: 1 };
+    const children = trigger.kind === "repeat" ? [trigger.trigger] : trigger.triggers;
+    const measured = children.map(measureTrigger);
+    return {
+        depth: 1 + Math.max(...measured.map(({ depth }) => depth)),
+        predicates: measured.reduce((total, { predicates }) => total + predicates, 0),
+    };
+};
+const collectCheckpointFrontiers = (trigger) => {
+    if (trigger.kind === "event" || trigger.kind === "terminal_text")
+        return trigger.since.kind === "checkpoint" ? [trigger.since.name] : [];
+    const children = trigger.kind === "repeat" ? [trigger.trigger] : trigger.triggers;
+    return children.flatMap(collectCheckpointFrontiers);
+};
+const validateTriggerSemantics = (trigger, path, context) => {
+    if (trigger.kind === "event") {
+        const exact = trigger.exact;
+        if (trigger.ignore_fields.length > 0 &&
+            (typeof exact !== "object" || exact === null || Array.isArray(exact)))
+            context.addIssue({
+                code: "custom",
+                message: "ignored fields require an exact object payload",
+                path: [...path, "ignore_fields"],
+            });
+        if (typeof exact === "object" &&
+            exact !== null &&
+            !Array.isArray(exact) &&
+            trigger.ignore_fields.some((field) => field in exact))
+            context.addIssue({
+                code: "custom",
+                message: "exact payload must omit every ignored field",
+                path: [...path, "exact"],
+            });
+        return;
+    }
+    if (trigger.kind === "terminal_text")
+        return;
+    if (trigger.kind === "repeat") {
+        validateTriggerSemantics(trigger.trigger, [...path, "trigger"], context);
+        return;
+    }
+    for (const [index, child] of trigger.triggers.entries())
+        validateTriggerSemantics(child, [...path, "triggers", index], context);
+};
+const validateTransition = (input) => {
+    const { transition, validation, path, context } = input;
+    validation.transitions += 1;
+    validation.actions += transition.actions.length;
+    const measured = measureTrigger(transition.when);
+    validation.predicates += measured.predicates;
+    validateTriggerSemantics(transition.when, [...path, "when"], context);
+    if (measured.depth > PROCESS_REACTIVE_LIMITS.triggerDepth)
+        context.addIssue({
+            code: "custom",
+            message: "trigger nesting exceeds the v1 limit",
+            path: [...path, "when"],
+        });
+    if (validation.transitionIds.has(transition.id))
+        context.addIssue({
+            code: "custom",
+            message: "transition ids must be unique",
+            path: [...path, "id"],
+        });
+    validation.transitionIds.add(transition.id);
+    for (const action of transition.actions) {
+        if (action.type !== "checkpoint")
+            continue;
+        if (validation.checkpoints.has(action.name))
+            context.addIssue({
+                code: "custom",
+                message: "checkpoint action names must be unique",
+                path: [...path, "actions"],
+            });
+        validation.checkpoints.add(action.name);
+    }
+    for (const name of collectCheckpointFrontiers(transition.when))
+        validation.checkpointReferences.push({
+            name,
+            stateId: input.stateId,
+            path: [...path, "when"],
+        });
+    if (transition.target.kind !== "goto")
+        return;
+    if (!validation.knownStates.has(transition.target.state)) {
+        context.addIssue({
+            code: "custom",
+            message: "transition target state is not declared",
+            path: [...path, "target", "state"],
+        });
+        return;
+    }
+    validation.adjacency.get(input.stateId)?.add(transition.target.state);
+};
+const validateTotalsAndReferences = (scenario, validation, context) => {
+    for (const [count, limit, message] of [
+        [
+            validation.transitions,
+            PROCESS_REACTIVE_LIMITS.transitions,
+            "scenario has too many transitions",
+        ],
+        [
+            validation.predicates,
+            PROCESS_REACTIVE_LIMITS.predicates,
+            "scenario has too many predicates",
+        ],
+        [
+            validation.actions,
+            PROCESS_REACTIVE_LIMITS.actions,
+            "scenario has too many actions",
+        ],
+    ])
+        if (count > limit)
+            context.addIssue({ code: "custom", message, path: ["states"] });
+    const available = definitelyAvailableCheckpoints(scenario);
+    for (const reference of validation.checkpointReferences)
+        if (!available.get(reference.stateId)?.has(reference.name))
+            context.addIssue({
+                code: "custom",
+                message: "checkpoint frontier is not definitely available before this transition",
+                path: reference.path,
+            });
+};
+const validateReachability = (scenario, stateIds, validation, context) => {
+    const reachable = new Set();
+    const pending = validation.knownStates.has(scenario.initial_state)
+        ? [scenario.initial_state]
+        : [];
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined || reachable.has(current))
+            continue;
+        reachable.add(current);
+        pending.push(...(validation.adjacency.get(current) ?? []));
+    }
+    for (const [index, id] of stateIds.entries())
+        if (!reachable.has(id))
+            context.addIssue({
+                code: "custom",
+                message: "state is unreachable from the initial state",
+                path: ["states", index],
+            });
+};
+const validateScenarioGraph = (scenario, context) => {
+    const stateIds = scenario.states.map(({ id }) => id);
+    const knownStates = new Set(stateIds);
+    if (knownStates.size !== stateIds.length)
+        context.addIssue({
+            code: "custom",
+            message: "state ids must be unique",
+            path: ["states"],
+        });
+    if (!knownStates.has(scenario.initial_state))
+        context.addIssue({
+            code: "custom",
+            message: "initial state is not declared",
+            path: ["initial_state"],
+        });
+    const validation = {
+        knownStates,
+        transitionIds: new Set(),
+        checkpoints: new Set(),
+        checkpointReferences: [],
+        adjacency: new Map(stateIds.map((id) => [id, new Set()])),
+        transitions: 0,
+        predicates: 0,
+        actions: 0,
+    };
+    for (const [stateIndex, state] of scenario.states.entries()) {
+        if (state.deadline_ms > scenario.deadline_ms)
+            context.addIssue({
+                code: "custom",
+                message: "state deadline must not exceed scenario deadline",
+                path: ["states", stateIndex, "deadline_ms"],
+            });
+        for (const [transitionIndex, transition] of state.on.entries())
+            validateTransition({
+                stateId: state.id,
+                transition,
+                path: ["states", stateIndex, "on", transitionIndex],
+                validation,
+                context,
+            });
+    }
+    validateTotalsAndReferences(scenario, validation, context);
+    validateReachability(scenario, stateIds, validation, context);
+};
+/** Strict boundary schema for a bounded declarative reactive scenario. */
+export const processReactiveScenarioSchema = z.preprocess((input, context) => preflightProcessReactiveScenario(input, context, PROCESS_REACTIVE_LIMITS), scenarioShapeSchema.superRefine((scenario, context) => validateScenarioGraph(scenario, context)));

package/dist/domain/processReactiveScenarioPreflight.js

@@ -0,0 +1,120 @@
+import { z } from "zod";
+const isUnknownRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const reject = (context, message) => {
+    context.addIssue({ code: "custom", message });
+    return false;
+};
+const inspectJsonValue = (value, context, limits) => {
+    const pending = [{ value, depth: 1 }];
+    const seen = new WeakSet();
+    let nodes = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            break;
+        nodes += 1;
+        if (nodes > limits.jsonNodes)
+            return reject(context, "event exact JSON exceeds the v1 node limit");
+        if (current.depth > limits.jsonDepth)
+            return reject(context, "event exact JSON exceeds the v1 depth limit");
+        if (typeof current.value !== "object" || current.value === null)
+            continue;
+        if (seen.has(current.value))
+            return reject(context, "event exact JSON must not contain cycles");
+        seen.add(current.value);
+        if (Array.isArray(current.value)) {
+            if (current.value.length + nodes > limits.jsonNodes)
+                return reject(context, "event exact JSON exceeds the v1 node limit");
+            for (const child of current.value)
+                pending.push({ value: child, depth: current.depth + 1 });
+            continue;
+        }
+        if (!isUnknownRecord(current.value))
+            continue;
+        for (const key in current.value) {
+            if (!Object.hasOwn(current.value, key))
+                continue;
+            if (nodes + pending.length >= limits.jsonNodes)
+                return reject(context, "event exact JSON exceeds the v1 node limit");
+            pending.push({
+                value: current.value[key],
+                depth: current.depth + 1,
+            });
+        }
+    }
+    return true;
+};
+const collectTriggerRoots = (states, context, limits) => {
+    const pending = [];
+    let transitions = 0;
+    for (const stateValue of states) {
+        if (!isUnknownRecord(stateValue) || !Array.isArray(stateValue["on"]))
+            continue;
+        transitions += stateValue["on"].length;
+        if (transitions > limits.transitions) {
+            reject(context, "scenario has too many transitions");
+            return null;
+        }
+        for (const transitionValue of stateValue["on"])
+            if (isUnknownRecord(transitionValue))
+                pending.push({ value: transitionValue["when"], depth: 1 });
+    }
+    return pending;
+};
+const enqueueTriggerChildren = (trigger, depth, traversal) => {
+    if (trigger["kind"] === "repeat") {
+        traversal.pending.push({ value: trigger["trigger"], depth: depth + 1 });
+        return true;
+    }
+    if (trigger["kind"] !== "all" &&
+        trigger["kind"] !== "any" &&
+        trigger["kind"] !== "sequence")
+        return true;
+    const children = trigger["triggers"];
+    if (!Array.isArray(children))
+        return true;
+    if (children.length > traversal.limits.childrenPerComposite)
+        return reject(traversal.context, "trigger group has too many children");
+    for (const child of children)
+        traversal.pending.push({ value: child, depth: depth + 1 });
+    return true;
+};
+const inspectTriggerTree = (pending, context, limits) => {
+    let nodes = 0;
+    const maximumNodes = limits.predicates * limits.triggerDepth;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        if (current === undefined)
+            break;
+        nodes += 1;
+        if (nodes > maximumNodes)
+            return reject(context, "trigger tree exceeds the v1 limit");
+        if (current.depth > limits.triggerDepth)
+            return reject(context, "trigger nesting exceeds the v1 limit");
+        if (isUnknownRecord(current.value) &&
+            current.value["kind"] === "event" &&
+            !inspectJsonValue(current.value["exact"], context, limits))
+            return false;
+        if (isUnknownRecord(current.value) &&
+            !enqueueTriggerChildren(current.value, current.depth, {
+                pending,
+                context,
+                limits,
+            }))
+            return false;
+    }
+    return true;
+};
+/** Reject oversized unknown trees before the recursive Zod schema visits them. */
+export const preflightProcessReactiveScenario = (input, context, limits) => {
+    if (!isUnknownRecord(input) || !Array.isArray(input["states"]))
+        return input;
+    if (input["states"].length > limits.states) {
+        reject(context, "scenario has too many states");
+        return z.NEVER;
+    }
+    const pending = collectTriggerRoots(input["states"], context, limits);
+    if (pending === null || !inspectTriggerTree(pending, context, limits))
+        return z.NEVER;
+    return input;
+};

package/dist/domain/processReactiveTransition.js

@@ -0,0 +1,159 @@
+const counterValue = (counters, id) => counters.find((counter) => counter.id === id)?.count ?? 0;
+const incrementCounter = (counters, id) => {
+    let found = false;
+    const updated = counters.map((counter) => {
+        if (counter.id !== id)
+            return counter;
+        found = true;
+        return { id, count: counter.count + 1 };
+    });
+    return found ? updated : [...updated, { id, count: 1 }];
+};
+/** Commit one uniquely selected transition after its declarative effects succeed. */
+const applyProcessReactiveTransition = (input) => {
+    const outcome = input.transition.target.kind === "finish"
+        ? input.transition.target.outcome
+        : null;
+    const stateAfter = input.transition.target.kind === "goto"
+        ? input.transition.target.state
+        : null;
+    const record = {
+        sequence: input.snapshot.transitions.length,
+        transition_id: input.transition.id,
+        state_before: input.snapshot.active_state,
+        state_after: stateAfter,
+        outcome,
+        trigger_event_ids: input.triggerEventIds,
+        action_event_ids: input.effectResults.map(({ observation }) => observation.event_id),
+        action_types: input.transition.actions.map(({ type }) => type),
+    };
+    const consumed = new Set(input.snapshot.consumed_event_ids);
+    for (const eventId of input.consumeEventIds)
+        consumed.add(eventId);
+    const checkpoints = [...input.snapshot.checkpoints];
+    for (const [index, action] of input.transition.actions.entries())
+        if (action.type === "checkpoint")
+            checkpoints.push({
+                name: action.name,
+                event_id: input.effectResults[index].observation.event_id,
+                capture_order: input.effectResults[index].observation.capture_order,
+            });
+    const completedCaptureOrder = Math.max(input.observation.capture_order, ...input.effectResults.map(({ observation }) => observation.capture_order));
+    let next = {
+        ...input.snapshot,
+        status: outcome === null ? "running" : "finished",
+        outcome,
+        active_state: stateAfter ?? input.snapshot.active_state,
+        state_entry_capture_order: stateAfter === null
+            ? input.snapshot.state_entry_capture_order
+            : completedCaptureOrder + 1,
+        consumed_event_ids: [...consumed],
+        transition_uses: incrementCounter(input.snapshot.transition_uses, input.transition.id),
+        state_visits: stateAfter === null
+            ? input.snapshot.state_visits
+            : incrementCounter(input.snapshot.state_visits, stateAfter),
+        checkpoints,
+        transitions: [...input.snapshot.transitions, record],
+    };
+    if (stateAfter !== null) {
+        const nextState = input.scenario.states.find(({ id }) => id === stateAfter);
+        if (nextState === undefined ||
+            counterValue(next.state_visits, stateAfter) > nextState.max_visits)
+            next = { ...next, status: "finished", outcome: "capture_incomplete" };
+    }
+    return next.outcome === "capture_incomplete"
+        ? {
+            kind: "finished",
+            snapshot: next,
+            evaluations: input.evaluations,
+            outcome: next.outcome,
+        }
+        : {
+            kind: "transition",
+            snapshot: next,
+            evaluations: input.evaluations,
+            record,
+        };
+};
+const effectObservationMatchesAction = (action, observation) => {
+    const payload = typeof observation.payload === "object" &&
+        observation.payload !== null &&
+        !Array.isArray(observation.payload)
+        ? observation.payload
+        : null;
+    const journalIdentityMatches = observation.source_sequence === observation.location.index &&
+        observation.capture_order === observation.location.capture_order &&
+        observation.event_id ===
+            `obs.${observation.location.collection}.${String(observation.location.index)}`;
+    if (!journalIdentityMatches || payload === null)
+        return false;
+    if (action.type === "checkpoint")
+        return (observation.source === "filesystem" &&
+            observation.location.collection === "filesystem_checkpoints" &&
+            payload["name"] === action.name);
+    if (observation.source !== "interaction" ||
+        observation.location.collection !== "interaction_events" ||
+        payload["outcome"] !== "dispatched")
+        return false;
+    if (action.type === "send_input")
+        return (payload["type"] === "input" &&
+            payload["data"] ===
+                (action.sensitive
+                    ? `<redacted-input:${String(Buffer.byteLength(action.data))}-bytes>`
+                    : action.data));
+    if (action.type === "resize")
+        return (payload["type"] === "resize" &&
+            payload["data"] === `${String(action.columns)}x${String(action.rows)}`);
+    return payload["type"] === "signal" && payload["data"] === action.signal;
+};
+const failedProposal = (proposed, outcome) => ({
+    kind: "finished",
+    outcome,
+    evaluations: proposed.evaluations,
+    snapshot: { ...proposed.snapshot, status: "finished", outcome },
+});
+/** Commit a proposal only after the host reports every effect as successful. */
+export const commitProcessReactiveProposal = (scenario, proposed, results) => {
+    if (results.some(({ status }) => status === "target_lost"))
+        return failedProposal(proposed, "target_lost");
+    const state = scenario.states.find(({ id }) => id === proposed.snapshot.active_state);
+    const transition = state?.on.find(({ id }) => id === proposed.proposal.transition_id);
+    const observation = proposed.snapshot.observations.find(({ event_id }) => event_id === proposed.proposal.observation_event_id);
+    if (transition === undefined ||
+        observation === undefined ||
+        canonicalize(transition) !== proposed.proposal.transition_identity ||
+        canonicalize(proposed.effects) !== canonicalize(transition.actions))
+        return failedProposal(proposed, "target_lost");
+    if (results.length !== transition.actions.length ||
+        results.some(({ status }) => status === "rejected"))
+        return failedProposal(proposed, "action_rejected");
+    const succeeded = results.filter((result) => result.status === "succeeded");
+    let previousOrder = proposed.snapshot.observations.find(({ event_id }) => event_id === proposed.proposal.observation_event_id)?.capture_order ?? -1;
+    const knownEventIds = new Set([
+        ...proposed.snapshot.observations.map(({ event_id }) => event_id),
+        ...proposed.snapshot.transitions.flatMap(({ action_event_ids }) => action_event_ids),
+    ]);
+    for (const [index, result] of succeeded.entries()) {
+        const action = transition.actions[index];
+        const effectObservation = result.observation;
+        if (action === undefined ||
+            !effectObservationMatchesAction(action, effectObservation) ||
+            !Number.isSafeInteger(effectObservation.capture_order) ||
+            effectObservation.capture_order <= previousOrder ||
+            knownEventIds.has(effectObservation.event_id))
+            return failedProposal(proposed, "action_rejected");
+        knownEventIds.add(effectObservation.event_id);
+        previousOrder = effectObservation.capture_order;
+    }
+    return applyProcessReactiveTransition({
+        scenario,
+        snapshot: proposed.snapshot,
+        observation,
+        transition,
+        triggerEventIds: proposed.proposal.trigger_event_ids,
+        consumeEventIds: proposed.proposal.consume_event_ids,
+        effectResults: succeeded,
+        evaluations: proposed.evaluations,
+    });
+};
+import canonicalize from "canonicalize";

package/dist/domain/processScenario.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { resolve } from "node:path";
 import canonicalize from "canonicalize";
 import { z } from "zod";
+import { replayMachineSchema } from "./replayMachine.js";
 const positiveBudget = z.number().int().positive();
 const timedEventBase = { at_ms: z.number().int().nonnegative() };
 const environmentName = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/u);
@@ -213,6 +214,7 @@ export const processScenarioSchema = z
     }),
     replay: z
         .object({
+        machine: replayMachineSchema.nullable().default(null),
         http: z
             .array(z.object({
             method: z.string().max(16),
@@ -251,6 +253,7 @@ export const processScenarioSchema = z
             .default([]),
     })
         .default({
+        machine: null,
         http: [],
         websocket_messages: [],
         websocket_connections: [],
@@ -327,6 +330,15 @@ export const processScenarioSchema = z
             message: "command shim names must be unique",
             path: ["command_shims"],
         });
+    if (scenario.replay.machine !== null &&
+        (scenario.replay.http.length > 0 ||
+            scenario.replay.websocket_messages.length > 0 ||
+            scenario.replay.websocket_connections.length > 0))
+        context.addIssue({
+            code: "custom",
+            message: "a replay machine cannot be combined with static HTTP or WebSocket scripts",
+            path: ["replay"],
+        });
 });
 /** Parse untrusted process scenario input and apply safe default budgets. */
 export const parseProcessScenario = (input) => processScenarioSchema.parse(input);