rea-agents 2.2.0 → 2.3.0

package/dist/domain/processReactiveMatching.js

@@ -0,0 +1,210 @@
+import canonicalize from "canonicalize";
+import { comparableProcessObservationPayload } from "./processObservation.js";
+import { PROCESS_REACTIVE_LIMITS, } from "./processReactiveScenario.js";
+const spendEvaluationWork = (budget, units) => {
+    if (units > budget.remaining)
+        return false;
+    budget.remaining -= units;
+    return true;
+};
+const noMatch = (overflow = false) => ({
+    matched: false,
+    eventIds: [],
+    consumeIds: [],
+    lastOrder: -1,
+    overflow,
+});
+const frontierOrder = (frontier, snapshot) => {
+    switch (frontier.kind) {
+        case "scenario_start":
+            return -1;
+        case "state_entry":
+            return snapshot.state_entry_capture_order - 1;
+        case "checkpoint":
+            return (snapshot.checkpoints.findLast(({ name }) => name === frontier.name)
+                ?.capture_order ?? null);
+        case "event_id":
+            return (snapshot.observations.find(({ event_id }) => event_id === frontier.event_id)?.capture_order ?? null);
+    }
+};
+const eligibleObservations = (frontier, context) => {
+    const frontierValue = frontierOrder(frontier, context.snapshot);
+    if (frontierValue === null)
+        return [];
+    const lowerBound = Math.max(frontierValue, context.afterOrder);
+    const consumed = new Set(context.snapshot.consumed_event_ids);
+    return context.snapshot.observations.filter(({ capture_order, event_id }) => capture_order > lowerBound &&
+        (context.upperOrder === null || capture_order <= context.upperOrder) &&
+        !consumed.has(event_id));
+};
+const canonicalJson = (value) => {
+    const serialized = canonicalize(value);
+    if (serialized === undefined)
+        throw new TypeError("Reactive scenario value is not canonical JSON");
+    return serialized;
+};
+const matchEvent = (trigger, context) => {
+    const expected = canonicalJson(comparableProcessObservationPayload(trigger.exact, trigger.ignore_fields));
+    const matches = [];
+    for (const observation of eligibleObservations(trigger.since, context)) {
+        if (!spendEvaluationWork(context.budget, 1))
+            return noMatch(true);
+        if (observation.source === trigger.source &&
+            canonicalJson(comparableProcessObservationPayload(observation.payload, trigger.ignore_fields)) === expected)
+            matches.push(observation);
+    }
+    if (matches.length < trigger.cardinality.min ||
+        matches.length > trigger.cardinality.max)
+        return noMatch();
+    const eventIds = matches.map(({ event_id }) => event_id);
+    return {
+        matched: true,
+        eventIds,
+        consumeIds: trigger.consume ? eventIds : [],
+        lastOrder: matches.at(-1)?.capture_order ?? context.afterOrder,
+        overflow: false,
+    };
+};
+const occurrenceRange = (haystack, needle, occurrence) => {
+    let offset = 0;
+    let start = -1;
+    for (let found = 0; found < occurrence; found += 1) {
+        start = haystack.indexOf(needle, offset);
+        if (start < 0)
+            return null;
+        offset = start + needle.length;
+    }
+    return { start, end: offset };
+};
+const matchTerminalText = (trigger, context) => {
+    const chunks = [];
+    for (const observation of eligibleObservations(trigger.since, context)) {
+        if (!spendEvaluationWork(context.budget, 1))
+            return noMatch(true);
+        if (observation.source === "terminal_raw" &&
+            typeof observation.payload === "object" &&
+            observation.payload !== null &&
+            !Array.isArray(observation.payload) &&
+            typeof observation.payload["data"] === "string")
+            chunks.push({ observation, text: observation.payload["data"] });
+    }
+    let rawBytes = 0;
+    for (const { text } of chunks) {
+        if (text.length > PROCESS_REACTIVE_LIMITS.terminalMatchBytes)
+            return noMatch(true);
+        const bytes = Buffer.byteLength(text);
+        rawBytes += bytes;
+        if (rawBytes > PROCESS_REACTIVE_LIMITS.terminalMatchBytes ||
+            !spendEvaluationWork(context.budget, bytes))
+            return noMatch(true);
+    }
+    const range = occurrenceRange(chunks.map(({ text }) => text).join(""), trigger.literal, trigger.occurrence);
+    if (range === null)
+        return noMatch();
+    let firstChunk = 0;
+    let lastChunk = 0;
+    let characters = 0;
+    for (const [index, chunk] of chunks.entries()) {
+        characters += chunk.text.length;
+        if (characters <= range.start)
+            firstChunk = index + 1;
+        if (characters >= range.end) {
+            lastChunk = index;
+            break;
+        }
+    }
+    const matched = chunks
+        .slice(firstChunk, lastChunk + 1)
+        .map(({ observation }) => observation);
+    const eventIds = matched.map(({ event_id }) => event_id);
+    return {
+        matched: true,
+        eventIds,
+        consumeIds: trigger.consume ? eventIds : [],
+        lastOrder: matched.at(-1)?.capture_order ?? context.afterOrder,
+        overflow: false,
+    };
+};
+const mergeMatches = (matches) => ({
+    matched: matches.every(({ matched }) => matched),
+    eventIds: [...new Set(matches.flatMap(({ eventIds }) => eventIds))],
+    consumeIds: [...new Set(matches.flatMap(({ consumeIds }) => consumeIds))],
+    lastOrder: Math.max(-1, ...matches.map(({ lastOrder }) => lastOrder)),
+    overflow: matches.some(({ overflow }) => overflow),
+});
+const matchEarliestPrefix = (trigger, context) => {
+    for (const observation of context.snapshot.observations) {
+        if (observation.capture_order <= context.afterOrder)
+            continue;
+        if (context.upperOrder !== null &&
+            observation.capture_order > context.upperOrder)
+            break;
+        const matched = matchTrigger(trigger, {
+            ...context,
+            upperOrder: observation.capture_order,
+        });
+        if (matched.matched || matched.overflow)
+            return matched;
+    }
+    return noMatch();
+};
+const matchTrigger = (trigger, context) => {
+    if (trigger.kind === "event")
+        return matchEvent(trigger, context);
+    if (trigger.kind === "terminal_text")
+        return matchTerminalText(trigger, context);
+    if (trigger.kind === "all")
+        return mergeMatches(trigger.triggers.map((child) => matchTrigger(child, context)));
+    if (trigger.kind === "any") {
+        const evaluated = trigger.triggers.map((child) => matchTrigger(child, context));
+        const matches = evaluated.filter(({ matched }) => matched);
+        return matches.length === 0
+            ? noMatch(evaluated.some(({ overflow }) => overflow))
+            : mergeMatches(matches);
+    }
+    if (trigger.kind === "sequence") {
+        const matches = [];
+        let cursor = context.afterOrder;
+        for (const child of trigger.triggers) {
+            const matched = matchEarliestPrefix(child, {
+                ...context,
+                afterOrder: cursor,
+            });
+            if (!matched.matched)
+                return noMatch(matched.overflow);
+            matches.push(matched);
+            cursor = matched.lastOrder;
+        }
+        return mergeMatches(matches);
+    }
+    const matches = [];
+    let cursor = context.afterOrder;
+    while (matches.length < trigger.max) {
+        const matched = matchEarliestPrefix(trigger.trigger, {
+            ...context,
+            afterOrder: cursor,
+        });
+        if (!matched.matched || matched.lastOrder <= cursor)
+            break;
+        matches.push(matched);
+        cursor = matched.lastOrder;
+    }
+    if (matches.length === trigger.max) {
+        const excess = matchEarliestPrefix(trigger.trigger, {
+            ...context,
+            afterOrder: cursor,
+        });
+        if (excess.matched || excess.overflow)
+            return noMatch(excess.overflow);
+    }
+    if (matches.length < trigger.min)
+        return noMatch(matches.some(({ overflow }) => overflow));
+    return mergeMatches(matches);
+};
+/** Match one trigger using a shared deterministic work budget. */
+export const matchProcessReactiveTrigger = (trigger, snapshot, budget) => matchTrigger(trigger, {
+    snapshot,
+    budget,
+    afterOrder: -1,
+    upperOrder: null,
+});

package/dist/domain/processReactiveRuntime.js

@@ -0,0 +1,109 @@
+import { matchProcessReactiveTrigger } from "./processReactiveMatching.js";
+import { PROCESS_REACTIVE_LIMITS, } from "./processReactiveScenario.js";
+export { commitProcessReactiveProposal } from "./processReactiveTransition.js";
+const counterValue = (counters, id) => counters.find((counter) => counter.id === id)?.count ?? 0;
+/** Create the initial immutable reducer state for one validated scenario. */
+export const createProcessReactiveSnapshot = (scenario) => ({
+    status: "running",
+    outcome: null,
+    active_state: scenario.initial_state,
+    state_entry_capture_order: 0,
+    observations: [],
+    consumed_event_ids: [],
+    transition_uses: [],
+    state_visits: [{ id: scenario.initial_state, count: 1 }],
+    checkpoints: [],
+    transitions: [],
+});
+const finishedDecision = (snapshot, outcome, evaluations = []) => ({
+    kind: "finished",
+    outcome,
+    evaluations,
+    snapshot: { ...snapshot, status: "finished", outcome },
+});
+const reduceControlInput = (snapshot, input) => {
+    if (input.kind === "cleanup_failed")
+        return finishedDecision(snapshot, "cleanup_failed");
+    if (snapshot.status === "finished")
+        return { kind: "already_finished", snapshot, evaluations: [] };
+    if (input.kind === "observation")
+        return null;
+    if (input.kind === "state_deadline")
+        return input.state_id === snapshot.active_state &&
+            input.state_entry_capture_order === snapshot.state_entry_capture_order
+            ? finishedDecision(snapshot, "predicate_timeout")
+            : { kind: "waiting", snapshot, evaluations: [] };
+    if (input.kind === "scenario_deadline")
+        return finishedDecision(snapshot, "scenario_deadline");
+    return finishedDecision(snapshot, "cancelled");
+};
+/** Advance one validated scenario using only an observation or explicit deadline. */
+export const reduceProcessReactiveScenario = (scenario, snapshot, input) => {
+    const controlDecision = reduceControlInput(snapshot, input);
+    if (controlDecision !== null)
+        return controlDecision;
+    if (input.kind !== "observation")
+        return finishedDecision(snapshot, "capture_incomplete");
+    const prior = snapshot.observations.at(-1);
+    if ((prior !== undefined &&
+        input.observation.capture_order <= prior.capture_order) ||
+        snapshot.observations.some(({ event_id }) => event_id === input.observation.event_id))
+        return finishedDecision(snapshot, "capture_incomplete");
+    if (snapshot.observations.length >= PROCESS_REACTIVE_LIMITS.retainedObservations)
+        return finishedDecision(snapshot, "capture_incomplete");
+    const observed = {
+        ...snapshot,
+        observations: [...snapshot.observations, input.observation],
+    };
+    const state = scenario.states.find(({ id }) => id === observed.active_state);
+    if (state === undefined)
+        return finishedDecision(observed, "target_lost");
+    const budget = { remaining: PROCESS_REACTIVE_LIMITS.evaluationWork };
+    const matches = state.on.map((transition) => ({
+        transition,
+        match: matchProcessReactiveTrigger(transition.when, observed, budget),
+        uses: counterValue(observed.transition_uses, transition.id),
+    }));
+    if (matches.some(({ match }) => match.overflow))
+        return finishedDecision(observed, "capture_incomplete");
+    const evaluations = matches.map(({ transition, match, uses }) => ({
+        transition_id: transition.id,
+        status: uses >= transition.max_uses
+            ? "exhausted"
+            : match.matched
+                ? "matched"
+                : "unmatched",
+        matched_event_ids: match.eventIds,
+    }));
+    const eligible = matches.filter(({ transition, match, uses }) => match.matched && uses < transition.max_uses);
+    if (eligible.length === 0)
+        return { kind: "waiting", snapshot: observed, evaluations };
+    const minimumPriority = Math.min(...eligible.map(({ transition }) => transition.priority));
+    const winners = eligible.filter(({ transition }) => transition.priority === minimumPriority);
+    if (winners.length !== 1)
+        return finishedDecision(observed, "ambiguous_match", evaluations);
+    const winner = winners[0];
+    if (winner === undefined)
+        return finishedDecision(observed, "capture_incomplete", evaluations);
+    const targetDeclaration = winner.transition.target;
+    if (targetDeclaration.kind === "goto") {
+        const target = scenario.states.find(({ id }) => id === targetDeclaration.state);
+        if (target === undefined ||
+            counterValue(observed.state_visits, target.id) >= target.max_visits)
+            return finishedDecision(observed, "capture_incomplete", evaluations);
+    }
+    return {
+        kind: "proposal",
+        snapshot: observed,
+        evaluations,
+        effects: winner.transition.actions,
+        proposal: {
+            transition_id: winner.transition.id,
+            transition_identity: canonicalize(winner.transition) ?? "",
+            observation_event_id: input.observation.event_id,
+            trigger_event_ids: winner.match.eventIds,
+            consume_event_ids: winner.match.consumeIds,
+        },
+    };
+};
+import canonicalize from "canonicalize";

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)));