Reverse engineer anything with agents, from app behavior down to native binaries.
TypeScript agent-skillsai-agentsbinary-analysisclaude-codeclicodexcordisdecompilerdeveloper-toolsdshdsh-pluginghidrahopperllmmcpmodel-context-protocolreareverse-engineeringstatic-analysistouhou
refactor(process): remove fixed scenario ceilings
morlutoabf7c1142e75
diff --git a/docs/adr/0002-controlled-replay-authority-and-sandbox.md b/docs/adr/0002-controlled-replay-authority-and-sandbox.mdindex e8e91b61e..dced78982 100644--- a/docs/adr/0002-controlled-replay-authority-and-sandbox.md+++ b/docs/adr/0002-controlled-replay-authority-and-sandbox.md@@ -321,7 +321,8 @@ Every limit has a conservative product default. The v1 plan and result commit:- cgroup memory, swap, task, and CPU ceilings;- Node/V8 heap ceiling as defense in depth;- private tmpfs bytes;-- module count and aggregate bytes, case count, and input bytes;+- serialized worker-protocol bytes, aggregate module bytes, and case-input+ bytes; preset-generated cases also have a fixed preflight count ceiling;- stdout, stderr, exception, stack, and aggregate retained-output bytes; and- structured-result depth and node count.diff --git a/docs/process-capture.md b/docs/process-capture.mdindex 4215922dc..d2e801b4f 100644--- a/docs/process-capture.md+++ b/docs/process-capture.md@@ -118,8 +118,8 @@ inherited under operator policy.Scenario arguments, environment names, timed interactions, shim routes andoutput chunks, filesystem checkpoints, and static HTTP/WebSocket scripts areaccepted without fixed item-count ceilings. The run still obeys its timeout-and the configured output, frame, process, filesystem, protocol-event,-body-byte, and connection budgets; each filesystem checkpoint uses those same+and the configured output-byte, process, filesystem, protocol-event, body-byte,+and connection budgets; each filesystem checkpoint uses those samebounded snapshot limits.## Reactive process scenarios@@ -127,8 +127,8 @@ bounded snapshot limits.Set `reactive` to a process reactive scenario declaration when interactionmust follow observed output instead of guessed delays. The graph declares aninitial state, absolute scenario and state deadlines, explicitly prioritized-transitions, bounded uses and visits, trigger predicates, ordered actions, and-either a next state or `passed` outcome.+transitions, caller-chosen use and visit counts, trigger predicates, ordered+actions, and either a next state or `passed` outcome.The admitted runtime slice matches decoded UTF-8 terminal literals and exact`terminal_raw`, `interaction`, `process`, `filesystem`, `http`, `websocket`, or@@ -136,7 +136,7 @@ The admitted runtime slice matches decoded UTF-8 terminal literals and exactevent-complete lifecycle. Filesystem events identify named checkpoints; shimevents identify a command and route. Live predicates receive the same normalizedand redacted payload later persisted in Evidence. Predicates may compose with-bounded `all`, `any`, `sequence`, and `repeat` nodes and may select a frontier at+`all`, `any`, `sequence`, and `repeat` nodes and may select a frontier atscenario start, state entry, a prior checkpoint, or an exact event ID. Actionscan write PTY input, resize it, signal the root process, or capture a namedfilesystem checkpoint. `terminal_rendered`, `lifecycle`, and `replay_transition`@@ -145,9 +145,12 @@ target launches.Reactive results are recorded in `reactive_run`, including the terminal outcome,active state, matched event IDs, action evidence IDs, and deterministic-transition journal. Terminal controls also commit the last admitted observation-order, so later output cannot be moved ahead of a timeout, cancellation, or-target loss during validation. If the process exits before the graph finishes,+transition journal. The reducer retains and evaluates every admitted+observation through the scenario deadline; it has no fixed state, transition,+predicate, action, repeat, or history-count ceilings. Recursive input depth has+a stack safety guard. Terminal controls also commit the last admitted+observation order, so later output cannot be moved ahead of a timeout,+cancellation, or target loss during validation. If the process exits before the graph finishes,the outcome is `target_lost`; state/scenario deadlines remain distinct`predicate_timeout`/`scenario_deadline` outcomes. Timed `events` remainavailable for fixed schedules, but they are not silently translated into the@@ -163,9 +166,10 @@ the initial tree.Each command shim matches an exact argument array. Routes can emit timed stdoutor stderr chunks and then exit or receive `SIGINT`, `SIGTERM`, or `SIGKILL`.-Unmatched and exhausted calls are recorded. Shim observations are bounded by-the scenario protocol-event limit; exceeding it marks the whole capture-truncated while replay continues.+Unmatched and exhausted calls are recorded. Shim observations are included in+the capture without a separate fixed count ceiling. Other configured+observation and byte budgets remain explicit in the capture result when they+affect completeness.## Run a replay machine directly@@ -178,9 +182,13 @@ transition. It never returns request bodies, request headers, or capturedvalues. It also reports the initial and final states, whether the final state isterminal, configured limits, and committed usage.-The direct boundary accepts at most 10,000 events, 4 MiB of declared action-JSON, 1,024 action text fields, and 1,024 possible sensitive-capture operations.-These caps bound both returned content and secret-redaction work.+The direct evaluator has no fixed state, transition, event, guard, capture,+action, or action-byte count ceiling. It indexes transitions by protocol and+path, evaluates events in order, and returns a decision for each offered event+plus actions for used transitions. Caller-declared `max_uses`, `max_visits`,+`max_transitions`, and protocol budgets determine the finite run; there is no+upper schema cap on those values. Result size follows the input and is not+truncated by an arbitrary item quota.Refused events remain data rather than aborting the run. Outcomes distinguishunmatched events, invalid states, failed guards, exhausted transitions, invaliddiff --git a/src/application/JavaScriptReplayPlanning.test.ts b/src/application/JavaScriptReplayPlanning.test.tsnew file mode 100644index 000000000..b545fff21--- /dev/null+++ b/src/application/JavaScriptReplayPlanning.test.ts@@ -0,0 +1,109 @@+import { describe, expect, it, vi } from "vitest";++import {+ prepareReplayPlan,+ type EnabledJavaScriptReplayPolicy,+ type JavaScriptReplayHost,+} from "./JavaScriptReplayPlanning.js";+import { controlledReplayInputSchema } from "../domain/javascriptReplay.js";++const root = "/approved";+const policy: EnabledJavaScriptReplayPolicy = {+ status: "enabled",+ roots: [root],+ nodePath: "/runtime/node",+ bubblewrapPath: "/runtime/bwrap",+ systemdRunPath: "/runtime/systemd-run",+ systemctlPath: "/runtime/systemctl",+ shellPath: "/runtime/sh",+};++const inputWithExpandedManifest = () => {+ const modules = Array.from({ length: 130 }, (_, index) => ({+ alias: `module-${index}`,+ path: `${root}/module.mjs`,+ format: "esm" as const,+ role: "module" as const,+ dependencies: {},+ }));+ const first = modules[0];+ if (first === undefined) throw new TypeError("Missing fixture module");+ modules[0] = {+ ...first,+ dependencies: Object.fromEntries(+ Array.from({ length: 129 }, (_, index) => [+ `dependency-${index}`,+ `module-${index + 1}`,+ ]),+ ),+ };+ return controlledReplayInputSchema.parse({+ mode: "plan",+ left: {+ modules,+ entry_alias: "module-0",+ entry_export: "default",+ },+ cases: Array.from({ length: 129 }, (_, index) => ({+ case_id: `case-${index}`,+ arguments: Array.from({ length: 17 }, () => "value"),+ })),+ });+};++describe("controlled replay planning input bounds", () => {+ it("accepts module, dependency, case, and argument counts beyond old quotas", () => {+ const input = inputWithExpandedManifest();++ expect(input.left.modules).toHaveLength(130);+ expect(Object.keys(input.left.modules[0]?.dependencies ?? {})).toHaveLength(+ 129,+ );+ expect(input.cases).toHaveLength(129);+ expect(input.cases[0]?.arguments).toHaveLength(17);+ });++ it("rejects an oversized protocol manifest before probing or reading", async () => {+ const probe = vi.fn(async () => undefined);+ const readSource = vi.fn(async () => ({+ canonicalPath: `${root}/module.mjs`,+ bytes: new Uint8Array(),+ }));+ const host: JavaScriptReplayHost = {+ readSource,+ identifyExecutable: vi.fn(async (path) => ({+ path,+ version: "1",+ sha256: "0".repeat(64),+ })),+ identifyWorker: vi.fn(async () => ({+ path: "/worker.js",+ version: "1",+ sha256: "0".repeat(64),+ })),+ identifyRuntimeClosure: vi.fn(async () => []),+ seccompDigest: () => "0".repeat(64),+ probe,+ };+ const input = controlledReplayInputSchema.parse({+ mode: "plan",+ left: {+ modules: Array.from({ length: 300 }, (_, index) => ({+ alias: `module-${index}`,+ path: `/${"p".repeat(4_095)}`,+ format: "esm",+ dependencies: {},+ })),+ entry_alias: "module-0",+ },+ cases: [{ case_id: "empty", arguments: [] }],+ limits: { protocol_bytes: 1024 * 1024 },+ });++ await expect(prepareReplayPlan(input, policy, host)).rejects.toThrow(+ "Replay plan input exceeds its protocol byte limit",+ );+ expect(probe).not.toHaveBeenCalled();+ expect(readSource).not.toHaveBeenCalled();+ });+});diff --git a/src/application/ProcessCaptureLifecycle.ts b/src/application/ProcessCaptureLifecycle.tsindex ccc13ba62..b9eb2d1f3 100644--- a/src/application/ProcessCaptureLifecycle.ts+++ b/src/application/ProcessCaptureLifecycle.ts@@ -373,10 +373,7 @@ export const captureTerminalFrames = (options: {options.terminal.onData((data) => {options.onOutput();const bytes = Buffer.byteLength(data);- if (- options.frames.length >= options.scenario.limits.frames ||- outputBytes + bytes > options.scenario.limits.output_bytes- ) {+ if (outputBytes + bytes > options.scenario.limits.output_bytes) {truncated = true;return;}diff --git a/src/application/ProcessCaptureObservation.test.ts b/src/application/ProcessCaptureObservation.test.tsindex 3be38f447..7899f499b 100644--- a/src/application/ProcessCaptureObservation.test.ts+++ b/src/application/ProcessCaptureObservation.test.ts@@ -30,17 +30,19 @@ it("returns detached terminal and filesystem checkpoint observations", async ()columns: 40,rows: 12,scrollback: 100,- maxFrames: 10,- maxBytes: 10_000,+ maxBytes: 100_000,normalize: (value) => value,recordEvent: (collection, index) =>observed.push(`${collection}:${String(index)}`),});renderer.write("A", 20);renderer.resize(40, 12, 10);+ for (let index = 0; index < 20; index += 1)+ renderer.resize(40, 12, 11 + index);const frames = await renderer.frames();- expect(frames.map(({ at_ms }) => at_ms)).toEqual([20, 10]);- expect(observed).toEqual(["rendered_frames:0", "rendered_frames:1"]);+ expect(frames).toHaveLength(22);+ expect(frames.slice(0, 2).map(({ at_ms }) => at_ms)).toEqual([20, 10]);+ expect(observed).toHaveLength(22);if (frames[0] !== undefined) Reflect.set(frames[0], "cursor_x", 999);expect((await renderer.frames())[0]?.cursor_x).not.toBe(999);await renderer.dispose();diff --git a/src/application/ProcessHarness.ts b/src/application/ProcessHarness.tsindex e5f92bb67..cd76e1f94 100644--- a/src/application/ProcessHarness.ts+++ b/src/application/ProcessHarness.ts@@ -106,7 +106,6 @@ const createTerminalRenderer = (columns: scenario.terminal.columns,rows: scenario.terminal.rows,scrollback: scenario.terminal.scrollback,- maxFrames: scenario.limits.frames,maxBytes: scenario.limits.output_bytes,normalize: (value) =>normalizeProcessText(value, scenario, temporaryRoot, terminalPid()),diff --git a/src/application/ProcessReactiveCoordinator.ts b/src/application/ProcessReactiveCoordinator.tsindex 63f3b6540..97b67b671 100644--- a/src/application/ProcessReactiveCoordinator.ts+++ b/src/application/ProcessReactiveCoordinator.ts@@ -35,8 +35,26 @@ export interface ProcessReactiveTimerHost {const systemTimerHost: ProcessReactiveTimerHost = {schedule: (callback, delayMs) => {- const timer = setTimeout(callback, delayMs);- return { cancel: () => clearTimeout(timer) };+ const maximumTimerDelay = 2_147_483_647;+ let remaining = Math.max(0, delayMs);+ let timer: NodeJS.Timeout | undefined;+ let cancelled = false;+ const scheduleNext = (): void => {+ if (cancelled) return;+ const interval = Math.min(remaining, maximumTimerDelay);+ timer = setTimeout(() => {+ remaining -= interval;+ if (remaining === 0) callback();+ else scheduleNext();+ }, interval);+ };+ scheduleNext();+ return {+ cancel: () => {+ cancelled = true;+ if (timer !== undefined) clearTimeout(timer);+ },+ };},};diff --git a/src/application/TerminalRenderer.ts b/src/application/TerminalRenderer.tsindex 314f7532c..44bf4d580 100644--- a/src/application/TerminalRenderer.ts+++ b/src/application/TerminalRenderer.ts@@ -17,14 +17,13 @@ interface TerminalRendererOptions {readonly columns: number;readonly rows: number;readonly scrollback: number;- readonly maxFrames: number;readonly maxBytes: number;readonly normalize: (value: string) => string;readonly recordEvent?: RecordProcessCaptureEvent;}-/** Owns one headless terminal and serializes writes into deterministic frames. *//**+ * Owns one headless terminal and serializes writes into deterministic frames.* Reconstructs bounded terminal states while raw PTY chunks remain authoritative.** Rendered frames answer what an operator saw after control-sequence handling;@@ -108,10 +107,7 @@ export class TerminalRenderer {const bytes =Buffer.byteLength(serializedState) +lines.reduce((total, line) => total + Buffer.byteLength(line), 0);- if (- this.#frames.length >= this.options.maxFrames ||- this.#capturedBytes + bytes > this.options.maxBytes- ) {+ if (this.#capturedBytes + bytes > this.options.maxBytes) {this.#truncated = true;return;}diff --git a/src/domain/javascriptReplay.ts b/src/domain/javascriptReplay.tsindex b145be839..1b795aac6 100644--- a/src/domain/javascriptReplay.ts+++ b/src/domain/javascriptReplay.ts@@ -16,18 +16,13 @@ const replayModuleSchema = zpath: absolutePathSchema,format: z.enum(["esm", "commonjs-factory"]),role: z.enum(["module", "stub"]).default("module"),- dependencies: z- .record(z.string().min(1).max(256), aliasSchema)- .refine((value) => Object.keys(value).length <= 128, {- message: "Replay modules may declare at most 128 dependencies",- })- .default({}),+ dependencies: z.record(z.string().min(1).max(256), aliasSchema).default({}),}).strict();const replaySideSchema = z.object({- modules: z.array(replayModuleSchema).min(1).max(128),+ modules: z.array(replayModuleSchema).min(1),entry_alias: aliasSchema,entry_export: z.string().min(1).max(256).default("default"),})@@ -117,7 +112,7 @@ const determinismSchema = zconst controlledReplayInputShape = {left: replaySideSchema,right: replaySideSchema.optional(),- cases: z.array(explicitCaseSchema).max(128).default([]),+ cases: z.array(explicitCaseSchema).default([]),generator: generatorSchema.optional(),determinism: determinismSchema.default({clock_iso: "2000-01-01T00:00:00.000Z",@@ -174,12 +169,6 @@ export const controlledReplayInputSchema = zpath: ["cases"],message: "At least one explicit or generated case is required",});- if (value.cases.length + (value.generator?.count ?? 0) > 128)- context.addIssue({- code: "custom",- path: ["generator", "count"],- message: "Explicit and generated replay cases must total at most 128",- });});const moduleCommitmentSchema = zdiff --git a/src/domain/processCaptureReactiveSchema.test.ts b/src/domain/processCaptureReactiveSchema.test.tsnew file mode 100644index 000000000..8dd1687ab--- /dev/null+++ b/src/domain/processCaptureReactiveSchema.test.ts@@ -0,0 +1,34 @@+import { describe, expect, it } from "vitest";++import { processReactiveRunSchema } from "./processCaptureReactiveSchema.js";++describe("process reactive capture schema", () => {+ it("accepts every committed transition without a fixed journal ceiling", () => {+ const transitions = Array.from({ length: 130 }, (_, sequence) => ({+ sequence,+ transition_id: `transition_${String(sequence)}`,+ state_before: "active",+ state_after: "active",+ outcome: null,+ trigger_event_ids: Array.from(+ { length: 80 },+ (_, index) => `event_${String(index)}`,+ ),+ action_event_ids: Array.from(+ { length: 300 },+ (_, index) => `action_${String(index)}`,+ ),+ action_types: Array.from({ length: 300 }, () => "send_input" as const),+ }));++ const parsed = processReactiveRunSchema.safeParse({+ status: "running",+ outcome: null,+ active_state: "active",+ transitions,+ });++ expect(parsed.success).toBe(true);+ if (parsed.success) expect(parsed.data.transitions).toHaveLength(130);+ });+});diff --git a/src/domain/processCaptureReactiveSchema.ts b/src/domain/processCaptureReactiveSchema.tsindex f9773cb08..a515b5895 100644--- a/src/domain/processCaptureReactiveSchema.ts+++ b/src/domain/processCaptureReactiveSchema.ts@@ -1,7 +1,5 @@import { z } from "zod";-import { PROCESS_REACTIVE_LIMITS } from "./processReactiveScenario.js";-const processReactiveOutcomeSchema = z.enum(["passed","predicate_timeout",@@ -18,23 +16,17 @@ const processReactiveTransitionShape = {sequence: z.number().int().nonnegative(),transition_id: z.string().min(1).max(64),state_before: z.string().min(1).max(64),- trigger_event_ids: z- .array(z.string().min(1))- .max(PROCESS_REACTIVE_LIMITS.predicates),- action_event_ids: z- .array(z.string().min(1))- .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),- action_types: z- .array(- z.enum([- "send_input",- "resize",- "close_stdin",- "send_signal",- "checkpoint",- ]),- )- .max(PROCESS_REACTIVE_LIMITS.actionsPerTransition),+ trigger_event_ids: z.array(z.string().min(1)),+ action_event_ids: z.array(z.string().min(1)),+ action_types: z.array(+ z.enum([+ "send_input",+ "resize",+ "close_stdin",+ "send_signal",+ "checkpoint",+ ]),+ ),};const processReactiveTransitionSchema = z.union([@@ -67,9 +59,7 @@ const processReactiveRunShape = {}),).default([]),- transitions: z- .array(processReactiveTransitionSchema)- .max(PROCESS_REACTIVE_LIMITS.transitions),+ transitions: z.array(processReactiveTransitionSchema),};/** Serialized reactive reducer state admitted by process capture. */diff --git a/src/domain/processReactiveMatching.ts b/src/domain/processReactiveMatching.tsindex b0fc3688a..dea1e7ef4 100644--- a/src/domain/processReactiveMatching.ts+++ b/src/domain/processReactiveMatching.ts@@ -2,49 +2,31 @@ import canonicalize from "canonicalize";import type { ProcessObservation } from "./processObservation.js";import { comparableProcessObservationPayload } from "./processObservation.js";-import {- PROCESS_REACTIVE_LIMITS,- type ProcessReactiveFrontier,- type ProcessReactiveTrigger,+import type {+ ProcessReactiveFrontier,+ ProcessReactiveTrigger,} from "./processReactiveScenario.js";import type { ProcessReactiveSnapshot } from "./processReactiveRuntime.js";-/** Internal bounded trigger-match result used by the pure reducer. */+/** Trigger match result used by the pure reducer. */export type ProcessReactiveTriggerMatch = {readonly eventIds: readonly string[];readonly consumeIds: readonly string[];readonly lastOrder: number;-} & (- | { readonly matched: true; readonly overflow: false }- | { readonly matched: false; readonly overflow: boolean }-);--interface EvaluationBudget {- remaining: number;-}+ readonly matched: boolean;+};interface TriggerMatchContext {readonly snapshot: ProcessReactiveSnapshot;- readonly budget: EvaluationBudget;readonly afterOrder: number;readonly upperOrder: number | null;}-const spendEvaluationWork = (- budget: EvaluationBudget,- units: number,-): boolean => {- if (units > budget.remaining) return false;- budget.remaining -= units;- return true;-};--const noMatch = (overflow = false): ProcessReactiveTriggerMatch => ({- matched: false,+const noMatch = (): ProcessReactiveTriggerMatch => ({eventIds: [],consumeIds: [],lastOrder: -1,- overflow,+ matched: false,});const frontierOrder = (@@ -102,7 +84,6 @@ const matchEvent = ();const matches: ProcessObservation[] = [];for (const observation of eligibleObservations(trigger.since, context)) {- if (!spendEvaluationWork(context.budget, 1)) return noMatch(true);if (observation.source === trigger.source &&canonicalJson(@@ -121,11 +102,10 @@ const matchEvent = (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,};};@@ -150,7 +130,6 @@ const matchTerminalText = (): ProcessReactiveTriggerMatch => {const chunks: { observation: ProcessObservation; text: string }[] = [];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" &&@@ -160,18 +139,6 @@ const matchTerminalText = ()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,@@ -194,29 +161,32 @@ const matchTerminalText = (.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: readonly ProcessReactiveTriggerMatch[],): ProcessReactiveTriggerMatch => {- 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<string>();+ const consumeIds = new Set<string>();+ 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 = (@@ -234,7 +204,7 @@ const matchEarliestPrefix = (...context,upperOrder: observation.capture_order,});- if (matched.matched || matched.overflow) return matched;+ if (matched.matched) return matched;}return noMatch();};@@ -255,9 +225,7 @@ const matchTrigger = (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: ProcessReactiveTriggerMatch[] = [];@@ -267,7 +235,7 @@ const matchTrigger = (...context,afterOrder: cursor,});- if (!matched.matched) return noMatch(matched.overflow);+ if (!matched.matched) return noMatch();matches.push(matched);cursor = matched.lastOrder;}@@ -289,22 +257,19 @@ const matchTrigger = (...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));+ if (matches.length < trigger.min) return noMatch();return mergeMatches(matches);};-/** Match one trigger using a shared deterministic work budget. */+/** Match one trigger against every eligible retained observation. */export const matchProcessReactiveTrigger = (trigger: ProcessReactiveTrigger,snapshot: ProcessReactiveSnapshot,- budget: EvaluationBudget,): ProcessReactiveTriggerMatch =>matchTrigger(trigger, {snapshot,- budget,afterOrder: -1,upperOrder: null,});diff --git a/src/domain/processReactiveRuntime.ts b/src/domain/processReactiveRuntime.tsindex ce8993b3e..4e122ef68 100644--- a/src/domain/processReactiveRuntime.ts+++ b/src/domain/processReactiveRuntime.ts@@ -1,7 +1,6 @@import type { ProcessObservation } from "./processObservation.js";import { matchProcessReactiveTrigger } from "./processReactiveMatching.js";import {- PROCESS_REACTIVE_LIMITS,type ProcessReactiveAction,type ProcessReactiveScenario,} from "./processReactiveScenario.js";@@ -150,10 +149,7 @@ const observeInput = ();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",@@ -228,14 +224,11 @@ export const reduceProcessReactiveScenario = (const observed = admitted.snapshot;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: ProcessReactiveEvaluation[] = matches.map(({ transition, match, uses }) => ({transition_id: transition.id,@@ -254,8 +247,9 @@ export const reduceProcessReactiveScenario = ();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,diff --git a/src/domain/processReactiveRuntimePart3.test.ts b/src/domain/processReactiveRuntimePart3.test.tsindex f8b603894..21ad3423d 100644--- a/src/domain/processReactiveRuntimePart3.test.ts+++ b/src/domain/processReactiveRuntimePart3.test.ts@@ -10,7 +10,6 @@ import {reduceProcessReactiveScenario,} from "./processReactiveRuntime.js";import {- PROCESS_REACTIVE_LIMITS,processReactiveScenarioSchema,type ProcessReactiveAction,type ProcessReactiveScenario,@@ -154,55 +153,35 @@ const offer = (};describe("process reactive runtime lifecycle", () => {- it("preserves overflow when no any branch matches", () => {- const scenario = scenarioWith([- finish("bounded_any", {- kind: "any",- triggers: [- terminalTrigger("never"),- {- kind: "event",- source: "shim",- exact: { name: "also-never" },- ignore_fields: [],- since: { kind: "scenario_start" },- consume: false,- cardinality: { min: 1, max: 1 },- },- ],- }),- ]);+ it("matches terminal text after the previous retained-data ceiling", () => {+ const scenario = scenarioWith([finish("large_output", terminalTrigger())]);const decision = reduceProcessReactiveScenario(scenario,createProcessReactiveSnapshot(scenario),{kind: "observation",observation: observation("terminal_raw", 0, {- data: "x".repeat(PROCESS_REACTIVE_LIMITS.evaluationWork + 1),+ data: `${"x".repeat(70_000)}Ready`,}),},);- expect(decision).toMatchObject({- kind: "finished",- outcome: "capture_incomplete",- });+ expect(decision.kind).toBe("proposal");});- it("fails closed at the deterministic per-reduction work budget", () => {- const transitions = Array.from(- { length: PROCESS_REACTIVE_LIMITS.predicates },- (_, index) =>- finish(`event_${String(index)}`, {- kind: "event",- source: "shim",- exact: { name: `expected_${String(index)}` },- ignore_fields: ["sequence"],- since: { kind: "scenario_start" },- consume: false,- cardinality: { min: 1, max: 1 },- }),++ it("evaluates all configured predicates against all retained observations", () => {+ const transitions = Array.from({ length: 80 }, (_, index) =>+ finish(`event_${String(index)}`, {+ kind: "event",+ source: "shim",+ exact: { name: `expected_${String(index)}` },+ ignore_fields: ["sequence"],+ since: { kind: "scenario_start" },+ consume: false,+ cardinality: { min: 1, max: 1 },+ }),);const scenario = scenarioWith(transitions);- const retained = Array.from({ length: 128 }, (_, order) =>+ const retained = Array.from({ length: 130 }, (_, order) =>observation("shim", order, { name: "other", sequence: order }),);const snapshot = {@@ -217,9 +196,8 @@ describe("process reactive runtime lifecycle", () => {sequence: retained.length,}),);- expect(decision).toMatchObject({- kind: "finished",- outcome: "capture_incomplete",- });+ expect(decision).toMatchObject({ kind: "waiting" });+ if (decision.kind === "waiting")+ expect(decision.snapshot.observations).toHaveLength(131);});});diff --git a/src/domain/processReactiveScenario.test.ts b/src/domain/processReactiveScenario.test.tsindex 9a4e20772..b268c898f 100644--- a/src/domain/processReactiveScenario.test.ts+++ b/src/domain/processReactiveScenario.test.ts@@ -40,11 +40,66 @@ const baseScenario = () => ({});describe("process reactive scenario schema", () => {- it("parses a bounded terminal scenario", () => {+ it("parses a terminal scenario", () => {expect(processReactiveScenarioSchema.parse(baseScenario())).toMatchObject({initial_state: "starting",});- expect(PROCESS_REACTIVE_LIMITS.triggerDepth).toBe(6);+ expect(PROCESS_REACTIVE_LIMITS.triggerDepth).toBe(256);+ });++ it("accepts caller-defined scenario sizes without count ceilings", () => {+ const states = Array.from({ length: 40 }, (_, index) => ({+ id: `state_${String(index)}`,+ max_visits: 300,+ deadline_ms: 30_000,+ on: [] as unknown[],+ }));+ const manyPredicates = {+ kind: "repeat",+ trigger: {+ kind: "all",+ triggers: Array.from({ length: 20 }, () => terminalTrigger()),+ },+ min: 1,+ max: 1_000,+ };+ const sendInputs = Array.from({ length: 300 }, () => ({+ type: "send_input",+ data: "x",+ sensitive: false,+ }));+ const transitions = Array.from({ length: 130 }, (_, index) => ({+ id: `transition_${String(index)}`,+ priority: index,+ max_uses: 300,+ when: index === 0 ? manyPredicates : terminalTrigger(),+ actions: index === 0 ? sendInputs : [],+ target:+ index > 0 && index <= 39+ ? { kind: "goto", state: `state_${String(index)}` }+ : { kind: "finish", outcome: "passed" },+ }));+ states[0]!.on = transitions;+ for (let index = 1; index < states.length; index += 1) {+ const state = states[index]!;+ state.on = [+ {+ ...finishTransition(),+ id: `finish_${String(index)}`,+ max_uses: 300,+ actions: [{ type: "checkpoint", name: `ready_${String(index)}` }],+ },+ ];+ }+ const parsed = processReactiveScenarioSchema.safeParse({+ initial_state: "state_0",+ deadline_ms: 30_000,+ states,+ });+ expect(+ parsed.success,+ parsed.success ? "" : JSON.stringify(parsed.error.issues),+ ).toBe(true);});it.each([diff --git a/src/domain/processReactiveScenario.ts b/src/domain/processReactiveScenario.tsindex 7fd07a793..9004e4624 100644--- a/src/domain/processReactiveScenario.ts+++ b/src/domain/processReactiveScenario.ts@@ -5,35 +5,18 @@ import { processObservationSourceSchema } from "./processObservation.js";import { definitelyAvailableCheckpoints } from "./processReactiveCheckpointDataflow.js";import { preflightProcessReactiveScenario } from "./processReactiveScenarioPreflight.js";-/** Fixed public bounds for process reactive scenarios. */+/** 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,} as const;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 positiveRuntime = z.number().int().safe().positive();const frontierSchema = z.discriminatedUnion("kind", [z.strictObject({ kind: z.literal("scenario_start") }),@@ -118,8 +101,8 @@ const processReactiveTriggerSchema: z.ZodType<ProcessReactiveTrigger> = z.lazy(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",@@ -132,37 +115,28 @@ const processReactiveTriggerSchema: z.ZodType<ProcessReactiveTrigger> = z.lazy(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),+ 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",@@ -207,34 +181,24 @@ 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({initial_state: identifierSchema,deadline_ms: positiveRuntime,- states: z.array(stateSchema).min(1).max(PROCESS_REACTIVE_LIMITS.states),+ states: z.array(stateSchema).min(1),});/** Parsed process reactive scenario declaration. */@@ -242,23 +206,19 @@ export type ProcessReactiveScenario = z.infer<typeof scenarioShapeSchema>;type TriggerMeasurements = {readonly depth: number;- readonly predicates: number;};const measureTrigger = (trigger: ProcessReactiveTrigger,): TriggerMeasurements => {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),};};@@ -320,9 +280,6 @@ type GraphValidation = {readonly path: PropertyKey[];}>;readonly adjacency: ReadonlyMap<string, Set<string>>;- transitions: number;- predicates: number;- actions: number;};type ReactiveTransition =@@ -336,10 +293,7 @@ const validateTransition = (input: {readonly context: z.RefinementCtx;}): void => {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({@@ -387,25 +341,6 @@ const validateTotalsAndReferences = (validation: GraphValidation,context: z.RefinementCtx,): void => {- 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",- ],- ] as const)- 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))@@ -466,9 +401,6 @@ const validateScenarioGraph = (checkpoints: new Set(),checkpointReferences: [],adjacency: new Map(stateIds.map((id) => [id, new Set<string>()])),- transitions: 0,- predicates: 0,- actions: 0,};for (const [stateIndex, state] of scenario.states.entries()) {if (state.deadline_ms > scenario.deadline_ms)diff --git a/src/domain/processReactiveScenarioPreflight.ts b/src/domain/processReactiveScenarioPreflight.tsindex 0c3526ad5..a1b736766 100644--- a/src/domain/processReactiveScenarioPreflight.ts+++ b/src/domain/processReactiveScenarioPreflight.ts@@ -1,13 +1,8 @@import { z } from "zod";interface ReactivePreflightLimits {- readonly states: number;- readonly transitions: number;- readonly predicates: number;readonly triggerDepth: number;- readonly childrenPerComposite: number;readonly jsonDepth: number;- readonly jsonNodes: number;}type PendingTrigger = { readonly value: unknown; readonly depth: number };@@ -33,16 +28,9 @@ const inspectJsonValue = (): boolean => {const pending: PendingTrigger[] = [{ value, depth: 1 }];const seen = new WeakSet<object>();- 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 configured node limit",- );if (current.depth > limits.jsonDepth)return reject(context,@@ -53,11 +41,6 @@ const inspectJsonValue = (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 configured node limit",- );for (const child of current.value)pending.push({ value: child, depth: current.depth + 1 });continue;@@ -65,11 +48,6 @@ const inspectJsonValue = (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 configured node limit",- );pending.push({value: current.value[key],depth: current.depth + 1,@@ -79,21 +57,11 @@ const inspectJsonValue = (return true;};-const collectTriggerRoots = (- states: readonly unknown[],- context: z.RefinementCtx,- limits: ReactivePreflightLimits,-): PendingTrigger[] | null => {+const collectTriggerRoots = (states: readonly unknown[]): PendingTrigger[] => {const pending: PendingTrigger[] = [];- 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 });@@ -118,8 +86,6 @@ const enqueueTriggerChildren = (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;@@ -130,14 +96,9 @@ const inspectTriggerTree = (context: z.RefinementCtx,limits: ReactivePreflightLimits,): boolean => {- 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 configured limit");if (current.depth > limits.triggerDepth)return reject(context, "trigger nesting exceeds the configured limit");if (@@ -166,12 +127,7 @@ export const preflightProcessReactiveScenario = (limits: ReactivePreflightLimits,): unknown => {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;+ const pending = collectTriggerRoots(input["states"]);+ if (!inspectTriggerTree(pending, context, limits)) return z.NEVER;return input;};diff --git a/src/domain/processScenario.test.ts b/src/domain/processScenario.test.tsindex 61a3e8ddc..9a607f854 100644--- a/src/domain/processScenario.test.ts+++ b/src/domain/processScenario.test.ts@@ -16,6 +16,23 @@ describe("process scenario collection inputs", () => {expect(scenario.checkpoints).toHaveLength(65);});+ it("lets callers raise the output byte budget without a tool-side ceiling", () => {+ const scenario = processScenarioSchema.parse({+ executable: "/bin/echo",+ working_directory: "/tmp",+ limits: { output_bytes: 10_000_001 },+ });++ expect(scenario.limits.output_bytes).toBe(10_000_001);+ expect(+ processScenarioSchema.safeParse({+ executable: "/bin/echo",+ working_directory: "/tmp",+ limits: { frames: 100_001 },+ }).success,+ ).toBe(false);+ });+it("accepts large interaction and replay descriptions under the run budgets", () => {const environment = Object.fromEntries(Array.from({ length: 65 }, (_, index) => [`APP_VALUE_${index}`, "x"]),diff --git a/src/domain/processScenario.ts b/src/domain/processScenario.tsindex 2fe011ccb..1dae696c8 100644--- a/src/domain/processScenario.ts+++ b/src/domain/processScenario.ts@@ -207,8 +207,7 @@ export const processScenarioSchema = zsettle_ms: z.number().int().nonnegative().max(10_000).default(100),limits: z.object({- output_bytes: positiveBudget.max(10_000_000).default(1_000_000),- frames: positiveBudget.max(100_000).default(10_000),+ output_bytes: positiveBudget.safe().default(1_000_000),files: positiveBudget.max(100_000).default(10_000),file_bytes: positiveBudget.max(100_000_000).default(10_000_000),processes: positiveBudget.max(10_000).default(1_000),@@ -217,9 +216,9 @@ export const processScenarioSchema = zconnections: positiveBudget.max(1_000).default(100),filesystem_depth: z.number().int().min(1).max(64).default(16),})+ .strict().default({output_bytes: 1_000_000,- frames: 10_000,files: 10_000,file_bytes: 10_000_000,processes: 1_000,diff --git a/src/domain/replayMachine.ts b/src/domain/replayMachine.tsindex 342b35f9e..f1fdf24f8 100644--- a/src/domain/replayMachine.ts+++ b/src/domain/replayMachine.ts@@ -6,9 +6,9 @@ import { z } from "zod";const replayIdentifierSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9_-]{0,63}$/u);-const replayPathSchema = z- .array(z.union([z.string().max(256), z.number().int().nonnegative()]))- .max(32);+const replayPathSchema = z.array(+ z.union([z.string(), z.number().int().nonnegative()]),+);const sensitiveHeaderNames = new Set(["authorization","cookie",@@ -18,12 +18,8 @@ const sensitiveHeaderNames = new Set([const headerNameSchema = z.string().min(1)- .max(256).regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u);-const headerValueSchema = z- .string()- .max(8_192)- .regex(/^[\t\x20-\x7e\x80-\xff]*$/u);+const headerValueSchema = z.string().regex(/^[\t\x20-\x7e\x80-\xff]*$/u);const replayHeaderMatchersSchema = z.record(headerNameSchema, headerValueSchema).superRefine((headers, context) => {@@ -73,11 +69,10 @@ const replayTriggerSchema = z.discriminatedUnion("protocol", [method: z.string().min(1)- .max(16).transform((method) => method.toUpperCase()),path: z.string().startsWith("/"),headers: replayHeaderMatchersSchema.default({}),- body: z.string().max(1_000_000).nullable().default(null),+ body: z.string().nullable().default(null),}),z.strictObject({protocol: z.literal("websocket_connect"),@@ -87,7 +82,7 @@ const replayTriggerSchema = z.discriminatedUnion("protocol", [z.strictObject({protocol: z.literal("websocket_message"),path: z.string().startsWith("/"),- body: z.string().max(1_000_000).nullable().default(null),+ body: z.string().nullable().default(null),}),]);@@ -96,16 +91,16 @@ const replayActionSchema = z.discriminatedUnion("type", [type: z.literal("http_response"),status: z.number().int().min(100).max(599),headers: z.record(headerNameSchema, headerValueSchema).default({}),- body: z.string().max(1_000_000),+ body: z.string(),}),z.strictObject({type: z.literal("websocket_send"),- data: z.string().max(1_000_000),+ data: z.string(),}),z.strictObject({ type: z.literal("disconnect") }),z.strictObject({type: z.literal("delay"),- duration_ms: z.number().int().nonnegative().max(30_000),+ duration_ms: z.number().int().nonnegative(),}),]);@@ -113,7 +108,7 @@ const replayTransitionSchema = z.strictObject({id: replayIdentifierSchema,from: replayIdentifierSchema,to: replayIdentifierSchema,- priority: z.number().int().min(0).max(1_000).default(100),+ priority: z.number().int().min(0).default(100),trigger: replayTriggerSchema,guards: z.array(@@ -122,7 +117,6 @@ const replayTransitionSchema = z.strictObject({value: replayValueSourceSchema,}),)- .max(32).default([]),captures: z.array(@@ -132,10 +126,9 @@ const replayTransitionSchema = z.strictObject({sensitive: z.boolean().default(false),}),)- .max(32).default([]),- actions: z.array(replayActionSchema).min(1).max(32),- max_uses: z.number().int().min(1).max(10_000),+ actions: z.array(replayActionSchema).min(1),+ max_uses: z.number().int().min(1),});const transitionSignature = (@@ -158,19 +151,18 @@ const replayMachineBaseSchema = z.strictObject({z.strictObject({name: replayIdentifierSchema,terminal: z.boolean().default(false),- max_visits: z.number().int().min(1).max(100_000).default(100_000),+ max_visits: z.number().int().min(1).default(100_000),}),)- .min(1)- .max(256),- transitions: z.array(replayTransitionSchema).min(1).max(2_000),- max_transitions: z.number().int().min(1).max(100_000),+ .min(1),+ transitions: z.array(replayTransitionSchema).min(1),+ max_transitions: z.number().int().min(1),limits: z.strictObject({- connections: z.number().int().min(1).max(1_000).default(100),- messages: z.number().int().min(1).max(100_000).default(10_000),- bytes: z.number().int().min(1).max(10_000_000).default(1_000_000),- duration_ms: z.number().int().min(1).max(300_000).default(30_000),+ connections: z.number().int().min(1).default(100),+ messages: z.number().int().min(1).default(10_000),+ bytes: z.number().int().min(1).default(1_000_000),+ duration_ms: z.number().int().min(1).default(30_000),}).default({connections: 100,diff --git a/src/domain/replayMachineRun.test.ts b/src/domain/replayMachineRun.test.tsindex d5927cf64..5b7fb25a1 100644--- a/src/domain/replayMachineRun.test.ts+++ b/src/domain/replayMachineRun.test.ts@@ -335,7 +335,7 @@ describe("direct replay machine protocol and limits", () => {});});-describe("direct replay machine output bounds", () => {+describe("direct replay machine large inputs", () => {it("records large repeated actions once instead of amplifying each match", () => {const largeBody = "x".repeat(1_000_000);const input = parseMachineRun(@@ -374,7 +374,7 @@ describe("direct replay machine output bounds", () => {expect(JSON.stringify(result).length).toBeLessThan(1_100_000);});- it("rejects aggregate action output above four MiB", () => {+ it("retains actions above the former four MiB aggregate cap", () => {const largeBody = "x".repeat(1_000_000);const parsed = replayMachineRunInputSchema.safeParse({machine: {@@ -395,31 +395,42 @@ describe("direct replay machine output bounds", () => {],max_transitions: 1,},- events: [],+ events: [+ {+ protocol: "websocket_connect",+ connection: "initial",+ at_ms: 0,+ method: null,+ path: "/socket",+ headers: {},+ body: "",+ },+ ],});- expect(parsed.success).toBe(false);- if (!parsed.success)- expect(parsed.error.issues).toEqual(- expect.arrayContaining([- expect.objectContaining({ path: ["machine", "transitions"] }),- ]),- );+ expect(parsed.success).toBe(true);+ if (parsed.success) {+ const result = runReplayMachine(parsed.data);+ expect(result.transition_actions[0]?.actions).toHaveLength(5);+ expect(JSON.stringify(result).length).toBeGreaterThan(5 * 1_000_000);+ }});- it("bounds action-field and sensitive-redaction work structurally", () => {+ it("accepts event counts and action fields beyond former caps", () => {const input = loginRun();- const excessiveCaptures = replayMachineRunInputSchema.safeParse({+ const largeEventRun = replayMachineRunInputSchema.safeParse({...input,- events: Array.from({ length: 1_025 }, () => input.events[0]),+ events: Array.from({ length: 10_001 }, (_, index) =>+ httpEvent("/missing", index),+ ),});- expect(excessiveCaptures.success).toBe(false);- if (!excessiveCaptures.success)- expect(excessiveCaptures.error.issues).toEqual(- expect.arrayContaining([expect.objectContaining({ path: ["events"] })]),+ expect(largeEventRun.success).toBe(true);+ if (largeEventRun.success)+ expect(runReplayMachine(largeEventRun.data).decisions).toHaveLength(+ 10_001,);- const excessiveFields = replayMachineRunInputSchema.safeParse({+ const largeHeaderTable = replayMachineRunInputSchema.safeParse({machine: {initial_state: "waiting",states: [{ name: "waiting" }, { name: "done", terminal: true }],@@ -447,14 +458,25 @@ describe("direct replay machine output bounds", () => {],max_transitions: 1,},- events: [],+ events: [+ {+ protocol: "http",+ connection: "not_applicable",+ at_ms: 0,+ method: "GET",+ path: "/done",+ headers: {},+ body: "",+ },+ ],});- expect(excessiveFields.success).toBe(false);- if (!excessiveFields.success)- expect(excessiveFields.error.issues).toEqual(- expect.arrayContaining([- expect.objectContaining({ path: ["machine", "transitions"] }),- ]),- );+ expect(largeHeaderTable.success).toBe(true);+ if (largeHeaderTable.success) {+ const result = runReplayMachine(largeHeaderTable.data);+ const action = result.transition_actions[0]?.actions[0];+ expect(action?.type).toBe("http_response");+ if (action?.type === "http_response")+ expect(Object.keys(action.headers)).toHaveLength(1_024);+ }});});diff --git a/src/domain/replayMachineRun.ts b/src/domain/replayMachineRun.tsindex c631eea4a..623fc9d40 100644--- a/src/domain/replayMachineRun.ts+++ b/src/domain/replayMachineRun.ts@@ -16,74 +16,11 @@ const refusalOutcomeSchema = z.enum(["limit_exhausted",]);-const MAX_DIRECT_REPLAY_EVENTS = 10_000;-const MAX_DIRECT_REPLAY_ACTION_BYTES = 4 * 1_024 * 1_024;-const MAX_DIRECT_REPLAY_ACTION_FIELDS = 1_024;-const MAX_DIRECT_REPLAY_SENSITIVE_CAPTURES = 1_024;--const actionFieldCount = (machine: ReplayMachine): number =>- machine.transitions.reduce(- (total, transition) =>- total +- transition.actions.reduce(- (fields, action) =>- fields +- (action.type === "http_response"- ? Object.keys(action.headers).length + 1- : action.type === "websocket_send"- ? 1- : 0),- 0,- ),- 0,- );--const maximumSensitiveCapturesPerEvent = (machine: ReplayMachine): number =>- Math.max(- 0,- ...machine.transitions.map(- ({ captures }) => captures.filter(({ sensitive }) => sensitive).length,- ),- );-/** Complete declarative input for one direct replay-machine run. */-export const replayMachineRunInputSchema = z- .strictObject({- machine: replayMachineSchema,- events: z.array(replayMachineEventSchema).max(MAX_DIRECT_REPLAY_EVENTS),- })- .superRefine(({ machine, events }, context) => {- const actionBytes = Buffer.byteLength(- JSON.stringify(- machine.transitions.map(({ id, actions }) => ({ id, actions })),- ),- );- if (actionBytes > MAX_DIRECT_REPLAY_ACTION_BYTES)- context.addIssue({- code: "custom",- path: ["machine", "transitions"],- message: "direct replay actions exceed the 4 MiB output boundary",- input: machine.transitions,- });- if (actionFieldCount(machine) > MAX_DIRECT_REPLAY_ACTION_FIELDS)- context.addIssue({- code: "custom",- path: ["machine", "transitions"],- message: "direct replay actions exceed the 1,024-field output boundary",- input: machine.transitions,- });- if (- maximumSensitiveCapturesPerEvent(machine) * events.length >- MAX_DIRECT_REPLAY_SENSITIVE_CAPTURES- )- context.addIssue({- code: "custom",- path: ["events"],- message:- "direct replay events exceed the 1,024 sensitive-capture operation boundary",- input: events,- });- });+export const replayMachineRunInputSchema = z.strictObject({+ machine: replayMachineSchema,+ events: z.array(replayMachineEventSchema),+});const replayMachineRunDecisionSchema = z.strictObject({event_sequence: z.number().int().nonnegative(),@@ -99,20 +36,19 @@ const replayRunActionSchema = z.discriminatedUnion("type", [z.string().min(1)- .max(256).regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u),- z.string().max(8_192),+ z.string(),),- body: z.string().max(1_000_000),+ body: z.string(),}),z.strictObject({type: z.literal("websocket_send"),- data: z.string().max(1_000_000),+ data: z.string(),}),z.strictObject({ type: z.literal("disconnect") }),z.strictObject({type: z.literal("delay"),- duration_ms: z.number().int().nonnegative().max(30_000),+ duration_ms: z.number().int().nonnegative(),}),]);@@ -126,14 +62,12 @@ const replayMachineRunJournalEntrySchema = z.strictObject({transition_id: replayRunIdentifierSchema,state_before: replayRunIdentifierSchema,state_after: replayRunIdentifierSchema,- captured_aliases: z- .array(- z.strictObject({- name: replayRunIdentifierSchema,- sensitive: z.boolean(),- }),- )- .max(32),+ captured_aliases: z.array(+ z.strictObject({+ name: replayRunIdentifierSchema,+ sensitive: z.boolean(),+ }),+ ),});/** Capture-value-free result of directly evaluating a finite replay machine. */@@ -141,20 +75,14 @@ export const replayMachineRunOutputSchema = z.strictObject({initial_state: replayRunIdentifierSchema,final_state: replayRunIdentifierSchema,terminal: z.boolean(),- decisions: z- .array(replayMachineRunDecisionSchema)- .max(MAX_DIRECT_REPLAY_EVENTS),- transition_journal: z- .array(replayMachineRunJournalEntrySchema)- .max(MAX_DIRECT_REPLAY_EVENTS),- transition_actions: z- .array(- z.strictObject({- transition_id: replayRunIdentifierSchema,- actions: z.array(replayRunActionSchema).max(32),- }),- )- .max(2_000),+ decisions: z.array(replayMachineRunDecisionSchema),+ transition_journal: z.array(replayMachineRunJournalEntrySchema),+ transition_actions: z.array(+ z.strictObject({+ transition_id: replayRunIdentifierSchema,+ actions: z.array(replayRunActionSchema),+ }),+ ),limits: z.strictObject({configured: z.strictObject({transitions: z.number().int().positive(),@@ -214,6 +142,9 @@ export const runReplayMachine = (const decisions: ReplayMachineRunOutput["decisions"] = [];const transitionJournal: ReplayMachineRunOutput["transition_journal"] = [];const usedTransitionIds = new Set<string>();+ const transitionById = new Map(+ input.machine.transitions.map((transition) => [transition.id, transition]),+ );for (const [eventSequence, event] of input.events.entries()) {const decision = runtime.dispatch(event);@@ -224,9 +155,7 @@ export const runReplayMachine = (});if (decision.outcome !== "matched") continue;usedTransitionIds.add(decision.transition.transition_id);- const definition = input.machine.transitions.find(- ({ id }) => id === decision.transition.transition_id,- );+ const definition = transitionById.get(decision.transition.transition_id);if (definition === undefined)throw new TypeError("Replay runtime selected an unknown transition");transitionJournal.push({diff --git a/src/domain/replayMachineRuntime.ts b/src/domain/replayMachineRuntime.tsindex 825f5259b..aa3709cc9 100644--- a/src/domain/replayMachineRuntime.ts+++ b/src/domain/replayMachineRuntime.ts@@ -1,9 +1,12 @@-import canonicalize from "canonicalize";import { z } from "zod";import type { ReplayMachine } from "./replayMachine.js";type ReplayTransition = ReplayMachine["transitions"][number];+type IndexedReplayTransition = {+ readonly transition: ReplayTransition;+ readonly declarationOrder: number;+};type ReplayValueSource = ReplayTransition["captures"][number]["value"];interface TransitionRecordOptions {readonly sequence: number;@@ -22,12 +25,8 @@ const replayEventHeadersSchema = zz.string().min(1)- .max(256).regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u),- z- .string()- .max(8_192)- .regex(/^[\t\x20-\x7e\x80-\xff]*$/u),+ z.string().regex(/^[\t\x20-\x7e\x80-\xff]*$/u),).superRefine((headers, context) => {const normalized = Object.keys(headers).map((name) => name.toLowerCase());@@ -41,9 +40,9 @@ const replayEventHeadersSchema = zconst replayEventFields = {at_ms: z.number().int().safe().nonnegative(),- path: z.string().startsWith("/").max(8_192),+ path: z.string().startsWith("/"),headers: replayEventHeadersSchema,- body: z.string().max(1_000_000),+ body: z.string(),};export const replayMachineEventSchema = z.discriminatedUnion("protocol", [@@ -53,7 +52,6 @@ export const replayMachineEventSchema = z.discriminatedUnion("protocol", [method: z.string().min(1)- .max(16).transform((method) => method.toUpperCase()),...replayEventFields,}),@@ -162,6 +160,9 @@ const actionJsonBody = (transition: ReplayTransition): string | undefined => {return undefined;};+const triggerKey = (transition: ReplayTransition): string =>+ `${transition.trigger.protocol}\0${transition.trigger.path}`;+const readValue = (source: ReplayValueSource,event: ReplayMachineEvent,@@ -207,19 +208,87 @@ const triggerMatches = (return true;};-const isJsonCompatible = (value: unknown): boolean => {- if (value === null || typeof value === "string" || typeof value === "boolean")- return true;- if (typeof value === "number") return Number.isFinite(value);- if (Array.isArray(value)) return value.every(isJsonCompatible);- if (typeof value !== "object") return false;- return Object.values(value).every(isJsonCompatible);+const replayValuesEqual = (left: unknown, right: unknown): boolean => {+ const pending: [unknown, unknown][] = [[left, right]];+ while (pending.length > 0) {+ const pair = pending.pop();+ if (pair === undefined) continue;+ const [currentLeft, currentRight] = pair;+ if (+ currentLeft === null ||+ typeof currentLeft === "string" ||+ typeof currentLeft === "boolean"+ ) {+ if (currentLeft !== currentRight) return false;+ continue;+ }+ if (typeof currentLeft === "number") {+ if (+ !Number.isFinite(currentLeft) ||+ currentLeft !== currentRight ||+ typeof currentRight !== "number" ||+ !Number.isFinite(currentRight)+ )+ return false;+ continue;+ }+ if (Array.isArray(currentLeft)) {+ if (+ !Array.isArray(currentRight) ||+ currentLeft.length !== currentRight.length+ )+ return false;+ for (let index = 0; index < currentLeft.length; index += 1)+ pending.push([currentLeft[index], currentRight[index]]);+ continue;+ }+ if (+ typeof currentLeft !== "object" ||+ currentLeft === null ||+ typeof currentRight !== "object" ||+ currentRight === null ||+ Array.isArray(currentRight)+ )+ return false;+ const leftKeys = Object.keys(currentLeft).sort();+ const rightKeys = Object.keys(currentRight).sort();+ if (+ leftKeys.length !== rightKeys.length ||+ leftKeys.some((key, index) => key !== rightKeys[index])+ )+ return false;+ for (const key of leftKeys)+ pending.push([+ Reflect.get(currentLeft, key),+ Reflect.get(currentRight, key),+ ]);+ }+ return true;};-const replayValuesEqual = (left: unknown, right: unknown): boolean =>- isJsonCompatible(left) &&- isJsonCompatible(right) &&- (Object.is(left, right) || canonicalize(left) === canonicalize(right));+const isJsonCompatible = (value: unknown): boolean => {+ const pending: unknown[] = [value];+ while (pending.length > 0) {+ const candidate = pending.pop();+ if (+ candidate === null ||+ typeof candidate === "string" ||+ typeof candidate === "boolean"+ )+ continue;+ if (typeof candidate === "number") {+ if (!Number.isFinite(candidate)) return false;+ continue;+ }+ if (Array.isArray(candidate)) {+ for (const item of candidate) pending.push(item);+ continue;+ }+ if (typeof candidate !== "object") return false;+ for (const item of Object.values(candidate)) pending.push(item);+ }+ return true;+};const createTransitionRecord = ({sequence,@@ -241,6 +310,10 @@ const createTransitionRecord = ({/** Stateful evaluator for one validated replay-machine instance. */export class ReplayMachineRuntime {+ readonly #transitionsByTrigger = new Map<+ string,+ readonly IndexedReplayTransition[]+ >();readonly #variables = new Map<string, unknown>();readonly #sensitiveValues = new Map<string, Set<string>>();readonly #uses = new Map<string, number>();@@ -256,6 +329,25 @@ export class ReplayMachineRuntime {constructor(readonly machine: ReplayMachine) {this.#state = machine.initial_state;this.#stateVisits.set(machine.initial_state, 1);+ const byTrigger = new Map<string, IndexedReplayTransition[]>();+ for (const [+ declarationOrder,+ transition,+ ] of machine.transitions.entries()) {+ const key = triggerKey(transition);+ const indexed = byTrigger.get(key) ?? [];+ indexed.push({ transition, declarationOrder });+ byTrigger.set(key, indexed);+ }+ for (const [key, indexed] of byTrigger)+ this.#transitionsByTrigger.set(+ key,+ indexed.sort(+ (left, right) =>+ left.transition.priority - right.transition.priority ||+ left.declarationOrder - right.declarationOrder,+ ),+ );}/** Current machine state after all accepted transitions. */@@ -321,19 +413,14 @@ export class ReplayMachineRuntime {};if (!this.#admitEvent(normalizedEvent))return this.#refusal("limit_exhausted");- const matching = this.machine.transitions- .map((transition, declarationOrder) => ({- transition,- declarationOrder,- }))- .filter(({ transition }) => triggerMatches(transition, normalizedEvent));- const eligible = matching- .filter(({ transition }) => transition.from === this.#state)- .sort(- (left, right) =>- left.transition.priority - right.transition.priority ||- left.declarationOrder - right.declarationOrder,- );+ const matching = (+ this.#transitionsByTrigger.get(+ `${normalizedEvent.protocol}\0${normalizedEvent.path}`,+ ) ?? []+ ).filter(({ transition }) => triggerMatches(transition, normalizedEvent));+ const eligible = matching.filter(+ ({ transition }) => transition.from === this.#state,+ );if (eligible.length === 0)return this.#refusal(matching.length === 0diff --git a/src/domain/replayMachineUncapped.test.ts b/src/domain/replayMachineUncapped.test.tsnew file mode 100644index 000000000..fc8760198--- /dev/null+++ b/src/domain/replayMachineUncapped.test.ts@@ -0,0 +1,129 @@+import { describe, expect, it } from "vitest";++import { replayMachineSchema } from "./replayMachine.js";++const websocketActions = (count: number) =>+ Array.from({ length: count }, () => ({+ type: "websocket_send" as const,+ data: "ok",+ }));++const websocketMachine = () => ({+ initial_state: "start",+ states: [+ { name: "start" },+ { name: "active", max_visits: 100_001 },+ { name: "done", terminal: true },+ ],+ transitions: [+ {+ id: "begin",+ from: "start",+ to: "active",+ trigger: { protocol: "websocket_connect", path: "/begin" },+ actions: websocketActions(1),+ max_uses: 10_001,+ },+ {+ id: "finish",+ from: "active",+ to: "done",+ trigger: { protocol: "websocket_message", path: "/finish" },+ actions: websocketActions(1),+ max_uses: 10_001,+ },+ ],+ max_transitions: 100_001,+ limits: {+ connections: 1_001,+ messages: 100_001,+ bytes: 10_000_001,+ duration_ms: 300_001,+ },+});++describe("finite replay machine schema input size", () => {+ it("accepts states, transitions, guards, captures, actions, and paths beyond old caps", () => {+ const states: { name: string; terminal?: boolean }[] = Array.from(+ { length: 257 },+ (_, index) => ({+ name: `state-${index}`,+ }),+ );+ states.push({ name: "complete", terminal: true });+ const transitions = Array.from({ length: 257 }, (_, index) => ({+ id: `chain-${index}`,+ from: `state-${index}`,+ to: index === 256 ? "complete" : `state-${index + 1}`,+ trigger: { protocol: "http", method: "GET", path: `/chain-${index}` },+ actions: [{ type: "http_response", status: 200, body: "" }],+ max_uses: 10_001,+ }));+ transitions.push(+ ...Array.from({ length: 1_745 }, (_, index) => ({+ id: `loop-${index}`,+ from: "state-0",+ to: "state-0",+ trigger: { protocol: "http", method: "GET", path: `/loop-${index}` },+ actions: [{ type: "http_response", status: 200, body: "" }],+ max_uses: 10_001,+ })),+ );++ const parsed = replayMachineSchema.safeParse({+ initial_state: "state-0",+ states,+ transitions,+ max_transitions: 100_001,+ limits: {+ connections: 1_001,+ messages: 100_001,+ bytes: 10_000_001,+ duration_ms: 300_001,+ },+ });++ expect(parsed.success).toBe(true);+ if (parsed.success) {+ expect(parsed.data.states).toHaveLength(258);+ expect(parsed.data.transitions).toHaveLength(2_002);+ }+ });++ it("accepts over 32 guards, captures, actions, and path segments", () => {+ const path = Array.from({ length: 33 }, (_, index) => `key-${index}`);+ const input = websocketMachine();+ const machine = {+ ...input,+ transitions: [+ {+ id: "capture",+ from: "start",+ to: "active",+ trigger: { protocol: "websocket_connect", path: "/begin" },+ captures: Array.from({ length: 33 }, () => ({+ variable: "value",+ value: { source: "request_json", path },+ sensitive: false,+ })),+ actions: websocketActions(33),+ max_uses: 10_001,+ },+ {+ id: "guarded-finish",+ from: "active",+ to: "done",+ trigger: { protocol: "websocket_message", path: "/finish" },+ guards: Array.from({ length: 33 }, () => ({+ variable: "value",+ value: { source: "request_json", path },+ })),+ actions: websocketActions(33),+ max_uses: 10_001,+ },+ ],+ };++ expect(replayMachineSchema.safeParse(machine).success).toBe(true);+ });+});diff --git a/tests/boundary/providers/replay/javascriptReplay.test.ts b/tests/boundary/providers/replay/javascriptReplay.test.tsindex 7a9ee359a..9580cb46d 100644--- a/tests/boundary/providers/replay/javascriptReplay.test.ts+++ b/tests/boundary/providers/replay/javascriptReplay.test.ts@@ -185,26 +185,12 @@ describe("controlled JavaScript replay planning", () => {).toBe(true);});- it("rejects relative paths and more than 128 combined cases", () => {+ it("rejects relative module paths", () => {expect(controlledReplayInputSchema.safeParse({...input("plan", "relative/parser.mjs"),}).success,).toBe(false);- expect(- controlledReplayInputSchema.safeParse({- ...input("plan"),- cases: Array.from({ length: 65 }, (_, index) => ({- case_id: `explicit-${String(index)}`,- arguments: [],- })),- generator: {- preset: "parser-boundaries",- seed: 1,- count: 64,- },- }).success,- ).toBe(false);});it("rejects oversized aggregate cases before probing or reading", async () => {