rea-agents 3.0.0 → 3.2.0

package/dist/domain/processCaptureReactiveValidation.js

@@ -118,6 +118,8 @@ const replayTransitions = (scenario, run, observations, require) => {
         while ((run.controls[controlIndex]?.after_capture_order ??
             Number.MAX_SAFE_INTEGER) < observation.capture_order) {
             const control = run.controls[controlIndex];
+            if (control === undefined)
+                break;
             advanceControl(control, controlIndex);
             controlIndex += 1;
         }
@@ -125,6 +127,8 @@ const replayTransitions = (scenario, run, observations, require) => {
     }
     for (; controlIndex < run.controls.length; controlIndex += 1) {
         const control = run.controls[controlIndex];
+        if (control === undefined)
+            break;
         advanceControl(control, controlIndex);
     }
     require(transitionIndex ===
@@ -141,10 +145,11 @@ const validateControls = (run, observations, require) => {
         require(control.sequence ===
             index, `reactive_run.controls[${String(index)}].sequence`, "reactive control sequence must be contiguous");
         require(admittedOrders.has(control.after_capture_order), `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoff must identify the last admitted observation");
+        const previous = run.controls.at(index - 1);
         require(index === 0 ||
-            control.after_capture_order >=
-                run.controls[index - 1]
-                    .after_capture_order, `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoffs must be ordered");
+            (previous !== undefined &&
+                control.after_capture_order >=
+                    previous.after_capture_order), `reactive_run.controls[${String(index)}].after_capture_order`, "reactive control cutoffs must be ordered");
     }
 };
 /** Validate one capture's reactive journal by replaying the production reducer. */

package/dist/domain/processCaptureValidation.js

@@ -1,7 +1,11 @@
 import { validateProcessCaptureReactiveRun } from "./processCaptureReactiveValidation.js";
 import { replayMachineSchema } from "./replayMachine.js";
 import { digestProcessCommitment } from "./processScenario.js";
-const orderedTimestamps = (values) => values.every((value, index) => index === 0 || value.at_ms >= values[index - 1].at_ms);
+const orderedTimestamps = (values) => values.every((value, index) => {
+    const previous = values[index - 1];
+    return previous === undefined || value.at_ms >= previous.at_ms;
+});
+const transitionsAreContiguous = (previous, current) => previous !== undefined && previous.state_after === current.state_before;
 const validateCommitments = (capture, require) => {
     const { manifest } = capture;
     require(manifest.scenario.executable_sha256 ===
@@ -82,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 &&
@@ -192,13 +190,13 @@ const validateReplayEvents = (capture, require) => {
         if (index === 0)
             require(transition.state_before ===
                 machine?.initial_state, "replay_transitions", "first replay transition does not start at the declared initial state");
+        const previous = capture.replay_transitions[index - 1];
         if (index > 0)
-            require(capture.replay_transitions[index - 1].state_after ===
-                transition.state_before, "replay_transitions", "replay transition states are not contiguous");
+            require(transitionsAreContiguous(previous, transition), "replay_transitions", "replay transition states are not contiguous");
     }
 };
 /** 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,5 +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";
@@ -97,6 +97,10 @@ const filesystemObservations = (capture) => [
         effects: capture.filesystem_effects,
     },
 ];
+const sameJsonValue = (left, right) => {
+    const encodedLeft = canonicalize(left);
+    return encodedLeft !== undefined && encodedLeft === canonicalize(right);
+};
 /** Canonical observations for one process-comparison dimension. */
 export const processDimensionObservations = (capture, dimension) => {
     switch (dimension) {
@@ -117,7 +121,7 @@ export const processDimensionObservations = (capture, dimension) => {
     }
 };
 const classifyCollection = (left, right) => {
-    if (JSON.stringify(left) === JSON.stringify(right))
+    if (sameJsonValue(left, right))
         return "unchanged";
     if (left.length === 0)
         return "added";
@@ -141,7 +145,7 @@ const firstCollectionDivergence = (dimension, left, right) => {
     for (let index = 0; index < length; index += 1) {
         const leftValue = left[index] ?? null;
         const rightValue = right[index] ?? null;
-        if (JSON.stringify(leftValue) === JSON.stringify(rightValue))
+        if (sameJsonValue(leftValue, rightValue))
             continue;
         return {
             status: "found",
@@ -164,15 +168,8 @@ const chooseFirstDivergence = (candidates) => {
     })[0] ?? { status: "none" });
 };
 const assertComparable = (left, right, options) => {
-    const invalid = [
-        ...validateProcessCapture(left),
-        ...validateProcessCapture(right),
-    ];
-    if (invalid.length > 0)
-        throw new TypeError(`Invalid Process Capture v4: ${invalid[0].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;
@@ -239,8 +236,7 @@ const compareDimensions = (left, right, sameNormalization) => {
         interaction: classify("interaction", left.interaction_events, right.interaction_events),
         exit: hasUnknown(left, "exit") || hasUnknown(right, "exit")
             ? "unknown"
-            : JSON.stringify({ exit: left.exit, settlement: left.settlement }) ===
-                JSON.stringify({ exit: right.exit, settlement: right.settlement })
+            : sameJsonValue({ exit: left.exit, settlement: left.settlement }, { exit: right.exit, settlement: right.settlement })
                 ? "unchanged"
                 : "changed",
         filesystem: classify("filesystem", filesystemObservations(left), filesystemObservations(right)),
@@ -250,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.
@@ -266,7 +262,7 @@ export const compareProcessCaptures = (left, right, options = {}) => {
                 trace: compareProcessTraces(left, right, options.traceSpecification),
             };
     }
-    const sameNormalization = JSON.stringify(left.normalization) === JSON.stringify(right.normalization);
+    const sameNormalization = sameJsonValue(left.normalization, right.normalization);
     const exactDimensions = compareDimensions(left, right, sameNormalization);
     const trace = options.traceSpecification === undefined
         ? undefined

package/dist/domain/processObservation.js

@@ -52,14 +52,13 @@ export const createProcessObservation = (input) => ({
 const atMilliseconds = (value) => {
     if (typeof value !== "object" || value === null)
         return null;
-    for (const name of ["at_ms", "dispatched_at_ms"])
-        if (name in value) {
-            const candidate = value[name];
-            if (typeof candidate === "number" && Number.isSafeInteger(candidate))
-                return candidate;
-        }
+    if ("at_ms" in value && isSafeMillisecond(value.at_ms))
+        return value.at_ms;
+    if ("dispatched_at_ms" in value && isSafeMillisecond(value.dispatched_at_ms))
+        return value.dispatched_at_ms;
     return null;
 };
+const isSafeMillisecond = (value) => typeof value === "number" && Number.isSafeInteger(value);
 /** Derive the stable capture-local identity for one normalized observation. */
 export const processObservationSubject = (source, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value))

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,20 +95,32 @@ 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 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,
     };
 };
-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)
@@ -143,7 +132,7 @@ const matchEarliestPrefix = (trigger, context) => {
             ...context,
             upperOrder: observation.capture_order,
         });
-        if (matched.matched || matched.overflow)
+        if (matched.matched)
             return matched;
     }
     return noMatch();
@@ -158,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 = [];
@@ -171,7 +158,7 @@ const matchTrigger = (trigger, context) => {
                 afterOrder: cursor,
             });
             if (!matched.matched)
-                return noMatch(matched.overflow);
+                return noMatch();
             matches.push(matched);
             cursor = matched.lastOrder;
         }
@@ -194,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)