rea-agents 3.1.0 → 3.2.1

package/dist/domain/processCaptureValidation.js

@@ -86,12 +86,6 @@ const validateLifecycle = (capture, require) => {
     require(capture.exit.reason === "exited" ||
         capture.exit.code ===
             null, "exit", "deadline termination cannot declare a normal exit code");
-    require(capture.settlement.state !== "quiesced" ||
-        capture.settlement.cleanup_outcome ===
-            "not_required", "settlement.cleanup_outcome", "quiesced settlement cannot require cleanup");
-    require(capture.settlement.state === "quiesced" ||
-        capture.settlement.cleanup_outcome !==
-            "not_required", "settlement.cleanup_outcome", "non-quiesced settlement must report cleanup");
 };
 const shimPlans = (capture) => capture.manifest.shim_plan.flatMap((shim) => typeof shim === "object" &&
     shim !== null &&
@@ -202,7 +196,7 @@ const validateReplayEvents = (capture, require) => {
     }
 };
 /** Recompute v4 commitments and cross-field invariants without side effects. */
-export const validateProcessCapture = (capture) => {
+export const collectProcessCaptureIssues = (capture) => {
     const issues = [];
     const require = (condition, path, message) => {
         if (!condition)

package/dist/domain/processComparison.js

@@ -1,6 +1,5 @@
 import canonicalize from "canonicalize";
 import { z } from "zod";
-import { validateProcessCapture } from "./processCapture.js";
 import { jsonValueSchema } from "./jsonValue.js";
 import { compareProcessTraces, processTraceOutcomesDiffer, processTraceComparisonResultSchema, } from "./processTraceComparison.js";
 import { dimensionsForTraceSources, traceCoversObservedDimension, } from "./processTraceDimensionProjection.js";
@@ -169,16 +168,8 @@ const chooseFirstDivergence = (candidates) => {
     })[0] ?? { status: "none" });
 };
 const assertComparable = (left, right, options) => {
-    const invalid = [
-        ...validateProcessCapture(left),
-        ...validateProcessCapture(right),
-    ];
-    const firstInvalid = invalid.at(0);
-    if (firstInvalid !== undefined)
-        throw new TypeError(`Invalid Process Capture v4: ${firstInvalid.path}`);
-    if (left.schema_version !== right.schema_version ||
-        left.manifest.comparison_contract_sha256 !==
-            right.manifest.comparison_contract_sha256)
+    if (left.manifest.comparison_contract_sha256 !==
+        right.manifest.comparison_contract_sha256)
         throw new TypeError("Process captures have incompatible comparison contracts");
     if (options.maxCaptureAgeMs === undefined)
         return;
@@ -255,7 +246,7 @@ const compareDimensions = (left, right, sameNormalization) => {
     };
 };
 /**
- * Compare two Process Capture v4 observations without treating absence as proof.
+ * Compare two process capture observations without treating absence as proof.
  *
  * Observed differences outrank residual unknowns. A capture may therefore be
  * definitively changed in one dimension while completeness remains unknown.

package/dist/domain/processReactiveMatching.js

@@ -1,18 +1,10 @@
 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,
+const noMatch = () => ({
     eventIds: [],
     consumeIds: [],
     lastOrder: -1,
-    overflow,
+    matched: false,
 });
 const frontierOrder = (frontier, snapshot) => {
     switch (frontier.kind) {
@@ -47,8 +39,6 @@ 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);
@@ -58,11 +48,10 @@ const matchEvent = (trigger, context) => {
         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,
+        matched: true,
     };
 };
 const occurrenceRange = (haystack, needle, occurrence) => {
@@ -79,8 +68,6 @@ const occurrenceRange = (haystack, needle, occurrence) => {
 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 &&
@@ -88,16 +75,6 @@ const matchTerminalText = (trigger, context) => {
             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();
@@ -118,26 +95,31 @@ const matchTerminalText = (trigger, context) => {
         .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,
+        matched: true,
     };
 };
 const mergeMatches = (matches) => {
-    const base = {
-        eventIds: [...new Set(matches.flatMap(({ eventIds }) => eventIds))],
-        consumeIds: [...new Set(matches.flatMap(({ consumeIds }) => consumeIds))],
-        lastOrder: Math.max(-1, ...matches.map(({ lastOrder }) => lastOrder)),
+    const eventIds = new Set();
+    const consumeIds = new Set();
+    let lastOrder = -1;
+    let matched = true;
+    for (const match of matches) {
+        for (const eventId of match.eventIds)
+            eventIds.add(eventId);
+        for (const eventId of match.consumeIds)
+            consumeIds.add(eventId);
+        lastOrder = Math.max(lastOrder, match.lastOrder);
+        matched &&= match.matched;
+    }
+    return {
+        eventIds: [...eventIds],
+        consumeIds: [...consumeIds],
+        lastOrder,
+        matched,
     };
-    return matches.every(({ matched }) => matched)
-        ? { ...base, matched: true, overflow: false }
-        : {
-            ...base,
-            matched: false,
-            overflow: matches.some(({ overflow }) => overflow),
-        };
 };
 const matchEarliestPrefix = (trigger, context) => {
     for (const observation of context.snapshot.observations) {
@@ -150,7 +132,7 @@ const matchEarliestPrefix = (trigger, context) => {
             ...context,
             upperOrder: observation.capture_order,
         });
-        if (matched.matched || matched.overflow)
+        if (matched.matched)
             return matched;
     }
     return noMatch();
@@ -165,9 +147,7 @@ const matchTrigger = (trigger, 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);
+        return matches.length === 0 ? noMatch() : mergeMatches(matches);
     }
     if (trigger.kind === "sequence") {
         const matches = [];
@@ -178,7 +158,7 @@ const matchTrigger = (trigger, context) => {
                 afterOrder: cursor,
             });
             if (!matched.matched)
-                return noMatch(matched.overflow);
+                return noMatch();
             matches.push(matched);
             cursor = matched.lastOrder;
         }
@@ -201,17 +181,16 @@ const matchTrigger = (trigger, context) => {
             ...context,
             afterOrder: cursor,
         });
-        if (excess.matched || excess.overflow)
-            return noMatch(excess.overflow);
+        if (excess.matched)
+            return noMatch();
     }
     if (matches.length < trigger.min)
-        return noMatch(matches.some(({ overflow }) => overflow));
+        return noMatch();
     return mergeMatches(matches);
 };
-/** Match one trigger using a shared deterministic work budget. */
-export const matchProcessReactiveTrigger = (trigger, snapshot, budget) => matchTrigger(trigger, {
+/** Match one trigger against every eligible retained observation. */
+export const matchProcessReactiveTrigger = (trigger, snapshot) => matchTrigger(trigger, {
     snapshot,
-    budget,
     afterOrder: -1,
     upperOrder: null,
 });

package/dist/domain/processReactiveRuntime.js

@@ -1,5 +1,5 @@
 import { matchProcessReactiveTrigger } from "./processReactiveMatching.js";
-import { PROCESS_REACTIVE_LIMITS, } from "./processReactiveScenario.js";
+import {} from "./processReactiveScenario.js";
 export { commitProcessReactiveProposal } from "./processReactiveTransition.js";
 const counterValue = (counters, id) => counters.find((counter) => counter.id === id)?.count ?? 0;
 const observeInput = (snapshot, observation) => {
@@ -7,8 +7,7 @@ const observeInput = (snapshot, observation) => {
     if (duplicate !== undefined)
         return { kind: "invalid" };
     const prior = snapshot.observations.at(-1);
-    if ((prior !== undefined && observation.capture_order <= prior.capture_order) ||
-        snapshot.observations.length >= PROCESS_REACTIVE_LIMITS.retainedObservations)
+    if (prior !== undefined && observation.capture_order <= prior.capture_order)
         return { kind: "invalid" };
     return {
         kind: "new",
@@ -69,14 +68,11 @@ export const reduceProcessReactiveScenario = (scenario, snapshot, input) => {
     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),
+        match: matchProcessReactiveTrigger(transition.when, observed),
         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
@@ -89,7 +85,7 @@ export const reduceProcessReactiveScenario = (scenario, snapshot, input) => {
     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 minimumPriority = eligible.reduce((minimum, { transition }) => Math.min(minimum, transition.priority), Number.POSITIVE_INFINITY);
     const winners = eligible.filter(({ transition }) => transition.priority === minimumPriority);
     if (winners.length !== 1)
         return finishedDecision(observed, "ambiguous_match", evaluations);

package/dist/domain/processReactiveScenario.js

@@ -3,34 +3,15 @@ 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. */
+/** Structural depth guard for recursive Zod parsing. */
 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,
+    // Recursive Zod schemas need a practical stack guard, not a small tree quota.
+    triggerDepth: 256,
+    jsonDepth: 256,
 };
-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 identifierSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
+const checkpointNameSchema = z.string().regex(/^[A-Za-z0-9][A-Za-z0-9_-]*$/u);
+const positiveRuntime = z.number().int().safe().positive();
 const frontierSchema = z.discriminatedUnion("kind", [
     z.strictObject({ kind: z.literal("scenario_start") }),
     z.strictObject({ kind: z.literal("state_entry") }),
@@ -51,7 +32,6 @@ const processReactiveTriggerSchema = z.lazy(() => z.discriminatedUnion("kind", [
         exact: jsonValueSchema,
         ignore_fields: z
             .array(ignoredFieldSchema)
-            .max(5)
             .refine((values) => new Set(values).size === values.length, {
             message: "ignored event fields must be unique",
         }),
@@ -59,8 +39,8 @@ const processReactiveTriggerSchema = z.lazy(() => z.discriminatedUnion("kind", [
         consume: z.boolean(),
         cardinality: z
             .strictObject({
-            min: z.number().int().positive().max(256),
-            max: z.number().int().positive().max(256),
+            min: z.number().int().safe().positive(),
+            max: z.number().int().safe().positive(),
         })
             .refine(({ min, max }) => min <= max, {
             message: "cardinality min must not exceed max",
@@ -70,40 +50,31 @@ const processReactiveTriggerSchema = z.lazy(() => z.discriminatedUnion("kind", [
         kind: z.literal("terminal_text"),
         view: z.literal("decoded"),
         encoding: z.literal("utf8"),
-        literal: z.string().min(1).max(10_000),
+        literal: z.string().min(1),
         case_sensitive: z.literal(true),
         control_sequences: z.literal("include"),
-        occurrence: z.number().int().positive().max(1_000),
+        occurrence: z.number().int().safe().positive(),
         since: frontierSchema,
         consume: z.boolean(),
     }),
     z.strictObject({
         kind: z.literal("all"),
-        triggers: z
-            .array(processReactiveTriggerSchema)
-            .min(2)
-            .max(PROCESS_REACTIVE_LIMITS.childrenPerComposite),
+        triggers: z.array(processReactiveTriggerSchema).min(2),
     }),
     z.strictObject({
         kind: z.literal("any"),
-        triggers: z
-            .array(processReactiveTriggerSchema)
-            .min(2)
-            .max(PROCESS_REACTIVE_LIMITS.childrenPerComposite),
+        triggers: z.array(processReactiveTriggerSchema).min(2),
     }),
     z.strictObject({
         kind: z.literal("sequence"),
-        triggers: z
-            .array(processReactiveTriggerSchema)
-            .min(1)
-            .max(PROCESS_REACTIVE_LIMITS.childrenPerComposite),
+        triggers: z.array(processReactiveTriggerSchema).min(1),
     }),
     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),
+        min: z.number().int().safe().positive(),
+        max: z.number().int().safe().positive(),
     })
         .refine(({ min, max }) => min <= max, {
         message: "repeat min must not exceed max",
@@ -120,13 +91,13 @@ const signalTargetSchema = z.discriminatedUnion("kind", [
 const processReactiveActionSchema = z.discriminatedUnion("type", [
     z.strictObject({
         type: z.literal("send_input"),
-        data: z.string().max(1_000_000),
+        data: z.string(),
         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),
+        columns: z.number().int().positive(),
+        rows: z.number().int().positive(),
     }),
     z.strictObject({ type: z.literal("close_stdin") }),
     z.strictObject({
@@ -142,42 +113,30 @@ const transitionTargetSchema = z.discriminatedUnion("kind", [
 ]);
 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),
+    priority: z.number().int().safe().min(0),
+    max_uses: z.number().int().safe().positive(),
     when: processReactiveTriggerSchema,
-    actions: z
-        .array(processReactiveActionSchema)
-        .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),
+    actions: z.array(processReactiveActionSchema),
     target: transitionTargetSchema,
 });
 const stateSchema = z.strictObject({
     id: identifierSchema,
-    max_visits: z
-        .number()
-        .int()
-        .positive()
-        .max(PROCESS_REACTIVE_LIMITS.stateVisits),
+    max_visits: z.number().int().safe().positive(),
     deadline_ms: positiveRuntime,
-    on: z.array(transitionSchema).min(1).max(128),
+    on: z.array(transitionSchema).min(1),
 });
 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),
+    states: z.array(stateSchema).min(1),
 });
 const measureTrigger = (trigger) => {
     if (trigger.kind === "event" || trigger.kind === "terminal_text")
-        return { depth: 1, predicates: 1 };
+        return { depth: 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),
+        depth: 1 + measured.reduce((maximum, { depth }) => Math.max(maximum, depth), 0),
     };
 };
 const collectCheckpointFrontiers = (trigger) => {
@@ -218,15 +177,12 @@ const validateTriggerSemantics = (trigger, path, 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",
+            message: "trigger nesting exceeds the configured limit",
             path: [...path, "when"],
         });
     if (validation.transitionIds.has(transition.id))
@@ -266,25 +222,6 @@ const validateTransition = (input) => {
     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))
@@ -335,9 +272,6 @@ const validateScenarioGraph = (scenario, context) => {
         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)

package/dist/domain/processReactiveScenarioPreflight.js

@@ -7,24 +7,18 @@ const reject = (context, message) => {
 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");
+            return reject(context, "event exact JSON exceeds the configured 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;
@@ -34,8 +28,6 @@ const inspectJsonValue = (value, context, limits) => {
         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,
@@ -44,17 +36,11 @@ const inspectJsonValue = (value, context, limits) => {
     }
     return true;
 };
-const collectTriggerRoots = (states, context, limits) => {
+const collectTriggerRoots = (states) => {
     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 });
@@ -73,24 +59,17 @@ const enqueueTriggerChildren = (trigger, depth, traversal) => {
     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");
+            return reject(context, "trigger nesting exceeds the configured limit");
         if (isUnknownRecord(current.value) &&
             current.value["kind"] === "event" &&
             !inspectJsonValue(current.value["exact"], context, limits))
@@ -109,12 +88,8 @@ const inspectTriggerTree = (pending, context, limits) => {
 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))
+    const pending = collectTriggerRoots(input["states"]);
+    if (!inspectTriggerTree(pending, context, limits))
         return z.NEVER;
     return input;
 };

package/dist/domain/processReactiveTransition.js

@@ -1,3 +1,24 @@
+const createTransitionRecord = (input) => {
+    const state = {
+        sequence: input.sequence,
+        transition_id: input.transition.id,
+        state_before: input.stateBefore,
+        trigger_event_ids: input.triggerEventIds,
+        action_event_ids: input.effectResults.map(({ observation }) => observation.event_id),
+        action_types: input.transition.actions.map(({ type }) => type),
+    };
+    return input.transition.target.kind === "finish"
+        ? {
+            ...state,
+            state_after: null,
+            outcome: input.transition.target.outcome,
+        }
+        : {
+            ...state,
+            state_after: input.transition.target.state,
+            outcome: null,
+        };
+};
 const counterValue = (counters, id) => counters.find((counter) => counter.id === id)?.count ?? 0;
 const incrementCounter = (counters, id) => {
     let found = false;
@@ -13,22 +34,15 @@ const incrementCounter = (counters, id) => {
 const applyProcessReactiveTransition = (input) => {
     if (input.effectResults.length !== input.transition.actions.length)
         throw new TypeError("Reactive transition effects do not match the admitted actions");
-    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 = {
+    const record = createTransitionRecord({
         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),
-    };
+        stateBefore: input.snapshot.active_state,
+        transition: input.transition,
+        triggerEventIds: input.triggerEventIds,
+        effectResults: input.effectResults,
+    });
+    const outcome = record.outcome;
+    const stateAfter = record.state_after;
     const consumed = new Set(input.snapshot.consumed_event_ids);
     for (const eventId of input.consumeEventIds)
         consumed.add(eventId);
@@ -45,10 +59,8 @@ const applyProcessReactiveTransition = (input) => {
             });
     }
     const completedCaptureOrder = Math.max(input.observation.capture_order, ...input.effectResults.map(({ observation }) => observation.capture_order));
-    let next = {
+    const nextState = {
         ...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
@@ -61,6 +73,9 @@ const applyProcessReactiveTransition = (input) => {
         checkpoints,
         transitions: [...input.snapshot.transitions, record],
     };
+    let next = outcome === null
+        ? { ...nextState, status: "running", outcome: null }
+        : { ...nextState, status: "finished", outcome };
     if (stateAfter !== null) {
         const nextState = input.scenario.states.find(({ id }) => id === stateAfter);
         if (nextState === undefined ||