@dreamboard-games/sdk 0.5.0-alpha.2 → 0.5.0-alpha.3

package/dist/testing.js

@@ -1,52 +1,1913 @@
 import {
-  ScenarioAssertionError,
-  ScenarioDefinitionValidationError,
-  ScenarioReplayError,
-  advanceScenarioReplay,
-  assertScenario,
-  compareCanonicalScenarioJson,
-  createExpectApi,
-  createScenarioAuthoring,
-  digestScenarioJson,
-  enumerateScenarioInteractionParams,
-  inspectScenarioReplayAuthority,
-  probeScenarioCommand,
-  projectScenarioCommandParams,
-  replayScenario,
-  resolveScenarioCheckpoint,
-  toScenarioReplayDefinition
-} from "./chunk-BI4G3PM2.js";
-import {
-  StaleContractArtifactError,
-  isStaleContractArtifactError
-} from "./chunk-S2JEDVWH.js";
+  SourceSnapshotSchema,
+  computePluginActionSetVersion,
+  createSourceLifecycle,
+  materializePluginGameplayFrame
+} from "./chunk-ZPRKWPEP.js";
 import {
-  PluginRuntimeBoundary,
-  createPluginRuntimeClient
-} from "./chunk-3BAD4VC2.js";
-import "./chunk-PN5O6GG2.js";
-import "./chunk-GDPKTBUR.js";
+  immutableCopy
+} from "./chunk-DMFVAZI2.js";
 import {
-  BROWSER_INTERACTION_ACTUATOR_KINDS,
-  DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
-  browserInteractionEffectSchema
-} from "./chunk-WHR5UW3F.js";
+  assertReducerBundleContract,
+  collectReducerDefinitionIndex,
+  createClientParamSchemasByPhase,
+  createIngressRuntimeCodec,
+  createInteractionResolver,
+  createProjectionBuilder,
+  createReducerBundle,
+  createTrustedRuntimeScope,
+  manifestSchemaFamily,
+  nextRandomInt
+} from "./chunk-LRILEVKC.js";
 import {
-  DREAMBOARD_PLUGIN_PROTOCOL,
-  DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
-  PluginProtocolFrameSchema,
-  PluginProtocolStepSchema,
-  PluginProtocolTapeSchema,
-  computePluginActionSetVersion,
+  GameOutcomeSchema,
+  ReducerSessionStateSchema,
   digestPluginRuntimeJson,
-  materializePluginGameplayFrame
-} from "./chunk-VCDWP5VL.js";
-import "./chunk-H6VDGFL5.js";
-import {
-  RuntimeJsonSchema
-} from "./chunk-PF7L4BMG.js";
-import "./chunk-UGH54WZ2.js";
-import "./chunk-PZ5AY32C.js";
+  encodeCanonicalPluginRuntimeJson
+} from "./chunk-FMM5LVJW.js";
+import "./chunk-VUWNJXLJ.js";
+
+// src/testing/scenario-definition-validation.ts
+import { z as z2 } from "zod";
+
+// src/testing/scenario-schema.ts
+import { z } from "zod";
+var ScenarioSchemaValueError = class extends Error {
+  path;
+  constructor(path, message) {
+    super(message);
+    this.name = "ScenarioSchemaValueError";
+    this.path = path;
+  }
+};
+function appendScenarioPath(path, key) {
+  if (typeof key === "number") {
+    return `${path}[${key}]`;
+  }
+  if (typeof key === "symbol") {
+    return `${path}[${String(key)}]`;
+  }
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function resolvePlayerSeatReference(options) {
+  if (!isPlainObject(options.value)) {
+    throw new ScenarioSchemaValueError(
+      options.path,
+      "expected a seat reference shaped as { seat: number }"
+    );
+  }
+  const keys = Object.keys(options.value);
+  if (keys.length !== 1 || keys[0] !== "seat") {
+    throw new ScenarioSchemaValueError(
+      options.path,
+      "expected a seat reference with only the 'seat' field"
+    );
+  }
+  const seat = options.value.seat;
+  const seatPath = appendScenarioPath(options.path, "seat");
+  if (typeof seat !== "number" || !Number.isSafeInteger(seat)) {
+    throw new ScenarioSchemaValueError(
+      seatPath,
+      "expected a finite safe integer"
+    );
+  }
+  if (seat < 0 || seat >= options.playerIds.length) {
+    throw new ScenarioSchemaValueError(
+      seatPath,
+      `expected a seat from 0 through ${Math.max(0, options.playerIds.length - 1)}`
+    );
+  }
+  const playerId = options.playerIds[seat];
+  if (playerId === void 0) {
+    throw new ScenarioSchemaValueError(
+      seatPath,
+      `could not resolve seat ${seat}`
+    );
+  }
+  return playerId;
+}
+function projectPlayerSeatReference(options) {
+  if (typeof options.value !== "string") {
+    throw new ScenarioSchemaValueError(
+      options.path,
+      "expected a runtime player id string"
+    );
+  }
+  const seat = options.playerIds.indexOf(options.value);
+  if (seat < 0) {
+    throw new ScenarioSchemaValueError(
+      options.path,
+      `runtime player id '${options.value}' is not assigned to a scenario seat`
+    );
+  }
+  return { seat };
+}
+function tupleDefinition(schema) {
+  return schema._zod.def;
+}
+function intersectionDefinition(schema) {
+  return schema._zod.def;
+}
+function asClassicSchema(schema) {
+  return schema;
+}
+function resolveScenarioSeatReferences(options) {
+  return transformScenarioSchemaValue({ ...options, direction: "resolve" });
+}
+function projectScenarioSeatReferences(options) {
+  return transformScenarioSchemaValue({ ...options, direction: "project" });
+}
+function transformScenarioSchemaValue(options) {
+  const { schema, value, playerIds, path } = options;
+  if (manifestSchemaFamily(schema) === "playerId") {
+    return options.direction === "resolve" ? resolvePlayerSeatReference({ value, playerIds, path }) : projectPlayerSeatReference({ value, playerIds, path });
+  }
+  if (schema instanceof z.ZodOptional || schema instanceof z.ZodExactOptional) {
+    return value === void 0 ? value : transformScenarioSchemaValue({
+      schema: asClassicSchema(schema.unwrap()),
+      value,
+      playerIds,
+      path,
+      direction: options.direction
+    });
+  }
+  if (schema instanceof z.ZodNullable) {
+    return value === null ? value : transformScenarioSchemaValue({
+      schema: asClassicSchema(schema.unwrap()),
+      value,
+      playerIds,
+      path,
+      direction: options.direction
+    });
+  }
+  if (schema instanceof z.ZodDefault || schema instanceof z.ZodPrefault || schema instanceof z.ZodCatch || schema instanceof z.ZodReadonly || schema instanceof z.ZodNonOptional) {
+    return transformScenarioSchemaValue({
+      schema: asClassicSchema(schema.unwrap()),
+      value,
+      playerIds,
+      path,
+      direction: options.direction
+    });
+  }
+  if (schema instanceof z.ZodArray) {
+    if (!Array.isArray(value)) return value;
+    return value.map(
+      (item, index) => transformScenarioSchemaValue({
+        schema: asClassicSchema(schema.element),
+        value: item,
+        playerIds,
+        path: appendScenarioPath(path, index),
+        direction: options.direction
+      })
+    );
+  }
+  if (schema instanceof z.ZodTuple) {
+    if (!Array.isArray(value)) return value;
+    const definition = tupleDefinition(schema);
+    const items = definition.items ?? [];
+    return value.map((item, index) => {
+      const itemSchema = items[index] ?? definition.rest;
+      return itemSchema ? transformScenarioSchemaValue({
+        schema: asClassicSchema(itemSchema),
+        value: item,
+        playerIds,
+        path: appendScenarioPath(path, index),
+        direction: options.direction
+      }) : item;
+    });
+  }
+  if (schema instanceof z.ZodObject) {
+    if (!isPlainObject(value)) return value;
+    const output = { ...value };
+    for (const [key, childSchema] of Object.entries(schema.shape)) {
+      if (!Object.prototype.hasOwnProperty.call(value, key)) continue;
+      output[key] = transformScenarioSchemaValue({
+        schema: asClassicSchema(childSchema),
+        value: value[key],
+        playerIds,
+        path: appendScenarioPath(path, key),
+        direction: options.direction
+      });
+    }
+    return output;
+  }
+  if (schema instanceof z.ZodRecord) {
+    if (!isPlainObject(value)) return value;
+    if (manifestSchemaFamily(schema.keyType) === "playerId") {
+      throw new ScenarioSchemaValueError(
+        path,
+        "player-valued record keys cannot be represented by scenario seat references"
+      );
+    }
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        transformScenarioSchemaValue({
+          schema: asClassicSchema(schema.valueType),
+          value: item,
+          playerIds,
+          path: appendScenarioPath(path, key),
+          direction: options.direction
+        })
+      ])
+    );
+  }
+  if (schema instanceof z.ZodUnion) {
+    let firstSeatError;
+    for (const option of schema.options) {
+      try {
+        if (options.direction === "project" && !asClassicSchema(option).safeParse(value).success) {
+          continue;
+        }
+        const resolved = transformScenarioSchemaValue({
+          schema: asClassicSchema(option),
+          value,
+          playerIds,
+          path,
+          direction: options.direction
+        });
+        if (options.direction === "project" || asClassicSchema(option).safeParse(resolved).success) {
+          return resolved;
+        }
+      } catch (error) {
+        if (firstSeatError === void 0 && error instanceof ScenarioSchemaValueError) {
+          firstSeatError = error;
+        }
+      }
+    }
+    if (firstSeatError) throw firstSeatError;
+    return value;
+  }
+  if (schema instanceof z.ZodIntersection) {
+    const definition = intersectionDefinition(schema);
+    const leftResolved = transformScenarioSchemaValue({
+      schema: asClassicSchema(definition.left),
+      value,
+      playerIds,
+      path,
+      direction: options.direction
+    });
+    return transformScenarioSchemaValue({
+      schema: asClassicSchema(definition.right),
+      value: leftResolved,
+      playerIds,
+      path,
+      direction: options.direction
+    });
+  }
+  if (schema instanceof z.ZodPipe) {
+    return transformScenarioSchemaValue({
+      schema: asClassicSchema(schema.in),
+      value,
+      playerIds,
+      path,
+      direction: options.direction
+    });
+  }
+  if (schema instanceof z.ZodLazy) {
+    return transformScenarioSchemaValue({
+      schema: asClassicSchema(schema.unwrap()),
+      value,
+      playerIds,
+      path,
+      direction: options.direction
+    });
+  }
+  return value;
+}
+
+// src/testing/scenario-definition-validation.ts
+var ScenarioDefinitionValidationError = class extends Error {
+  code;
+  path;
+  constructor(options) {
+    super(
+      `Invalid scenario definition at '${options.path}': ${options.reason}.`
+    );
+    this.name = "ScenarioDefinitionValidationError";
+    this.code = options.code;
+    this.path = options.path;
+  }
+};
+var checkpointIdPattern = /^[a-z0-9][a-z0-9-]*$/u;
+function validateCheckpoints(definition) {
+  if (!Object.prototype.hasOwnProperty.call(definition, "checkpoints")) return;
+  const checkpoints = requireObject(
+    definition.checkpoints,
+    "scenario.checkpoints"
+  );
+  assertJsonSerializable(checkpoints, "scenario.checkpoints");
+  const occupied = /* @__PURE__ */ new Map();
+  for (const [id, candidate] of Object.entries(checkpoints)) {
+    const path = appendScenarioPath("scenario.checkpoints", id);
+    if (!checkpointIdPattern.test(id) || id === "setup") {
+      fail({
+        code: "INVALID_VALUE",
+        path,
+        reason: "checkpoint ids must be lowercase kebab-case and cannot be 'setup'"
+      });
+    }
+    const checkpoint = requireObject(candidate, path);
+    assertExactKeys(checkpoint, ["segment", "completed"], path);
+    assertOwn(checkpoint, "segment", path);
+    assertOwn(checkpoint, "completed", path);
+    if (!["setup", "given", "when"].includes(String(checkpoint.segment))) {
+      fail({
+        code: "INVALID_VALUE",
+        path: appendScenarioPath(path, "segment"),
+        reason: "expected setup, given, or when"
+      });
+    }
+    const completed = assertSafeInteger(
+      checkpoint.completed,
+      appendScenarioPath(path, "completed")
+    );
+    const segment = checkpoint.segment;
+    const maximum = segment === "setup" ? 0 : definition[segment].length;
+    if (completed < 0 || completed > maximum || segment === "setup" && completed !== 0) {
+      fail({
+        code: "OUT_OF_RANGE",
+        path: appendScenarioPath(path, "completed"),
+        reason: `expected 0 through ${maximum} for ${segment}`
+      });
+    }
+    const coordinate = `${segment}:${completed}`;
+    const previous = occupied.get(coordinate);
+    if (previous !== void 0) {
+      fail({
+        code: "INVALID_VALUE",
+        path,
+        reason: `duplicates checkpoint '${previous}' at ${coordinate}`
+      });
+    }
+    occupied.set(coordinate, id);
+  }
+}
+function fail(options) {
+  throw new ScenarioDefinitionValidationError(options);
+}
+function isPlainObject2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function requireObject(value, path) {
+  if (!isPlainObject2(value)) {
+    fail({ code: "INVALID_TYPE", path, reason: "expected a plain object" });
+  }
+  return value;
+}
+function assertExactKeys(value, allowed, path) {
+  const allowedSet = new Set(allowed);
+  for (const key of Object.keys(value)) {
+    if (!allowedSet.has(key)) {
+      fail({
+        code: "UNKNOWN_FIELD",
+        path: appendScenarioPath(path, key),
+        reason: "field is not part of the scenario contract"
+      });
+    }
+  }
+}
+function assertOwn(value, key, path) {
+  if (!Object.prototype.hasOwnProperty.call(value, key)) {
+    fail({
+      code: "INVALID_TYPE",
+      path: appendScenarioPath(path, key),
+      reason: "required field is missing"
+    });
+  }
+}
+function assertSafeInteger(value, path) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+    fail({
+      code: "UNSAFE_INTEGER",
+      path,
+      reason: "expected a finite safe integer"
+    });
+  }
+  return value;
+}
+function assertJsonSerializable(value, path, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    return;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      fail({
+        code: "NON_SERIALIZABLE",
+        path,
+        reason: "non-finite numbers are not JSON-serializable"
+      });
+    }
+    return;
+  }
+  if (typeof value !== "object") {
+    fail({
+      code: "NON_SERIALIZABLE",
+      path,
+      reason: `${typeof value} values are not JSON-serializable`
+    });
+  }
+  if (ancestors.has(value)) {
+    fail({
+      code: "NON_SERIALIZABLE",
+      path,
+      reason: "cyclic values are not JSON-serializable"
+    });
+  }
+  if (!Array.isArray(value) && !isPlainObject2(value)) {
+    fail({
+      code: "NON_SERIALIZABLE",
+      path,
+      reason: "class instances are not JSON-serializable scenario data"
+    });
+  }
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index += 1) {
+      if (!Object.prototype.hasOwnProperty.call(value, index)) {
+        fail({
+          code: "NON_SERIALIZABLE",
+          path: appendScenarioPath(path, index),
+          reason: "sparse array entries are not allowed"
+        });
+      }
+      assertJsonSerializable(
+        value[index],
+        appendScenarioPath(path, index),
+        ancestors
+      );
+    }
+    const extraKeys = Reflect.ownKeys(value).filter((key) => {
+      if (key === "length") return false;
+      return typeof key !== "string" || !/^(0|[1-9][0-9]*)$/.test(key);
+    });
+    if (extraKeys.length > 0) {
+      const key = extraKeys[0];
+      fail({
+        code: "NON_SERIALIZABLE",
+        path: appendScenarioPath(path, key),
+        reason: "array metadata is not JSON-serializable"
+      });
+    }
+    ancestors.delete(value);
+    return;
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  for (const key of Reflect.ownKeys(value)) {
+    if (typeof key === "symbol") {
+      fail({
+        code: "NON_SERIALIZABLE",
+        path: appendScenarioPath(path, key),
+        reason: "symbol keys are not JSON-serializable"
+      });
+    }
+    const descriptor = descriptors[key];
+    if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) {
+      fail({
+        code: "NON_SERIALIZABLE",
+        path: appendScenarioPath(path, key),
+        reason: "only enumerable data properties are allowed"
+      });
+    }
+    assertJsonSerializable(
+      descriptor.value,
+      appendScenarioPath(path, key),
+      ancestors
+    );
+  }
+  ancestors.delete(value);
+}
+function playerIdsForDefinition(game, players) {
+  const declared = game.contract.manifest.literals.playerIds;
+  return Array.from(
+    { length: players },
+    (_, index) => declared[index] ?? `player-${index + 1}`
+  );
+}
+function commandSchemas(game, interactionId) {
+  const schemasByPhase = createClientParamSchemasByPhase(
+    game
+  );
+  const schemas = Object.values(schemasByPhase).flatMap((schemas2) => {
+    const schema = schemas2[interactionId];
+    return schema ? [schema] : [];
+  });
+  const index = collectReducerDefinitionIndex(
+    game
+  );
+  for (const phase of index.phasesByName.values()) {
+    const steps = phase.interactions.find(([id]) => id === interactionId)?.[1].steps;
+    if (steps)
+      schemas.push(
+        z2.partialRecord(
+          z2.enum(steps.entries.map((step) => step.key)),
+          z2.unknown()
+        ).refine((params) => Object.keys(params).length === 1)
+      );
+  }
+  return schemas;
+}
+function issuePath(path, issue) {
+  return issue.path.reduce(appendScenarioPath, path);
+}
+function validateCommand(options) {
+  const command = requireObject(options.command, options.path);
+  assertJsonSerializable(command, options.path);
+  assertExactKeys(command, ["actor", "interactionId", "params"], options.path);
+  for (const field of ["actor", "interactionId", "params"]) {
+    assertOwn(command, field, options.path);
+  }
+  const actorPath = appendScenarioPath(options.path, "actor");
+  const actor = requireObject(command.actor, actorPath);
+  assertExactKeys(actor, ["seat"], actorPath);
+  assertOwn(actor, "seat", actorPath);
+  const actorSeat = assertSafeInteger(
+    actor.seat,
+    appendScenarioPath(actorPath, "seat")
+  );
+  if (actorSeat < 0 || actorSeat >= options.playerIds.length) {
+    fail({
+      code: "OUT_OF_RANGE",
+      path: appendScenarioPath(actorPath, "seat"),
+      reason: `expected a seat from 0 through ${Math.max(0, options.playerIds.length - 1)}`
+    });
+  }
+  const interactionPath = appendScenarioPath(options.path, "interactionId");
+  if (typeof command.interactionId !== "string" || command.interactionId === "") {
+    fail({
+      code: "INVALID_TYPE",
+      path: interactionPath,
+      reason: "expected a non-empty string"
+    });
+  }
+  const paramsPath = appendScenarioPath(options.path, "params");
+  const schemas = commandSchemas(options.game, command.interactionId);
+  if (schemas.length === 0) {
+    fail({
+      code: "UNKNOWN_INTERACTION",
+      path: interactionPath,
+      reason: `interaction '${command.interactionId}' is not declared by the game`
+    });
+  }
+  let firstSeatError;
+  let firstIssue;
+  for (const schema of schemas) {
+    try {
+      const resolved = resolveScenarioSeatReferences({
+        schema,
+        value: command.params,
+        playerIds: options.playerIds,
+        path: paramsPath
+      });
+      const parsed = schema.safeParse(resolved);
+      if (parsed.success) return;
+      firstIssue ??= parsed.error.issues[0];
+    } catch (error) {
+      if (error instanceof ScenarioSchemaValueError) {
+        firstSeatError ??= error;
+        continue;
+      }
+      throw error;
+    }
+  }
+  if (firstSeatError) {
+    fail({
+      code: firstSeatError.message.includes("seat from") ? "OUT_OF_RANGE" : "INVALID_COMMAND_PARAMS",
+      path: firstSeatError.path,
+      reason: firstSeatError.message
+    });
+  }
+  fail({
+    code: "INVALID_COMMAND_PARAMS",
+    path: firstIssue ? issuePath(paramsPath, firstIssue) : paramsPath,
+    reason: firstIssue?.message ?? "parameters do not match the interaction contract"
+  });
+}
+function validateScenarioDefinition(game, value) {
+  const definition = requireObject(value, "scenario");
+  assertExactKeys(
+    definition,
+    ["id", "description", "setup", "given", "when", "checkpoints", "then"],
+    "scenario"
+  );
+  for (const field of ["id", "setup", "given", "when", "then"]) {
+    assertOwn(definition, field, "scenario");
+  }
+  if (typeof definition.id !== "string" || definition.id === "") {
+    fail({
+      code: "INVALID_TYPE",
+      path: "scenario.id",
+      reason: "expected a non-empty string"
+    });
+  }
+  if (Object.prototype.hasOwnProperty.call(definition, "description") && typeof definition.description !== "string") {
+    fail({
+      code: "INVALID_TYPE",
+      path: "scenario.description",
+      reason: "expected a string when provided"
+    });
+  }
+  const setup = requireObject(definition.setup, "scenario.setup");
+  assertExactKeys(setup, ["players", "seed", "options"], "scenario.setup");
+  assertOwn(setup, "players", "scenario.setup");
+  assertOwn(setup, "seed", "scenario.setup");
+  const players = assertSafeInteger(setup.players, "scenario.setup.players");
+  const normalSetup = game.contract.manifest.normalSetup;
+  if (normalSetup === void 0 || !Number.isSafeInteger(normalSetup.minPlayers) || !Number.isSafeInteger(normalSetup.maxPlayers) || normalSetup.minPlayers <= 0 || normalSetup.maxPlayers < normalSetup.minPlayers) {
+    fail({
+      code: "NORMAL_SETUP_UNAVAILABLE",
+      path: "scenario.setup.players",
+      reason: "the game manifest does not provide valid normal setup bounds"
+    });
+  }
+  if (players < normalSetup.minPlayers || players > normalSetup.maxPlayers) {
+    fail({
+      code: "OUT_OF_RANGE",
+      path: "scenario.setup.players",
+      reason: `expected ${normalSetup.minPlayers} through ${normalSetup.maxPlayers} players`
+    });
+  }
+  assertSafeInteger(setup.seed, "scenario.setup.seed");
+  assertJsonSerializable(definition.id, "scenario.id");
+  if (Object.prototype.hasOwnProperty.call(definition, "description")) {
+    assertJsonSerializable(definition.description, "scenario.description");
+  }
+  assertJsonSerializable(setup, "scenario.setup");
+  if (!Array.isArray(definition.given)) {
+    fail({
+      code: "INVALID_TYPE",
+      path: "scenario.given",
+      reason: "expected an array"
+    });
+  }
+  if (!Array.isArray(definition.when)) {
+    fail({
+      code: "INVALID_TYPE",
+      path: "scenario.when",
+      reason: "expected an array"
+    });
+  }
+  if (typeof definition.then !== "function") {
+    fail({
+      code: "INVALID_TYPE",
+      path: "scenario.then",
+      reason: "expected an assertion function"
+    });
+  }
+  validateCheckpoints(definition);
+  const playerIds = playerIdsForDefinition(game, players);
+  definition.given.forEach(
+    (command, index) => validateCommand({
+      game,
+      command,
+      path: `scenario.given[${index}]`,
+      playerIds
+    })
+  );
+  definition.when.forEach(
+    (command, index) => validateCommand({
+      game,
+      command,
+      path: `scenario.when[${index}]`,
+      playerIds
+    })
+  );
+}
+
+// src/testing/definitions.ts
+function resolveScenarioCheckpoint(definition, selector) {
+  if (typeof selector !== "string") {
+    return structuredClone(selector);
+  }
+  const checkpoint = definition.checkpoints?.[selector];
+  if (checkpoint === void 0) {
+    const available = Object.keys(definition.checkpoints ?? {}).sort();
+    throw new ScenarioDefinitionValidationError({
+      code: "INVALID_VALUE",
+      path: "scenario.checkpoints",
+      reason: `checkpoint '${selector}' is not declared by scenario '${definition.id}'` + (available.length === 0 ? "; no named checkpoints are available" : `; available checkpoints: ${available.join(", ")}`)
+    });
+  }
+  return structuredClone(checkpoint);
+}
+var ScenarioReplayError = class extends Error {
+  scenarioId;
+  segment;
+  index;
+  interactionId;
+  errorCode;
+  reducerMessage;
+  trace;
+  constructor(options) {
+    super(
+      `Scenario '${options.scenarioId}' rejected ${options.segment}[${options.index}] interaction '${options.interactionId}' with ${options.errorCode}` + (options.reducerMessage ? `: ${options.reducerMessage}` : ".")
+    );
+    this.name = "ScenarioReplayError";
+    this.scenarioId = options.scenarioId;
+    this.segment = options.segment;
+    this.index = options.index;
+    this.interactionId = options.interactionId;
+    this.errorCode = options.errorCode;
+    this.reducerMessage = options.reducerMessage;
+    this.trace = options.trace ?? [];
+  }
+};
+function createScenarioAuthoring(game) {
+  return {
+    defineScenario(definition) {
+      validateScenarioDefinition(game, definition);
+      return definition;
+    }
+  };
+}
+function toScenarioReplayDefinition(definition) {
+  const replay = {
+    id: definition.id,
+    ...definition.description === void 0 ? {} : { description: definition.description },
+    setup: definition.setup,
+    given: definition.given,
+    when: definition.when
+  };
+  return structuredClone(replay);
+}
+
+// src/testing/scenario-assertion-error.ts
+var SCENARIO_ASSERTION_ERROR_CODE = "SCENARIO_ASSERTION_FAILED";
+var ScenarioAssertionError = class extends Error {
+  code = SCENARIO_ASSERTION_ERROR_CODE;
+  constructor(message) {
+    super(message);
+    this.name = "ScenarioAssertionError";
+  }
+};
+function scenarioAssertionFailure(message) {
+  throw new ScenarioAssertionError(message);
+}
+
+// src/testing/create-expect-api.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isDeepStrictEqual(actual, expected) {
+  if (Object.is(actual, expected)) return true;
+  if (typeof actual !== typeof expected) return false;
+  if (actual === null || expected === null) return false;
+  if (typeof actual !== "object" || typeof expected !== "object") return false;
+  if (actual instanceof Date || expected instanceof Date) {
+    return actual instanceof Date && expected instanceof Date && Object.is(actual.getTime(), expected.getTime());
+  }
+  if (actual instanceof RegExp || expected instanceof RegExp) {
+    return actual instanceof RegExp && expected instanceof RegExp && actual.source === expected.source && actual.flags === expected.flags;
+  }
+  if (Array.isArray(actual) || Array.isArray(expected)) {
+    return Array.isArray(actual) && Array.isArray(expected) && actual.length === expected.length && actual.every((value, index) => isDeepStrictEqual(value, expected[index]));
+  }
+  const actualPrototype = Object.getPrototypeOf(actual);
+  const expectedPrototype = Object.getPrototypeOf(expected);
+  if (actualPrototype !== expectedPrototype) return false;
+  const actualRecord = actual;
+  const expectedRecord = expected;
+  const actualKeys = Object.keys(actualRecord);
+  const expectedKeys = Object.keys(expectedRecord);
+  return actualKeys.length === expectedKeys.length && actualKeys.every(
+    (key) => Object.prototype.hasOwnProperty.call(expectedRecord, key) && isDeepStrictEqual(actualRecord[key], expectedRecord[key])
+  );
+}
+function matchPartial(actual, expected, path = "value") {
+  if (!isRecord(expected)) {
+    return isDeepStrictEqual(actual, expected) ? null : `${path} does not match`;
+  }
+  if (!isRecord(actual)) {
+    return `${path} is not an object`;
+  }
+  for (const [key, expectedValue] of Object.entries(expected)) {
+    const actualValue = actual[key];
+    if (!(key in actual)) {
+      return `${path}.${key} is missing`;
+    }
+    const mismatch = matchPartial(actualValue, expectedValue, `${path}.${key}`);
+    if (mismatch) {
+      return mismatch;
+    }
+  }
+  return null;
+}
+function asDescriptorList(actual) {
+  if (!Array.isArray(actual)) {
+    scenarioAssertionFailure("Expected interaction descriptor array.");
+  }
+  return actual;
+}
+function findInteraction(descriptors, interactionId) {
+  return descriptors.find(
+    (descriptor) => descriptor.interactionId === interactionId
+  ) ?? null;
+}
+function assertDescriptorMatches(descriptor, opts) {
+  if (!opts) {
+    return;
+  }
+  const mismatch = matchPartial(descriptor, opts, "interaction");
+  if (mismatch) {
+    scenarioAssertionFailure(mismatch);
+  }
+}
+function createSubmissionErrorMatcher(actual, expected, options) {
+  if (isRecord(actual) && (actual.kind === "accepted" || actual.kind === "rejected")) {
+    if (actual.kind === "accepted") {
+      scenarioAssertionFailure(
+        "Expected probe command to reject, but it was accepted."
+      );
+    }
+    const errorCode = typeof actual.errorCode === "string" ? actual.errorCode : void 0;
+    const message = typeof actual.message === "string" ? actual.message : "";
+    if (expected.errorCode !== void 0 && errorCode !== expected.errorCode) {
+      scenarioAssertionFailure(
+        `Expected rejection errorCode '${expected.errorCode}', received '${errorCode ?? "undefined"}'.`
+      );
+    }
+    if (typeof expected.message === "string" && message !== expected.message) {
+      scenarioAssertionFailure(
+        `Expected rejection message '${expected.message}', received '${message}'.`
+      );
+    }
+    if (expected.message instanceof RegExp && !expected.message.test(message)) {
+      scenarioAssertionFailure(
+        `Expected rejection message '${message}' to match ${String(expected.message)}.`
+      );
+    }
+    return Promise.resolve();
+  }
+  const resolvePromise = () => {
+    if (typeof actual === "function") {
+      return Promise.resolve().then(() => actual());
+    }
+    return Promise.resolve(actual);
+  };
+  return resolvePromise().then(
+    () => scenarioAssertionFailure("Expected promise to reject."),
+    (error) => {
+      if (!(error instanceof Error)) {
+        scenarioAssertionFailure("Expected rejection to be an Error.");
+      }
+      if (expected.errorCode !== void 0 && error.errorCode !== expected.errorCode) {
+        scenarioAssertionFailure(
+          `Expected rejection errorCode '${expected.errorCode}', received '${error.errorCode ?? "undefined"}'.${formatLastDiagnosticRejection(options)}`
+        );
+      }
+      if (typeof expected.message === "string" && error.message !== expected.message) {
+        scenarioAssertionFailure(
+          `Expected rejection message '${expected.message}', received '${error.message}'.${formatLastDiagnosticRejection(
+            options
+          )}`
+        );
+      }
+      if (expected.message instanceof RegExp && !expected.message.test(error.message)) {
+        scenarioAssertionFailure(
+          `Expected rejection message '${error.message}' to match ${String(
+            expected.message
+          )}.${formatLastDiagnosticRejection(options)}`
+        );
+      }
+    }
+  );
+}
+function formatLastDiagnosticRejection(options) {
+  const rejection = options.lastDiagnosticRejection?.();
+  if (!rejection) return "";
+  const rule = rejection.ruleId ? ` ruleId=${rejection.ruleId}` : "";
+  const message = rejection.message ? ` message=${rejection.message}` : "";
+  return `
+last rejection: errorCode=${rejection.errorCode}${rule}${message}`;
+}
+function assertLength(actual, expected) {
+  if (actual === null || actual === void 0 || typeof actual.length !== "number") {
+    scenarioAssertionFailure(
+      "toHaveLength expects a value with a numeric length."
+    );
+  }
+  const length = actual.length;
+  if (length !== expected) {
+    scenarioAssertionFailure(
+      `Expected length ${expected}, received ${length}.`
+    );
+  }
+}
+function formatInteractionExplanation(explanation) {
+  if (!explanation) {
+    return "";
+  }
+  const lines = [
+    `availability: ${explanation.availability}`,
+    ...explanation.rules.map((rule) => {
+      const code = rule.errorCode ? ` (${rule.errorCode})` : "";
+      const message = rule.message ? `: ${rule.message}` : "";
+      return `rule ${rule.ruleId} ${rule.outcome}${code}${message}`;
+    }),
+    ...explanation.inputs.map(
+      (input) => `input ${input.key} eligibleCount=${input.eligibleCount}`
+    )
+  ];
+  return `
+${lines.join("\n")}`;
+}
+function assertThrown(actual, predicate) {
+  if (typeof actual !== "function") {
+    scenarioAssertionFailure("toThrow expects a function.");
+  }
+  try {
+    actual();
+  } catch (error) {
+    if (!(error instanceof Error)) {
+      scenarioAssertionFailure("Thrown value is not an Error.");
+    }
+    if (predicate === void 0) {
+      return;
+    }
+    if (typeof predicate === "string" && error.message !== predicate) {
+      scenarioAssertionFailure(
+        `Expected thrown message '${predicate}', received '${error.message}'.`
+      );
+    }
+    if (predicate instanceof RegExp && !predicate.test(error.message)) {
+      scenarioAssertionFailure(
+        `Expected thrown message '${error.message}' to match ${String(predicate)}.`
+      );
+    }
+    if (typeof predicate === "function" && !predicate(error)) {
+      scenarioAssertionFailure("Thrown error did not satisfy predicate.");
+    }
+    return;
+  }
+  scenarioAssertionFailure("Expected function to throw.");
+}
+function createExpectApi(options = {}) {
+  const buildMatchers = (actual) => ({
+    toBe: (expected) => {
+      if (actual !== expected) {
+        scenarioAssertionFailure(
+          `Expected '${String(actual)}' to be '${String(expected)}'.`
+        );
+      }
+    },
+    toEqual: (expected) => {
+      if (!isDeepStrictEqual(actual, expected)) {
+        scenarioAssertionFailure("Expected values to be deeply equal.");
+      }
+    },
+    toMatchObject: (expected) => {
+      const mismatch = matchPartial(actual, expected);
+      if (mismatch) {
+        scenarioAssertionFailure(mismatch);
+      }
+    },
+    toBeDefined: () => {
+      if (actual === void 0) {
+        scenarioAssertionFailure("Expected value to be defined.");
+      }
+    },
+    toBeUndefined: () => {
+      if (actual !== void 0) {
+        scenarioAssertionFailure(
+          `Expected value to be undefined, but received '${String(actual)}'.`
+        );
+      }
+    },
+    toBeNull: () => {
+      if (actual !== null) {
+        scenarioAssertionFailure(
+          `Expected value to be null, but received '${String(actual)}'.`
+        );
+      }
+    },
+    toContain: (expected) => {
+      if (Array.isArray(actual)) {
+        if (!actual.includes(expected)) {
+          scenarioAssertionFailure("Expected array to contain value.");
+        }
+        return;
+      }
+      if (typeof actual === "string") {
+        if (!actual.includes(String(expected))) {
+          scenarioAssertionFailure("Expected string to contain value.");
+        }
+        return;
+      }
+      scenarioAssertionFailure(
+        "toContain expects an array or string actual value."
+      );
+    },
+    toContainEqual: (expected) => {
+      if (!Array.isArray(actual)) {
+        scenarioAssertionFailure(
+          "toContainEqual expects an array actual value."
+        );
+      }
+      if (!actual.some((value) => isDeepStrictEqual(value, expected))) {
+        scenarioAssertionFailure("Expected array to contain an equal value.");
+      }
+    },
+    toHaveLength: (expected) => {
+      assertLength(actual, expected);
+    },
+    toBeGreaterThan: (expected) => {
+      if (typeof actual !== "number") {
+        scenarioAssertionFailure(
+          "toBeGreaterThan expects a number actual value."
+        );
+      }
+      if (actual <= expected) {
+        scenarioAssertionFailure(`Expected ${actual} to be > ${expected}.`);
+      }
+    },
+    toBeGreaterThanOrEqual: (expected) => {
+      if (typeof actual !== "number") {
+        scenarioAssertionFailure(
+          "toBeGreaterThanOrEqual expects a number actual value."
+        );
+      }
+      if (actual < expected) {
+        scenarioAssertionFailure(`Expected ${actual} to be >= ${expected}.`);
+      }
+    },
+    toThrow: (predicate) => {
+      assertThrown(actual, predicate);
+    },
+    toMatchSnapshot: (filename) => {
+      if (!options.matchSnapshot) {
+        scenarioAssertionFailure(
+          "Snapshot matching is not configured for this expect API."
+        );
+      }
+      options.matchSnapshot(filename, actual);
+    },
+    toRejectWith: (expected) => createSubmissionErrorMatcher(actual, expected, options),
+    toHaveInteraction: (interactionId, opts) => {
+      const descriptors = asDescriptorList(actual);
+      const descriptor = findInteraction(descriptors, interactionId);
+      if (!descriptor) {
+        scenarioAssertionFailure(
+          `Expected interaction '${interactionId}' to exist.`
+        );
+      }
+      assertDescriptorMatches(descriptor, opts);
+    },
+    toBeGatedBy: (reason, opts) => {
+      const descriptor = Array.isArray(actual) ? (() => {
+        if (!opts?.interactionId) {
+          scenarioAssertionFailure(
+            "toBeGatedBy on a descriptor array requires opts.interactionId."
+          );
+        }
+        return findInteraction(
+          asDescriptorList(actual),
+          opts.interactionId
+        );
+      })() : actual;
+      if (!descriptor) {
+        scenarioAssertionFailure("Expected interaction descriptor to exist.");
+      }
+      if (descriptor.availability?.status === "available") {
+        scenarioAssertionFailure("Expected interaction to be unavailable.");
+      }
+      const actualReason = descriptor.availability?.status === "notYourTurn" || descriptor.availability?.status === "blocked" ? descriptor.availability.reason : void 0;
+      if (actualReason !== reason) {
+        scenarioAssertionFailure(
+          `Expected unavailable reason '${reason}', received '${actualReason ?? "undefined"}'.`
+        );
+      }
+    },
+    toBeAvailable: (explanation) => {
+      const descriptor = Array.isArray(actual) ? (() => {
+        if (!explanation?.interactionId) {
+          scenarioAssertionFailure(
+            "toBeAvailable on a descriptor array requires an explanation."
+          );
+        }
+        return findInteraction(
+          asDescriptorList(actual),
+          explanation.interactionId
+        );
+      })() : actual;
+      if (!descriptor) {
+        scenarioAssertionFailure(
+          `Expected interaction descriptor to exist.${formatInteractionExplanation(
+            explanation
+          )}`
+        );
+      }
+      if (descriptor.availability?.status !== "available") {
+        scenarioAssertionFailure(
+          `Expected interaction '${descriptor.interactionId ?? "unknown"}' to be available.${formatInteractionExplanation(
+            explanation
+          )}`
+        );
+      }
+    },
+    not: {
+      toHaveInteraction: (interactionId) => {
+        const descriptors = asDescriptorList(actual);
+        if (findInteraction(descriptors, interactionId)) {
+          scenarioAssertionFailure(
+            `Expected interaction '${interactionId}' to be absent.`
+          );
+        }
+      }
+    }
+  });
+  return (actual) => buildMatchers(actual);
+}
+
+// src/testing/player-roster.ts
+function resolvePlayerRoster(game, count) {
+  const setup = game.contract.manifest.normalSetup;
+  if (!setup) throw new Error("Game manifest does not expose normal setup.");
+  if (!Number.isSafeInteger(count) || count < setup.minPlayers || count > setup.maxPlayers)
+    throw new Error("Player count is outside manifest limits.");
+  const declared = game.contract.manifest.literals.playerIds;
+  if (declared.length < count)
+    throw new Error("Manifest roster does not contain enough players.");
+  return declared.slice(0, count);
+}
+
+// src/testing/reducer-runtime.ts
+function createReducerTestingRuntime(definition, options = {}, bundle = createReducerBundle(definition, options)) {
+  const codec = createIngressRuntimeCodec(definition);
+  const parseState = (state) => codec.parseState(state);
+  const parseInput = (input) => codec.parseInput(input);
+  const scope = createTrustedRuntimeScope(definition);
+  const interactions = createInteractionResolver(scope, {
+    diagnostics: options.descriptorDiagnostics ?? (options.diagnostics === "verbose" ? "verbose" : void 0)
+  });
+  const projection = createProjectionBuilder(scope, interactions);
+  function inspect({ state, playerId, interactionId }) {
+    if (typeof playerId !== "string")
+      throw new Error("Expected a string playerId.");
+    return {
+      state: scope.toCombinedState(parseState(state)),
+      playerId: codec.parsePlayerId(playerId),
+      interactionId
+    };
+  }
+  return {
+    ...bundle,
+    async validateInput({ state, input }) {
+      return interactions.validateClientInput(
+        scope.toCombinedState(parseState(state)),
+        parseInput(input)
+      );
+    },
+    async reduce(input) {
+      const result = await bundle.dispatch(input);
+      if (result.kind === "reject") return result;
+      return {
+        kind: result.kind,
+        state: result.state,
+        events: result.events,
+        ...result.terminal ? { terminal: result.terminal } : {}
+      };
+    },
+    project({ state, playerIds, projectionMode }) {
+      if (projectionMode !== "actionsOnly")
+        return bundle.project({ state, playerIds });
+      return projection.project({
+        state: parseState(state),
+        playerIds: playerIds.map((id) => codec.parsePlayerId(id)),
+        projectionMode
+      });
+    },
+    explainInteraction(input) {
+      return interactions.explainInteraction(inspect(input));
+    },
+    currentClientParamSchema(input) {
+      return interactions.currentClientParamSchema(inspect(input));
+    },
+    resolveInteractionActionability(input) {
+      return interactions.resolveInteractionActionability(inspect(input));
+    },
+    enumerateInteractionParams(input) {
+      return interactions.enumerateInteractionParams({
+        ...inspect(input),
+        maxEvaluations: input.maxEvaluations
+      });
+    }
+  };
+}
+
+// src/testing/scenario-player-refs.ts
+var ScenarioCommandParamsError = class extends Error {
+  path;
+  constructor(path, message) {
+    super(`${path}: ${message}`);
+    this.name = "ScenarioCommandParamsError";
+    this.path = path;
+  }
+};
+function isScenarioSeatRef(value) {
+  if (!isPlainRecord(value)) return false;
+  const keys = Object.keys(value);
+  return keys.length === 1 && keys[0] === "seat" && Number.isSafeInteger(value.seat) && value.seat >= 0;
+}
+function resolveScenarioSeatRef(options) {
+  if (!isScenarioSeatRef(options.ref)) {
+    throw new ScenarioCommandParamsError(
+      options.path,
+      "expected a scenario seat reference"
+    );
+  }
+  const playerId = options.playerIds[options.ref.seat];
+  if (playerId === void 0) {
+    throw new ScenarioCommandParamsError(
+      `${options.path}.seat`,
+      `seat ${options.ref.seat} is out of range for ${options.playerIds.length} player(s)`
+    );
+  }
+  return playerId;
+}
+function resolveScenarioCommandParams(options) {
+  const candidateSchemas = clientParamSchemaCandidates(options);
+  let firstSeatError;
+  let firstIssue;
+  for (const schema of candidateSchemas) {
+    try {
+      const resolved = resolveScenarioSeatReferences({
+        schema,
+        value: options.params,
+        playerIds: options.playerIds,
+        path: `${options.path}.params`
+      });
+      const parsed = schema.safeParse(resolved);
+      if (parsed.success) {
+        return resolved;
+      }
+      firstIssue ??= parsed.error.issues[0];
+    } catch (error) {
+      if (error instanceof ScenarioSchemaValueError) {
+        firstSeatError ??= error;
+        continue;
+      }
+      throw error;
+    }
+  }
+  if (firstSeatError) {
+    throw new ScenarioCommandParamsError(
+      firstSeatError.path,
+      firstSeatError.message
+    );
+  }
+  const suffix = firstIssue?.path.map(
+    (part) => typeof part === "number" ? `[${part}]` : `.${String(part)}`
+  ).join("") ?? "";
+  throw new ScenarioCommandParamsError(
+    `${options.path}.params${suffix}`,
+    firstIssue?.message ?? "invalid interaction parameters"
+  );
+}
+function projectScenarioCommandParams(options) {
+  const candidateSchemas = clientParamSchemaCandidates(options);
+  let firstSeatError;
+  for (const schema of candidateSchemas) {
+    if (!schema.safeParse(options.params).success) continue;
+    try {
+      const projected = projectScenarioSeatReferences({
+        schema,
+        value: options.params,
+        playerIds: options.playerIds,
+        path: `${options.path}.params`
+      });
+      if (isPlainRecord(projected)) return projected;
+    } catch (error) {
+      if (error instanceof ScenarioSchemaValueError) {
+        firstSeatError ??= error;
+        continue;
+      }
+      throw error;
+    }
+  }
+  if (firstSeatError) {
+    throw new ScenarioCommandParamsError(
+      firstSeatError.path,
+      firstSeatError.message
+    );
+  }
+  throw new ScenarioCommandParamsError(
+    `${options.path}.params`,
+    "runtime interaction parameters do not match a client parameter schema"
+  );
+}
+function clientParamSchemaCandidates(options) {
+  if (options.currentSchema) return [options.currentSchema];
+  const schemas = createClientParamSchemasByPhase(options.game);
+  const currentPhaseSchema = schemas[options.phase]?.[options.interactionId];
+  const candidateSchemas = [
+    ...currentPhaseSchema ? [currentPhaseSchema] : [],
+    ...Object.entries(schemas).flatMap(([phase, schemasForPhase]) => {
+      if (phase === options.phase) return [];
+      const schema = schemasForPhase[options.interactionId];
+      return schema ? [schema] : [];
+    })
+  ];
+  if (candidateSchemas.length === 0) {
+    throw new ScenarioCommandParamsError(
+      `${options.path}.interactionId`,
+      `interaction '${options.interactionId}' has no client parameter schema`
+    );
+  }
+  return candidateSchemas;
+}
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// src/testing/scenario-replay.ts
+async function replayScenario(options) {
+  validateReplayDefinition(options.game, options.scenario);
+  const scenario = cloneReplayDefinition(options.scenario);
+  const checkpoint = normalizeCheckpoint(scenario, options.at);
+  const playerIds = resolvePlayerRoster(options.game, scenario.setup.players);
+  const events = [];
+  const bundle = createScenarioBundle(options.game, events, options.bundle);
+  const normalSetup = options.game.contract.manifest.normalSetup;
+  if (!normalSetup) {
+    throw new ScenarioDefinitionValidationError({
+      code: "NORMAL_SETUP_UNAVAILABLE",
+      path: "scenario.setup.players",
+      reason: "the game manifest does not expose normal setup"
+    });
+  }
+  const table = normalSetup.createInitialTable({ playerIds });
+  const initialized = await bundle.initialize({
+    table,
+    playerIds: [...playerIds],
+    rngSeed: scenario.setup.seed,
+    options: scenario.setup.options
+  });
+  const runtime = new ScenarioReplayImplementation({
+    game: options.game,
+    productionBundle: options.bundle,
+    scenario,
+    playerIds,
+    reducerState: initialized.state,
+    terminal: initialized.terminal ?? null,
+    checkpoint: { segment: "setup", completed: 0 },
+    trace: [],
+    events
+  });
+  await runtime.replayTo(checkpoint);
+  return runtime;
+}
+async function materializeScenarioRuntimeCheckpoint(options) {
+  const replay = requireScenarioReplayImplementation(
+    await replayScenario(options)
+  );
+  return {
+    checkpoint: structuredClone(replay.checkpoint),
+    checkpointDigest: replay.checkpointDigest,
+    playerIds: [...replay.playerIds],
+    state: structuredClone(replay.reducerState),
+    terminal: structuredClone(replay.terminal)
+  };
+}
+function cloneReplayDefinition(scenario) {
+  return structuredClone({
+    id: scenario.id,
+    ...scenario.description === void 0 ? {} : { description: scenario.description },
+    setup: scenario.setup,
+    given: scenario.given,
+    when: scenario.when
+  });
+}
+async function assertScenario(options) {
+  const replay = requireScenarioReplayImplementation(options.replay);
+  if (!replay.complete) {
+    throw new Error(
+      `Scenario '${replay.scenarioId}' assertions require a full replay; checkpoint is ${replay.checkpoint.segment}:${replay.checkpoint.completed}.`
+    );
+  }
+  const context = {
+    expect: createExpectApi({
+      lastDiagnosticRejection: () => lastRejectedEvent(replay.diagnostics)
+    }),
+    state: replay.state,
+    view: replay.view,
+    interactions: replay.interactions,
+    explain: replay.explain,
+    get diagnostics() {
+      return replay.diagnostics;
+    },
+    probe: (command) => replay.probe(command)
+  };
+  await options.assertion(context);
+}
+async function probeScenarioCommand(options) {
+  return requireScenarioReplayImplementation(options.replay).probe(
+    options.command
+  );
+}
+var ScenarioReplayImplementation = class _ScenarioReplayImplementation {
+  scenarioId;
+  scenario;
+  game;
+  playerIds;
+  bundle;
+  productionBundle;
+  events;
+  checkpoint;
+  reducerState;
+  terminal;
+  trace;
+  constructor(state) {
+    this.scenarioId = state.scenario.id;
+    this.scenario = state.scenario;
+    this.game = state.game;
+    this.playerIds = [...state.playerIds];
+    this.reducerState = structuredClone(state.reducerState);
+    this.terminal = structuredClone(state.terminal);
+    this.checkpoint = structuredClone(state.checkpoint);
+    this.trace = structuredClone(
+      state.trace
+    );
+    this.events = structuredClone(state.events);
+    this.productionBundle = state.productionBundle;
+    this.bundle = createScenarioBundle(
+      state.game,
+      this.events,
+      this.productionBundle
+    );
+    this.state = this.state.bind(this);
+    this.view = this.view.bind(this);
+    this.interactions = this.interactions.bind(this);
+    this.explain = this.explain.bind(this);
+  }
+  get checkpointDigest() {
+    return digestPluginRuntimeJson({
+      digestVersion: "scenario-checkpoint@1",
+      scenarioId: this.scenarioId,
+      checkpoint: this.checkpoint,
+      reducerState: this.reducerState,
+      terminal: this.terminal,
+      trace: this.trace
+    });
+  }
+  get complete() {
+    return this.checkpoint.segment === "when" && this.checkpoint.completed === this.scenario.when.length;
+  }
+  get diagnostics() {
+    const flow = readFlowState(this.reducerState);
+    return {
+      events: structuredClone(this.events),
+      lastDispatch: lastAcceptedDispatch(this.events),
+      flow: {
+        currentPhase: flow.currentPhase,
+        activeSeats: flow.activePlayers.flatMap((playerId) => {
+          const seat = this.playerIds.indexOf(playerId);
+          return seat < 0 ? [] : [{ seat }];
+        })
+      }
+    };
+  }
+  state() {
+    return structuredClone(this.reducerState.domain);
+  }
+  view(seat) {
+    const playerId = this.playerId(seat, "seat");
+    const projection = this.project(playerId);
+    return structuredClone(projection.seats?.[playerId]?.view ?? null);
+  }
+  interactions(seat) {
+    const playerId = this.playerId(seat, "seat");
+    const projection = this.project(playerId);
+    const refs = projection.seats?.[playerId]?.availableInteractionRefs ?? [];
+    const interactionsByRef = projection.interactionsByRef ?? {};
+    return structuredClone(
+      refs.flatMap((ref) => {
+        const descriptor = interactionsByRef[ref];
+        return descriptor ? [descriptor] : [];
+      })
+    );
+  }
+  explain(seat, interactionId) {
+    return structuredClone(
+      this.bundle.explainInteraction({
+        state: this.reducerState,
+        playerId: this.playerId(seat, "seat"),
+        interactionId
+      })
+    );
+  }
+  clone() {
+    return new _ScenarioReplayImplementation({
+      game: this.game,
+      productionBundle: this.productionBundle,
+      scenario: this.scenario,
+      playerIds: this.playerIds,
+      reducerState: this.reducerState,
+      terminal: this.terminal,
+      checkpoint: this.checkpoint,
+      trace: this.trace,
+      events: this.events
+    });
+  }
+  inspectionAuthority(perspective) {
+    const selectedPlayerId = perspective.kind === "player" ? this.playerId({ seat: perspective.seat }, "perspective.seat") : null;
+    const projection = this.bundle.project({
+      state: this.reducerState,
+      playerIds: selectedPlayerId ? [selectedPlayerId] : []
+    });
+    const descriptors = selectedPlayerId ? descriptorsForPlayer(projection, selectedPlayerId) : [];
+    const flow = readFlowState(this.reducerState);
+    return {
+      game: this.game,
+      scenario: structuredClone(this.scenario),
+      playerIds: [...this.playerIds],
+      checkpoint: structuredClone(this.checkpoint),
+      checkpointDigest: this.checkpointDigest,
+      publicState: structuredClone(this.reducerState.domain.publicState),
+      view: structuredClone(
+        selectedPlayerId ? projection.seats[selectedPlayerId]?.view ?? null : null
+      ),
+      scheduler: {
+        phase: flow.currentPhase ?? "",
+        step: readPhaseStep(this.reducerState.domain.phase),
+        activePlayerIds: [...projection.schedulerFlow?.activePlayerIds ?? []],
+        pendingPlayerIds: [
+          ...projection.schedulerFlow?.pendingPlayerIds ?? projection.simultaneousPhase?.pendingPlayerIds ?? []
+        ],
+        continuationDependencies: structuredClone(
+          projection.schedulerFlow?.continuationDependencies ?? []
+        )
+      },
+      interactions: descriptors.map((descriptor) => ({
+        descriptor: structuredClone(descriptor),
+        explanation: structuredClone(
+          this.bundle.explainInteraction({
+            state: this.reducerState,
+            playerId: selectedPlayerId,
+            interactionId: String(descriptor.interactionId ?? "")
+          })
+        ),
+        actionability: structuredClone(
+          this.bundle.resolveInteractionActionability({
+            state: this.reducerState,
+            playerId: selectedPlayerId,
+            interactionId: String(descriptor.interactionId ?? "")
+          })
+        )
+      })),
+      entropy: {
+        seed: this.reducerState.runtime.rng.seed,
+        draws: structuredClone(this.reducerState.runtime.rng.draws ?? [])
+      },
+      commandTrace: structuredClone(this.trace)
+    };
+  }
+  currentClientParamSchema(seat, interactionId) {
+    return this.bundle.currentClientParamSchema({
+      state: this.reducerState,
+      playerId: this.playerId({ seat }, "actor"),
+      interactionId
+    });
+  }
+  enumerateInteractionParams(options) {
+    return structuredClone(
+      this.bundle.enumerateInteractionParams({
+        state: this.reducerState,
+        playerId: this.playerId({ seat: options.seat }, "perspective.seat"),
+        interactionId: options.interactionId,
+        maxEvaluations: options.maxEvaluations
+      })
+    );
+  }
+  async advance(command) {
+    const clone = new _ScenarioReplayImplementation({
+      game: this.game,
+      productionBundle: this.productionBundle,
+      scenario: this.scenario,
+      playerIds: this.playerIds,
+      reducerState: this.reducerState,
+      terminal: this.terminal,
+      checkpoint: this.checkpoint,
+      trace: this.trace,
+      events: this.events
+    });
+    const result = await clone.dispatch(command, "probe", 0);
+    if (result.kind === "accept") {
+      clone.trace.push({
+        segment: this.checkpoint.segment === "when" ? "when" : "given",
+        index: this.checkpoint.completed,
+        command: structuredClone(command),
+        trace: structuredClone(result.trace)
+      });
+      return {
+        kind: "accepted",
+        replay: clone,
+        trace: structuredClone(result.trace)
+      };
+    }
+    return {
+      kind: "rejected",
+      errorCode: result.errorCode,
+      ...result.message === void 0 ? {} : { message: result.message },
+      trace: structuredClone(result.trace)
+    };
+  }
+  async replayTo(target) {
+    const givenCount = target.segment === "setup" ? 0 : target.segment === "given" ? target.completed : this.scenario.given.length;
+    const whenCount = target.segment === "when" ? target.completed : 0;
+    for (let index = 0; index < givenCount; index += 1) {
+      await this.dispatchRequired("given", index, this.scenario.given[index]);
+    }
+    this.checkpoint = { segment: "given", completed: givenCount };
+    for (let index = 0; index < whenCount; index += 1) {
+      await this.dispatchRequired("when", index, this.scenario.when[index]);
+    }
+    this.checkpoint = structuredClone(target);
+  }
+  async probe(command) {
+    const clone = requireScenarioReplayImplementation(this.clone());
+    const result = await clone.dispatch(command, "probe", 0);
+    if (result.kind === "accept") {
+      const accepted = {
+        kind: "accepted",
+        command,
+        checkpointDigest: digestPluginRuntimeJson({
+          digestVersion: "scenario-probe@1",
+          from: this.checkpointDigest,
+          command,
+          reducerState: clone.reducerState,
+          trace: result.trace
+        }),
+        trace: result.trace,
+        toBeAccepted() {
+        },
+        toRejectWith(expected) {
+          scenarioAssertionFailure(
+            `Expected probe to reject${expected.errorCode ? ` with ${expected.errorCode}` : ""}, but it was accepted.`
+          );
+        }
+      };
+      return accepted;
+    }
+    const rejected = {
+      kind: "rejected",
+      command,
+      errorCode: result.errorCode,
+      ...result.message === void 0 ? {} : { message: result.message },
+      trace: result.trace,
+      toBeAccepted() {
+        scenarioAssertionFailure(
+          `Expected probe to be accepted, but it rejected with ${result.errorCode}.`
+        );
+      },
+      toRejectWith(expected) {
+        assertRejectionMatches(result, expected);
+      }
+    };
+    return rejected;
+  }
+  async dispatchRequired(segment, index, command) {
+    const result = await this.dispatch(command, segment, index);
+    if (result.kind === "reject") {
+      throw new ScenarioReplayError({
+        scenarioId: this.scenarioId,
+        segment,
+        index,
+        interactionId: command.interactionId,
+        errorCode: result.errorCode,
+        reducerMessage: result.message,
+        trace: result.trace
+      });
+    }
+    this.trace.push({
+      segment,
+      index,
+      command: structuredClone(command),
+      trace: result.trace
+    });
+  }
+  async dispatch(command, segment, index) {
+    if (this.terminal)
+      return { kind: "reject", errorCode: "game-ended", trace: [] };
+    const phase = readFlowState(this.reducerState).currentPhase ?? "";
+    const playerId = resolveScenarioSeatRef({
+      ref: command.actor,
+      playerIds: this.playerIds,
+      path: `scenario.${segment}[${index}].actor`
+    });
+    const params = resolveScenarioCommandParams({
+      game: this.game,
+      currentSchema: this.currentClientParamSchema(
+        command.actor.seat,
+        command.interactionId
+      ),
+      phase,
+      interactionId: command.interactionId,
+      params: command.params,
+      playerIds: this.playerIds,
+      path: `scenario.${segment}[${index}]`
+    });
+    const result = await this.bundle.dispatch({
+      state: this.reducerState,
+      input: {
+        kind: "interaction",
+        playerId,
+        interactionId: command.interactionId,
+        params
+      }
+    });
+    if (result.kind === "reject") {
+      return {
+        kind: "reject",
+        errorCode: result.errorCode,
+        ...result.message === void 0 ? {} : { message: result.message },
+        trace: []
+      };
+    }
+    this.reducerState = structuredClone(result.state);
+    this.terminal = result.terminal ?? null;
+    return {
+      kind: "accept",
+      trace: summarizeWireTrace(result.trace)
+    };
+  }
+  playerId(seat, path) {
+    return resolveScenarioSeatRef({
+      ref: seat,
+      playerIds: this.playerIds,
+      path
+    });
+  }
+  project(playerId) {
+    return this.bundle.project({
+      state: this.reducerState,
+      playerIds: [playerId]
+    });
+  }
+};
+function inspectScenarioReplayAuthority(options) {
+  return requireScenarioReplayImplementation(
+    options.replay
+  ).inspectionAuthority(options.perspective);
+}
+function currentScenarioClientParamSchema(replay, seat, interactionId) {
+  return requireScenarioReplayImplementation(replay).currentClientParamSchema(
+    seat,
+    interactionId
+  );
+}
+function enumerateScenarioInteractionParams(options) {
+  return requireScenarioReplayImplementation(
+    options.replay
+  ).enumerateInteractionParams(options);
+}
+function advanceScenarioReplay(options) {
+  return requireScenarioReplayImplementation(options.replay).advance(
+    options.command
+  );
+}
+function descriptorsForPlayer(projection, playerId) {
+  const refs = projection.seats[playerId]?.availableInteractionRefs ?? [];
+  const interactionsByRef = projection.interactionsByRef ?? {};
+  return refs.flatMap((ref) => {
+    const descriptor = interactionsByRef[ref];
+    return descriptor ? [descriptor] : [];
+  });
+}
+function createScenarioBundle(game, events, bundle) {
+  return createReducerTestingRuntime(
+    game,
+    {
+      diagnostics: {
+        event(event) {
+          events.push(structuredClone(event));
+        }
+      }
+    },
+    bundle
+  );
+}
+function validateReplayDefinition(game, replay) {
+  validateScenarioDefinition(game, {
+    ...replay,
+    then: () => void 0
+  });
+}
+function normalizeCheckpoint(scenario, checkpoint) {
+  if (checkpoint === void 0) {
+    return { segment: "when", completed: scenario.when.length };
+  }
+  const maximum = checkpoint.segment === "setup" ? 0 : checkpoint.segment === "given" ? scenario.given.length : scenario.when.length;
+  if (!Number.isSafeInteger(checkpoint.completed) || checkpoint.completed < 0 || checkpoint.completed > maximum || checkpoint.segment === "setup" && checkpoint.completed !== 0) {
+    throw new ScenarioDefinitionValidationError({
+      code: "OUT_OF_RANGE",
+      path: "at.completed",
+      reason: `expected 0 through ${maximum} for ${checkpoint.segment}`
+    });
+  }
+  return structuredClone(checkpoint);
+}
+function readFlowState(state) {
+  const flow = state.domain?.flow;
+  if (typeof flow !== "object" || flow === null) {
+    return { currentPhase: null, activePlayers: [] };
+  }
+  const record = flow;
+  return {
+    currentPhase: typeof record.currentPhase === "string" ? record.currentPhase : null,
+    activePlayers: Array.isArray(record.activePlayers) ? record.activePlayers.filter(
+      (playerId) => typeof playerId === "string"
+    ) : []
+  };
+}
+function readPhaseStep(phase) {
+  if (!phase || typeof phase !== "object") return null;
+  const step = phase.step;
+  return typeof step === "string" ? step : null;
+}
+function summarizeWireTrace(trace) {
+  return trace.flatMap((entry) => {
+    switch (entry.kind) {
+      case "acceptedClientInput":
+        return [
+          {
+            kind: "acceptedClientInput",
+            interactionId: entry.input.interactionId,
+            playerId: entry.input.playerId
+          }
+        ];
+      case "phaseEntered":
+        return [{ kind: "phaseEntered", from: entry.from, to: entry.to }];
+      case "rngConsumption":
+        return [
+          {
+            kind: "rngConsumption",
+            version: entry.version,
+            operation: entry.operation,
+            drawIndex: entry.drawIndex
+          }
+        ];
+    }
+  });
+}
+function lastAcceptedDispatch(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index];
+    if (event?.type === "submitAccepted") {
+      return {
+        submissionId: event.submissionId,
+        trace: structuredClone(event.trace)
+      };
+    }
+  }
+  return null;
+}
+function lastRejectedEvent(diagnostics) {
+  for (let index = diagnostics.events.length - 1; index >= 0; index -= 1) {
+    const event = diagnostics.events[index];
+    if (event?.type === "submitRejected") return event;
+  }
+  return null;
+}
+function assertRejectionMatches(rejection, expected) {
+  if (expected.errorCode !== void 0 && rejection.errorCode !== expected.errorCode) {
+    scenarioAssertionFailure(
+      `Expected rejection errorCode '${expected.errorCode}', received '${rejection.errorCode}'.`
+    );
+  }
+  if (typeof expected.message === "string" && rejection.message !== expected.message) {
+    scenarioAssertionFailure(
+      `Expected rejection message '${expected.message}', received '${rejection.message ?? "undefined"}'.`
+    );
+  }
+  if (expected.message instanceof RegExp && !expected.message.test(rejection.message ?? "")) {
+    scenarioAssertionFailure(
+      `Expected rejection message '${rejection.message ?? ""}' to match ${String(expected.message)}.`
+    );
+  }
+}
+function requireScenarioReplayImplementation(replay) {
+  if (!(replay instanceof ScenarioReplayImplementation)) {
+    throw new Error(
+      "Scenario replay was not created by replayScenario(); alternate replay implementations are not supported."
+    );
+  }
+  return replay;
+}
 
 // src/testing/inspection/flow-diagnostic.ts
 function createFlowDiagnostic(options) {
@@ -234,11 +2095,12 @@ function projectDispatchTrace(commandTrace, playerIds, perspective) {
             }
           ];
         }
-        case "appliedInstruction":
+        case "phaseEntered":
           return [
             {
-              kind: "appliedInstruction",
-              instructionKind: trace.instruction
+              kind: "phaseEntered",
+              from: trace.from,
+              to: trace.to
             }
           ];
         case "rngConsumption":
@@ -266,8 +2128,20 @@ function assertSeed(seed) {
   }
 }
 
+// src/testing/canonical.ts
+function canonicalScenarioJson(value) {
+  return encodeCanonicalPluginRuntimeJson(value);
+}
+function digestScenarioJson(value) {
+  return digestPluginRuntimeJson(value);
+}
+function compareCanonicalScenarioJson(left, right) {
+  const leftJson = canonicalScenarioJson(left);
+  const rightJson = canonicalScenarioJson(right);
+  return leftJson === rightJson ? 0 : leftJson < rightJson ? -1 : 1;
+}
+
 // src/testing/exploration/cursor.ts
-import { Buffer } from "buffer";
 var CURSOR_VERSION = 1;
 var ExploreCursorError = class extends Error {
   code = "TEST_EXPLORE_CURSOR_STALE";
@@ -290,9 +2164,12 @@ function createExploreCursor(options) {
     seedOverride: options.seedOverride ?? null,
     nextOrdinal: options.nextOrdinal
   };
-  const encoded = Buffer.from(JSON.stringify(payload), "utf8").toString(
-    "base64url"
-  );
+  const encoded = btoa(
+    Array.from(
+      new TextEncoder().encode(JSON.stringify(payload)),
+      (byte) => String.fromCharCode(byte)
+    ).join("")
+  ).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
   const digest = digestPluginRuntimeJson(payload).slice("sha256:".length);
   return `dbx1.${encoded}.${digest}`;
 }
@@ -308,7 +2185,12 @@ function readExploreCursor(options) {
   let payload;
   try {
     payload = JSON.parse(
-      Buffer.from(encoded, "base64url").toString("utf8")
+      new TextDecoder("utf-8", { fatal: true }).decode(
+        Uint8Array.from(
+          atob(encoded.replaceAll("-", "+").replaceAll("_", "/")),
+          (character) => character.charCodeAt(0)
+        )
+      )
     );
   } catch {
     return stale();
@@ -436,6 +2318,11 @@ async function exploreTransitions(options) {
         interactionId: action.interactionId,
         params: projectScenarioCommandParams({
           game: options.game,
+          currentSchema: currentScenarioClientParamSchema(
+            replay,
+            action.actor.seat,
+            action.interactionId
+          ),
           phase: node.flow.phase,
           interactionId: action.interactionId,
           params: assignment,
@@ -539,7 +2426,7 @@ async function exploreSeeds(options, range) {
           actions: inspected.node.actions.map(({ actor, interactionId }) => ({
             seat: actor.seat,
             interactionId,
-            concreteOptionCount: counts.get(`${actor.seat}:${interactionId}`) ?? "lazy"
+            concreteOptionCount: counts.get(`${actor.seat}:${interactionId}`) ?? "unknown"
           }))
         }
       });
@@ -582,7 +2469,7 @@ async function concreteOptionCounts(options) {
   for (const action of options.node.actions) {
     const remaining = options.maxEvaluations - evaluated;
     if (remaining <= 0) {
-      counts.set(`${action.actor.seat}:${action.interactionId}`, "lazy");
+      counts.set(`${action.actor.seat}:${action.interactionId}`, "unknown");
       continue;
     }
     const result = enumerateScenarioInteractionParams({
@@ -595,7 +2482,7 @@ async function concreteOptionCounts(options) {
     evaluated += result.enumeration.evaluated;
     counts.set(
       `${action.actor.seat}:${action.interactionId}`,
-      result.enumeration.status === "enumerated" ? result.enumeration.assignments.length : "lazy"
+      result.enumeration.status === "enumerated" ? result.enumeration.assignments.length : "unknown"
     );
   }
   return counts;
@@ -644,90 +2531,6 @@ function assertSeedRange(range) {
   }
 }
 
-// src/testing/ui-fixture/canonical.ts
-import { createHash } from "crypto";
-var sha256DigestPattern = /^sha256:[a-f0-9]{64}$/;
-function compareCanonicalStrings(left, right) {
-  return left === right ? 0 : left < right ? -1 : 1;
-}
-function isSha256Digest(value) {
-  return sha256DigestPattern.test(value);
-}
-function canonicalizeUIFixtureJson(value) {
-  if (value === null) {
-    return null;
-  }
-  switch (typeof value) {
-    case "boolean":
-    case "string":
-      return value;
-    case "number":
-      if (Number.isFinite(value)) {
-        return value;
-      }
-      break;
-    case "object": {
-      if (Array.isArray(value)) {
-        return value.map((item) => canonicalizeUIFixtureJson(item));
-      }
-      if (Object.getPrototypeOf(value) !== Object.prototype) {
-        break;
-      }
-      const entries = Object.entries(value);
-      return Object.fromEntries(
-        entries.filter(([, item]) => item !== void 0).sort(([left], [right]) => compareCanonicalStrings(left, right)).map(([key, item]) => [key, canonicalizeUIFixtureJson(item)])
-      );
-    }
-  }
-  throw new Error(
-    `UI fixture values must be deterministic JSON. Received ${typeof value}.`
-  );
-}
-function canonicalUIFixtureJson(value) {
-  return JSON.stringify(canonicalizeUIFixtureJson(value));
-}
-function digestUIFixtureJson(value) {
-  return sha256(canonicalUIFixtureJson(value));
-}
-function digestUIFixtureRequest(request) {
-  return digestUIFixtureJson({
-    digestVersion: "ui-replay-request@2",
-    request
-  });
-}
-function digestUIFixtureTransportRequest(request) {
-  return digestUIFixtureJson({
-    digestVersion: "ui-fixture-runtime-command@3",
-    request
-  });
-}
-function digestPluginProtocolTape(tape) {
-  return digestUIFixtureJson({
-    digestVersion: "plugin-protocol-tape@2",
-    tape
-  });
-}
-function canonicalizeUIScenarioFixture(fixture) {
-  return canonicalizeUIFixtureJson({
-    ...fixture,
-    tags: [...fixture.tags].sort(),
-    environment: {
-      ...fixture.environment,
-      viewportTags: [...fixture.environment.viewportTags].sort()
-    }
-  });
-}
-function serializeUIScenarioFixture(fixture) {
-  return `${JSON.stringify(canonicalizeUIScenarioFixture(fixture), null, 2)}
-`;
-}
-function digestUIScenarioFixture(fixture) {
-  return sha256(serializeUIScenarioFixture(fixture));
-}
-function sha256(value) {
-  return `sha256:${createHash("sha256").update(value).digest("hex")}`;
-}
-
 // src/testing/reducer-scenario/create-reducer-scenario-runner.ts
 function createReducerScenarioRunner(options) {
   return {
@@ -742,7 +2545,7 @@ function createReducerScenarioRunner(options) {
           playerIds: [options.viewer.playerId]
         });
         const staticProjection = options.bundle.boardStatic();
-        const flow = readFlowState(state);
+        const flow = readFlowState2(state);
         const materialized = materializePluginGameplayFrame({
           currentPhase: flow.currentPhase,
           activePlayers: flow.activePlayers,
@@ -763,7 +2566,7 @@ function createReducerScenarioRunner(options) {
           staticProjection,
           gameVersion,
           actionSetVersion,
-          projectionDigest: digestUIFixtureJson({
+          projectionDigest: digestScenarioJson({
             digestVersion: "reducer-scenario-frame@2",
             scenarioId: options.scenarioId,
             frameId: id,
@@ -847,857 +2650,587 @@ function createReducerScenarioRunner(options) {
     }
   };
 }
-function readFlowState(state) {
+function readFlowState2(state) {
   return {
     currentPhase: state.domain?.flow?.currentPhase ?? null,
     activePlayers: [...state.domain?.flow?.activePlayers ?? []]
   };
 }
 
-// src/testing/ui-scenario/define-ui-scenario.ts
-function defineUIScenario(scenario) {
-  return Object.freeze(scenario);
-}
-
-// src/testing/ui-fixture/create-fixture-host-harness.ts
-var DEFAULT_CHANNEL_ID = "fixture-channel";
-function createFixtureHostHarness(options) {
-  const strict = options.strict ?? true;
-  const latencyMs = options.latencyMs ?? 0;
-  const channelId = options.channelId ?? DEFAULT_CHANNEL_ID;
-  const events = [];
-  const frameById = new Map(
-    options.tape.frames.map((frame) => [frame.id, frame])
-  );
-  let eventSequence = 0;
-  let envelopeSequence = 0;
-  let stepCursor = 0;
-  let currentFrameId = null;
-  let onMessage = null;
-  let firstFixtureError = null;
-  const pendingHandlers = /* @__PURE__ */ new Set();
-  const record = (event) => {
-    const entry = {
-      sequence: ++eventSequence,
-      atMs: options.nowMs?.() ?? eventSequence,
-      ...event
-    };
-    events.push(entry);
-    options.onEvent?.(entry);
-  };
-  const createFixtureError = (code, message) => {
-    record({ kind: "diagnostic" });
-    const error = new Error(message);
-    error.name = "FixtureHostHarnessError";
-    Object.assign(error, { errorCode: code });
-    return error;
-  };
-  const rememberFixtureError = (error) => {
-    if (firstFixtureError) {
-      return;
-    }
-    firstFixtureError = error instanceof Error ? error : createFixtureError(
-      "fixture-unknown-error",
-      "Fixture host failed with an unknown error."
-    );
-  };
-  const throwFixtureError = () => {
-    if (firstFixtureError) {
-      throw firstFixtureError;
-    }
-  };
-  const sendHostPayload = (payload) => {
-    if (!onMessage) {
-      return;
-    }
-    onMessage({
-      protocol: DREAMBOARD_PLUGIN_PROTOCOL,
-      version: DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
-      channelId,
-      sequence: ++envelopeSequence,
-      payload
-    });
-  };
-  const sendInit = () => {
-    sendHostPayload({
-      type: "runtime.init",
-      session: options.tape.session
-    });
-  };
-  const publishFrame = (frameId) => {
-    const frame = frameById.get(frameId);
-    if (!frame) {
-      throw createFixtureError(
-        "fixture-missing-frame",
-        `Plugin protocol tape references missing frame '${frameId}'.`
+// src/testing/sources/test-source.ts
+function createTestSource(initial) {
+  const sessionId = crypto.randomUUID();
+  const submissions = [];
+  const lifecycle = createSourceLifecycle({
+    send(command) {
+      submissions.push(
+        Object.freeze({
+          operation: command.type === "interaction.submit" ? "submit" : "cancel",
+          interactionId: command.interactionId,
+          ...command.type === "interaction.submit" ? { params: immutableCopy(command.params) } : {},
+          resolve(result) {
+            lifecycle.result({
+              ...result,
+              type: "interaction.result",
+              clientActionId: command.clientActionId
+            });
+          }
+        })
       );
+    },
+    recover() {
+    },
+    close() {
     }
-    currentFrameId = frame.id;
-    record({
-      kind: "frame-sent",
-      frameId: frame.id,
-      projectionDigest: frame.projectionDigest
-    });
-    sendHostPayload({
-      type: "gameplay.frame",
-      frame: frame.frame
+  });
+  function emit(value) {
+    const snapshot = SourceSnapshotSchema.parse(value);
+    lifecycle.session({ sessionId, players: snapshot.players });
+    lifecycle.frame({
+      ...snapshot.frame,
+      basis: {
+        version: snapshot.version,
+        perspectivePlayerId: snapshot.me,
+        actionSetVersion: computePluginActionSetVersion({
+          version: snapshot.version,
+          availableInteractions: snapshot.frame.availableInteractions
+        })
+      }
     });
+  }
+  emit(initial);
+  return {
+    ...lifecycle.source,
+    get submissions() {
+      return [...submissions];
+    },
+    emit
   };
-  const drainHostFrames = () => {
-    while (options.tape.steps[stepCursor]?.kind === "host.frame") {
-      const step = options.tape.steps[stepCursor];
-      stepCursor += 1;
-      publishFrame(step.frameId);
-    }
-  };
-  const drainOneHostFrame = () => {
-    if (options.tape.steps[stepCursor]?.kind !== "host.frame") {
-      return;
-    }
-    const step = options.tape.steps[stepCursor];
-    stepCursor += 1;
-    publishFrame(step.frameId);
-  };
-  const waitForConfiguredLatency = async () => {
-    if (latencyMs <= 0) {
-      await Promise.resolve();
-      return;
-    }
-    await new Promise((resolve) => setTimeout(resolve, latencyMs));
+}
+
+// src/testing/sources/local-source.ts
+import { createStore } from "@tanstack/store";
+import { z as z3 } from "zod";
+var checkpointSchema = z3.object({
+  state: ReducerSessionStateSchema,
+  terminal: GameOutcomeSchema.nullable()
+}).strict();
+async function localSource(game, options) {
+  const setup = game.contract.manifest.normalSetup;
+  if (!setup) throw new Error("Game manifest does not expose normal setup.");
+  const playerIds = resolvePlayerRoster(game, options.players);
+  const runtime = createReducerTestingRuntime(game);
+  const initial = await runtime.initialize({
+    table: setup.createInitialTable({ playerIds }),
+    playerIds,
+    rngSeed: options.seed,
+    options: options.options
+  });
+  return createLocalProvider(
+    game,
+    runtime,
+    playerIds,
+    { state: initial.state, terminal: initial.terminal ?? null },
+    options.as ?? playerIds[0]
+  );
+}
+function createLocalProvider(game, runtime, playerIds, initial, selectedPlayerId) {
+  let checkpoint = immutableCopy(checkpointSchema.parse(initial));
+  let revision = 1;
+  let playerId = selectedPlayerId;
+  let epoch = 0;
+  let disposed = false;
+  let inFlight = false;
+  let disconnect = () => {
   };
-  const consumeExpectedStep = (kind, requestDigest) => {
-    const step = options.tape.steps[stepCursor];
-    if (!step) {
-      throw createFixtureError(
-        "fixture-protocol-exhausted",
-        `Plugin protocol tape has no remaining step for ${kind}.`
-      );
-    }
-    if (step.kind !== kind) {
-      throw createFixtureError(
-        "fixture-protocol-step-mismatch",
-        `Expected protocol step '${step.kind}' but received '${kind}'.`
-      );
-    }
-    if (step.fromFrameId !== currentFrameId) {
-      throw createFixtureError(
-        "fixture-protocol-frame-mismatch",
-        `Expected protocol from frame '${step.fromFrameId}' but current frame is '${currentFrameId ?? "<none>"}'.`
-      );
-    }
-    if (step.requestDigest !== requestDigest) {
-      const mode = strict ? "strict" : "compatible";
-      throw createFixtureError(
-        "fixture-protocol-digest-mismatch",
-        `${mode} fixture protocol digest mismatch for ${kind}: expected ${step.requestDigest}, received ${requestDigest}.`
-      );
-    }
-    stepCursor += 1;
-    return step;
+  const session = {
+    sessionId: crypto.randomUUID(),
+    players: playerIds.map((id) => ({ playerId: id, displayName: id }))
   };
-  const handleSubmit = async (command) => {
-    const requestDigest = digestUIFixtureTransportRequest({
-      operation: "submit",
-      basis: command.basis,
-      interactionId: command.interactionId,
-      payload: command.params
-    });
-    const step = consumeExpectedStep("client.submit", requestDigest);
-    record({
-      kind: "submit-received",
-      requestDigest,
-      result: step.response.accepted ? "accepted" : "rejected"
-    });
-    await waitForConfiguredLatency();
-    sendHostPayload({
-      ...step.response,
-      clientActionId: command.clientActionId
+  const store = createStore({
+    snapshot: null,
+    connection: "connecting",
+    request: null
+  });
+  let lifecycle;
+  function assertOpen() {
+    if (disposed) throw new Error("Local source disposed.");
+  }
+  function assertIdle() {
+    assertOpen();
+    if (inFlight || store.get().request)
+      throw new Error("A gameplay interaction is already pending.");
+  }
+  function makeFrame(state = checkpoint.state) {
+    const projection = runtime.project({ state, playerIds: [playerId] });
+    const provisional = materializePluginGameplayFrame({
+      currentPhase: state.domain.flow.currentPhase,
+      activePlayers: projection.schedulerFlow?.activePlayerIds ?? [],
+      dynamicProjection: projection,
+      staticProjection: runtime.boardStatic(),
+      perspectivePlayerId: playerId,
+      version: revision,
+      actionSetVersion: "pending"
     });
-    if (step.response.accepted) {
-      await waitForConfiguredLatency();
-      drainHostFrames();
-    }
-  };
-  const handleClientPayload = (payload) => {
-    const trackHandler = (promise) => {
-      pendingHandlers.add(promise);
-      promise.catch((error) => {
-        rememberFixtureError(error);
-      }).finally(() => {
-        pendingHandlers.delete(promise);
-      });
-    };
-    switch (payload.type) {
-      case "runtime.ready":
-        record({ kind: "ready-received" });
-        break;
-      case "runtime.ack":
-        record({ kind: "ack-received" });
-        break;
-      case "interaction.submit":
-        trackHandler(handleSubmit(payload));
-        break;
-      case "runtime.error":
-        record({ kind: "diagnostic" });
-        break;
-      default: {
-        const _exhaustive = payload;
-        return _exhaustive;
+    return {
+      ...provisional,
+      basis: {
+        ...provisional.basis,
+        actionSetVersion: computePluginActionSetVersion({
+          version: revision,
+          availableInteractions: provisional.availableInteractions
+        })
       }
-    }
-  };
-  const transport = {
-    start(nextOnMessage) {
-      onMessage = nextOnMessage;
-      queueMicrotask(() => {
-        sendInit();
-        drainOneHostFrame();
+    };
+  }
+  function publish() {
+    lifecycle.frame(makeFrame());
+  }
+  async function execute(input) {
+    assertOpen();
+    if (inFlight) throw new Error("A gameplay interaction is already pending.");
+    if (checkpoint.terminal)
+      return { accepted: false, errorCode: "game-ended" };
+    inFlight = true;
+    const generation = epoch;
+    try {
+      const result = await runtime.dispatch({ state: checkpoint.state, input });
+      if (disposed || generation !== epoch)
+        throw new Error("Local source lifetime changed.");
+      if (result.kind === "reject")
+        return {
+          accepted: false,
+          errorCode: result.errorCode,
+          ...result.message === void 0 ? {} : { message: result.message }
+        };
+      checkpoint = immutableCopy({
+        state: result.state,
+        terminal: result.terminal ?? null
       });
-      return () => {
-        onMessage = null;
-      };
-    },
-    send(message) {
-      handleClientPayload(message);
+      revision++;
+      publish();
+      return { accepted: true };
+    } finally {
+      if (generation === epoch) inFlight = false;
     }
-  };
-  return {
-    transport,
-    tape: options.tape,
-    reset() {
-      eventSequence = 0;
-      envelopeSequence = 0;
-      stepCursor = 0;
-      currentFrameId = null;
-      firstFixtureError = null;
-      pendingHandlers.clear();
-      events.length = 0;
-      if (onMessage) {
-        sendInit();
-        drainOneHostFrame();
+  }
+  function replaceLifetime() {
+    if (!playerIds.includes(playerId))
+      throw new Error("Unknown local source seat.");
+    epoch++;
+    inFlight = false;
+    disconnect();
+    lifecycle?.source.dispose();
+    const generation = epoch;
+    lifecycle = createSourceLifecycle({
+      context: { sessionId: session.sessionId, playerId },
+      send(command) {
+        const current = lifecycle;
+        void execute(
+          command.type === "interaction.cancel" ? {
+            kind: "interaction.cancel",
+            playerId,
+            interactionId: command.interactionId
+          } : {
+            kind: "interaction",
+            playerId,
+            interactionId: command.interactionId,
+            params: command.params
+          }
+        ).then((result) => {
+          if (generation === epoch)
+            current.result({
+              ...result,
+              type: "interaction.result",
+              clientActionId: command.clientActionId
+            });
+        }).catch((error) => {
+          if (generation === epoch)
+            current.fail(
+              error instanceof Error ? error : new Error(String(error))
+            );
+        });
+      },
+      recover: publish,
+      close() {
       }
+    });
+    lifecycle.session(session);
+    publish();
+    store.setState(() => lifecycle.source.store.get());
+    const subscription = lifecycle.source.store.subscribe(
+      () => store.setState(() => lifecycle.source.store.get())
+    );
+    disconnect = () => subscription.unsubscribe();
+  }
+  replaceLifetime();
+  return {
+    store: {
+      get: () => store.get(),
+      subscribe: (listener) => store.subscribe(listener)
     },
-    async flush() {
-      await waitForConfiguredLatency();
-      await Promise.resolve();
-      while (pendingHandlers.size > 0) {
-        await Promise.allSettled([...pendingHandlers]);
-      }
-      throwFixtureError();
+    async submit(interactionId, params) {
+      assertIdle();
+      return lifecycle.source.submit(interactionId, params);
     },
-    async advanceHost() {
-      await waitForConfiguredLatency();
-      drainHostFrames();
-      throwFixtureError();
+    async cancel(interactionId) {
+      assertIdle();
+      return lifecycle.source.cancel(interactionId);
     },
-    getCurrentFrameId() {
-      if (!currentFrameId) {
-        throw createFixtureError(
-          "fixture-frame-not-started",
-          "Fixture host has not emitted a gameplay frame."
-        );
-      }
-      return currentFrameId;
+    async apply(command) {
+      assertIdle();
+      const actor = resolveScenarioSeatRef({
+        ref: command.actor,
+        playerIds,
+        path: "command.actor"
+      });
+      const currentSchema = runtime.currentClientParamSchema({
+        state: checkpoint.state,
+        playerId: actor,
+        interactionId: command.interactionId
+      });
+      const params = resolveScenarioCommandParams({
+        game,
+        currentSchema,
+        phase: checkpoint.state.domain.flow.currentPhase,
+        interactionId: command.interactionId,
+        params: command.params,
+        playerIds,
+        path: "command"
+      });
+      return execute({
+        kind: "interaction",
+        playerId: actor,
+        interactionId: command.interactionId,
+        params
+      });
     },
-    getEvents() {
-      return events.map((event) => ({ ...event }));
+    switchSeat(next) {
+      assertOpen();
+      if (!playerIds.includes(next))
+        throw new Error("Unknown local source seat.");
+      if (next === playerId) return;
+      playerId = next;
+      replaceLifetime();
     },
-    assertConsumed() {
-      throwFixtureError();
-      if (stepCursor !== options.tape.steps.length) {
-        throw createFixtureError(
-          "fixture-unconsumed-protocol-steps",
-          `Plugin protocol tape consumed ${stepCursor} of ${options.tape.steps.length} protocol step(s).`
-        );
+    checkpoint() {
+      assertOpen();
+      return structuredClone(checkpoint);
+    },
+    restore(value) {
+      assertOpen();
+      const next = checkpointSchema.parse(value);
+      runtime.project({ state: next.state, playerIds: [...playerIds] });
+      const restoredRoster = next.state.domain.table.playerOrder;
+      if (restoredRoster.length !== playerIds.length || restoredRoster.some((id, index) => id !== playerIds[index]))
+        throw new Error("Checkpoint roster does not match the local session.");
+      checkpoint = immutableCopy(next);
+      revision++;
+      replaceLifetime();
+    },
+    inspect() {
+      assertOpen();
+      return store.get().snapshot;
+    },
+    async explore({ maxEvaluations }) {
+      assertOpen();
+      if (!Number.isSafeInteger(maxEvaluations) || maxEvaluations < 1)
+        throw new Error("Enumeration budget must be a positive integer.");
+      if (checkpoint.terminal) return [];
+      const commands = [];
+      let remaining = maxEvaluations;
+      const capturedState = checkpoint.state;
+      const capturedEpoch = epoch;
+      const capturedRevision = revision;
+      for (const descriptor of store.get().snapshot.frame.availableInteractions) {
+        if (remaining <= 0) break;
+        const result = runtime.enumerateInteractionParams({
+          state: checkpoint.state,
+          playerId,
+          interactionId: descriptor.interactionId,
+          maxEvaluations: remaining
+        });
+        if (!result.found || !result.visible || !result.enumeration) continue;
+        remaining -= result.enumeration.evaluated;
+        for (const params of result.enumeration.assignments) {
+          const probe = await runtime.dispatch({
+            state: structuredClone(capturedState),
+            input: {
+              kind: "interaction",
+              playerId,
+              interactionId: descriptor.interactionId,
+              params
+            }
+          });
+          if (disposed || capturedEpoch !== epoch || capturedRevision !== revision)
+            throw new Error("Source changed during exploration.");
+          if (probe.kind === "reject") continue;
+          const projected = projectScenarioCommandParams({
+            game,
+            currentSchema: runtime.currentClientParamSchema({
+              state: checkpoint.state,
+              playerId,
+              interactionId: descriptor.interactionId
+            }),
+            phase: checkpoint.state.domain.flow.currentPhase,
+            interactionId: descriptor.interactionId,
+            params,
+            playerIds,
+            path: "explore"
+          });
+          commands.push({
+            actor: { seat: playerIds.indexOf(playerId) },
+            interactionId: descriptor.interactionId,
+            params: projected
+          });
+        }
       }
+      return commands;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      epoch++;
+      lifecycle.source.dispose();
+      disconnect();
     }
   };
 }
 
-// src/testing/ui-fixture/FixturePluginRuntime.tsx
-import { useMemo } from "react";
-import { jsx } from "react/jsx-runtime";
-function FixturePluginRuntime({
-  harness,
-  runtime,
-  children
-}) {
-  const fixtureRuntime = useMemo(
-    () => runtime ?? createPluginRuntimeClient({ transport: harness.transport }),
-    [harness.transport, runtime]
+// src/testing/sources/scenario-source.ts
+async function scenarioSource(game, scenario, options = {}) {
+  const materialized = await materializeScenarioRuntimeCheckpoint({
+    game,
+    scenario,
+    ...options.at === void 0 ? {} : { at: resolveScenarioCheckpoint(scenario, options.at) }
+  });
+  return createLocalProvider(
+    game,
+    createReducerTestingRuntime(game),
+    materialized.playerIds,
+    { state: materialized.state, terminal: materialized.terminal },
+    options.as ?? materialized.playerIds[0]
   );
-  return /* @__PURE__ */ jsx(PluginRuntimeBoundary, { runtime: fixtureRuntime, children });
 }
 
-// src/testing/ui-fixture/compile-plugin-protocol-tape.ts
-function compilePluginProtocolTape(options) {
-  const frames = options.trace.frames.map(
-    (frame) => materializeTraceFrame(frame, options.trace.viewer.playerId)
-  );
-  const frameById = new Map(frames.map((frame) => [frame.id, frame]));
-  const steps = [];
-  const firstFrame = frames[0];
-  if (!firstFrame) {
-    throw new Error(
-      `Reducer scenario '${options.trace.scenarioId}' did not record frames.`
-    );
-  }
-  steps.push({
-    id: `${firstFrame.id}.host-frame`,
-    kind: "host.frame",
-    frameId: firstFrame.id
-  });
-  for (const exchange of options.trace.exchanges) {
-    const fromFrame = frameById.get(exchange.fromFrameId);
-    if (!fromFrame) {
-      throw new Error(
-        `Reducer exchange '${exchange.id}' references missing frame '${exchange.fromFrameId}'.`
-      );
-    }
-    if (exchange.operation === "validate") {
-      continue;
-    }
-    steps.push({
-      id: exchange.id,
-      kind: "client.submit",
-      fromFrameId: exchange.fromFrameId,
-      requestDigest: digestRuntimeCommand(exchange, fromFrame),
-      response: exchange.result.kind === "accepted" ? {
-        type: "interaction.result",
-        clientActionId: exchange.id,
-        accepted: true
-      } : {
-        type: "interaction.result",
-        clientActionId: exchange.id,
-        accepted: false,
-        errorCode: exchange.result.diagnostics[0]?.code ?? "fixture-rejected",
-        message: exchange.result.diagnostics[0]?.message
-      }
-    });
-    if (exchange.result.kind === "accepted") {
-      if (!frameById.has(exchange.result.toFrameId)) {
-        throw new Error(
-          `Reducer exchange '${exchange.id}' references missing toFrameId '${exchange.result.toFrameId}'.`
-        );
+// src/testing/sources/fuzz.ts
+async function fuzz(game, options) {
+  if (!Number.isSafeInteger(options.steps) || options.steps < 0)
+    throw new Error("Fuzz steps must be a nonnegative integer.");
+  const players = options.players ?? game.contract.manifest.normalSetup?.minPlayers;
+  if (!players) throw new Error("Game manifest does not expose normal setup.");
+  const source = await localSource(game, { players, seed: options.seed });
+  let rng = {
+    seed: options.seed,
+    cursor: 0,
+    draws: [],
+    trace: []
+  };
+  const commands = [];
+  try {
+    for (let step = 0; step < options.steps && !source.checkpoint().terminal; step++) {
+      const actors = [];
+      for (const player of source.inspect().players) {
+        source.switchSeat(player.playerId);
+        if (source.inspect().frame.availableInteractions.some(
+          (interaction) => interaction.availability.status === "available"
+        ))
+          actors.push(player.playerId);
       }
-      steps.push({
-        id: `${exchange.id}.host-frame`,
-        kind: "host.frame",
-        frameId: exchange.result.toFrameId
+      if (actors.length === 0) break;
+      const [actorIndex, actorRng] = nextRandomInt(actors.length, rng);
+      rng = actorRng;
+      source.switchSeat(actors[actorIndex]);
+      const choices = await source.explore({
+        maxEvaluations: options.maxEvaluations ?? 5e3
       });
+      if (choices.length === 0) break;
+      const [index, next] = nextRandomInt(choices.length, rng);
+      rng = next;
+      const command = choices[index];
+      commands.push(command);
+      const result = await source.apply(command);
+      if (!result.accepted)
+        throw new Error(`Explored command rejected: ${result.errorCode}`);
     }
+    return { commands, checkpoint: source.checkpoint() };
+  } catch (error) {
+    return {
+      commands,
+      checkpoint: source.checkpoint(),
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  } finally {
+    source.dispose();
   }
-  return {
-    session: options.session,
-    frames,
-    steps
-  };
-}
-function materializeTraceFrame(frame, perspectivePlayerId) {
-  const flow = readFlowState2(frame.reducerState);
-  return {
-    id: frame.id,
-    frame: materializePluginGameplayFrame({
-      currentPhase: flow.currentPhase,
-      activePlayers: flow.activePlayers,
-      dynamicProjection: frame.dynamicProjection,
-      staticProjection: frame.staticProjection,
-      perspectivePlayerId,
-      version: frame.gameVersion,
-      actionSetVersion: frame.actionSetVersion
-    }),
-    projectionDigest: frame.projectionDigest
-  };
-}
-function digestRuntimeCommand(exchange, frame) {
-  return digestUIFixtureTransportRequest({
-    operation: exchange.operation === "validate" ? "validate" : "submit",
-    basis: frame.frame.basis,
-    interactionId: exchange.input.interactionId,
-    payload: exchange.input.params
-  });
-}
-function readFlowState2(state) {
-  return {
-    currentPhase: state.domain?.flow?.currentPhase ?? null,
-    activePlayers: [...state.domain?.flow?.activePlayers ?? []]
-  };
-}
-
-// src/testing/ui-fixture/deterministic-environment.ts
-var defaultFixtureEnvironmentInit = {
-  clockIso: "2026-01-01T00:00:00.000Z",
-  randomSeed: "dreamboard-ui-fixture",
-  locale: "en-US",
-  timezone: "UTC",
-  reducedMotion: true,
-  network: "blocked"
-};
-function createDeterministicIdFactory(seed) {
-  let cursor = 0;
-  return () => {
-    cursor += 1;
-    return `fixture-${slug(seed)}-${cursor.toString(36).padStart(4, "0")}`;
-  };
-}
-function fixtureEnvironmentInitFor(options) {
-  return {
-    ...defaultFixtureEnvironmentInit,
-    clockIso: options.clockIso,
-    randomSeed: options.randomSeed
-  };
-}
-function slug(value) {
-  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 48) || "seed";
 }
 
-// src/testing/ui-fixture/schema.ts
-import { z } from "zod";
-var UI_SCENARIO_FIXTURE_SCHEMA_VERSION = 2;
-var UI_SCENARIO_FIXTURE_BUNDLE_SCHEMA_VERSION = 2;
-var UI_SCENARIO_FIXTURE_SUPPORTED_BROWSER_PROTOCOL_MAJOR = 3;
-var UI_SCENARIO_FIXTURE_PLUGIN_RUNTIME_PROTOCOL = DREAMBOARD_PLUGIN_PROTOCOL_VERSION;
-var digestSchema = z.string().refine(isSha256Digest, {
-  message: "Expected a sha256:<64 lowercase hex> digest."
-});
-var nonEmptyStringSchema = z.string().min(1);
-var jsonSchema = RuntimeJsonSchema;
-var environmentSchema = z.object({
-  clockIso: nonEmptyStringSchema,
-  randomSeed: nonEmptyStringSchema,
-  locale: z.literal("en-US"),
-  timezone: z.literal("UTC"),
-  viewportTags: z.array(z.enum(["desktop", "tablet", "phone", "touch"]))
-}).strict();
-var uiFixtureFrameSchema = PluginProtocolFrameSchema;
-var uiFixtureProtocolStepSchema = PluginProtocolStepSchema;
-var pluginProtocolTapeSchema = PluginProtocolTapeSchema.refine(
-  (tape) => tape.frames.length > 0,
-  "UI fixture protocol tapes require at least one gameplay frame."
-);
-var browserInteractionIntentRequestSchema = z.object({
-  surface: nonEmptyStringSchema,
-  scopeId: nonEmptyStringSchema.optional(),
-  interactionKey: nonEmptyStringSchema.optional(),
-  interactionId: nonEmptyStringSchema.optional(),
-  intent: nonEmptyStringSchema,
-  inputKey: nonEmptyStringSchema.optional(),
-  candidateValue: jsonSchema.optional(),
-  candidateValueKey: nonEmptyStringSchema.optional(),
-  actuatorKind: z.enum(BROWSER_INTERACTION_ACTUATOR_KINDS).optional(),
-  allowDisabled: z.boolean().optional()
-}).strict();
-var browserInteractionEffectRequestSchema = z.object({
-  surface: nonEmptyStringSchema,
-  scopeId: nonEmptyStringSchema.optional(),
-  interactionKey: nonEmptyStringSchema.optional(),
-  interactionId: nonEmptyStringSchema.optional(),
-  effect: browserInteractionEffectSchema,
-  allowDisabled: z.boolean().optional()
-}).strict();
-var uiReplayRequestSchema = z.union([
-  browserInteractionIntentRequestSchema,
-  browserInteractionEffectRequestSchema
-]);
-var uiReplayExecutionSchema = z.union([
-  z.object({
-    kind: z.literal("activate")
-  }).strict(),
-  z.object({
-    kind: z.literal("fill"),
-    value: z.string()
-  }).strict(),
-  z.object({
-    kind: z.literal("drag"),
-    target: browserInteractionEffectRequestSchema
-  }).strict()
-]);
-var uiStepExpectationSchema = z.object({
-  frameId: nonEmptyStringSchema.optional(),
-  projectionDigest: digestSchema.optional(),
-  semanticDigest: digestSchema.optional(),
-  draftDigest: digestSchema.optional(),
-  submissionDigest: digestSchema.optional(),
-  focusedInteractionKey: nonEmptyStringSchema.optional(),
-  visibleInteractionKeys: z.array(nonEmptyStringSchema).optional()
-}).strict();
-var uiResolvedReplayIdentitySchema = z.object({
-  stepId: nonEmptyStringSchema,
-  surface: nonEmptyStringSchema,
-  scopeId: nonEmptyStringSchema,
-  interactionKey: nonEmptyStringSchema,
-  interactionId: nonEmptyStringSchema,
-  actuatorId: nonEmptyStringSchema,
-  descriptorDigest: digestSchema.optional(),
-  draftDigest: digestSchema.optional()
-}).strict();
-var portableSemanticReplayStepSchema = z.object({
-  stepId: nonEmptyStringSchema,
-  requestDigest: digestSchema,
-  resolve: uiReplayRequestSchema,
-  execute: uiReplayExecutionSchema,
-  expectedIdentity: uiResolvedReplayIdentitySchema.optional(),
-  expect: uiStepExpectationSchema
-}).strict();
-var uiScenarioReplayStepSchema = z.union([
-  portableSemanticReplayStepSchema,
-  z.object({
-    stepId: nonEmptyStringSchema,
-    kind: z.literal("assert"),
-    expect: uiStepExpectationSchema
-  }).strict()
+// src/testing/candidate-verification.ts
+var CANDIDATE_INPUT_FIELDS = /* @__PURE__ */ new Set([
+  "reducer",
+  "bundle",
+  "scenarios",
+  "maxScenarios",
+  "maxStepsPerScenario"
 ]);
-var uiScenarioFixtureSchema = z.object({
-  schemaVersion: z.literal(UI_SCENARIO_FIXTURE_SCHEMA_VERSION),
-  browserInteractionProtocol: z.literal(
-    DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION
-  ),
-  pluginRuntimeProtocol: z.literal(DREAMBOARD_PLUGIN_PROTOCOL_VERSION),
-  id: nonEmptyStringSchema,
-  title: nonEmptyStringSchema,
-  gameId: nonEmptyStringSchema,
-  tags: z.array(nonEmptyStringSchema),
-  source: z.object({
-    scenarioId: nonEmptyStringSchema,
-    reducerFingerprint: nonEmptyStringSchema,
-    uiContractFingerprint: nonEmptyStringSchema,
-    renderModule: nonEmptyStringSchema,
-    renderModuleDigest: digestSchema,
-    sourceDigest: digestSchema,
-    sourceFiles: z.array(nonEmptyStringSchema).optional()
-  }).strict(),
-  viewer: z.object({
-    seatId: nonEmptyStringSchema,
-    playerId: nonEmptyStringSchema.optional()
-  }).strict(),
-  environment: environmentSchema,
-  protocol: pluginProtocolTapeSchema,
-  replay: z.array(uiScenarioReplayStepSchema),
-  expected: z.object({
-    initialProjectionDigest: digestSchema,
-    finalProjectionDigest: digestSchema,
-    finalSemanticDigest: digestSchema,
-    submissionDigest: digestSchema
-  }).strict()
-}).strict();
-var uiScenarioFixtureBundleIndexSchema = z.object({
-  schemaVersion: z.literal(UI_SCENARIO_FIXTURE_BUNDLE_SCHEMA_VERSION),
-  bundleId: nonEmptyStringSchema,
-  sdkCommit: nonEmptyStringSchema,
-  pluginRuntimeProtocol: z.literal(DREAMBOARD_PLUGIN_PROTOCOL_VERSION),
-  browserInteractionProtocol: z.literal(
-    DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION
-  ),
-  fixtures: z.array(
-    z.object({
-      id: nonEmptyStringSchema,
-      file: nonEmptyStringSchema,
-      sha256: digestSchema,
-      renderModule: nonEmptyStringSchema,
-      renderModuleSha256: digestSchema,
-      components: z.array(nonEmptyStringSchema),
-      capabilities: z.array(nonEmptyStringSchema)
-    }).strict()
-  )
-}).strict();
-function parseUIScenarioFixture(value) {
-  const fixture = uiScenarioFixtureSchema.parse(
-    value
-  );
-  validateUIScenarioFixtureReferences(fixture);
-  return fixture;
-}
-function parseUIScenarioFixtureBundleIndex(value) {
-  const bundle = uiScenarioFixtureBundleIndexSchema.parse(value);
-  assertSupportedBrowserInteractionProtocol(bundle.browserInteractionProtocol);
-  const ids = /* @__PURE__ */ new Set();
-  for (const entry of bundle.fixtures) {
-    if (ids.has(entry.id)) {
-      throw new Error(`Duplicate fixture id '${entry.id}' in bundle index.`);
-    }
-    ids.add(entry.id);
+var MAX_DIAGNOSTIC_MESSAGE_LENGTH = 2e3;
+var MAX_DIAGNOSTIC_TRACE_ENTRIES = 100;
+async function runCandidateVerification(input) {
+  assertCandidateInputFields(input);
+  assertReducerBundleContract(input.bundle, "candidate verification");
+  const scenarios = normalizeScenarios(input.scenarios);
+  if (scenarios.length === 0) {
+    throw new Error("Candidate verification requires at least one scenario.");
   }
-  return bundle;
-}
-function assertSupportedBrowserInteractionProtocol(version) {
-  const major = Number(version.split(".")[0]);
-  if (major !== UI_SCENARIO_FIXTURE_SUPPORTED_BROWSER_PROTOCOL_MAJOR) {
+  const maxScenarios = input.maxScenarios ?? scenarios.length;
+  assertPositiveInteger(maxScenarios, "maxScenarios");
+  if (scenarios.length > maxScenarios) {
     throw new Error(
-      `Unsupported browser-interaction protocol '${version}'. Expected major ${UI_SCENARIO_FIXTURE_SUPPORTED_BROWSER_PROTOCOL_MAJOR}.`
+      `Candidate verification contains ${scenarios.length} scenarios, exceeding limit ${maxScenarios}.`
     );
   }
-}
-function validateUIScenarioFixtureReferences(fixture) {
-  assertSupportedBrowserInteractionProtocol(fixture.browserInteractionProtocol);
-  const frameIds = /* @__PURE__ */ new Set();
-  const stepIds = /* @__PURE__ */ new Set();
-  for (const frame of fixture.protocol.frames) {
-    if (frameIds.has(frame.id)) {
-      throw new Error(`Duplicate fixture frame id '${frame.id}'.`);
-    }
-    frameIds.add(frame.id);
+  const maxStepsPerScenario = input.maxStepsPerScenario ?? 1e3;
+  assertPositiveInteger(maxStepsPerScenario, "maxStepsPerScenario");
+  const results = [];
+  for (const scenario of scenarios) {
+    results.push(
+      await runScenario({
+        reducer: input.reducer,
+        bundle: input.bundle,
+        scenario,
+        maxStepsPerScenario
+      })
+    );
   }
-  for (const step of fixture.protocol.steps) {
-    if (stepIds.has(step.id)) {
-      throw new Error(`Duplicate protocol step id '${step.id}'.`);
-    }
-    stepIds.add(step.id);
-    if (step.kind === "host.frame") {
-      if (!frameIds.has(step.frameId)) {
-        throw new Error(
-          `Protocol step '${step.id}' references missing frameId '${step.frameId}'.`
-        );
-      }
-      continue;
-    }
-    if (!frameIds.has(step.fromFrameId)) {
-      throw new Error(
-        `Protocol step '${step.id}' references missing fromFrameId '${step.fromFrameId}'.`
-      );
+  const failed = results.filter((result) => result.status === "failed").length;
+  return {
+    status: failed === 0 ? "passed" : "failed",
+    scenarioSummary: {
+      total: results.length,
+      passed: results.length - failed,
+      failed,
+      scenarios: results
     }
-  }
-  for (const step of fixture.replay) {
-    if ("resolve" in step) {
-      const actualDigest = digestUIFixtureRequest(
-        step.resolve
-      );
-      if (step.requestDigest !== actualDigest) {
-        throw new Error(
-          `Replay step '${step.stepId}' requestDigest ${step.requestDigest} does not match ${actualDigest}.`
-        );
+  };
+}
+async function runScenario(input) {
+  const actualSteps = input.scenario.given.length + input.scenario.when.length;
+  if (actualSteps > input.maxStepsPerScenario) {
+    return {
+      id: input.scenario.id,
+      status: "failed",
+      diagnostic: {
+        kind: "limit",
+        message: `Scenario contains ${actualSteps} replay steps, exceeding maxStepsPerScenario limit ${input.maxStepsPerScenario}.`,
+        actualSteps,
+        maxStepsPerScenario: input.maxStepsPerScenario
       }
-    }
-    const expectedFrameId = step.expect.frameId;
-    if (expectedFrameId && !frameIds.has(expectedFrameId)) {
-      throw new Error(
-        `Replay step '${step.stepId}' expects missing frameId '${expectedFrameId}'.`
-      );
-    }
+    };
   }
-}
-
-// src/testing/ui-fixture/compiler.ts
-function compileUIScenarioFixture(options) {
-  const firstFrame = options.protocol.frames[0];
-  const finalFrame = lastPublishedFrame(options.protocol);
-  if (!firstFrame || !finalFrame) {
-    throw new Error(
-      "compileUIScenarioFixture requires at least one protocol frame."
-    );
+  let replay;
+  try {
+    replay = await replayScenario({
+      game: input.reducer,
+      bundle: input.bundle,
+      scenario: input.scenario
+    });
+  } catch (error) {
+    return {
+      id: input.scenario.id,
+      status: "failed",
+      diagnostic: replayDiagnostic(error)
+    };
   }
-  const replay = options.replay ?? [];
-  const submissionDigest = options.expected?.submissionDigest ?? digestUIFixtureJson({
-    digestVersion: "ui-submission@1",
-    fixtureId: options.id,
-    replay: replay.map(
-      (step) => "requestDigest" in step ? step.requestDigest : step.stepId
-    )
-  });
-  const finalSemanticDigest = options.expected?.finalSemanticDigest ?? digestUIFixtureJson({
-    digestVersion: "ui-semantic@1",
-    fixtureId: options.id,
-    frameId: finalFrame.id,
-    projectionDigest: finalFrame.projectionDigest
-  });
-  return parseUIScenarioFixture(
-    canonicalizeUIScenarioFixture({
-      schemaVersion: 2,
-      browserInteractionProtocol: DREAMBOARD_BROWSER_INTERACTION_PROTOCOL_VERSION,
-      pluginRuntimeProtocol: DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
-      id: options.id,
-      title: options.title,
-      gameId: options.gameId,
-      tags: [...options.tags ?? []],
-      source: options.source,
-      viewer: options.viewer,
-      environment: options.environment,
-      protocol: options.protocol,
-      replay,
-      expected: {
-        initialProjectionDigest: options.expected?.initialProjectionDigest ?? firstFrame.projectionDigest,
-        finalProjectionDigest: options.expected?.finalProjectionDigest ?? finalFrame.projectionDigest,
-        finalSemanticDigest,
-        submissionDigest
+  try {
+    await assertScenario({ replay, assertion: input.scenario.then });
+    return { id: input.scenario.id, status: "passed" };
+  } catch (error) {
+    return {
+      id: input.scenario.id,
+      status: "failed",
+      diagnostic: {
+        kind: "assertion",
+        message: boundedMessage(error)
       }
-    })
-  );
+    };
+  }
 }
-function lastPublishedFrame(protocol) {
-  const frameById = new Map(protocol.frames.map((frame) => [frame.id, frame]));
-  for (let index = protocol.steps.length - 1; index >= 0; index -= 1) {
-    const step = protocol.steps[index];
-    if (step?.kind === "host.frame") {
-      return frameById.get(step.frameId);
+function assertCandidateInputFields(input) {
+  for (const field of Object.keys(input)) {
+    if (!CANDIDATE_INPUT_FIELDS.has(field)) {
+      throw new Error(
+        `Candidate verification input contains unsupported field '${field}'.`
+      );
     }
   }
-  return protocol.frames[protocol.frames.length - 1];
 }
-function assertDeterministicUIScenarioFixture(first, second) {
-  const firstBytes = serializeUIScenarioFixture(first);
-  const secondBytes = serializeUIScenarioFixture(second);
-  if (firstBytes !== secondBytes) {
-    throw new Error(
-      `UI scenario fixture '${first.id}' is non-deterministic across compilation runs.`
-    );
+function assertPositiveInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${field} must be a positive safe integer.`);
   }
 }
-function assertUniqueReplayIdentity(step, candidates) {
-  if (candidates.length !== 1) {
+function normalizeScenarios(input) {
+  if (typeof input !== "object" || input === null) {
     throw new Error(
-      `Replay step '${step.stepId}' resolved ${candidates.length} identities; expected exactly one.`
+      "Candidate verification scenarios must be an array or record."
     );
   }
-  const candidate = candidates[0];
-  if (!candidate) {
-    throw new Error(`Replay step '${step.stepId}' did not resolve.`);
-  }
-  const expected = step.expectedIdentity;
-  if (!expected) {
-    return candidate;
-  }
-  for (const key of [
-    "surface",
-    "scopeId",
-    "interactionKey",
-    "interactionId",
-    "actuatorId",
-    "descriptorDigest",
-    "draftDigest"
-  ]) {
-    const expectedValue = expected[key];
-    if (expectedValue !== void 0 && candidate[key] !== expectedValue) {
-      throw new Error(
-        `Replay step '${step.stepId}' resolved ${key} '${String(
-          candidate[key]
-        )}', expected '${expectedValue}'.`
-      );
-    }
-  }
-  return candidate;
-}
-function assertUIStepExpectationSatisfied(stepId, expected, actual) {
-  for (const key of [
-    "frameId",
-    "projectionDigest",
-    "semanticDigest",
-    "draftDigest",
-    "submissionDigest",
-    "focusedInteractionKey"
-  ]) {
-    if (expected[key] !== void 0 && expected[key] !== actual[key]) {
-      throw new Error(
-        `Replay step '${stepId}' expected ${key} '${expected[key]}', received '${actual[key]}'.`
-      );
+  const scenarios = Array.isArray(input) ? [...input] : Object.values(input);
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const scenario of scenarios) {
+    if (typeof scenario?.id !== "string" || scenario.id.length === 0) {
+      throw new Error("Candidate verification scenario id is required.");
     }
-  }
-  if (expected.visibleInteractionKeys) {
-    const actualKeys = new Set(actual.visibleInteractionKeys ?? []);
-    const missing = expected.visibleInteractionKeys.filter(
-      (key) => !actualKeys.has(key)
-    );
-    if (missing.length > 0) {
+    if (seenIds.has(scenario.id)) {
       throw new Error(
-        `Replay step '${stepId}' missing visible interactions: ${missing.join(
-          ", "
-        )}.`
+        `Candidate verification scenario id '${scenario.id}' is duplicated.`
       );
     }
+    seenIds.add(scenario.id);
   }
+  return scenarios;
 }
-
-// src/testing/ui-scenario/replay-builders.ts
-function semanticStep(options, execute) {
-  return {
-    stepId: options.stepId,
-    requestDigest: digestUIFixtureRequest(options.resolve),
-    resolve: options.resolve,
-    execute,
-    expectedIdentity: options.expectedIdentity,
-    expect: options.expect
-  };
-}
-function activate(options) {
-  return semanticStep(options, { kind: "activate" });
-}
-function fill(options) {
-  return semanticStep(options, { kind: "fill", value: options.value });
-}
-function press(options) {
-  return activate(options);
-}
-function drag(options) {
-  return semanticStep(options, { kind: "drag", target: options.target });
+function replayDiagnostic(error) {
+  if (error instanceof ScenarioReplayError) {
+    return {
+      kind: "replay",
+      message: boundedMessage(error),
+      scenarioId: error.scenarioId,
+      segment: error.segment,
+      index: error.index,
+      interactionId: error.interactionId,
+      errorCode: error.errorCode,
+      ...error.reducerMessage === void 0 ? {} : { reducerMessage: boundedText(error.reducerMessage) },
+      trace: error.trace.slice(0, MAX_DIAGNOSTIC_TRACE_ENTRIES)
+    };
+  }
+  return { kind: "replay", message: boundedMessage(error) };
 }
-function submit(options) {
-  return activate(options);
+function boundedMessage(error) {
+  return boundedText(error instanceof Error ? error.message : String(error));
 }
-function assertStep(stepId, expect) {
-  return {
-    stepId,
-    kind: "assert",
-    expect
-  };
+function boundedText(value) {
+  return value.slice(0, MAX_DIAGNOSTIC_MESSAGE_LENGTH);
 }
 export {
-  FixturePluginRuntime,
   ScenarioAssertionError,
   ScenarioDefinitionValidationError,
   ScenarioReplayError,
-  StaleContractArtifactError,
-  UI_SCENARIO_FIXTURE_BUNDLE_SCHEMA_VERSION,
-  UI_SCENARIO_FIXTURE_PLUGIN_RUNTIME_PROTOCOL,
-  UI_SCENARIO_FIXTURE_SCHEMA_VERSION,
-  UI_SCENARIO_FIXTURE_SUPPORTED_BROWSER_PROTOCOL_MAJOR,
-  activate,
-  assertDeterministicUIScenarioFixture,
   assertScenario,
-  assertStep,
-  assertSupportedBrowserInteractionProtocol,
-  assertUIStepExpectationSatisfied,
-  assertUniqueReplayIdentity,
-  canonicalUIFixtureJson,
-  canonicalizeUIFixtureJson,
-  canonicalizeUIScenarioFixture,
-  compilePluginProtocolTape,
-  compileUIScenarioFixture,
-  createDeterministicIdFactory,
   createExpectApi,
-  createFixtureHostHarness,
   createReducerScenarioRunner,
   createScenarioAuthoring,
-  defaultFixtureEnvironmentInit,
-  defineUIScenario,
-  digestPluginProtocolTape,
-  digestUIFixtureJson,
-  digestUIFixtureRequest,
-  digestUIFixtureTransportRequest,
-  digestUIScenarioFixture,
-  drag,
+  createTestSource,
   exploreScenario,
-  fill,
-  fixtureEnvironmentInitFor,
+  fuzz,
   inspectScenario,
-  isSha256Digest,
-  isStaleContractArtifactError,
-  parseUIScenarioFixture,
-  parseUIScenarioFixtureBundleIndex,
-  pluginProtocolTapeSchema,
-  portableSemanticReplayStepSchema,
-  press,
+  localSource,
+  materializeScenarioRuntimeCheckpoint,
   probeScenarioCommand,
   replayScenario,
   resolveScenarioCheckpoint,
-  serializeUIScenarioFixture,
-  submit,
-  toScenarioReplayDefinition,
-  uiFixtureFrameSchema,
-  uiFixtureProtocolStepSchema,
-  uiReplayExecutionSchema,
-  uiReplayRequestSchema,
-  uiResolvedReplayIdentitySchema,
-  uiScenarioFixtureBundleIndexSchema,
-  uiScenarioFixtureSchema,
-  uiScenarioReplayStepSchema,
-  uiStepExpectationSchema
+  runCandidateVerification,
+  scenarioSource,
+  toScenarioReplayDefinition
 };
 //# sourceMappingURL=testing.js.map