rea-agents 3.1.0 → 3.2.0

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

package/dist/domain/replayMachineRuntime.js

@@ -1,15 +1,11 @@
-import canonicalize from "canonicalize";
 import { z } from "zod";
+import { isJsonCompatible, replayValuesEqual } from "./replayMachineValues.js";
 /** One bounded inbound protocol event offered to a replay machine. */
 const replayEventHeadersSchema = z
     .record(z
     .string()
     .min(1)
-    .max(256)
-    .regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u), z
-    .string()
-    .max(8_192)
-    .regex(/^[\t\x20-\x7e\x80-\xff]*$/u))
+    .regex(/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/u), z.string().regex(/^[\t\x20-\x7e\x80-\xff]*$/u))
     .superRefine((headers, context) => {
     const normalized = Object.keys(headers).map((name) => name.toLowerCase());
     if (new Set(normalized).size !== normalized.length)
@@ -21,9 +17,9 @@ const replayEventHeadersSchema = z
 });
 const 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", [
     z.strictObject({
@@ -32,7 +28,6 @@ export const replayMachineEventSchema = z.discriminatedUnion("protocol", [
         method: z
             .string()
             .min(1)
-            .max(16)
             .transform((method) => method.toUpperCase()),
         ...replayEventFields,
     }),
@@ -84,6 +79,7 @@ const actionJsonBody = (transition) => {
             return action.data;
     return undefined;
 };
+const triggerKey = (transition) => `${transition.trigger.protocol}\0${transition.trigger.path}`;
 const readValue = (source, event, transition) => {
     switch (source.source) {
         case "request_header":
@@ -114,20 +110,6 @@ const triggerMatches = (transition, event) => {
         return trigger.body === null || trigger.body === event.body;
     return true;
 };
-const isJsonCompatible = (value) => {
-    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, right) => isJsonCompatible(left) &&
-    isJsonCompatible(right) &&
-    (Object.is(left, right) || canonicalize(left) === canonicalize(right));
 const createTransitionRecord = ({ sequence, atMs, stateBefore, transition, captures, }) => ({
     sequence,
     at_ms: atMs,
@@ -142,6 +124,7 @@ const createTransitionRecord = ({ sequence, atMs, stateBefore, transition, captu
 /** Stateful evaluator for one validated replay-machine instance. */
 export class ReplayMachineRuntime {
     machine;
+    #transitionsByTrigger = new Map();
     #variables = new Map();
     #sensitiveValues = new Map();
     #uses = new Map();
@@ -157,6 +140,16 @@ export class ReplayMachineRuntime {
         this.machine = machine;
         this.#state = machine.initial_state;
         this.#stateVisits.set(machine.initial_state, 1);
+        const byTrigger = new Map();
+        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. */
     get state() {
@@ -207,25 +200,11 @@ 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.#matchingTransitions(normalizedEvent);
+        const eligible = matching.filter(({ transition }) => this.#transitionStartsHere(transition));
         if (eligible.length === 0)
-            return this.#refusal(matching.length === 0
-                ? "unmatched"
-                : normalizedEvent.protocol === "websocket_connect" &&
-                    normalizedEvent.connection === "reconnect"
-                    ? "unexpected_reconnect"
-                    : "invalid_state");
-        const guarded = eligible.filter(({ transition }) => transition.guards.every((guard) => this.#variables.has(guard.variable) &&
-            replayValuesEqual(this.#variables.get(guard.variable), readValue(guard.value, normalizedEvent, transition))));
+            return this.#refusal(this.#noEligibleReason(matching, normalizedEvent));
+        const guarded = eligible.filter(({ transition }) => this.#transitionGuardsMatch(transition, normalizedEvent));
         if (guarded.length === 0)
             return this.#refusal("guard_failed");
         if (this.#timeline.length >= this.machine.max_transitions)
@@ -272,6 +251,27 @@ export class ReplayMachineRuntime {
             transition: record,
         };
     }
+    #matchingTransitions(event) {
+        return (this.#transitionsByTrigger.get(`${event.protocol}\0${event.path}`) ?? []).filter(({ transition }) => triggerMatches(transition, event));
+    }
+    #transitionStartsHere(transition) {
+        return transition.from === this.#state;
+    }
+    #noEligibleReason(matching, event) {
+        if (matching.length === 0)
+            return "unmatched";
+        return event.protocol === "websocket_connect" &&
+            event.connection === "reconnect"
+            ? "unexpected_reconnect"
+            : "invalid_state";
+    }
+    #transitionGuardsMatch(transition, event) {
+        return transition.guards.every((guard) => {
+            if (!this.#variables.has(guard.variable))
+                return false;
+            return replayValuesEqual(this.#variables.get(guard.variable), readValue(guard.value, event, transition));
+        });
+    }
     #admitEvent(event) {
         const connections = this.#connections + (event.protocol === "websocket_connect" ? 1 : 0);
         const messages = this.#messages + (event.protocol === "websocket_message" ? 1 : 0);