rea-agents 3.0.0 → 3.2.0

package/dist/domain/reconstructionVerificationSchemas.js

@@ -2,8 +2,8 @@ import { z } from "zod";
 const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
 const unknownIdSchema = z.string().regex(/^unk_[a-f0-9]{64}$/u);
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]{0,99}$/u);
-const titleSchema = z.string().trim().min(1).max(500);
+const claimIdSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9._-]*$/u);
+const titleSchema = z.string().trim().min(1);
 const verificationStatusSchema = z.enum(["pass", "fail", "unknown"]);
 const commonClaim = {
     claim_id: claimIdSchema,
@@ -52,9 +52,8 @@ const reconstructionClaimSchema = z.discriminatedUnion("kind", [
 /** Finite, typed behavioral and structural specification. */
 export const reconstructionSpecificationSchema = z
     .object({
-    schema_version: z.literal(1),
-    name: z.string().trim().min(1).max(200),
-    claims: z.array(reconstructionClaimSchema).min(1).max(100),
+    name: z.string().trim().min(1),
+    claims: z.array(reconstructionClaimSchema).min(1),
 })
     .superRefine((value, context) => {
     const ids = value.claims.map(({ claim_id: id }) => id);
@@ -67,20 +66,9 @@ export const reconstructionSpecificationSchema = z
             message: "Claim comparison selectors must be unique",
         });
 });
-/** Bounded reconstruction-verification input. */
+/** Reconstruction-verification input. */
 export const reconstructionVerificationInputSchema = z.strictObject({
     specification: reconstructionSpecificationSchema,
-    coverage: z
-        .strictObject({
-        workspace_id: z.string().regex(/^rcw_[a-f0-9]{64}$/u),
-        revision: z.number().int().min(1),
-        revision_sha256: digestSchema,
-        boundary_id: z.string().min(1).max(200),
-    })
-        .optional(),
-    offset: z.number().int().min(0).default(0),
-    limit: z.number().int().min(1).max(100).default(100),
-    unknown_registry_approved: z.literal(true).optional(),
 });
 export const reconstructionClaimResultSchema = z.object({
     claim_id: claimIdSchema,
@@ -97,18 +85,19 @@ export const reconstructionClaimResultSchema = z.object({
         "contradiction",
     ]),
     comparison_evidence_id: evidenceIdSchema,
-    left_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    right_evidence_ids: z.array(evidenceIdSchema).min(1).max(100),
-    evidence_links: z.array(evidenceIdSchema).min(3).max(201),
-    unknown_ids: z.array(unknownIdSchema).max(100),
+    left_evidence_ids: z.array(evidenceIdSchema).min(1),
+    right_evidence_ids: z.array(evidenceIdSchema).min(1),
+    evidence_links: z.array(evidenceIdSchema).min(3),
+    unknown_ids: z.array(unknownIdSchema),
     limitations: z.array(z.string()),
 });
-/** Evidence-cited result over every declared claim, independently paged. */
-export const reconstructionVerificationResultSchema = z.object({
+/** Evidence-cited result over every declared claim. */
+export const reconstructionVerificationResultSchema = z
+    .object({
     status: verificationStatusSchema,
     specification_sha256: digestSchema,
     summary: z.object({
-        total: z.number().int().min(1).max(100),
+        total: z.number().int().min(1),
         passed: z.number().int().min(0),
         failed: z.number().int().min(0),
         unknown: z.number().int().min(0),
@@ -116,20 +105,43 @@ export const reconstructionVerificationResultSchema = z.object({
         structural: z.number().int().min(0),
     }),
     claims: z.object({
-        items: z.array(reconstructionClaimResultSchema).max(100),
-        offset: z.number().int().min(0),
-        limit: z.number().int().min(1).max(100),
-        total: z.number().int().min(1).max(100),
-        next_offset: z.number().int().min(0).nullable(),
+        items: z.array(reconstructionClaimResultSchema),
     }),
-    recommended_probes: z
-        .array(z.object({
-        operation: z.string().min(1).max(200),
-        rationale: z.string().min(1).max(1_000),
-        claim_ids: z.array(claimIdSchema).min(1).max(100),
-        unknown_ids: z.array(unknownIdSchema).max(100),
-    }))
-        .max(2_000),
-    evidence_links: z.array(evidenceIdSchema).min(3).max(20_100),
+    recommended_probes: z.array(z.object({
+        operation: z.string().min(1),
+        rationale: z.string().min(1),
+        claim_ids: z.array(claimIdSchema).min(1),
+        unknown_ids: z.array(unknownIdSchema),
+    })),
+    evidence_links: z.array(evidenceIdSchema).min(3),
     limitations: z.array(z.string()),
+})
+    .superRefine((result, context) => {
+    const { summary } = result;
+    const expectedStatus = summary.failed > 0 ? "fail" : summary.unknown > 0 ? "unknown" : "pass";
+    const issues = [
+        [
+            summary.total !== summary.passed + summary.failed + summary.unknown,
+            "Claim status counts must equal the summary total",
+            ["summary", "total"],
+        ],
+        [
+            summary.total !== summary.behavioral + summary.structural,
+            "Claim kind counts must equal the summary total",
+            ["summary", "total"],
+        ],
+        [
+            result.claims.items.length !== summary.total,
+            "Retained claims must equal the summary total",
+            ["claims", "items"],
+        ],
+        [
+            result.status !== expectedStatus,
+            "Verification status must summarize claim statuses",
+            ["status"],
+        ],
+    ];
+    for (const [invalid, message, path] of issues)
+        if (invalid)
+            context.addIssue({ code: "custom", message, path: [...path] });
 });

package/dist/domain/referenceSourceGraph.js

@@ -2,13 +2,12 @@ import { createHash } from "node:crypto";
 import { posix } from "node:path";
 import canonicalize from "canonicalize";
 import { z } from "zod";
-const MAX_PATH = 4_096;
+import { compareUnicodeCodePoints } from "./unicodeCodePointOrder.js";
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const boundedTextSchema = z.string().min(1).max(1_024);
+const boundedTextSchema = z.string().min(1);
 const relativePathSchema = z
     .string()
     .min(1)
-    .max(MAX_PATH)
     .refine((path) => !path.startsWith("/") &&
     !path.includes("\\") &&
     path
@@ -26,40 +25,33 @@ const classificationSchema = z.enum([
 ]);
 const entryBaseShape = {
     path: relativePathSchema,
-    classifications: z.array(classificationSchema).min(1).max(8),
-    limitations: z.array(boundedTextSchema).max(100),
+    classifications: z.array(classificationSchema).min(1),
+    limitations: z.array(boundedTextSchema),
 };
-const sourceFileSchema = z
-    .strictObject({
+const sourceFileBaseShape = {
     ...entryBaseShape,
     kind: z.literal("file"),
-    sha256: digestSchema.nullable(),
-    size: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER).nullable(),
-    language: z.string().min(1).max(100).nullable(),
-    content_state: z.enum([
-        "hashed",
-        "redacted-secret",
-        "excluded",
-        "unreadable",
-        "too-large",
-        "unknown",
-    ]),
-})
-    .superRefine((file, context) => {
-    checkSortedUnique(file.classifications, "classifications", context);
-    if ((file.content_state === "hashed") !== (file.sha256 !== null))
-        context.addIssue({
-            code: "custom",
-            message: "Only hashed files have a content digest",
-            path: ["sha256"],
-        });
-    if (file.content_state === "hashed" && file.size === null)
-        context.addIssue({
-            code: "custom",
-            message: "Hashed files require a byte size",
-            path: ["size"],
-        });
-});
+    language: z.string().min(1).nullable(),
+};
+const sourceFileSchema = z.union([
+    z.strictObject({
+        ...sourceFileBaseShape,
+        sha256: digestSchema,
+        size: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+        content_state: z.literal("hashed"),
+    }),
+    z.strictObject({
+        ...sourceFileBaseShape,
+        sha256: z.null(),
+        size: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER).nullable(),
+        content_state: z.enum([
+            "redacted-secret",
+            "excluded",
+            "unreadable",
+            "unknown",
+        ]),
+    }),
+]);
 const sourceDirectorySchema = z.strictObject({
     ...entryBaseShape,
     kind: z.literal("directory"),
@@ -74,7 +66,6 @@ const sourceDirectorySchema = z.strictObject({
 const symlinkTargetSchema = z
     .string()
     .min(1)
-    .max(MAX_PATH)
     .refine((target) => target === "<outside-root>" ||
     (!target.startsWith("/") &&
         !target.includes("\\") &&
@@ -91,21 +82,21 @@ const sourceSymlinkSchema = z.strictObject({
         "unknown",
     ]),
 });
-const sourceEntrySchema = z.discriminatedUnion("kind", [
+const sourceEntrySchema = z.union([
     sourceFileSchema,
     sourceDirectorySchema,
     sourceSymlinkSchema,
 ]);
 const sourceRelationshipSchema = z.strictObject({
     from_path: relativePathSchema,
-    to: z.string().min(1).max(MAX_PATH),
+    to: z.string().min(1),
     kind: z.enum(["imports", "requires", "references", "declares-module"]),
     resolution: z.enum(["internal", "external", "unresolved", "unknown"]),
     parse_state: z.enum(["parsed", "partial", "unknown"]),
 });
 const parseFailureSchema = z.strictObject({
     path: relativePathSchema,
-    parser: z.string().min(1).max(100),
+    parser: z.string().min(1),
     reason: boundedTextSchema,
 });
 const exclusionSchema = z.strictObject({
@@ -139,28 +130,27 @@ const vcsSchema = z
 ])
     .nullable();
 const graphShape = {
-    schema: z.literal("HistoricalSourceGraph/v1"),
+    schema: z.literal("HistoricalSourceGraph"),
     authority: z.literal("historical-reference"),
     root_alias: z.literal("$REFERENCE_ROOT"),
     root_sha256: digestSchema,
     inventory_state: z.enum(["complete", "partial", "unknown"]),
-    entries: z.array(sourceEntrySchema).max(100_000),
-    relationships: z.array(sourceRelationshipSchema).max(200_000),
-    parse_failures: z.array(parseFailureSchema).max(10_000),
-    exclusions: z.array(exclusionSchema).max(100_000),
-    languages: z.array(z.string().min(1).max(100)).max(1_000),
-    manifests: z.array(relativePathSchema).max(10_000),
+    entries: z.array(sourceEntrySchema),
+    relationships: z.array(sourceRelationshipSchema),
+    parse_failures: z.array(parseFailureSchema),
+    exclusions: z.array(exclusionSchema),
+    languages: z.array(z.string().min(1)),
+    manifests: z.array(relativePathSchema),
     vcs: vcsSchema,
     provenance: z.strictObject({
-        importer: z.string().min(1).max(100),
-        importer_version: z.string().min(1).max(100).nullable(),
+        importer: z.string().min(1),
+        importer_version: z.string().min(1).nullable(),
         caller: z
             .string()
             .min(1)
-            .max(200)
             .regex(/^[\w .:@/+-]+$/u),
     }),
-    limitations: z.array(boundedTextSchema).max(1_000),
+    limitations: z.array(boundedTextSchema),
 };
 const historicalSourceGraphStructureSchema = z
     .strictObject(graphShape)
@@ -178,14 +168,14 @@ const historicalSourceGraphInputSchema = z.strictObject({
     root_sha256: z.never().optional(),
 });
 const historicalSourceManifestBaseSchema = z.strictObject({
-    schema: z.literal("HistoricalSourceManifest/v1"),
+    schema: z.literal("HistoricalSourceManifest"),
     authority: z.literal("historical-reference"),
     manifest_id: z.string().regex(/^hsm_[a-f0-9]{64}$/u),
     graph_sha256: digestSchema,
     root_sha256: digestSchema,
     inventory_state: z.enum(["complete", "partial", "unknown"]),
-    entry_count: z.number().int().min(0).max(100_000),
-    relationship_count: z.number().int().min(0).max(200_000),
+    entry_count: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    relationship_count: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
 });
 /** Stable identity used to sort and deduplicate source parse failures. */
 export const historicalSourceParseFailureKey = (failure) => `${failure.path}\u0000${failure.parser}\u0000${failure.reason}`;
@@ -197,10 +187,10 @@ const canonicalJson = (value) => {
 };
 const digestCanonical = (value) => createHash("sha256").update(canonicalJson(value)).digest("hex");
 const relationshipKey = (relationship) => `${relationship.from_path}\u0000${relationship.to}\u0000${relationship.kind}\u0000${relationship.resolution}\u0000${relationship.parse_state}`;
-const compareCodePoints = (left, right) => left < right ? -1 : left > right ? 1 : 0;
 const checkSortedUnique = (values, field, context) => {
     for (let index = 1; index < values.length; index += 1)
-        if (compareCodePoints(values[index - 1] ?? "", values[index] ?? "") >= 0) {
+        if (compareUnicodeCodePoints(values[index - 1] ?? "", values[index] ?? "") >=
+            0) {
             context.addIssue({
                 code: "custom",
                 message: `${field} must be sorted and unique by Unicode code point`,
@@ -209,16 +199,18 @@ const checkSortedUnique = (values, field, context) => {
             return;
         }
 };
-const expectedLanguages = (entries) => [
+/** Derive the canonical language index from inventoried source files. */
+export const historicalSourceLanguages = (entries) => [
     ...new Set(entries.flatMap((entry) => entry.kind === "file" && entry.language !== null
         ? [entry.language]
         : [])),
-].sort(compareCodePoints);
-const expectedManifests = (entries) => entries
+].sort(compareUnicodeCodePoints);
+/** Derive the canonical manifest path index from inventoried source files. */
+export const historicalSourceManifests = (entries) => entries
     .flatMap((entry) => entry.kind === "file" && entry.classifications.includes("manifest")
     ? [entry.path]
     : [])
-    .sort(compareCodePoints);
+    .sort(compareUnicodeCodePoints);
 const checkRelationships = (graph, paths, context) => {
     const files = new Set(graph.entries.flatMap((entry) => entry.kind === "file" ? [entry.path] : []));
     for (const [index, relationship] of graph.relationships.entries()) {
@@ -292,14 +284,14 @@ function checkGraphInvariants(graph, context) {
     checkSortedUnique(graph.parse_failures.map(historicalSourceParseFailureKey), "parse_failures", context);
     checkSortedUnique(graph.exclusions.map(({ path, reason }) => `${path}\u0000${reason}`), "exclusions", context);
     if (canonicalJson(graph.languages) !==
-        canonicalJson(expectedLanguages(graph.entries)))
+        canonicalJson(historicalSourceLanguages(graph.entries)))
         context.addIssue({
             code: "custom",
             message: "languages must be derived from file entries",
             path: ["languages"],
         });
     if (canonicalJson(graph.manifests) !==
-        canonicalJson(expectedManifests(graph.entries)))
+        canonicalJson(historicalSourceManifests(graph.entries)))
         context.addIssue({
             code: "custom",
             message: "manifests must be derived from classified file entries",
@@ -355,7 +347,7 @@ export const computeHistoricalSourceGraphSha256 = (input) => digestCanonical(par
 export const createHistoricalSourceManifest = (input) => {
     const graph = parseHistoricalSourceGraph(input);
     const semantic = {
-        schema: "HistoricalSourceManifest/v1",
+        schema: "HistoricalSourceManifest",
         authority: "historical-reference",
         graph_sha256: computeHistoricalSourceGraphSha256(graph),
         root_sha256: graph.root_sha256,

package/dist/domain/referenceSourceImportParsing.js

@@ -1,10 +1,6 @@
 import { parse } from "@babel/parser";
 import { isCallExpression, isExportAllDeclaration, isExportNamedDeclaration, isIdentifier, isImport, isImportDeclaration, isMemberExpression, isNode, isStringLiteral, isTSExternalModuleReference, isTSImportEqualsDeclaration, isTSModuleDeclaration, } from "@babel/types";
-const MAX_REASON_LENGTH = 1_024;
 const codeSourceLanguages = new Set(["JavaScript", "TypeScript", "JSX", "TSX"]);
-const truncateReason = (reason) => reason.length > MAX_REASON_LENGTH
-    ? `${reason.slice(0, MAX_REASON_LENGTH - 3)}...`
-    : reason;
 const safeModuleName = (node) => {
     if (isStringLiteral(node))
         return node.value;
@@ -199,11 +195,11 @@ const parseWithBabel = (path, source, language) => {
         });
         return { ast, parseState: "parsed" };
     }
-    catch (error) {
+    catch (cause) {
         return {
             ast: undefined,
             parseState: "unknown",
-            reason: error instanceof Error ? error.message : "Parse failed",
+            reason: cause instanceof Error ? cause.message : "Parse failed",
         };
     }
 };
@@ -220,7 +216,7 @@ export const parseReferenceSourceImports = (path, bytes, language) => {
                 {
                     path,
                     parser: "babel",
-                    reason: truncateReason(reason ?? "Unknown parse failure"),
+                    reason: reason ?? "Unknown parse failure",
                 },
             ],
         };

package/dist/domain/replayMachine.js

@@ -2,12 +2,8 @@ import { MultiDirectedGraph } from "graphology";
 import { singleSource } from "graphology-shortest-path";
 import canonicalize from "canonicalize";
 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 replayIdentifierSchema = z.string().regex(/^[A-Za-z][A-Za-z0-9_-]*$/u);
+const replayPathSchema = z.array(z.union([z.string(), z.number().int().nonnegative()]));
 const sensitiveHeaderNames = new Set([
     "authorization",
     "cookie",
@@ -17,12 +13,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) => {
@@ -65,11 +57,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"),
@@ -79,7 +70,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),
     }),
 ]);
 const replayActionSchema = z.discriminatedUnion("type", [
@@ -87,30 +78,29 @@ 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().safe().nonnegative(),
     }),
 ]);
 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(z.strictObject({
         variable: replayIdentifierSchema,
         value: replayValueSourceSchema,
     }))
-        .max(32)
         .default([]),
     captures: z
         .array(z.strictObject({
@@ -118,10 +108,9 @@ const replayTransitionSchema = z.strictObject({
         value: replayValueSourceSchema,
         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 = (transition) => {
     const signature = canonicalize({
@@ -139,18 +128,17 @@ const replayMachineBaseSchema = z.strictObject({
         .array(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,

package/dist/domain/replayMachineRun.js

@@ -10,48 +10,10 @@ const refusalOutcomeSchema = z.enum([
     "unexpected_reconnect",
     "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) => 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) => 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({
+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,
-        });
+    events: z.array(replayMachineEventSchema),
 });
 const replayMachineRunDecisionSchema = z.strictObject({
     event_sequence: z.number().int().nonnegative(),
@@ -65,18 +27,17 @@ const replayRunActionSchema = z.discriminatedUnion("type", [
         headers: z.record(z
             .string()
             .min(1)
-            .max(256)
-            .regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u), z.string().max(8_192)),
-        body: z.string().max(1_000_000),
+            .regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u), z.string()),
+        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(),
     }),
 ]);
 const replayRunIdentifierSchema = z
@@ -88,31 +49,22 @@ const replayMachineRunJournalEntrySchema = z.strictObject({
     transition_id: replayRunIdentifierSchema,
     state_before: replayRunIdentifierSchema,
     state_after: replayRunIdentifierSchema,
-    captured_aliases: z
-        .array(z.strictObject({
+    captured_aliases: z.array(z.strictObject({
         name: replayRunIdentifierSchema,
         sensitive: z.boolean(),
-    }))
-        .max(32),
+    })),
 });
 /** Capture-value-free result of directly evaluating a finite replay machine. */
 export const replayMachineRunOutputSchema = z.strictObject({
-    schema_version: z.literal(1),
     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({
+    decisions: z.array(replayMachineRunDecisionSchema),
+    transition_journal: z.array(replayMachineRunJournalEntrySchema),
+    transition_actions: z.array(z.strictObject({
         transition_id: replayRunIdentifierSchema,
-        actions: z.array(replayRunActionSchema).max(32),
-    }))
-        .max(2_000),
+        actions: z.array(replayRunActionSchema),
+    })),
     limits: z.strictObject({
         configured: z.strictObject({
             transitions: z.number().int().positive(),
@@ -156,6 +108,7 @@ export const runReplayMachine = (input) => {
     const decisions = [];
     const transitionJournal = [];
     const usedTransitionIds = new Set();
+    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);
         decisions.push({
@@ -166,7 +119,7 @@ export const runReplayMachine = (input) => {
         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({
@@ -189,7 +142,6 @@ export const runReplayMachine = (input) => {
         actions: actions.map((action) => redactAction(runtime, action)),
     }));
     return replayMachineRunOutputSchema.parse({
-        schema_version: 1,
         initial_state: input.machine.initial_state,
         final_state: runtime.state,
         terminal: input.machine.states.find(({ name }) => name === runtime.state)