@dreamboard-games/sdk 0.4.0-alpha.8 → 0.4.0-alpha.9

package/dist/chunk-L3W2FPRQ.js

@@ -0,0 +1,1793 @@
+import {
+  createClientParamSchemasByPhase
+} from "./chunk-5XTAQ4EQ.js";
+import {
+  digestPluginRuntimeJson,
+  encodeCanonicalPluginRuntimeJson
+} from "./chunk-QQNL4WTX.js";
+import {
+  createReducerBundle
+} from "./chunk-XDGRC6OR.js";
+import {
+  manifestSchemaFamily
+} from "./chunk-YNW3KBDE.js";
+
+// 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;
+  }
+};
+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
+  );
+  return Object.values(schemasByPhase).flatMap((schemas) => {
+    const schema = schemas[interactionId];
+    return schema ? [schema] : [];
+  });
+}
+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", "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", "setupProfileId"],
+    "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");
+  if (Object.prototype.hasOwnProperty.call(setup, "setupProfileId")) {
+    if (setup.setupProfileId !== null && typeof setup.setupProfileId !== "string") {
+      fail({
+        code: "INVALID_TYPE",
+        path: "scenario.setup.setupProfileId",
+        reason: "expected a declared setup profile id or null"
+      });
+    }
+    if (typeof setup.setupProfileId === "string" && !Object.prototype.hasOwnProperty.call(
+      game.contract.manifest.setupProfilesById,
+      setup.setupProfileId
+    )) {
+      fail({
+        code: "UNKNOWN_SETUP_PROFILE",
+        path: "scenario.setup.setupProfileId",
+        reason: `setup profile '${setup.setupProfileId}' is not declared by the manifest`
+      });
+    }
+  }
+  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"
+    });
+  }
+  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
+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 === "insufficientResources" || 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
+          )}`
+        );
+      }
+    },
+    toBeActiveFor: (playerId, opts) => {
+      const descriptor = Array.isArray(actual) ? (() => {
+        if (!opts?.interactionId) {
+          scenarioAssertionFailure(
+            "toBeActiveFor on a descriptor array requires opts.interactionId."
+          );
+        }
+        return findInteraction(
+          asDescriptorList(actual),
+          opts.interactionId
+        );
+      })() : actual;
+      if (!descriptor) {
+        scenarioAssertionFailure("Expected interaction descriptor to exist.");
+      }
+      if (descriptor.context?.to !== playerId) {
+        scenarioAssertionFailure(
+          `Expected interaction to target '${playerId}', received '${descriptor.context?.to ?? "undefined"}'.`
+        );
+      }
+      if (descriptor.availability?.status !== "available") {
+        scenarioAssertionFailure("Expected interaction to be available.");
+      }
+    },
+    not: {
+      toHaveInteraction: (interactionId) => {
+        const descriptors = asDescriptorList(actual);
+        if (findInteraction(descriptors, interactionId)) {
+          scenarioAssertionFailure(
+            `Expected interaction '${interactionId}' to be absent.`
+          );
+        }
+      }
+    }
+  });
+  return (actual) => buildMatchers(actual);
+}
+
+// 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 parsed.data;
+      }
+      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) {
+  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 = resolvePlayerIds(options.game, scenario.setup.players);
+  const events = [];
+  const bundle = createScenarioBundle(options.game, events);
+  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 reducerState = await bundle.initialize({
+    table,
+    playerIds: [...playerIds],
+    rngSeed: scenario.setup.seed,
+    setup: typeof scenario.setup.setupProfileId === "string" ? {
+      profileId: scenario.setup.setupProfileId,
+      optionValues: {}
+    } : null
+  });
+  const runtime = new ScenarioReplayImplementation({
+    game: options.game,
+    scenario,
+    playerIds,
+    reducerState,
+    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)
+  };
+}
+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;
+  events;
+  checkpoint;
+  reducerState;
+  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.checkpoint = structuredClone(state.checkpoint);
+    this.trace = structuredClone(
+      state.trace
+    );
+    this.events = structuredClone(state.events);
+    this.bundle = createScenarioBundle(state.game, this.events);
+    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,
+      trace: this.trace
+    });
+  }
+  get complete() {
+    return this.checkpoint.segment === "when" && this.checkpoint.completed === this.scenario.when.length;
+  }
+  get diagnostics() {
+    const flow = readFlowState(this.reducerState);
+    const projection = this.project(this.playerIds[0]);
+    return {
+      events: structuredClone(this.events),
+      lastDispatch: lastAcceptedDispatch(this.events),
+      flow: {
+        currentPhase: flow.currentPhase,
+        currentStage: projection.currentStage ?? null,
+        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,
+      scenario: this.scenario,
+      playerIds: this.playerIds,
+      reducerState: this.reducerState,
+      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.projectSeatsDynamic({
+      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 : projection.sharedView ?? null
+      ),
+      scheduler: {
+        phase: flow.currentPhase ?? "",
+        step: readPhaseStep(this.reducerState.domain.phase),
+        activePlayerIds: [
+          ...projection.schedulerFlow?.activePlayerIds ?? projection.stageSeats ?? []
+        ],
+        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)
+    };
+  }
+  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,
+      scenario: this.scenario,
+      playerIds: this.playerIds,
+      reducerState: this.reducerState,
+      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) {
+    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,
+      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);
+    return {
+      kind: "accept",
+      trace: summarizeWireTrace(result.trace)
+    };
+  }
+  playerId(seat, path) {
+    return resolveScenarioSeatRef({
+      ref: seat,
+      playerIds: this.playerIds,
+      path
+    });
+  }
+  project(playerId) {
+    return this.bundle.projectSeatsDynamic({
+      state: this.reducerState,
+      playerIds: [playerId]
+    });
+  }
+};
+function inspectScenarioReplayAuthority(options) {
+  return requireScenarioReplayImplementation(
+    options.replay
+  ).inspectionAuthority(options.perspective);
+}
+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) {
+  return createReducerBundle(game, {
+    diagnostics: {
+      event(event) {
+        events.push(structuredClone(event));
+      }
+    }
+  });
+}
+function validateReplayDefinition(game, replay) {
+  validateScenarioDefinition(game, {
+    ...replay,
+    then: () => void 0
+  });
+}
+function resolvePlayerIds(game, count) {
+  const declared = game.contract.manifest.literals.playerIds;
+  return Array.from(
+    { length: count },
+    (_, index) => declared[index] ?? `player-${index + 1}`
+  );
+}
+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 "appliedEffect":
+        return [
+          {
+            kind: "appliedInstruction",
+            instruction: String(
+              entry.effect.kind ?? entry.effect.type ?? "effect"
+            )
+          }
+        ];
+      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/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;
+}
+
+export {
+  ScenarioDefinitionValidationError,
+  ScenarioReplayError,
+  createScenarioAuthoring,
+  toScenarioReplayDefinition,
+  ScenarioAssertionError,
+  createExpectApi,
+  resolveScenarioCommandParams,
+  projectScenarioCommandParams,
+  replayScenario,
+  materializeScenarioRuntimeCheckpoint,
+  assertScenario,
+  probeScenarioCommand,
+  inspectScenarioReplayAuthority,
+  enumerateScenarioInteractionParams,
+  advanceScenarioReplay,
+  digestScenarioJson,
+  compareCanonicalScenarioJson
+};
+//# sourceMappingURL=chunk-L3W2FPRQ.js.map