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

package/dist/chunk-BI4G3PM2.js

@@ -1,1864 +0,0 @@
-import {
-  createReducerTestingBundle
-} from "./chunk-S2JEDVWH.js";
-import {
-  createClientParamSchemasByPhase
-} from "./chunk-PN5O6GG2.js";
-import {
-  digestPluginRuntimeJson,
-  encodeCanonicalPluginRuntimeJson
-} from "./chunk-VCDWP5VL.js";
-import {
-  manifestSchemaFamily
-} from "./chunk-H6VDGFL5.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;
-  }
-};
-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
-  );
-  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", "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", "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"
-    });
-  }
-  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 === "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.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 : 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.project({
-      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 createReducerTestingBundle(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,
-  resolveScenarioCheckpoint,
-  ScenarioReplayError,
-  createScenarioAuthoring,
-  toScenarioReplayDefinition,
-  ScenarioAssertionError,
-  createExpectApi,
-  resolveScenarioCommandParams,
-  projectScenarioCommandParams,
-  replayScenario,
-  materializeScenarioRuntimeCheckpoint,
-  assertScenario,
-  probeScenarioCommand,
-  inspectScenarioReplayAuthority,
-  enumerateScenarioInteractionParams,
-  advanceScenarioReplay,
-  digestScenarioJson,
-  compareCanonicalScenarioJson
-};
-//# sourceMappingURL=chunk-BI4G3PM2.js.map