@dreamboard-games/cli 0.1.30-alpha.2 → 0.1.30-alpha.4

package/dist/agent-verifier/chunk-ON62IGWK.mjs

@@ -0,0 +1,3137 @@
+#!/usr/bin/env node
+import {
+  bundleTypeScriptModuleText,
+  importTypeScriptModule
+} from "./chunk-XKCJBIRY.mjs";
+import {
+  STALE_CONTRACT_ARTIFACT_CODE,
+  isStaleContractArtifactError,
+  toDreamboardApiError
+} from "./chunk-IDVQXGAO.mjs";
+import {
+  loadManifest
+} from "./chunk-27EEIZCI.mjs";
+import {
+  REDUCER_TESTING_TYPES_WRAPPER_CONTENT,
+  buildReducerTestingContractContent
+} from "./chunk-F2DIOJJZ.mjs";
+import {
+  createGameplayCapability,
+  createProjectSession,
+  createProjectSessionFromReducerSnapshot,
+  getSessionSnapshot,
+  hashContent,
+  startGame
+} from "./chunk-C3VW3DTA.mjs";
+import {
+  external_exports
+} from "./chunk-JZTH3EMV.mjs";
+import {
+  ensureDir,
+  exists,
+  readTextFileIfExists,
+  writeJsonFile,
+  writeTextFile
+} from "./chunk-IAYRNVUC.mjs";
+import {
+  PROJECT_DIR_NAME
+} from "./chunk-H76MT5UR.mjs";
+
+// src/services/testing/reducer-native-test-harness.ts
+import path2 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { readdir } from "fs/promises";
+import { isDeepStrictEqual } from "util";
+import {
+  contractFingerprint,
+  createReducerBundle
+} from "@dreamboard-games/sdk/reducer";
+import {
+  ReducerWireZod as ReducerContractZod
+} from "@dreamboard-games/sdk/reducer-contract";
+import { materializeManifestTable } from "@dreamboard-games/sdk/codegen";
+
+// src/services/gameplay-authority-submit.ts
+import { randomUUID } from "crypto";
+
+// ../../node_modules/.pnpm/@dreamboard-games+gameplay-authority-protocol@0.1.0-alpha.0/node_modules/@dreamboard-games/gameplay-authority-protocol/dist/frames.js
+var GAMEPLAY_AUTHORITY_AUDIENCE = "dreamboard-gameplay-authority";
+var GAMEPLAY_TUNNEL_AUDIENCE = "dreamboard-gameplay-authority-tunnel";
+var GameplayPermissionSchema = external_exports.enum([
+  "observe",
+  "submit",
+  "restore-history"
+]);
+var GameplayConnectionContextSchema = external_exports.object({
+  sessionId: external_exports.string().uuid(),
+  playerId: external_exports.string().min(1),
+  permissions: external_exports.array(GameplayPermissionSchema)
+});
+var GameplayActorKindSchema = external_exports.enum(["user", "demo", "perf"]);
+var JsonPatchOperationSchema = external_exports.object({
+  op: external_exports.string().min(1),
+  path: external_exports.string()
+}).catchall(external_exports.unknown());
+var ProjectedDeltaSchema = external_exports.object({
+  kind: external_exports.literal("delta"),
+  generation: external_exports.number().int().nonnegative(),
+  baseVersion: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  patch: external_exports.array(JsonPatchOperationSchema)
+});
+var ProjectedSnapshotSchema = external_exports.object({
+  kind: external_exports.literal("snapshot"),
+  generation: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  view: external_exports.unknown()
+});
+var BaseGameplayCapabilityClaimsSchema = external_exports.object({
+  typ: external_exports.literal("gameplay-capability"),
+  aud: external_exports.literal(GAMEPLAY_AUTHORITY_AUDIENCE),
+  iss: external_exports.string().min(1),
+  exp: external_exports.number().int().positive(),
+  iat: external_exports.number().int().positive().optional(),
+  jti: external_exports.string().min(1).optional(),
+  sessionId: external_exports.string().uuid(),
+  playerId: external_exports.string().min(1),
+  permissions: external_exports.array(GameplayPermissionSchema)
+});
+var UserGameplayCapabilityClaimsSchema = BaseGameplayCapabilityClaimsSchema.extend({
+  actorKind: external_exports.literal("user")
+});
+var DemoGameplayCapabilityClaimsSchema = BaseGameplayCapabilityClaimsSchema.extend({
+  actorKind: external_exports.literal("demo")
+});
+var PerfGameplayCapabilityClaimsSchema = BaseGameplayCapabilityClaimsSchema.extend({
+  actorKind: external_exports.literal("perf"),
+  perfRunId: external_exports.string().uuid(),
+  laneId: external_exports.string().min(1)
+});
+var GameplayCapabilityClaimsSchema = external_exports.discriminatedUnion("actorKind", [
+  UserGameplayCapabilityClaimsSchema,
+  DemoGameplayCapabilityClaimsSchema,
+  PerfGameplayCapabilityClaimsSchema
+]);
+var GameplayTunnelClaimsSchema = external_exports.object({
+  aud: external_exports.literal(GAMEPLAY_TUNNEL_AUDIENCE),
+  iss: external_exports.string().min(1),
+  exp: external_exports.number().int().positive(),
+  iat: external_exports.number().int().positive().optional(),
+  jti: external_exports.string().min(1).optional(),
+  targetInstanceId: external_exports.string().min(1),
+  sessionId: external_exports.string().uuid(),
+  playerId: external_exports.string().min(1),
+  // Permissions are cryptographically bound into the tunnel token so the owner
+  // task trusts the signed claim set rather than the unauthenticated
+  // `tunnel.bind` frame. An ingress task cannot grant a player capabilities the
+  // issued token did not attest.
+  permissions: external_exports.array(GameplayPermissionSchema)
+});
+var AuthConnectFrameSchema = external_exports.object({
+  type: external_exports.literal("auth.connect"),
+  capabilityToken: external_exports.string().min(1)
+});
+var AuthRefreshFrameSchema = external_exports.object({
+  type: external_exports.literal("auth.refresh"),
+  capabilityToken: external_exports.string().min(1)
+});
+var SessionResumeFrameSchema = external_exports.object({
+  type: external_exports.literal("session.resume"),
+  lastSeenGeneration: external_exports.number().int().nonnegative().nullable(),
+  lastSeenVersion: external_exports.number().int().nonnegative().nullable(),
+  unacknowledgedClientActionIds: external_exports.array(external_exports.string().min(1)).max(32)
+});
+var CommandSubmitFrameSchema = external_exports.object({
+  type: external_exports.literal("command.submit"),
+  clientActionId: external_exports.string().min(1).max(128),
+  expectedVersion: external_exports.number().int().nonnegative(),
+  actionSetVersion: external_exports.string().min(1),
+  interactionId: external_exports.string().min(1),
+  inputs: external_exports.record(external_exports.string(), external_exports.unknown())
+});
+var HistoryRestoreFrameSchema = external_exports.object({
+  type: external_exports.literal("history.restore"),
+  restoreId: external_exports.string().min(1).max(128),
+  targetGeneration: external_exports.number().int().nonnegative(),
+  targetVersion: external_exports.number().int().nonnegative()
+});
+var ClientGameplayFrameSchema = external_exports.discriminatedUnion("type", [
+  AuthConnectFrameSchema,
+  AuthRefreshFrameSchema,
+  SessionResumeFrameSchema,
+  CommandSubmitFrameSchema,
+  HistoryRestoreFrameSchema
+]);
+var TunnelBindFrameSchema = external_exports.object({
+  type: external_exports.literal("tunnel.bind"),
+  context: GameplayConnectionContextSchema
+});
+var TunnelClientFrameSchema = external_exports.discriminatedUnion("type", [
+  TunnelBindFrameSchema,
+  SessionResumeFrameSchema,
+  CommandSubmitFrameSchema,
+  HistoryRestoreFrameSchema
+]);
+var CommandAcceptedFrameSchema = external_exports.object({
+  type: external_exports.literal("command.accepted"),
+  clientActionId: external_exports.string().min(1),
+  generation: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  stateHash: external_exports.string().min(1),
+  update: ProjectedSnapshotSchema
+});
+var CommandRejectedFrameSchema = external_exports.object({
+  type: external_exports.literal("command.rejected"),
+  clientActionId: external_exports.string().min(1).optional(),
+  errorCode: external_exports.string().min(1),
+  message: external_exports.string().min(1),
+  currentGeneration: external_exports.number().int().nonnegative().optional(),
+  currentVersion: external_exports.number().int().nonnegative().optional()
+});
+var HistoryRestoredFrameSchema = external_exports.object({
+  type: external_exports.literal("history.restored"),
+  restoreId: external_exports.string().min(1),
+  generation: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  stateHash: external_exports.string().min(1),
+  update: ProjectedSnapshotSchema
+});
+var HistoryRestoreRejectedFrameSchema = external_exports.object({
+  type: external_exports.literal("history.restoreRejected"),
+  restoreId: external_exports.string().min(1).optional(),
+  errorCode: external_exports.string().min(1),
+  message: external_exports.string().min(1),
+  currentGeneration: external_exports.number().int().nonnegative().optional(),
+  currentVersion: external_exports.number().int().nonnegative().optional()
+});
+var AuthAcceptedFrameSchema = external_exports.object({
+  type: external_exports.literal("auth.accepted"),
+  expiresAt: external_exports.string().datetime()
+});
+var AuthorityRecoveringFrameSchema = external_exports.object({
+  type: external_exports.literal("authority.recovering"),
+  retryAfterMs: external_exports.number().int().positive(),
+  message: external_exports.string().min(1)
+});
+var SessionSnapshotFrameSchema = external_exports.object({
+  type: external_exports.literal("session.snapshot"),
+  generation: external_exports.number().int().nonnegative(),
+  version: external_exports.number().int().nonnegative(),
+  stateHash: external_exports.string().min(1),
+  update: ProjectedSnapshotSchema
+});
+var SessionDeltaFrameSchema = external_exports.object({
+  type: external_exports.literal("session.delta"),
+  clientActionId: external_exports.string().min(1).optional(),
+  update: ProjectedDeltaSchema
+});
+var ServerGameplayFrameSchema = external_exports.discriminatedUnion("type", [
+  AuthAcceptedFrameSchema,
+  AuthorityRecoveringFrameSchema,
+  SessionSnapshotFrameSchema,
+  SessionDeltaFrameSchema,
+  CommandAcceptedFrameSchema,
+  CommandRejectedFrameSchema,
+  HistoryRestoredFrameSchema,
+  HistoryRestoreRejectedFrameSchema
+]);
+var TunnelBoundFrameSchema = external_exports.object({
+  type: external_exports.literal("tunnel.bound"),
+  sessionId: external_exports.string().uuid(),
+  playerId: external_exports.string().min(1)
+});
+var TunnelServerFrameSchema = external_exports.discriminatedUnion("type", [
+  TunnelBoundFrameSchema,
+  AuthorityRecoveringFrameSchema,
+  SessionSnapshotFrameSchema,
+  SessionDeltaFrameSchema,
+  CommandAcceptedFrameSchema,
+  CommandRejectedFrameSchema,
+  HistoryRestoredFrameSchema,
+  HistoryRestoreRejectedFrameSchema
+]);
+
+// ../../node_modules/.pnpm/@dreamboard-games+gameplay-authority-client@0.1.0-alpha.1/node_modules/@dreamboard-games/gameplay-authority-client/dist/index.js
+var DEFAULT_OPEN_TIMEOUT_MS = 5e3;
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+var GameplayAuthorityRecoveringError = class extends Error {
+  retryAfterMs;
+  constructor(message, retryAfterMs) {
+    super(message);
+    this.name = "GameplayAuthorityRecoveringError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+async function connectGameplayAuthority(input) {
+  const webSocketFactory = input.webSocketFactory ?? browserWebSocketFactory();
+  const openTimeoutMs = input.openTimeoutMs ?? DEFAULT_OPEN_TIMEOUT_MS;
+  const requestTimeoutMs = input.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const socket = new webSocketFactory(input.websocketUrl, input.webSocketInit);
+  try {
+    await waitUntilOpen(socket, openTimeoutMs);
+    socket.send(JSON.stringify({
+      type: "auth.connect",
+      capabilityToken: input.capabilityToken
+    }));
+    await waitForServerFrame(socket, (frame) => frame.type === "auth.accepted", requestTimeoutMs);
+    return new WebSocketGameplayAuthorityClient(socket, requestTimeoutMs);
+  } catch (error) {
+    socket.close();
+    throw error;
+  }
+}
+var WebSocketGameplayAuthorityClient = class {
+  socket;
+  requestTimeoutMs;
+  constructor(socket, requestTimeoutMs) {
+    this.socket = socket;
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
+  resume(input = {}) {
+    this.socket.send(JSON.stringify({
+      type: "session.resume",
+      lastSeenGeneration: input.lastSeenGeneration ?? null,
+      lastSeenVersion: input.lastSeenVersion ?? null,
+      unacknowledgedClientActionIds: input.unacknowledgedClientActionIds ?? []
+    }));
+  }
+  async submitCommand(input) {
+    this.socket.send(JSON.stringify({
+      type: "command.submit",
+      clientActionId: input.clientActionId,
+      expectedVersion: input.expectedVersion,
+      actionSetVersion: input.actionSetVersion,
+      interactionId: input.interactionId,
+      inputs: input.inputs
+    }));
+    const frame = await waitForServerFrame(this.socket, (candidate) => candidate.type === "authority.recovering" || candidate.type === "command.accepted" && candidate.clientActionId === input.clientActionId || candidate.type === "command.rejected" && (candidate.clientActionId === void 0 || candidate.clientActionId === input.clientActionId), this.requestTimeoutMs);
+    throwIfRecovering(frame);
+    if (frame.type !== "command.accepted" && frame.type !== "command.rejected") {
+      throw new Error("Unexpected gameplay authority command frame.");
+    }
+    return frame;
+  }
+  async restoreHistory(input) {
+    this.socket.send(JSON.stringify({
+      type: "history.restore",
+      restoreId: input.restoreId,
+      targetGeneration: input.targetGeneration,
+      targetVersion: input.targetVersion
+    }));
+    const frame = await waitForServerFrame(this.socket, (candidate) => candidate.type === "authority.recovering" || candidate.type === "history.restored" && candidate.restoreId === input.restoreId || candidate.type === "history.restoreRejected" && (candidate.restoreId === void 0 || candidate.restoreId === input.restoreId), this.requestTimeoutMs);
+    throwIfRecovering(frame);
+    if (frame.type !== "history.restored" && frame.type !== "history.restoreRejected") {
+      throw new Error("Unexpected gameplay authority history frame.");
+    }
+    return frame;
+  }
+  frames(signal) {
+    return readServerFrames(this.socket, signal);
+  }
+  close() {
+    this.socket.close();
+  }
+};
+function throwIfRecovering(frame) {
+  if (frame.type === "authority.recovering") {
+    throw new GameplayAuthorityRecoveringError(frame.message, frame.retryAfterMs);
+  }
+}
+function browserWebSocketFactory() {
+  return BrowserGameplayAuthorityWebSocket;
+}
+var BrowserGameplayAuthorityWebSocket = class {
+  socket;
+  listeners = /* @__PURE__ */ new Map();
+  constructor(url, init) {
+    if (init?.headers && Object.keys(init.headers).length > 0) {
+      throw new Error("Browser WebSocket does not support custom headers; provide a webSocketFactory for header-aware runtimes.");
+    }
+    this.socket = new WebSocket(url);
+  }
+  send(data) {
+    this.socket.send(data);
+  }
+  close() {
+    this.socket.close();
+  }
+  on(event, listener) {
+    const wrapped = (observed) => {
+      if (event === "message" && "data" in observed) {
+        listener(observed.data);
+        return;
+      }
+      listener(observed);
+    };
+    const listeners = this.listeners.get(event) ?? /* @__PURE__ */ new Map();
+    listeners.set(listener, wrapped);
+    this.listeners.set(event, listeners);
+    this.socket.addEventListener(event, wrapped);
+  }
+  off(event, listener) {
+    const listeners = this.listeners.get(event);
+    const wrapped = listeners?.get(listener);
+    if (!listeners || !wrapped) {
+      return;
+    }
+    this.socket.removeEventListener(event, wrapped);
+    listeners.delete(listener);
+  }
+};
+async function waitUntilOpen(socket, timeoutMs) {
+  await waitForEvent(socket, "open", timeoutMs);
+}
+async function waitForEvent(socket, event, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const cleanup = installSocketListeners(socket, {
+      timeoutMs,
+      onEvent(observed) {
+        if (observed === event) {
+          cleanup();
+          resolve();
+        }
+      },
+      onError(error) {
+        cleanup();
+        reject(error instanceof Error ? error : new Error("gameplay socket error"));
+      },
+      onClose() {
+        cleanup();
+        reject(new Error("gameplay socket closed"));
+      },
+      onTimeout() {
+        cleanup();
+        reject(new Error("gameplay socket timed out"));
+      }
+    });
+  });
+}
+async function waitForServerFrame(socket, predicate, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const cleanup = installSocketListeners(socket, {
+      timeoutMs,
+      onMessage(data) {
+        let frame;
+        try {
+          frame = ServerGameplayFrameSchema.parse(JSON.parse(messageToString(data)));
+        } catch (error) {
+          cleanup();
+          reject(error instanceof Error ? error : new Error("invalid gameplay authority frame"));
+          return;
+        }
+        if (predicate(frame)) {
+          cleanup();
+          resolve(frame);
+        }
+      },
+      onError(error) {
+        cleanup();
+        reject(error instanceof Error ? error : new Error("gameplay socket error"));
+      },
+      onClose() {
+        cleanup();
+        reject(new Error("gameplay socket closed"));
+      },
+      onTimeout() {
+        cleanup();
+        reject(new Error("gameplay socket timed out"));
+      }
+    });
+  });
+}
+function installSocketListeners(socket, handlers) {
+  const timer = setTimeout(handlers.onTimeout, handlers.timeoutMs);
+  const onOpen = () => handlers.onEvent?.("open");
+  const onMessage = (data) => handlers.onMessage?.(data);
+  const onError = (error) => handlers.onError(error);
+  const onClose = () => handlers.onClose();
+  socket.on("open", onOpen);
+  socket.on("message", onMessage);
+  socket.on("error", onError);
+  socket.on("close", onClose);
+  return () => {
+    clearTimeout(timer);
+    socket.off?.("open", onOpen);
+    socket.off?.("message", onMessage);
+    socket.off?.("error", onError);
+    socket.off?.("close", onClose);
+  };
+}
+function readServerFrames(socket, signal) {
+  const queue = [];
+  let wake = null;
+  let closed = false;
+  let error = null;
+  const wakeReader = () => {
+    wake?.();
+    wake = null;
+  };
+  const onMessage = (data) => {
+    try {
+      queue.push(ServerGameplayFrameSchema.parse(JSON.parse(messageToString(data))));
+    } catch (candidate) {
+      error = candidate instanceof Error ? candidate : new Error("invalid gameplay authority frame");
+    }
+    wakeReader();
+  };
+  const onError = (candidate) => {
+    error = candidate instanceof Error ? candidate : new Error("gameplay socket error");
+    wakeReader();
+  };
+  const onClose = () => {
+    closed = true;
+    wakeReader();
+  };
+  const onAbort = () => {
+    closed = true;
+    wakeReader();
+  };
+  socket.on("message", onMessage);
+  socket.on("error", onError);
+  socket.on("close", onClose);
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const cleanup = () => {
+    socket.off?.("message", onMessage);
+    socket.off?.("error", onError);
+    socket.off?.("close", onClose);
+    signal?.removeEventListener("abort", onAbort);
+  };
+  const iterator = {
+    async next() {
+      while (!closed && !signal?.aborted) {
+        const next = queue.shift();
+        if (next) {
+          return { done: false, value: next };
+        }
+        if (error) {
+          cleanup();
+          throw error;
+        }
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+      }
+      cleanup();
+      if (error) {
+        throw error;
+      }
+      return { done: true, value: void 0 };
+    },
+    async return(value) {
+      closed = true;
+      wakeReader();
+      cleanup();
+      return { done: true, value };
+    },
+    async throw(candidate) {
+      closed = true;
+      wakeReader();
+      cleanup();
+      throw candidate;
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    async [Symbol.asyncDispose]() {
+      await this.return(void 0);
+    }
+  };
+  return iterator;
+}
+function messageToString(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return new TextDecoder().decode(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return new TextDecoder().decode(data);
+  }
+  return String(data);
+}
+
+// src/services/gameplay-authority-submit.ts
+var CLIENT_ACTION_ID_HEADER = "X-Dreamboard-Client-Action-Id";
+var DEFAULT_TIMEOUT_MS = 1e4;
+async function submitGameplayAuthorityAction(options) {
+  try {
+    const requestCapability = options.capabilityRequester ?? createGameplayCapability;
+    const connectAuthority = options.connectAuthority ?? connectGameplayAuthority;
+    const capability = await requestCapability({
+      path: {
+        sessionId: options.path.sessionId,
+        playerId: options.path.playerId
+      }
+    });
+    if (capability.error || !capability.data) {
+      return { error: capability.error ?? new Error("Missing capability.") };
+    }
+    const clientActionId = options.headers?.[CLIENT_ACTION_ID_HEADER] ?? options.clientActionIdFactory?.() ?? randomUUID();
+    const client = await connectAuthority({
+      websocketUrl: capability.data.websocketUrl,
+      capabilityToken: capability.data.token,
+      openTimeoutMs: DEFAULT_TIMEOUT_MS,
+      requestTimeoutMs: DEFAULT_TIMEOUT_MS
+    });
+    try {
+      const frame = await client.submitCommand({
+        clientActionId,
+        expectedVersion: options.body.expectedVersion,
+        actionSetVersion: options.body.actionSetVersion,
+        interactionId: options.path.interactionId,
+        inputs: options.body.inputs ?? {}
+      });
+      if (frame.type === "command.rejected") {
+        return {
+          data: {
+            success: false,
+            accepted: false,
+            version: typeof frame.currentVersion === "number" ? frame.currentVersion : options.body.expectedVersion,
+            actionSetVersion: options.body.actionSetVersion,
+            errorCode: typeof frame.errorCode === "string" ? frame.errorCode : void 0,
+            message: typeof frame.message === "string" ? frame.message : void 0,
+            clientActionId
+          }
+        };
+      }
+      const acceptedVersion = typeof frame.version === "number" ? frame.version : void 0;
+      if (acceptedVersion === void 0) {
+        return {
+          error: new Error("Accepted frame did not include a numeric version.")
+        };
+      }
+      const update = frame.update && typeof frame.update === "object" ? frame.update : {};
+      const view = update.view && typeof update.view === "object" ? update.view : {};
+      const projectedActionSetVersion = typeof view.actionSetVersion === "string" ? view.actionSetVersion : void 0;
+      return {
+        data: {
+          success: true,
+          accepted: true,
+          durabilityStatus: "COMMITTED",
+          version: acceptedVersion,
+          actionSetVersion: projectedActionSetVersion ?? options.body.actionSetVersion,
+          clientActionId
+        }
+      };
+    } catch (error) {
+      if (error instanceof GameplayAuthorityRecoveringError) {
+        return {
+          error: new Error(error.message || "Session authority is recovering.")
+        };
+      }
+      throw error;
+    } finally {
+      client.close();
+    }
+  } catch (error) {
+    return { error };
+  }
+}
+
+// src/ui/playwright-runner.ts
+import os from "os";
+import path from "path";
+function configurePlaywrightBrowsersPath() {
+  if (process.env.PLAYWRIGHT_BROWSERS_PATH) {
+    return;
+  }
+  const runtimeHome = process.env.HOME;
+  let realHome;
+  try {
+    realHome = os.userInfo().homedir;
+  } catch {
+    return;
+  }
+  if (!runtimeHome || path.resolve(runtimeHome) === path.resolve(realHome)) {
+    return;
+  }
+  const browserCachePath = process.platform === "darwin" ? path.join(realHome, "Library", "Caches", "ms-playwright") : process.platform === "win32" ? path.join(realHome, "AppData", "Local", "ms-playwright") : path.join(realHome, ".cache", "ms-playwright");
+  process.env.PLAYWRIGHT_BROWSERS_PATH = browserCachePath;
+}
+async function buildBrowserAuthInitScript(config) {
+  if (!config.authToken) return null;
+  return `(function(){localStorage.setItem('dreamboard_auth_token',${JSON.stringify(config.authToken)});})();`;
+}
+async function waitForGameReady(page, timeoutMs = 6e4) {
+  await page.waitForSelector('iframe[title="Game UI Plugin"]', {
+    timeout: timeoutMs
+  });
+}
+
+// src/services/workflows/resolve-setup-profile.ts
+function resolveSetupProfileSelection(options) {
+  const setupProfiles = options.manifest.setupProfiles ?? [];
+  const requestedSetupProfileId = options.requestedSetupProfileId?.trim() || void 0;
+  if (requestedSetupProfileId) {
+    const requestedProfile = setupProfiles.find(
+      (profile) => profile.id === requestedSetupProfileId
+    );
+    if (!requestedProfile) {
+      const knownProfiles = setupProfiles.map((profile) => profile.id).join(", ");
+      throw new Error(
+        setupProfiles.length === 0 ? `Unknown setup profile '${requestedSetupProfileId}'. The manifest defines no setup profiles.` : `Unknown setup profile '${requestedSetupProfileId}'. Expected one of: ${knownProfiles}.`
+      );
+    }
+    return {
+      id: requestedProfile.id,
+      name: requestedProfile.name,
+      source: "explicit"
+    };
+  }
+  if (setupProfiles.length === 0) {
+    return {
+      id: null,
+      name: null,
+      source: "none"
+    };
+  }
+  if (setupProfiles.length === 1) {
+    return {
+      id: setupProfiles[0]?.id ?? null,
+      name: setupProfiles[0]?.name ?? null,
+      source: "implicit-single"
+    };
+  }
+  return {
+    id: setupProfiles[0]?.id ?? null,
+    name: setupProfiles[0]?.name ?? null,
+    source: "implicit-first"
+  };
+}
+
+// src/utils/session-game-source.ts
+function projectIdFromSessionGameSource(source) {
+  if (source.kind === "USER_COMPILED") {
+    return source.projectId;
+  }
+  return `demo:${source.slug}:${source.revisionId}`;
+}
+
+// src/services/testing/reducer-native-test-harness.ts
+globalThis.__DREAMBOARD_AUTHORING_WARNINGS__ = true;
+var GENERATED_TESTING_TYPES_PREFIX = "// Generated by dreamboard";
+var TESTING_TYPES_STUB = "export function defineScenario(scenario) { return scenario; }\n";
+var DEFAULT_TIMEOUT_MS2 = 1e4;
+var BASE_SUFFIX = ".base.ts";
+var SCENARIO_SUFFIX = ".scenario.ts";
+var SDK_UI_RUNTIME_EXTERNALS = [
+  "@radix-ui/react-accordion",
+  "@radix-ui/react-dialog",
+  "@radix-ui/react-label",
+  "@radix-ui/react-select",
+  "@radix-ui/react-slot",
+  "@radix-ui/react-tooltip",
+  "@use-gesture/react",
+  "clsx",
+  "framer-motion",
+  "lucide-react",
+  "react",
+  "react-dom",
+  "vaul"
+];
+function formatScenarioErrorForDisplay(options) {
+  const message = options.error.message || "Scenario failed.";
+  const scenarioFrame = findScenarioStackFrame({
+    stack: options.error.stack,
+    projectRoot: options.projectRoot,
+    scenarioFilePath: options.scenarioFilePath
+  });
+  return scenarioFrame ? `${message}
+${scenarioFrame}` : message;
+}
+function findScenarioStackFrame(options) {
+  if (!options.stack) {
+    return null;
+  }
+  const absolutePath = path2.resolve(options.scenarioFilePath);
+  const relativePath = path2.relative(options.projectRoot, absolutePath);
+  const normalizedRelativePath = relativePath.split(path2.sep).join("/");
+  const escapedAbsolutePath = escapeRegExp(absolutePath);
+  const escapedRelativePath = escapeRegExp(normalizedRelativePath);
+  const absoluteFrame = new RegExp(`${escapedAbsolutePath}:(\\d+):(\\d+)`);
+  const relativeFrame = new RegExp(`${escapedRelativePath}:(\\d+):(\\d+)`);
+  for (const line of options.stack.split("\n")) {
+    const normalizedLine = line.split(path2.sep).join("/");
+    const match = normalizedLine.match(absoluteFrame) ?? normalizedLine.match(relativeFrame);
+    if (match?.[1] && match?.[2]) {
+      return `at ${normalizedRelativePath}:${match[1]}:${match[2]}`;
+    }
+  }
+  return null;
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var testingExpectApiFactoryPromise;
+async function loadTestingExpectApiFactory() {
+  testingExpectApiFactoryPromise ??= import("@dreamboard-games/sdk/testing").then(
+    (module) => module.createExpectApi
+  );
+  return testingExpectApiFactoryPromise;
+}
+function createSubmissionError(errorCode, message, fallbackMessage) {
+  const error = new Error(message ?? fallbackMessage);
+  error.name = "SubmissionError";
+  error.errorCode = errorCode;
+  return error;
+}
+function parseJsonValue(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function deepEqual(left, right) {
+  return isDeepStrictEqual(left, right);
+}
+function normalizeScenarioRunners(runners) {
+  return runners && runners.length > 0 ? runners : ["reducer"];
+}
+function shouldRefreshReducerTestingTypes(existingContent) {
+  if (existingContent === null || existingContent.trim().length === 0 || existingContent === TESTING_TYPES_STUB || existingContent.startsWith(GENERATED_TESTING_TYPES_PREFIX)) {
+    return true;
+  }
+  return false;
+}
+async function discoverFiles(root, suffix) {
+  if (!await exists(root)) {
+    return [];
+  }
+  const entries = await readdir(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const entryPath = path2.join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await discoverFiles(entryPath, suffix));
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(suffix)) {
+      files.push(entryPath);
+    }
+  }
+  files.sort();
+  return files;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function parseTypedBaseDefinition(value) {
+  if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string" || !("setup" in value) || !isFunction(value.setup)) {
+    throw new Error("Invalid reducer-native base definition.");
+  }
+  const parentBaseId = "extends" in value && typeof value.extends === "string" ? value.extends : void 0;
+  const seed = "seed" in value && typeof value.seed === "number" ? value.seed : void 0;
+  const players = "players" in value && typeof value.players === "number" ? value.players : void 0;
+  if ((seed === void 0 || players === void 0) && !parentBaseId) {
+    throw new Error(
+      "Invalid reducer-native base definition. Base definitions without --extends must declare numeric seed and players."
+    );
+  }
+  const setupProfileId = "setupProfileId" in value && typeof value.setupProfileId === "string" ? value.setupProfileId : void 0;
+  return {
+    ...value,
+    seed,
+    players,
+    setupProfileId,
+    extends: parentBaseId
+  };
+}
+function parseTypedScenarioDefinition(value) {
+  if (typeof value !== "object" || value === null || !("id" in value) || typeof value.id !== "string" || !("from" in value) || typeof value.from !== "string" || !("when" in value) || !isFunction(value.when) || !("then" in value) || !isFunction(value.then)) {
+    throw new Error("Invalid reducer-native scenario definition.");
+  }
+  const phase = "phase" in value && typeof value.phase === "string" ? value.phase : void 0;
+  const stage = "stage" in value && typeof value.stage === "string" ? value.stage : void 0;
+  return {
+    ...value,
+    phase,
+    stage
+  };
+}
+async function isReducerNativeTestingWorkspace(projectRoot) {
+  return await exists(path2.join(projectRoot, "app", "game.ts")) && await exists(
+    path2.join(projectRoot, "shared", "generated", "ui-contract.ts")
+  );
+}
+async function ensureReducerNativeTestingFiles(projectRoot) {
+  const testingTypesPath = path2.join(projectRoot, "test", "testing-types.ts");
+  const testingContractPath = path2.join(
+    projectRoot,
+    "test",
+    "generated",
+    "testing-contract.ts"
+  );
+  const baseStatesPath = path2.join(
+    projectRoot,
+    "test",
+    "generated",
+    "base-states.generated.ts"
+  );
+  const baseStatesDtsPath = path2.join(
+    projectRoot,
+    "test",
+    "generated",
+    "base-states.generated.d.ts"
+  );
+  const scenarioManifestPath = path2.join(
+    projectRoot,
+    "test",
+    "generated",
+    "scenario-manifest.generated.ts"
+  );
+  await ensureDir(path2.dirname(testingTypesPath));
+  await ensureDir(path2.dirname(testingContractPath));
+  const existingTestingTypes = await readTextFileIfExists(testingTypesPath);
+  if (shouldRefreshReducerTestingTypes(existingTestingTypes)) {
+    await writeTextFile(
+      testingTypesPath,
+      REDUCER_TESTING_TYPES_WRAPPER_CONTENT
+    );
+  }
+  const rejectionCodes = await collectKnownRejectionCodes(projectRoot);
+  await writeTextFile(
+    testingContractPath,
+    buildReducerTestingContractContent({ rejectionCodes })
+  );
+  const header = "// Generated by dreamboard test generate. Do not edit by hand.\n";
+  if (!await exists(baseStatesPath)) {
+    await writeTextFile(
+      baseStatesPath,
+      `${header}export const BASE_STATES = {} as const;
+export const BASE_STATES_CONTRACT_FINGERPRINT = undefined;
+`
+    );
+  } else {
+    const existingBaseStates = await readTextFileIfExists(baseStatesPath);
+    if (existingBaseStates && !existingBaseStates.includes("BASE_STATES_CONTRACT_FINGERPRINT")) {
+      await writeTextFile(
+        baseStatesPath,
+        `${existingBaseStates.trimEnd()}
+export const BASE_STATES_CONTRACT_FINGERPRINT = undefined;
+`
+      );
+    }
+  }
+  if (!await exists(baseStatesDtsPath)) {
+    await writeTextFile(
+      baseStatesDtsPath,
+      `${header}export declare const BASE_STATES: Record<string, unknown>;
+export declare const BASE_STATES_CONTRACT_FINGERPRINT: string | undefined;
+`
+    );
+  } else {
+    const existingBaseStatesDts = await readTextFileIfExists(baseStatesDtsPath);
+    if (existingBaseStatesDts && !existingBaseStatesDts.includes("BASE_STATES_CONTRACT_FINGERPRINT")) {
+      await writeTextFile(
+        baseStatesDtsPath,
+        `${existingBaseStatesDts.trimEnd()}
+export declare const BASE_STATES_CONTRACT_FINGERPRINT: string | undefined;
+`
+      );
+    }
+  }
+  if (!await exists(scenarioManifestPath)) {
+    await writeTextFile(
+      scenarioManifestPath,
+      `${header}export const SCENARIO_MANIFEST = [] as const;
+`
+    );
+  }
+}
+var DEFAULT_REJECTION_CODES = [
+  "NOT_YOUR_TURN",
+  "action-unavailable",
+  "invalid-action-params",
+  "prompt-not-owned"
+];
+async function collectKnownRejectionCodes(projectRoot) {
+  const knownCodes = new Set(DEFAULT_REJECTION_CODES);
+  const gamePath = path2.join(projectRoot, "app", "game.ts");
+  if (!await exists(gamePath)) {
+    return Array.from(knownCodes).sort(
+      (left, right) => left.localeCompare(right)
+    );
+  }
+  try {
+    const module = await importTypeScriptModule(gamePath);
+    const phases = module.default?.phases ?? {};
+    for (const phase of Object.values(phases)) {
+      const interactions = phase.interactions ?? {};
+      for (const interaction of Object.values(interactions)) {
+        for (const errorCode of interaction.errorCodes ?? []) {
+          if (typeof errorCode === "string" && errorCode.length > 0) {
+            knownCodes.add(errorCode);
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return Array.from(knownCodes).sort(
+    (left, right) => left.localeCompare(right)
+  );
+}
+async function loadTypedBases(projectRoot) {
+  const baseFiles = await discoverFiles(
+    path2.join(projectRoot, "test", "bases"),
+    BASE_SUFFIX
+  );
+  const loaded = [];
+  for (const filePath of baseFiles) {
+    const externals = reducerNativeTestHelperExternals(projectRoot, filePath);
+    const [module, bundledText] = await Promise.all([
+      importTypeScriptModule(filePath),
+      bundleTypeScriptModuleText(filePath, { external: externals })
+    ]);
+    loaded.push({
+      filePath,
+      definition: parseTypedBaseDefinition(module.default),
+      bundleHash: hashContent(bundledText)
+    });
+  }
+  return loaded;
+}
+async function loadTypedScenarios(projectRoot, options) {
+  const scenarioFiles = options.scenarioPath ? [path2.resolve(projectRoot, options.scenarioPath)] : await discoverFiles(
+    path2.join(projectRoot, "test", "scenarios"),
+    SCENARIO_SUFFIX
+  );
+  const loaded = [];
+  for (const filePath of scenarioFiles) {
+    const externals = reducerNativeTestHelperExternals(projectRoot, filePath);
+    const [module, bundledText] = await Promise.all([
+      importTypeScriptModule(filePath),
+      bundleTypeScriptModuleText(filePath, { external: externals })
+    ]);
+    loaded.push({
+      filePath,
+      definition: parseTypedScenarioDefinition(module.default),
+      bundleHash: hashContent(bundledText)
+    });
+  }
+  return loaded;
+}
+function reducerNativeTestHelperExternals(projectRoot, filePath) {
+  const testingTypesPath = path2.join(projectRoot, "test", "testing-types");
+  const relative = path2.relative(path2.dirname(filePath), testingTypesPath).replaceAll("\\", "/");
+  const specifier = relative.startsWith(".") ? relative : `./${relative}`;
+  return [specifier, `${specifier}.ts`, ...SDK_UI_RUNTIME_EXTERNALS];
+}
+var JS_MAX_SAFE_INTEGER = 9007199254740991n;
+var JS_MIN_SAFE_INTEGER = -JS_MAX_SAFE_INTEGER;
+var JS_MAX_SAFE_INTEGER_EXCLUSIVE = JS_MAX_SAFE_INTEGER + 1n;
+var KotlinSeededRandom = class {
+  x;
+  y;
+  z;
+  w;
+  v;
+  addend;
+  constructor(seed) {
+    const seedBig = BigInt.asIntN(64, BigInt(Math.trunc(seed)));
+    const seed1 = Number(BigInt.asIntN(32, seedBig));
+    const seed2 = Number(BigInt.asIntN(32, seedBig >> 32n));
+    this.x = seed1 | 0;
+    this.y = seed2 | 0;
+    this.z = 0;
+    this.w = 0;
+    this.v = ~seed1;
+    this.addend = seed1 << 10 ^ seed2 >>> 4 | 0;
+    if ((this.x | this.y | this.z | this.w | this.v) === 0) {
+      throw new Error(
+        "Kotlin random seed must initialize at least one state word."
+      );
+    }
+    for (let index = 0; index < 64; index += 1) {
+      this.nextInt();
+    }
+  }
+  nextInt() {
+    let next = this.x | 0;
+    next ^= next >>> 2;
+    this.x = this.y;
+    this.y = this.z;
+    this.z = this.w;
+    const currentV = this.v | 0;
+    this.w = currentV;
+    next = next ^ next << 1 ^ currentV ^ currentV << 4 | 0;
+    this.v = next;
+    this.addend = this.addend + 362437 | 0;
+    return next + this.addend | 0;
+  }
+  nextBits(bitCount) {
+    if (bitCount <= 0) {
+      return 0;
+    }
+    return this.nextInt() >>> 32 - bitCount;
+  }
+  nextIntBound(bound) {
+    if (bound <= 0) {
+      throw new Error("bound must be positive");
+    }
+    if ((bound & -bound) === bound) {
+      const bitCount = 31 - Math.clz32(bound);
+      return this.nextBits(bitCount);
+    }
+    let value;
+    while (true) {
+      const bits = this.nextInt() >>> 1;
+      value = bits % bound;
+      if (bits - value + (bound - 1) >= 0) {
+        return value;
+      }
+    }
+  }
+  nextLong() {
+    return Number(this.nextLongBigInt());
+  }
+  nextLongBigInt() {
+    const high = BigInt(this.nextInt());
+    const low = BigInt(this.nextInt());
+    return BigInt.asIntN(64, (high << 32n) + low);
+  }
+  nextReducerRuntimeSeed() {
+    return Number(
+      this.nextLongRange(JS_MIN_SAFE_INTEGER, JS_MAX_SAFE_INTEGER_EXCLUSIVE)
+    );
+  }
+  nextLongRange(from, until) {
+    if (until <= from) {
+      throw new Error("until must be greater than from");
+    }
+    const bound = until - from;
+    const mask = bound - 1n;
+    if ((bound & mask) === 0n) {
+      return from + (BigInt.asUintN(64, this.nextLongBigInt()) & mask);
+    }
+    while (true) {
+      const bits = BigInt.asUintN(64, this.nextLongBigInt()) >> 1n;
+      const value = bits % bound;
+      if (BigInt.asIntN(64, bits + mask - value) >= 0n) {
+        return from + value;
+      }
+    }
+  }
+};
+function shuffleWithKotlinRandom(values, random) {
+  const next = [...values];
+  for (let index = next.length - 1; index > 0; index -= 1) {
+    const swapIndex = random.nextIntBound(index + 1);
+    const current = next[index];
+    next[index] = next[swapIndex];
+    next[swapIndex] = current;
+  }
+  return next;
+}
+function resolveEffectiveBaseSetup(options) {
+  const inheritedSetupProfileId = options.base.setupProfileId ?? (options.base.extends && options.basesById ? resolveEffectiveBaseSetup({
+    manifest: options.manifest,
+    base: options.basesById.get(options.base.extends)?.definition ?? (() => {
+      throw new Error(
+        `Base '${options.base.id}' extends unknown parent '${options.base.extends}'.`
+      );
+    })(),
+    basesById: options.basesById
+  }).setupProfileId : void 0);
+  const selection = resolveSetupProfileSelection({
+    manifest: options.manifest,
+    requestedSetupProfileId: inheritedSetupProfileId ?? void 0
+  });
+  return {
+    setupProfileId: selection.id
+  };
+}
+function resolveBaseDefinition(base, basesById) {
+  const inherited = base.definition.extends !== void 0 ? resolveBaseDefinition(
+    basesById.get(base.definition.extends) ?? (() => {
+      throw new Error(
+        `Base '${base.definition.id}' extends unknown parent '${base.definition.extends}'.`
+      );
+    })(),
+    basesById
+  ) : null;
+  const seed = base.definition.seed ?? inherited?.seed;
+  const players = base.definition.players ?? inherited?.players;
+  if (seed === void 0 || players === void 0) {
+    throw new Error(
+      `Base '${base.definition.id}' must resolve numeric seed and players.`
+    );
+  }
+  return {
+    ...base.definition,
+    seed,
+    players,
+    setupProfileId: base.definition.setupProfileId ?? inherited?.setupProfileId ?? void 0
+  };
+}
+function summarizeTableValidationError(manifest, error) {
+  const issues = error.message.split("; ").map((issue) => issue.trim()).filter((issue) => issue.length > 0);
+  if (issues.length === 0 || !issues.every((issue) => issue.startsWith("table"))) {
+    return error.message;
+  }
+  const boardBaseIdByRuntimeId = new Map(
+    (manifest.boards ?? []).flatMap(
+      (board) => board.scope === "perPlayer" ? Array.from(
+        { length: manifest.players.maxPlayers },
+        (_, index) => [`${board.id}:player-${index + 1}`, board.id]
+      ) : [[board.id, board.id]]
+    )
+  );
+  const representativeIssues = issues.slice(0, 3).map((issue) => {
+    const [, runtimeBoardId = ""] = issue.match(/^table\.boards\.byId\.([^.]+)\./) ?? [];
+    const boardBaseId = boardBaseIdByRuntimeId.get(runtimeBoardId);
+    if (!boardBaseId) {
+      return `- ${issue.replace(/^table\./, "")}`;
+    }
+    const boardSpecificPath = issue.replace(/^table\.boards\.byId\.[^.]+\./, "").replace(/^table\./, "");
+    return `- board '${boardBaseId}' (${runtimeBoardId}): ${boardSpecificPath}`;
+  });
+  return [
+    `Reducer-native table validation failed with ${issues.length} issue${issues.length === 1 ? "" : "s"}.`,
+    "Likely root cause: the generated test table shape does not match the authored manifest topology.",
+    ...representativeIssues,
+    "Pass --debug for the full validation dump."
+  ].join("\n");
+}
+var ShadowReducerRuntime = class {
+  constructor(manifest, gameModuleDefault, createInitialTable, seed, players, setupProfileId, debug = false) {
+    this.manifest = manifest;
+    this.gameModuleDefault = gameModuleDefault;
+    this.createInitialTable = createInitialTable;
+    this.seed = seed;
+    this.players = players;
+    this.setupProfileId = setupProfileId;
+    this.debug = debug;
+    if (typeof gameModuleDefault !== "object" || gameModuleDefault === null || !("contract" in gameModuleDefault)) {
+      throw new Error(
+        "app/game.ts must export a reducer-native game definition."
+      );
+    }
+    this.bundle = createReducerBundle(gameModuleDefault);
+    this.runtime = this.bundle.createInProcessRuntime();
+    this.playerIds = Array.from(
+      { length: players },
+      (_, index) => `player-${index + 1}`
+    );
+  }
+  manifest;
+  gameModuleDefault;
+  createInitialTable;
+  seed;
+  players;
+  setupProfileId;
+  debug;
+  bundle;
+  runtime;
+  playerIds;
+  historyRecords = [];
+  version = 0;
+  started = false;
+  async start() {
+    if (this.started) {
+      return;
+    }
+    const random = new KotlinSeededRandom(this.seed);
+    const shuffleItems = (values) => shuffleWithKotlinRandom(values, random);
+    const table = JSON.parse(
+      JSON.stringify(
+        this.createInitialTable?.({
+          playerIds: this.playerIds,
+          shuffleItems
+        }) ?? materializeManifestTable({
+          manifest: this.manifest,
+          playerIds: this.playerIds,
+          shuffleItems
+        })
+      )
+    );
+    const rngSeed = random.nextReducerRuntimeSeed();
+    try {
+      await this.runtime.initialize({
+        table,
+        playerIds: this.playerIds,
+        rngSeed,
+        setup: this.setupProfileId ? {
+          profileId: this.setupProfileId
+        } : null
+      });
+    } catch (error) {
+      if (!this.debug && error instanceof Error) {
+        throw new Error(summarizeTableValidationError(this.manifest, error));
+      }
+      throw error;
+    }
+    this.version = 0;
+    this.started = true;
+  }
+  phase() {
+    return (this.runtime.unsafeState()?.domain?.flow?.currentPhase ?? null) || "";
+  }
+  playerOrder() {
+    return this.playerIds;
+  }
+  rawState() {
+    return this.runtime.snapshot();
+  }
+  currentVersion() {
+    return this.version;
+  }
+  hydrate(snapshot, version = 0) {
+    this.runtime.hydrate({ state: structuredClone(snapshot) });
+    this.version = version;
+    this.started = true;
+  }
+  patchState(mutator) {
+    const next = structuredClone(this.rawState());
+    mutator(next);
+    this.hydrate(next, this.version + 1);
+  }
+  projectAllSeats() {
+    const projection = this.runtime.projectSeatsDynamic({
+      playerIds: this.playerIds
+    });
+    const interactionsByRef = projection.interactionsByRef && typeof projection.interactionsByRef === "object" && !Array.isArray(projection.interactionsByRef) ? projection.interactionsByRef : {};
+    const seats = Object.fromEntries(
+      Object.entries(projection.seats ?? {}).map(([playerId, seat]) => {
+        const availableInteractionRefs = Array.isArray(
+          seat.availableInteractionRefs
+        ) ? seat.availableInteractionRefs.filter(
+          (ref) => typeof ref === "string"
+        ) : [];
+        const availableInteractions = seat.availableInteractions ?? availableInteractionRefs.map((ref) => interactionsByRef[ref]).filter(
+          (descriptor) => !!descriptor && typeof descriptor === "object"
+        );
+        return [
+          playerId,
+          {
+            view: seat.view,
+            availableInteractions,
+            zones: seat.zones
+          }
+        ];
+      })
+    );
+    return {
+      currentStage: projection.currentStage ?? null,
+      stageSeats: projection.stageSeats ?? [],
+      seats
+    };
+  }
+  currentStage() {
+    return this.projectAllSeats().currentStage;
+  }
+  view(playerId) {
+    return this.runtime.projectSeatViewDynamic({
+      playerId
+    }) ?? null;
+  }
+  availableInteractionsForPlayer(playerId) {
+    const projection = this.projectAllSeats();
+    const seat = projection.seats[playerId];
+    const descriptors = seat?.availableInteractions ?? [];
+    return descriptors.filter(
+      (descriptor) => !!descriptor && typeof descriptor.interactionId === "string"
+    ).map((descriptor) => descriptor.interactionId);
+  }
+  /**
+   * Phase-kind interaction descriptors (action + prompt) available to
+   * `playerId` in the current phase. Surfaces the same projection the UI
+   * SDK consumes, so scenarios can assert addressee authorization and
+   * availability without reaching into game-specific state. Returned as
+   * loose records — the typed `InteractionDescriptor` shape is narrowed
+   * downstream in the workspace-generated `testing-contract.ts`.
+   */
+  interactionsForPlayer(playerId) {
+    return this.projectAllSeats().seats[playerId]?.availableInteractions ?? [];
+  }
+  explain(playerId, interactionId) {
+    const runtime = this.runtime;
+    if (typeof runtime.explainInteraction !== "function") {
+      throw new Error(
+        "The installed @dreamboard-games/sdk does not expose interaction explanations. Update the workspace SDK pin."
+      );
+    }
+    return runtime.explainInteraction({ playerId, interactionId });
+  }
+  clearHistory() {
+    this.historyRecords.length = 0;
+  }
+  async applyInput(input) {
+    const parsedInput = toReducerInput(input);
+    const result = await this.runtime.dispatch({ input: parsedInput });
+    if (result.kind === "reject") {
+      const record = {
+        input,
+        accepted: false,
+        errorCode: result.errorCode,
+        message: result.message
+      };
+      this.historyRecords.push(record);
+      throw createSubmissionError(
+        result.errorCode,
+        result.message,
+        "Reducer input rejected."
+      );
+    }
+    this.version += 1;
+    this.historyRecords.push({ input, accepted: true });
+  }
+  async submitInteraction(playerId, interactionId, params) {
+    await this.applyInput({
+      kind: "interaction",
+      playerId,
+      interactionId,
+      params
+    });
+  }
+};
+function toReducerInput(input) {
+  return {
+    kind: "interaction",
+    playerId: input.playerId,
+    interactionId: input.interactionId,
+    params: input.params
+  };
+}
+var RemoteGameplayTracker = class {
+  constructor(sessionId, playerId) {
+    this.sessionId = sessionId;
+    this.playerId = playerId;
+    this.state.playerId = playerId;
+  }
+  sessionId;
+  playerId;
+  state = {
+    version: -1,
+    actionSetVersion: "",
+    currentPhase: null,
+    playerId: "player-1",
+    view: null,
+    availableInteractions: []
+  };
+  liveBootstrap = false;
+  async bootstrap() {
+    const { data, error, response } = await getSessionSnapshot({
+      path: { sessionId: this.sessionId },
+      query: { playerId: this.playerId }
+    });
+    if (error || !data || data.type !== "gameplay") {
+      throw toDreamboardApiError(
+        error ?? { detail: "Gameplay snapshot was unavailable." },
+        response,
+        "Failed to load the remote gameplay bootstrap snapshot"
+      );
+    }
+    if (data.gameplay.actionSetVersion === "authority") {
+      return;
+    }
+    this.liveBootstrap = true;
+    this.applyGameplay(data.gameplay);
+  }
+  hasLiveBootstrap() {
+    return this.liveBootstrap;
+  }
+  snapshot() {
+    return {
+      ...this.state,
+      availableInteractions: [...this.state.availableInteractions]
+    };
+  }
+  applyShadow(shadow) {
+    const projection = shadow.projectAllSeats();
+    const playerId = this.playerId;
+    const seat = projection.seats[playerId];
+    this.state.version = shadow.currentVersion();
+    this.state.actionSetVersion = "";
+    this.state.playerId = playerId;
+    this.state.currentPhase = shadow.phase();
+    this.state.view = seat?.view ?? null;
+    this.state.availableInteractions = shadow.availableInteractionsForPlayer(playerId);
+  }
+  applyGameplay(gameplay) {
+    const playerId = gameplay.perspectivePlayerId;
+    const seat = gameplay.seats[playerId];
+    this.state.version = gameplay.version;
+    this.state.actionSetVersion = gameplay.actionSetVersion;
+    this.state.playerId = playerId;
+    this.state.currentPhase = gameplay.shared.currentPhase;
+    this.state.view = parseSeatView(seat?.view ?? "null");
+    this.state.availableInteractions = (seat?.availableInteractionRefs ?? []).map((ref) => gameplay.interactionsByRef[ref]).filter(
+      (interaction) => Boolean(interaction)
+    ).map((interaction) => interaction.interactionId);
+  }
+};
+function parseSeatView(raw) {
+  return raw ? parseJsonValue(raw) : null;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatIssuePath(label, path3) {
+  let formatted = label;
+  for (const segment of path3) {
+    formatted += typeof segment === "number" ? `[${segment}]` : `.${String(segment)}`;
+  }
+  return formatted;
+}
+function parseWirePayload(methodName, value, label, schema) {
+  const parsed = schema.safeParse(value);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  const firstIssue = parsed.error.issues[0];
+  const formattedPath = formatIssuePath(label, firstIssue?.path ?? []);
+  throw new Error(
+    `Reducer bundle returned invalid payload for '${methodName}': ${formattedPath} ${firstIssue?.message ?? "failed schema validation"}.`
+  );
+}
+function assertDispatchResultWireContract(result) {
+  return parseWirePayload(
+    "dispatch",
+    result,
+    "DispatchResult",
+    ReducerContractZod.DispatchResultSchema
+  );
+}
+async function createBrowserBridgeClient(page) {
+  const bridgeExists = async () => page.evaluate(
+    () => Boolean(
+      window.__dreamboardTestBridge__
+    )
+  );
+  const startedAt = Date.now();
+  while (!await bridgeExists()) {
+    if (Date.now() - startedAt > DEFAULT_TIMEOUT_MS2) {
+      const bodyText = await page.locator("body").innerText().catch(() => "");
+      const diagnostic = bodyText.trim().replace(/\s+/g, " ").slice(0, 400);
+      throw new Error(
+        diagnostic.length > 0 ? `Timed out waiting for browser test bridge. Page text: ${diagnostic}` : "Timed out waiting for browser test bridge."
+      );
+    }
+    await sleep(50);
+  }
+  return {
+    snapshot: () => page.evaluate(
+      () => window.__dreamboardTestBridge__.snapshot()
+    ),
+    submitInteraction: (playerId, interactionId, params) => page.evaluate(
+      ([nextPlayerId, nextInteractionId, nextParams]) => window.__dreamboardTestBridge__.submitInteraction(
+        nextPlayerId,
+        nextInteractionId,
+        nextParams
+      ),
+      [playerId, interactionId, params]
+    ),
+    waitForVersionChange: async (previousVersion, timeoutMs = DEFAULT_TIMEOUT_MS2) => {
+      const started = Date.now();
+      while (Date.now() - started < timeoutMs) {
+        const snapshot = await page.evaluate(
+          () => window.__dreamboardTestBridge__.snapshot()
+        );
+        if (snapshot.version > previousVersion) {
+          return snapshot;
+        }
+        await sleep(50);
+      }
+      throw new Error("Timed out waiting for browser gameplay version change.");
+    }
+  };
+}
+async function assertLiveMatchesShadow(runner, shadow, live) {
+  if (runner === "reducer") {
+    return;
+  }
+  const currentPhase = "currentPhase" in live ? live.currentPhase : shadow.phase();
+  if (currentPhase !== shadow.phase()) {
+    throw new Error(
+      `Live phase '${String(currentPhase)}' diverged from reducer phase '${shadow.phase()}'.`
+    );
+  }
+  const livePlayerId = "playerId" in live ? live.playerId : live.controllingPlayerId;
+  const liveView = "view" in live ? live.view : null;
+  if (livePlayerId && !deepEqual(liveView, await shadow.view(livePlayerId))) {
+    throw new Error("Live projected views diverged from reducer shadow views.");
+  }
+  const liveInteractions = "availableInteractions" in live ? live.availableInteractions : null;
+  if (livePlayerId && liveInteractions && !deepEqual(
+    liveInteractions,
+    shadow.availableInteractionsForPlayer(livePlayerId)
+  )) {
+    throw new Error(
+      "Live available-interactions metadata diverged from reducer shadow state."
+    );
+  }
+}
+async function loadBrowserDriver(projectRoot) {
+  const filePath = path2.join(projectRoot, "test", "browser-driver.ts");
+  if (!await exists(filePath)) {
+    return null;
+  }
+  const module = await importTypeScriptModule(filePath);
+  return module.default ?? module;
+}
+async function openBrowserPage(playUrl, config) {
+  configurePlaywrightBrowsersPath();
+  const { chromium } = await import("playwright");
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({
+    viewport: { width: 1440, height: 900 }
+  });
+  const initScript = await buildBrowserAuthInitScript(config);
+  if (initScript) {
+    await context.addInitScript({ content: initScript });
+  }
+  const page = await context.newPage();
+  await page.goto(playUrl, { waitUntil: "domcontentloaded" });
+  return { browser, page };
+}
+function sanitizeSnapshotSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+function createScenarioSnapshotMatcher(options) {
+  return (filename, actual) => {
+    const suffix = filename ? `.${sanitizeSnapshotSegment(filename)}` : "";
+    const snapshotPath = path2.join(
+      options.projectRoot,
+      "test",
+      "generated",
+      "snapshots",
+      `${sanitizeSnapshotSegment(options.scenarioId)}${suffix}.snapshot.json`
+    );
+    const wrappedValue = {
+      value: actual
+    };
+    const serialized = `${JSON.stringify(wrappedValue, null, 2)}
+`;
+    mkdirSync(path2.dirname(snapshotPath), { recursive: true });
+    if (!existsSync(snapshotPath) || options.updateSnapshots) {
+      writeFileSync(snapshotPath, serialized, "utf8");
+      return;
+    }
+    const previous = JSON.parse(readFileSync(snapshotPath, "utf8"));
+    if (!deepEqual(previous.value, actual)) {
+      throw new Error(
+        `Snapshot mismatch for scenario '${options.scenarioId}'. Re-run with --update-snapshots to refresh ${path2.relative(options.projectRoot, snapshotPath)}.`
+      );
+    }
+  };
+}
+async function createScenarioContext(options) {
+  const api = {
+    start: async () => {
+      await options.shadow.start();
+      if (options.runner === "remote" && options.remote) {
+        if (options.remote.tracker.hasLiveBootstrap()) {
+          const live = options.remote.tracker.snapshot();
+          await assertLiveMatchesShadow("remote", options.shadow, live);
+        } else {
+          options.remote.tracker.applyShadow(options.shadow);
+        }
+      }
+      if (options.runner === "browser" && options.browser) {
+        const live = await options.browser.bridge.snapshot();
+        await assertLiveMatchesShadow("browser", options.shadow, live);
+      }
+    },
+    patchState: async (mutator) => {
+      await api.start();
+      if (options.live || options.remote || options.browser || options.actionPlan) {
+        throw new Error(
+          "game.patchState is only supported for reducer snapshot scenarios. Use it to materialize a state before --from-scenario or reducer tests, not inside live replay/browser runners."
+        );
+      }
+      options.shadow.patchState(mutator);
+    },
+    submit: async (playerId, interactionId, params) => {
+      await api.start();
+      const interactionParams = params ?? {};
+      const normalizedInputs = interactionParams && typeof interactionParams === "object" && !Array.isArray(interactionParams) ? interactionParams : {};
+      const previousVersion = options.live ? options.live.version : options.actionPlan ? options.shadow.currentVersion() : options.runner === "remote" ? options.remote?.tracker.snapshot().version ?? 0 : options.runner === "browser" ? (await options.browser?.bridge.snapshot())?.version ?? 0 : 0;
+      if (options.live) {
+        if (!options.live.actionSetVersion) {
+          options.live.actionSetVersion = await fetchLiveActionSetVersion(
+            options.live.sessionId,
+            playerId
+          );
+        }
+        const submittedActionSetVersion = options.live.actionSetVersion;
+        const submitStartedAt = performance.now();
+        const clientActionId = randomUUID2();
+        const { data, error, response } = await submitGameplayAuthorityAction({
+          path: {
+            sessionId: options.live.sessionId,
+            playerId,
+            interactionId
+          },
+          body: {
+            expectedVersion: previousVersion,
+            actionSetVersion: options.live.actionSetVersion,
+            inputs: normalizedInputs
+          },
+          headers: { "X-Dreamboard-Client-Action-Id": clientActionId }
+        });
+        const durationMs = performance.now() - submitStartedAt;
+        options.live.diagnostics?.push({
+          index: options.live.submitIndex ?? 0,
+          playerId,
+          interactionId,
+          inputs: normalizedInputs,
+          expectedVersion: previousVersion,
+          actionSetVersion: submittedActionSetVersion,
+          responseStatus: response?.status,
+          responseBody: options.live.captureResponseBody === false ? void 0 : JSON.stringify(error ?? data ?? null),
+          accepted: data?.accepted ?? void 0,
+          errorCode: data?.accepted === false ? data.errorCode ?? void 0 : error && typeof error === "object" && "detail" in error ? String(error.detail) : void 0,
+          backendTiming: response?.headers?.get("server-timing") ?? response?.headers?.get("x-dreamboard-timing") ?? void 0,
+          durationMs
+        });
+        options.live.submitIndex = (options.live.submitIndex ?? 0) + 1;
+        if (error) {
+          throw createSubmissionError(
+            "api-error",
+            void 0,
+            "Failed to submit interaction"
+          );
+        }
+        if (data?.accepted === false) {
+          const shadowError = await tryShadowSubmit(
+            options.shadow,
+            playerId,
+            interactionId,
+            interactionParams
+          );
+          if (!shadowError || shadowError.errorCode !== data.errorCode) {
+            throw new Error(
+              "Live session rejection diverged from reducer shadow state."
+            );
+          }
+          throw createSubmissionError(
+            data.errorCode ?? void 0,
+            data.message ?? void 0,
+            "Interaction rejected"
+          );
+        }
+        options.live.version = typeof data?.version === "number" ? data.version : previousVersion + 1;
+        options.live.actionSetVersion = data?.actionSetVersion ?? options.live.actionSetVersion;
+      } else if (options.runner === "remote" && options.remote) {
+      } else if (options.runner === "browser" && options.browser) {
+        const handled = await options.browser.driver?.interaction?.(options.browser.bridge, {
+          playerId,
+          interactionId,
+          params: interactionParams
+        }) === true;
+        if (!handled) {
+          await options.browser.bridge.submitInteraction(
+            playerId,
+            interactionId,
+            interactionParams
+          );
+        }
+      }
+      await options.shadow.submitInteraction(
+        playerId,
+        interactionId,
+        interactionParams
+      );
+      if (options.actionPlan) {
+        options.actionPlan.diagnostics.push({
+          index: options.actionPlan.submitIndex ?? 0,
+          playerId,
+          interactionId,
+          inputs: normalizedInputs,
+          expectedVersion: previousVersion,
+          actionSetVersion: "",
+          accepted: true,
+          durationMs: 0
+        });
+        options.actionPlan.submitIndex = (options.actionPlan.submitIndex ?? 0) + 1;
+      }
+      if (options.runner === "remote" && options.remote) {
+        options.remote.tracker.applyShadow(options.shadow);
+        await assertLiveMatchesShadow(
+          "remote",
+          options.shadow,
+          options.remote.tracker.snapshot()
+        );
+      }
+      if (options.runner === "browser" && options.browser) {
+        const live = await options.browser.bridge.waitForVersionChange(previousVersion);
+        await assertLiveMatchesShadow("browser", options.shadow, live);
+      }
+    }
+  };
+  return {
+    game: api,
+    players: () => options.shadow.playerOrder(),
+    seat: (index) => {
+      const order = options.shadow.playerOrder();
+      if (!Number.isInteger(index) || index < 0 || index >= order.length) {
+        throw new Error(
+          `seat(${index}) is out of range; scenario has ${order.length} player(s).`
+        );
+      }
+      return order[index];
+    },
+    state: () => options.shadow.phase(),
+    view: (playerId) => options.shadow.view(playerId),
+    interactions: (playerId) => options.shadow.interactionsForPlayer(playerId),
+    explain: (playerId, interactionId) => options.shadow.explain(playerId, interactionId),
+    expect: options.expect
+  };
+}
+async function tryShadowSubmit(shadow, playerId, interactionId, params) {
+  try {
+    await shadow.submitInteraction(playerId, interactionId, params);
+    throw new Error("Expected shadow interaction to reject.");
+  } catch (error) {
+    if (error instanceof Error && error.name === "SubmissionError") {
+      return error;
+    }
+    throw error;
+  }
+}
+async function createSessionFromScenario(options) {
+  const startedAt = Date.now();
+  const materialized = await materializeScenarioReducerState(options);
+  const reducerHarnessMs = Date.now() - startedAt;
+  const hydrateStartedAt = Date.now();
+  const {
+    data: snapshot,
+    error,
+    response
+  } = await createProjectSessionFromReducerSnapshot({
+    path: { projectId: options.projectId },
+    body: {
+      compiledResultId: options.compiledResultId,
+      seed: materialized.seed,
+      playerCount: materialized.playerCount,
+      setupProfileId: materialized.setupProfileId ?? void 0,
+      baseId: materialized.baseId,
+      scenarioId: materialized.scenarioId,
+      reducerState: materialized.reducerState,
+      reducerStateVersion: materialized.reducerStateVersion,
+      fingerprintMetadata: materialized.fingerprintMetadata
+    }
+  });
+  const backendHydrateMs = Date.now() - hydrateStartedAt;
+  if (error || !snapshot) {
+    throw toDreamboardApiError(
+      error,
+      response,
+      `Failed to materialize scenario '${options.scenarioId}' from reducer snapshot`
+    );
+  }
+  return {
+    sessionId: snapshot.context.sessionId,
+    shortCode: snapshot.context.shortCode,
+    gameId: projectIdFromSessionGameSource(snapshot.context.gameSource),
+    seed: materialized.seed,
+    playerCount: materialized.playerCount,
+    setupProfileId: materialized.setupProfileId,
+    scenarioId: materialized.scenarioId,
+    phase: materialized.phase,
+    stage: materialized.stage,
+    materialization: {
+      mode: "snapshot",
+      totalMs: Date.now() - startedAt,
+      reducerHarnessMs,
+      backendHydrateMs
+    }
+  };
+}
+var MATERIALIZED_SCENARIO_CACHE_VERSION = 1;
+function materializedScenarioCachePath(options) {
+  return path2.join(
+    options.projectRoot,
+    PROJECT_DIR_NAME,
+    "dev",
+    "scenario-cache",
+    `${sanitizeSnapshotSegment(options.baseId)}.${sanitizeSnapshotSegment(
+      options.scenarioId
+    )}.${options.fingerprintHash}.json`
+  );
+}
+async function readMaterializedScenarioCache(options) {
+  const cachePath = materializedScenarioCachePath(options);
+  const text = await readTextFileIfExists(cachePath);
+  if (!text) return null;
+  try {
+    const payload = JSON.parse(
+      text
+    );
+    if (payload.cacheVersion !== MATERIALIZED_SCENARIO_CACHE_VERSION || payload.fingerprintHash !== options.fingerprintHash || !payload.materialized) {
+      return null;
+    }
+    return payload.materialized;
+  } catch {
+    return null;
+  }
+}
+async function writeMaterializedScenarioCache(options) {
+  const cachePath = materializedScenarioCachePath(options);
+  await ensureDir(path2.dirname(cachePath));
+  await writeJsonFile(cachePath, {
+    cacheVersion: MATERIALIZED_SCENARIO_CACHE_VERSION,
+    fingerprintHash: options.fingerprintHash,
+    materialized: options.materialized
+  });
+}
+async function materializeScenarioReducerState(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  let preloadedGeneratedBaseStates;
+  if (options.trustGeneratedFingerprint === true) {
+    const [generatedBaseStates2, scenarioManifest] = await Promise.all([
+      loadGeneratedBaseStates(options.projectRoot),
+      loadGeneratedScenarioManifest(options.projectRoot)
+    ]);
+    preloadedGeneratedBaseStates = generatedBaseStates2;
+    const scenarioEntry = scenarioManifest.find(
+      (entry) => entry.id === options.scenarioId
+    );
+    const generatedBase2 = scenarioEntry ? generatedBaseStates2?.[baseStateKey(scenarioEntry.base)] : null;
+    if (generatedBase2 && generatedBase2.fingerprint.compiledResultId === options.compiledResultId && generatedBase2.fingerprint.gameId === options.gameId) {
+      const cached2 = await readMaterializedScenarioCache({
+        projectRoot: options.projectRoot,
+        baseId: scenarioEntry.base,
+        scenarioId: options.scenarioId,
+        fingerprintHash: fingerprintHash(generatedBase2.fingerprint)
+      });
+      if (cached2) {
+        return cached2;
+      }
+    }
+  }
+  const [bases, scenarios, generatedBaseStates, manifest] = await Promise.all([
+    loadTypedBases(options.projectRoot),
+    loadTypedScenarios(options.projectRoot, {}),
+    preloadedGeneratedBaseStates === void 0 ? loadGeneratedBaseStates(options.projectRoot) : Promise.resolve(preloadedGeneratedBaseStates),
+    loadManifest(options.projectRoot)
+  ]);
+  const matchingScenarios = scenarios.filter(
+    (scenario2) => scenario2.definition.id === options.scenarioId
+  );
+  if (matchingScenarios.length === 0) {
+    throw new Error(
+      `Unknown scenario '${options.scenarioId}'. Available scenarios: ${scenarios.map((scenario2) => scenario2.definition.id).sort().join(", ")}`
+    );
+  }
+  if (matchingScenarios.length > 1) {
+    throw new Error(
+      `Scenario id '${options.scenarioId}' is defined more than once. Keep one scenario per file and one unique id per workspace.`
+    );
+  }
+  const scenario = matchingScenarios[0];
+  const basesById = new Map(bases.map((base2) => [base2.definition.id, base2]));
+  validateTypedScenarioBases([scenario], basesById);
+  const base = basesById.get(scenario.definition.from);
+  if (!base) {
+    throw new Error(
+      `Missing typed base '${scenario.definition.from}' for scenario '${scenario.definition.id}'.`
+    );
+  }
+  const generatedBase = generatedBaseStates?.[baseStateKey(base.definition.id)];
+  if (!generatedBase) {
+    throw new Error(
+      `Missing generated base artifact for '${base.definition.id}'. Run 'dreamboard test generate' before using --from-scenario.`
+    );
+  }
+  if (typeof generatedBase.version !== "number") {
+    throw new Error(
+      `Generated base artifact for '${base.definition.id}' is stale. Run 'dreamboard test generate' before using --from-scenario.`
+    );
+  }
+  const canTrustGeneratedFingerprint = options.trustGeneratedFingerprint === true && generatedBase.fingerprint.compiledResultId === options.compiledResultId && generatedBase.fingerprint.gameId === options.gameId;
+  const current = canTrustGeneratedFingerprint ? generatedBase.fingerprint : await currentFingerprint({
+    projectRoot: options.projectRoot,
+    base,
+    basesById,
+    compiledResultId: options.compiledResultId,
+    gameId: options.gameId
+  });
+  if (!canTrustGeneratedFingerprint) {
+    validateGeneratedFingerprint({
+      generated: generatedBase.fingerprint,
+      current
+    });
+  }
+  const currentHash = fingerprintHash(current);
+  const cached = await readMaterializedScenarioCache({
+    projectRoot: options.projectRoot,
+    baseId: base.definition.id,
+    scenarioId: scenario.definition.id,
+    fingerprintHash: currentHash
+  });
+  if (cached) {
+    return cached;
+  }
+  const [gameModule, manifestContractModule] = await Promise.all([
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "app", "game.ts")
+    ),
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
+    )
+  ]);
+  const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
+  const resolvedBase = resolveBaseDefinition(base, basesById);
+  const effectiveSetup = resolveEffectiveBaseSetup({
+    manifest,
+    base: base.definition,
+    basesById
+  });
+  const shadow = new ShadowReducerRuntime(
+    manifest,
+    gameModule.default,
+    createInitialTable,
+    resolvedBase.seed,
+    resolvedBase.players,
+    effectiveSetup.setupProfileId,
+    options.debug ?? false
+  );
+  shadow.hydrate(generatedBase.snapshot, generatedBase.version);
+  const context = await createScenarioContext({
+    runner: "reducer",
+    shadow,
+    expect: (await loadTestingExpectApiFactory())()
+  });
+  shadow.clearHistory();
+  await scenario.definition.when(context);
+  if (scenario.definition.phase && shadow.phase() !== scenario.definition.phase) {
+    throw new Error(
+      `Scenario '${scenario.definition.id}' expected phase '${scenario.definition.phase}' but reached '${shadow.phase()}'.`
+    );
+  }
+  if (scenario.definition.stage && shadow.currentStage() !== scenario.definition.stage) {
+    throw new Error(
+      `Scenario '${scenario.definition.id}' expected stage '${scenario.definition.stage}' but reached '${shadow.currentStage() ?? "null"}'.`
+    );
+  }
+  const materialized = {
+    baseId: base.definition.id,
+    scenarioId: scenario.definition.id,
+    seed: resolvedBase.seed,
+    playerCount: resolvedBase.players,
+    setupProfileId: effectiveSetup.setupProfileId,
+    reducerState: shadow.rawState(),
+    reducerStateVersion: shadow.currentVersion(),
+    fingerprintMetadata: {
+      baseFingerprintHash: fingerprintHash(generatedBase.fingerprint),
+      currentFingerprintHash: fingerprintHash(current),
+      baseBundleHash: generatedBase.fingerprint.baseBundleHash,
+      manifestHash: generatedBase.fingerprint.manifestHash,
+      appBundleHash: generatedBase.fingerprint.appBundleHash,
+      uiContractHash: generatedBase.fingerprint.uiContractHash,
+      baseId: base.definition.id,
+      scenarioId: scenario.definition.id
+    },
+    phase: shadow.phase(),
+    stage: shadow.currentStage()
+  };
+  await writeMaterializedScenarioCache({
+    projectRoot: options.projectRoot,
+    baseId: base.definition.id,
+    scenarioId: scenario.definition.id,
+    fingerprintHash: currentHash,
+    materialized
+  });
+  return materialized;
+}
+async function replayScenarioThroughBackend(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  const [
+    bases,
+    scenarios,
+    generatedBaseStates,
+    manifest,
+    gameModule,
+    manifestContractModule
+  ] = await Promise.all([
+    loadTypedBases(options.projectRoot),
+    loadTypedScenarios(options.projectRoot, {}),
+    loadGeneratedBaseStates(options.projectRoot),
+    loadManifest(options.projectRoot),
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "app", "game.ts")
+    ),
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
+    )
+  ]);
+  const matchingScenarios = scenarios.filter(
+    (scenario2) => scenario2.definition.id === options.scenarioId
+  );
+  if (matchingScenarios.length !== 1) {
+    throw new Error(
+      matchingScenarios.length === 0 ? `Unknown scenario '${options.scenarioId}'. Available scenarios: ${scenarios.map((scenario2) => scenario2.definition.id).sort().join(", ")}` : `Scenario id '${options.scenarioId}' is defined more than once. Keep one scenario per file and one unique id per workspace.`
+    );
+  }
+  const scenario = matchingScenarios[0];
+  const basesById = new Map(bases.map((base2) => [base2.definition.id, base2]));
+  validateTypedScenarioBases([scenario], basesById);
+  const base = basesById.get(scenario.definition.from);
+  if (!base) {
+    throw new Error(
+      `Missing typed base '${scenario.definition.from}' for scenario '${scenario.definition.id}'.`
+    );
+  }
+  const generatedBase = generatedBaseStates?.[baseStateKey(base.definition.id)];
+  if (!generatedBase) {
+    throw new Error(
+      `Missing generated base artifact for '${base.definition.id}'. Run 'dreamboard test generate' before replaying a scenario.`
+    );
+  }
+  validateGeneratedFingerprint({
+    generated: generatedBase.fingerprint,
+    current: await currentFingerprint({
+      projectRoot: options.projectRoot,
+      base,
+      basesById,
+      compiledResultId: options.compiledResultId,
+      gameId: options.gameId
+    })
+  });
+  const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
+  const resolvedBase = resolveBaseDefinition(base, basesById);
+  const effectiveSetup = resolveEffectiveBaseSetup({
+    manifest,
+    base: base.definition,
+    basesById
+  });
+  const shadow = new ShadowReducerRuntime(
+    manifest,
+    gameModule.default,
+    createInitialTable,
+    resolvedBase.seed,
+    resolvedBase.players,
+    effectiveSetup.setupProfileId,
+    options.debug ?? false
+  );
+  if (base.definition.extends) {
+    const parentArtifact = generatedBaseStates?.[baseStateKey(base.definition.extends)];
+    if (!parentArtifact || typeof parentArtifact.version !== "number") {
+      throw new Error(
+        `Base '${base.definition.id}' extends '${base.definition.extends}', but the parent artifact is missing or stale. Run 'dreamboard test generate' first.`
+      );
+    }
+    shadow.hydrate(parentArtifact.snapshot, parentArtifact.version);
+  }
+  const {
+    data: session,
+    error: sessionError,
+    response: sessionResponse
+  } = await createProjectSession({
+    path: { projectId: options.gameId },
+    body: {
+      compiledResultId: options.compiledResultId,
+      seed: resolvedBase.seed,
+      playerCount: resolvedBase.players,
+      autoAssignSeats: true,
+      setupProfileId: effectiveSetup.setupProfileId ?? void 0
+    }
+  });
+  if (!session || sessionError) {
+    throw toDreamboardApiError(
+      sessionError,
+      sessionResponse,
+      `Failed to create replay session for '${scenario.definition.id}'`
+    );
+  }
+  const { error: startError, response: startResponse } = await startGame({
+    path: { sessionId: session.sessionId }
+  });
+  if (startError) {
+    throw toDreamboardApiError(
+      startError,
+      startResponse,
+      `Failed to start replay session for '${scenario.definition.id}'`
+    );
+  }
+  const diagnostics = [];
+  const context = await createScenarioContext({
+    runner: "reducer",
+    shadow,
+    expect: (await loadTestingExpectApiFactory())(),
+    live: {
+      sessionId: session.sessionId,
+      version: 0,
+      actionSetVersion: "",
+      submitIndex: 0,
+      diagnostics,
+      captureResponseBody: options.captureResponseBody
+    }
+  });
+  await context.game.start();
+  await base.definition.setup({
+    game: context.game,
+    players: context.players,
+    seat: context.seat
+  });
+  shadow.clearHistory();
+  await scenario.definition.when(context);
+  if (scenario.definition.phase && shadow.phase() !== scenario.definition.phase) {
+    throw new Error(
+      `Scenario '${scenario.definition.id}' expected phase '${scenario.definition.phase}' but reached '${shadow.phase()}'.`
+    );
+  }
+  if (scenario.definition.stage && shadow.currentStage() !== scenario.definition.stage) {
+    throw new Error(
+      `Scenario '${scenario.definition.id}' expected stage '${scenario.definition.stage}' but reached '${shadow.currentStage() ?? "null"}'.`
+    );
+  }
+  return {
+    sessionId: session.sessionId,
+    shortCode: session.shortCode,
+    gameId: projectIdFromSessionGameSource(session.gameSource),
+    seed: resolvedBase.seed,
+    playerCount: resolvedBase.players,
+    setupProfileId: effectiveSetup.setupProfileId,
+    scenarioId: scenario.definition.id,
+    phase: shadow.phase(),
+    stage: shadow.currentStage(),
+    diagnostics
+  };
+}
+async function createScenarioActionPlan(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  const [
+    bases,
+    scenarios,
+    generatedBaseStates,
+    manifest,
+    gameModule,
+    manifestContractModule
+  ] = await Promise.all([
+    loadTypedBases(options.projectRoot),
+    loadTypedScenarios(options.projectRoot, {}),
+    loadGeneratedBaseStates(options.projectRoot),
+    loadManifest(options.projectRoot),
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "app", "game.ts")
+    ),
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
+    )
+  ]);
+  const matchingScenarios = scenarios.filter(
+    (scenario2) => scenario2.definition.id === options.scenarioId
+  );
+  if (matchingScenarios.length !== 1) {
+    throw new Error(
+      matchingScenarios.length === 0 ? `Unknown scenario '${options.scenarioId}'. Available scenarios: ${scenarios.map((scenario2) => scenario2.definition.id).sort().join(", ")}` : `Scenario id '${options.scenarioId}' is defined more than once. Keep one scenario per file and one unique id per workspace.`
+    );
+  }
+  const scenario = matchingScenarios[0];
+  const basesById = new Map(bases.map((base2) => [base2.definition.id, base2]));
+  validateTypedScenarioBases([scenario], basesById);
+  const base = basesById.get(scenario.definition.from);
+  if (!base) {
+    throw new Error(
+      `Missing typed base '${scenario.definition.from}' for scenario '${scenario.definition.id}'.`
+    );
+  }
+  const generatedBase = generatedBaseStates?.[baseStateKey(base.definition.id)];
+  if (!generatedBase) {
+    throw new Error(
+      `Missing generated base artifact for '${base.definition.id}'. Run 'dreamboard test generate' before replaying a scenario.`
+    );
+  }
+  validateGeneratedFingerprint({
+    generated: generatedBase.fingerprint,
+    current: await currentFingerprint({
+      projectRoot: options.projectRoot,
+      base,
+      basesById,
+      compiledResultId: options.compiledResultId,
+      gameId: options.gameId
+    })
+  });
+  const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
+  const resolvedBase = resolveBaseDefinition(base, basesById);
+  const effectiveSetup = resolveEffectiveBaseSetup({
+    manifest,
+    base: base.definition,
+    basesById
+  });
+  const shadow = new ShadowReducerRuntime(
+    manifest,
+    gameModule.default,
+    createInitialTable,
+    resolvedBase.seed,
+    resolvedBase.players,
+    effectiveSetup.setupProfileId,
+    options.debug ?? false
+  );
+  if (base.definition.extends) {
+    const parentArtifact = generatedBaseStates?.[baseStateKey(base.definition.extends)];
+    if (!parentArtifact || typeof parentArtifact.version !== "number") {
+      throw new Error(
+        `Base '${base.definition.id}' extends '${base.definition.extends}', but the parent artifact is missing or stale. Run 'dreamboard test generate' first.`
+      );
+    }
+    shadow.hydrate(parentArtifact.snapshot, parentArtifact.version);
+  }
+  const diagnostics = [];
+  const context = await createScenarioContext({
+    runner: "reducer",
+    shadow,
+    expect: (await loadTestingExpectApiFactory())(),
+    actionPlan: {
+      submitIndex: 0,
+      diagnostics
+    }
+  });
+  await context.game.start();
+  await base.definition.setup({
+    game: context.game,
+    players: context.players,
+    seat: context.seat
+  });
+  shadow.clearHistory();
+  await scenario.definition.when(context);
+  if (scenario.definition.phase && shadow.phase() !== scenario.definition.phase) {
+    throw new Error(
+      `Scenario '${scenario.definition.id}' expected phase '${scenario.definition.phase}' but reached '${shadow.phase()}'.`
+    );
+  }
+  if (scenario.definition.stage && shadow.currentStage() !== scenario.definition.stage) {
+    throw new Error(
+      `Scenario '${scenario.definition.id}' expected stage '${scenario.definition.stage}' but reached '${shadow.currentStage() ?? "null"}'.`
+    );
+  }
+  return {
+    gameId: options.gameId,
+    seed: resolvedBase.seed,
+    playerCount: resolvedBase.players,
+    setupProfileId: effectiveSetup.setupProfileId,
+    scenarioId: scenario.definition.id,
+    phase: shadow.phase(),
+    stage: shadow.currentStage(),
+    diagnostics
+  };
+}
+async function replayActionPlanThroughBackend(options) {
+  const session = await createActionPlanReplaySession(options);
+  return replayActionPlanInSession({
+    session,
+    actions: options.actions,
+    captureResponseBody: options.captureResponseBody
+  });
+}
+async function createActionPlanReplaySession(options) {
+  const {
+    data: session,
+    error: sessionError,
+    response: sessionResponse
+  } = await createProjectSession({
+    path: { projectId: options.gameId },
+    body: {
+      compiledResultId: options.compiledResultId,
+      seed: options.seed,
+      playerCount: options.playerCount,
+      autoAssignSeats: true,
+      setupProfileId: options.setupProfileId ?? void 0
+    }
+  });
+  if (!session || sessionError) {
+    throw toDreamboardApiError(
+      sessionError,
+      sessionResponse,
+      "Failed to create replay session from action plan"
+    );
+  }
+  const { error: startError, response: startResponse } = await startGame({
+    path: { sessionId: session.sessionId }
+  });
+  if (startError) {
+    throw toDreamboardApiError(
+      startError,
+      startResponse,
+      "Failed to start replay session from action plan"
+    );
+  }
+  return {
+    sessionId: session.sessionId,
+    shortCode: session.shortCode,
+    gameId: projectIdFromSessionGameSource(session.gameSource),
+    seed: options.seed,
+    playerCount: options.playerCount,
+    setupProfileId: options.setupProfileId ?? null,
+    scenarioId: options.scenarioId ?? "action-plan",
+    phase: null,
+    stage: null
+  };
+}
+async function replayActionPlanInSession(options) {
+  let version = 0;
+  let actionSetVersion = "";
+  const diagnostics = [];
+  for (const [index, action] of options.actions.entries()) {
+    if (index > 0) {
+      await waitForActionPacing({
+        actionIntervalMs: options.actionIntervalMs ?? 0,
+        actionJitterMs: options.actionJitterMs ?? 0
+      });
+    }
+    if (!actionSetVersion) {
+      actionSetVersion = await fetchLiveActionSetVersion(
+        options.session.sessionId,
+        action.playerId
+      );
+    }
+    const submittedActionSetVersion = actionSetVersion;
+    const submitStartedAt = performance.now();
+    const clientActionId = randomUUID2();
+    const { data, error, response } = await submitGameplayAuthorityAction({
+      path: {
+        sessionId: options.session.sessionId,
+        playerId: action.playerId,
+        interactionId: action.interactionId
+      },
+      body: {
+        expectedVersion: version,
+        actionSetVersion,
+        inputs: action.inputs ?? {}
+      },
+      headers: { "X-Dreamboard-Client-Action-Id": clientActionId }
+    });
+    const durationMs = performance.now() - submitStartedAt;
+    diagnostics.push({
+      index,
+      playerId: action.playerId,
+      interactionId: action.interactionId,
+      inputs: action.inputs ?? {},
+      expectedVersion: version,
+      actionSetVersion: submittedActionSetVersion,
+      responseStatus: response?.status,
+      responseBody: options.captureResponseBody === false ? void 0 : JSON.stringify(error ?? data ?? null),
+      accepted: data?.accepted ?? void 0,
+      errorCode: data?.accepted === false ? data.errorCode ?? void 0 : error && typeof error === "object" && "detail" in error ? String(error.detail) : void 0,
+      backendTiming: response?.headers?.get("server-timing") ?? response?.headers?.get("x-dreamboard-timing") ?? void 0,
+      durationMs
+    });
+    if (error) {
+      throw createSubmissionError(
+        "api-error",
+        void 0,
+        "Failed to submit interaction from action plan"
+      );
+    }
+    if (data?.accepted === false) {
+      throw createSubmissionError(
+        data.errorCode ?? void 0,
+        data.message ?? void 0,
+        "Interaction rejected while replaying action plan"
+      );
+    }
+    version = typeof data?.version === "number" ? data.version : version + 1;
+    actionSetVersion = data?.actionSetVersion ?? actionSetVersion;
+  }
+  return {
+    ...options.session,
+    diagnostics
+  };
+}
+async function fetchLiveActionSetVersion(sessionId, playerId) {
+  const { data, error, response } = await getSessionSnapshot({
+    path: { sessionId },
+    query: { playerId }
+  });
+  if (error || !data || data.type !== "gameplay") {
+    throw toDreamboardApiError(
+      error ?? { detail: "Gameplay snapshot was unavailable." },
+      response,
+      "Failed to read live gameplay action set version"
+    );
+  }
+  return data.gameplay.actionSetVersion;
+}
+async function waitForActionPacing(options) {
+  const intervalMs = Math.max(0, options.actionIntervalMs);
+  const jitterMs = Math.max(0, options.actionJitterMs);
+  if (intervalMs === 0 && jitterMs === 0) {
+    return;
+  }
+  const offsetMs = jitterMs === 0 ? 0 : Math.floor((Math.random() * 2 - 1) * jitterMs);
+  const delayMs = Math.max(0, intervalMs + offsetMs);
+  if (delayMs === 0) {
+    return;
+  }
+  await new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function baseStateKey(baseId) {
+  return baseId;
+}
+function fingerprintHash(fingerprint) {
+  return hashContent(JSON.stringify(fingerprint));
+}
+function sortBasesForArtifacts(bases, basesById) {
+  const ordered = [];
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (base) => {
+    if (visited.has(base.definition.id)) {
+      return;
+    }
+    if (visiting.has(base.definition.id)) {
+      throw new Error(
+        `Cyclic reducer-native base inheritance detected at '${base.definition.id}'.`
+      );
+    }
+    visiting.add(base.definition.id);
+    if (base.definition.extends) {
+      const parent = basesById.get(base.definition.extends);
+      if (!parent) {
+        throw new Error(
+          `Base '${base.definition.id}' extends unknown parent '${base.definition.extends}'.`
+        );
+      }
+      visit(parent);
+    }
+    visiting.delete(base.definition.id);
+    visited.add(base.definition.id);
+    ordered.push(base);
+  };
+  for (const base of bases) {
+    visit(base);
+  }
+  return ordered;
+}
+function writeProjectionSnapshots(options) {
+  const projectionDir = path2.join(
+    options.projectRoot,
+    "test",
+    "generated",
+    "bases",
+    options.baseId
+  );
+  rmSync(projectionDir, { recursive: true, force: true });
+  mkdirSync(projectionDir, { recursive: true });
+  const projection = options.shadow.projectAllSeats();
+  for (const [playerId, seatProjection] of Object.entries(projection.seats)) {
+    const outputPath = path2.join(projectionDir, `${playerId}.projection.json`);
+    writeFileSync(
+      outputPath,
+      `${JSON.stringify(
+        {
+          currentStage: projection.currentStage,
+          stageSeats: projection.stageSeats,
+          ...seatProjection
+        },
+        null,
+        2
+      )}
+`,
+      "utf8"
+    );
+  }
+}
+function validateTypedScenarioBases(scenarios, basesById) {
+  const available = new Set(basesById.keys());
+  const invalid = scenarios.filter((scenario) => !available.has(scenario.definition.from)).map(
+    (scenario) => path2.relative(process.cwd(), scenario.filePath) + ` -> '${scenario.definition.from}'`
+  );
+  if (invalid.length > 0) {
+    throw new Error(
+      `Unknown scenario base(s): ${invalid.join(", ")}. Available bases: ${Array.from(available).sort().join(", ")}`
+    );
+  }
+}
+async function writeReducerNativeGeneratedFiles(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  const manifest = await loadManifest(options.projectRoot);
+  const manifestHash = hashContent(JSON.stringify(manifest));
+  const appBundleHash = hashContent(
+    await bundleTypeScriptModuleText(
+      path2.join(options.projectRoot, "app", "game.ts")
+    )
+  );
+  const uiContractHash = hashContent(
+    await bundleTypeScriptModuleText(
+      path2.join(options.projectRoot, "shared", "generated", "ui-contract.ts"),
+      { external: SDK_UI_RUNTIME_EXTERNALS }
+    )
+  );
+  const generatedDir = path2.join(options.projectRoot, "test", "generated");
+  await ensureDir(generatedDir);
+  const baseStates = {};
+  const [gameModule, manifestContractModule] = await Promise.all([
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "app", "game.ts")
+    ),
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
+    )
+  ]);
+  const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
+  const contractFingerprintValue = contractFingerprint(
+    gameModule.default
+  ).value;
+  const basesById = new Map(
+    options.bases.map((base) => [base.definition.id, base])
+  );
+  for (const base of sortBasesForArtifacts(options.bases, basesById)) {
+    const resolvedBase = resolveBaseDefinition(base, basesById);
+    const effectiveSetup = resolveEffectiveBaseSetup({
+      manifest,
+      base: base.definition,
+      basesById
+    });
+    const shadow = new ShadowReducerRuntime(
+      manifest,
+      gameModule.default,
+      createInitialTable,
+      resolvedBase.seed,
+      resolvedBase.players,
+      effectiveSetup.setupProfileId,
+      options.debug ?? false
+    );
+    let parentFingerprintHash = null;
+    if (base.definition.extends) {
+      const parentArtifact = baseStates[baseStateKey(base.definition.extends)];
+      if (!parentArtifact) {
+        throw new Error(
+          `Base '${base.definition.id}' extends '${base.definition.extends}', but the parent artifact does not exist yet.`
+        );
+      }
+      if (parentArtifact.fingerprint.seed !== resolvedBase.seed) {
+        throw new Error(
+          `Base '${base.definition.id}' extends '${base.definition.extends}' but changes seed from ${parentArtifact.fingerprint.seed} to ${resolvedBase.seed}.`
+        );
+      }
+      if (parentArtifact.fingerprint.players !== resolvedBase.players) {
+        throw new Error(
+          `Base '${base.definition.id}' extends '${base.definition.extends}' but changes players from ${parentArtifact.fingerprint.players} to ${resolvedBase.players}.`
+        );
+      }
+      if ((parentArtifact.fingerprint.setupProfileId ?? null) !== (effectiveSetup.setupProfileId ?? null)) {
+        throw new Error(
+          `Base '${base.definition.id}' extends '${base.definition.extends}' but changes setup profile from ${parentArtifact.fingerprint.setupProfileId ?? "none"} to ${effectiveSetup.setupProfileId ?? "none"}.`
+        );
+      }
+      parentFingerprintHash = fingerprintHash(parentArtifact.fingerprint);
+      shadow.hydrate(parentArtifact.snapshot, parentArtifact.version);
+    }
+    const context = await createScenarioContext({
+      runner: "reducer",
+      shadow,
+      expect: (await loadTestingExpectApiFactory())()
+    });
+    await context.game.start();
+    await base.definition.setup({
+      game: context.game,
+      players: context.players,
+      seat: context.seat
+    });
+    baseStates[baseStateKey(base.definition.id)] = {
+      key: baseStateKey(base.definition.id),
+      base: base.definition.id,
+      snapshot: shadow.rawState(),
+      version: shadow.currentVersion(),
+      fingerprint: {
+        base: base.definition.id,
+        seed: resolvedBase.seed,
+        players: resolvedBase.players,
+        baseBundleHash: base.bundleHash,
+        manifestHash,
+        appBundleHash,
+        uiContractHash,
+        setupProfileId: effectiveSetup.setupProfileId,
+        compiledResultId: options.compiledResultId,
+        gameId: options.gameId,
+        parentBaseId: base.definition.extends ?? null,
+        parentFingerprintHash,
+        contractFingerprint: contractFingerprintValue
+      }
+    };
+    writeProjectionSnapshots({
+      projectRoot: options.projectRoot,
+      baseId: base.definition.id,
+      shadow
+    });
+  }
+  const header = "// Generated by dreamboard test generate. Do not edit by hand.\n";
+  await writeTextFile(
+    path2.join(generatedDir, "base-states.generated.ts"),
+    `${header}export const BASE_STATES = ${JSON.stringify(baseStates, null, 2)} as const;
+export const BASE_STATES_CONTRACT_FINGERPRINT = ${JSON.stringify(contractFingerprintValue)};
+`
+  );
+  await writeTextFile(
+    path2.join(generatedDir, "base-states.generated.d.ts"),
+    `${header}export declare const BASE_STATES: Record<string, unknown>;
+export declare const BASE_STATES_CONTRACT_FINGERPRINT: string | undefined;
+`
+  );
+  await writeTextFile(
+    path2.join(generatedDir, "scenario-manifest.generated.ts"),
+    `${header}export const SCENARIO_MANIFEST = ${JSON.stringify(
+      options.scenarios.map((scenario) => ({
+        id: scenario.definition.id,
+        filePath: path2.relative(generatedDir, scenario.filePath),
+        base: scenario.definition.from,
+        runners: normalizeScenarioRunners(scenario.definition.runners)
+      })),
+      null,
+      2
+    )} as const;
+`
+  );
+  await writeJsonFile(path2.join(generatedDir, ".generation-meta.json"), {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    contractFingerprint: contractFingerprintValue,
+    scenarioCount: options.scenarios.length,
+    baseStateCount: options.bases.length
+  });
+}
+async function loadGeneratedBaseStates(projectRoot) {
+  const filePath = path2.join(
+    projectRoot,
+    "test",
+    "generated",
+    "base-states.generated.ts"
+  );
+  if (!await exists(filePath)) {
+    return null;
+  }
+  const module = await importTypeScriptModule(filePath);
+  return module.BASE_STATES ?? null;
+}
+async function loadGeneratedScenarioManifest(projectRoot) {
+  const filePath = path2.join(
+    projectRoot,
+    "test",
+    "generated",
+    "scenario-manifest.generated.ts"
+  );
+  if (!await exists(filePath)) {
+    return [];
+  }
+  const module = await importTypeScriptModule(filePath);
+  const entries = module.SCENARIO_MANIFEST;
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    if (entry && typeof entry === "object" && "id" in entry && "base" in entry && typeof entry.id === "string" && typeof entry.base === "string") {
+      return [{ id: entry.id, base: entry.base }];
+    }
+    return [];
+  });
+}
+function validateGeneratedFingerprint(options) {
+  const mismatches = [];
+  if (options.generated.contractFingerprint && options.current.contractFingerprint && options.generated.contractFingerprint !== options.current.contractFingerprint) {
+    const error = new Error(
+      `Base states were generated for contract ${options.generated.contractFingerprint} but the current contract is ${options.current.contractFingerprint}. Remedy: run \`dreamboard test generate\`, then re-run the tests.`
+    );
+    error.code = STALE_CONTRACT_ARTIFACT_CODE;
+    throw error;
+  }
+  if (options.generated.baseBundleHash !== options.current.baseBundleHash) {
+    mismatches.push("base module changed");
+  }
+  if (options.generated.manifestHash !== options.current.manifestHash) {
+    mismatches.push("manifest changed");
+  }
+  if (options.generated.appBundleHash !== options.current.appBundleHash) {
+    mismatches.push("game reducer bundle changed");
+  }
+  if (options.generated.uiContractHash !== options.current.uiContractHash) {
+    mismatches.push("ui contract changed");
+  }
+  if (options.generated.seed !== options.current.seed || options.generated.players !== options.current.players) {
+    mismatches.push("base seed/player count changed");
+  }
+  if ((options.generated.setupProfileId ?? null) !== (options.current.setupProfileId ?? null)) {
+    mismatches.push("base setup profile changed");
+  }
+  if ((options.generated.parentBaseId ?? null) !== (options.current.parentBaseId ?? null)) {
+    mismatches.push("base parent changed");
+  }
+  if ((options.generated.parentFingerprintHash ?? null) !== (options.current.parentFingerprintHash ?? null)) {
+    mismatches.push("parent base artifact changed");
+  }
+  if (mismatches.length > 0) {
+    throw new Error(
+      `${mismatches.join("; ")}. Run 'dreamboard test generate' to refresh reducer-native base artifacts.`
+    );
+  }
+}
+async function currentFingerprint(options) {
+  const manifest = await loadManifest(options.projectRoot);
+  const gameModule = await importTypeScriptModule(
+    path2.join(options.projectRoot, "app", "game.ts")
+  );
+  const contractFingerprintValue = contractFingerprint(
+    gameModule.default
+  ).value;
+  const resolvedBase = resolveBaseDefinition(
+    options.base,
+    options.basesById ?? /* @__PURE__ */ new Map([[options.base.definition.id, options.base]])
+  );
+  const effectiveSetup = resolveEffectiveBaseSetup({
+    manifest,
+    base: options.base.definition,
+    basesById: options.basesById
+  });
+  let parentFingerprintHash = null;
+  if (options.base.definition.extends) {
+    const parentBase = options.basesById?.get(options.base.definition.extends);
+    if (!parentBase) {
+      throw new Error(
+        `Base '${options.base.definition.id}' extends unknown parent '${options.base.definition.extends}'.`
+      );
+    }
+    parentFingerprintHash = fingerprintHash(
+      await currentFingerprint({
+        projectRoot: options.projectRoot,
+        base: parentBase,
+        basesById: options.basesById,
+        compiledResultId: options.compiledResultId,
+        gameId: options.gameId
+      })
+    );
+  }
+  return {
+    base: options.base.definition.id,
+    seed: resolvedBase.seed,
+    players: resolvedBase.players,
+    baseBundleHash: options.base.bundleHash,
+    manifestHash: hashContent(JSON.stringify(manifest)),
+    appBundleHash: hashContent(
+      await bundleTypeScriptModuleText(
+        path2.join(options.projectRoot, "app", "game.ts")
+      )
+    ),
+    uiContractHash: hashContent(
+      await bundleTypeScriptModuleText(
+        path2.join(options.projectRoot, "shared", "generated", "ui-contract.ts"),
+        { external: SDK_UI_RUNTIME_EXTERNALS }
+      )
+    ),
+    setupProfileId: effectiveSetup.setupProfileId,
+    compiledResultId: options.compiledResultId,
+    gameId: options.gameId,
+    parentBaseId: options.base.definition.extends ?? null,
+    parentFingerprintHash,
+    contractFingerprint: contractFingerprintValue
+  };
+}
+async function generateReducerNativeArtifacts(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  const [bases, scenarios] = await Promise.all([
+    loadTypedBases(options.projectRoot),
+    loadTypedScenarios(options.projectRoot, {
+      scenarioPath: options.scenarioPath
+    })
+  ]);
+  const basesById = new Map(bases.map((base) => [base.definition.id, base]));
+  validateTypedScenarioBases(scenarios, basesById);
+  await writeReducerNativeGeneratedFiles({
+    projectRoot: options.projectRoot,
+    bases,
+    scenarios,
+    compiledResultId: options.compiledResultId,
+    gameId: options.gameId,
+    debug: options.debug
+  });
+  return { bases, scenarios };
+}
+async function runReducerNativeScenarios(options) {
+  await ensureReducerNativeTestingFiles(options.projectRoot);
+  const [
+    bases,
+    scenarios,
+    initialGeneratedBaseStates,
+    manifest,
+    gameModule,
+    manifestContractModule
+  ] = await Promise.all([
+    loadTypedBases(options.projectRoot),
+    loadTypedScenarios(options.projectRoot, {
+      scenarioPath: options.scenarioPath
+    }),
+    loadGeneratedBaseStates(options.projectRoot),
+    loadManifest(options.projectRoot),
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "app", "game.ts")
+    ),
+    importTypeScriptModule(
+      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
+    )
+  ]);
+  let generatedBaseStates = initialGeneratedBaseStates;
+  const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
+  const basesById = new Map(bases.map((base) => [base.definition.id, base]));
+  validateTypedScenarioBases(scenarios, basesById);
+  if (options.updateSnapshots) {
+    await writeReducerNativeGeneratedFiles({
+      projectRoot: options.projectRoot,
+      bases,
+      scenarios,
+      compiledResultId: options.compiledResultId,
+      gameId: options.gameId,
+      debug: options.debug
+    });
+    generatedBaseStates = await loadGeneratedBaseStates(options.projectRoot);
+  }
+  const runnerScenarios = scenarios.filter(
+    (scenario) => normalizeScenarioRunners(scenario.definition.runners).includes(
+      options.runner
+    )
+  );
+  let browser = null;
+  let page = null;
+  let browserBridge = null;
+  let browserDriver = null;
+  if (options.runner === "browser") {
+    const webBaseUrl = options.webBaseUrl ?? options.projectConfig.webBaseUrl;
+    if (!webBaseUrl) {
+      throw new Error(
+        "Browser runner requires a local webBaseUrl. Start the local web stack and configure the project for env local."
+      );
+    }
+    browserDriver = await loadBrowserDriver(options.projectRoot);
+    const opened = await openBrowserPage(
+      `${webBaseUrl}/_dev`,
+      options.resolvedConfig
+    );
+    browser = opened.browser;
+    page = opened.page;
+  }
+  try {
+    let passed = 0;
+    let failed = 0;
+    const results = [];
+    for (const scenario of runnerScenarios) {
+      const base = basesById.get(scenario.definition.from);
+      if (!base) {
+        throw new Error(
+          `Missing typed base '${scenario.definition.from}' for scenario '${scenario.definition.id}'.`
+        );
+      }
+      if (generatedBaseStates?.[baseStateKey(base.definition.id)]) {
+        validateGeneratedFingerprint({
+          generated: generatedBaseStates[baseStateKey(base.definition.id)].fingerprint,
+          current: await currentFingerprint({
+            projectRoot: options.projectRoot,
+            base,
+            basesById,
+            compiledResultId: options.compiledResultId,
+            gameId: options.gameId
+          })
+        });
+      } else if (options.runner !== "reducer") {
+        throw new Error(
+          "Missing reducer-native generated base artifacts. Run 'dreamboard test generate' first."
+        );
+      }
+      try {
+        const resolvedBase = resolveBaseDefinition(base, basesById);
+        const effectiveSetup = resolveEffectiveBaseSetup({
+          manifest,
+          base: base.definition,
+          basesById
+        });
+        const shadow = new ShadowReducerRuntime(
+          manifest,
+          gameModule.default,
+          createInitialTable,
+          resolvedBase.seed,
+          resolvedBase.players,
+          effectiveSetup.setupProfileId,
+          options.debug ?? false
+        );
+        if (base.definition.extends) {
+          const parentArtifact = generatedBaseStates?.[baseStateKey(base.definition.extends)];
+          if (!parentArtifact) {
+            throw new Error(
+              `Base '${base.definition.id}' extends '${base.definition.extends}', but the parent artifact is missing. Run 'dreamboard test generate' first.`
+            );
+          }
+          shadow.hydrate(parentArtifact.snapshot, parentArtifact.version);
+        }
+        let remote;
+        if (options.runner === "remote") {
+          const compiledResultId = options.compiledResultId ?? options.projectConfig.compile?.latestSuccessful?.resultId;
+          if (!compiledResultId) {
+            throw new Error(
+              "Remote runner requires a compiled result. Compile the workspace first."
+            );
+          }
+          const {
+            data: session,
+            error: sessionError,
+            response: sessionResponse
+          } = await createProjectSession({
+            path: { projectId: options.projectConfig.projectId },
+            body: {
+              compiledResultId,
+              seed: resolvedBase.seed,
+              playerCount: resolvedBase.players,
+              autoAssignSeats: true,
+              setupProfileId: effectiveSetup.setupProfileId ?? void 0
+            }
+          });
+          if (!session || sessionError) {
+            throw toDreamboardApiError(
+              sessionError,
+              sessionResponse,
+              "Failed to create remote-runner session."
+            );
+          }
+          const tracker = new RemoteGameplayTracker(
+            session.sessionId,
+            "player-1"
+          );
+          const { error: startError, response: startResponse } = await startGame({
+            path: { sessionId: session.sessionId }
+          });
+          if (startError) {
+            throw toDreamboardApiError(
+              startError,
+              startResponse,
+              "Failed to start remote-runner session."
+            );
+          }
+          await tracker.bootstrap();
+          remote = {
+            sessionId: session.sessionId,
+            tracker
+          };
+        }
+        if (options.runner === "browser" && page) {
+          const compiledResultId = options.compiledResultId ?? options.projectConfig.compile?.latestSuccessful?.resultId;
+          if (!compiledResultId) {
+            throw new Error(
+              "Browser runner requires a compiled result. Compile the workspace first."
+            );
+          }
+          const {
+            data: session,
+            error: sessionError,
+            response: sessionResponse
+          } = await createProjectSession({
+            path: { projectId: options.projectConfig.projectId },
+            body: {
+              compiledResultId,
+              seed: resolvedBase.seed,
+              playerCount: resolvedBase.players,
+              autoAssignSeats: true,
+              setupProfileId: effectiveSetup.setupProfileId ?? void 0
+            }
+          });
+          if (!session || sessionError) {
+            throw toDreamboardApiError(
+              sessionError,
+              sessionResponse,
+              "Failed to create browser-runner session."
+            );
+          }
+          const { error: startError, data: started } = await startGame({
+            path: { sessionId: session.sessionId }
+          });
+          if (startError || !started) {
+            throw new Error("Failed to start browser-runner session.");
+          }
+          await page.goto(
+            `${options.webBaseUrl ?? options.projectConfig.webBaseUrl}/_dev/play/${started.context.shortCode}`,
+            { waitUntil: "domcontentloaded" }
+          );
+          await waitForGameReady(page);
+          browserBridge = await createBrowserBridgeClient(page);
+          await browserDriver?.onReady?.(browserBridge);
+        }
+        const context = await createScenarioContext({
+          runner: options.runner,
+          shadow,
+          expect: (await loadTestingExpectApiFactory())({
+            matchSnapshot: createScenarioSnapshotMatcher({
+              projectRoot: options.projectRoot,
+              scenarioId: scenario.definition.id,
+              updateSnapshots: options.updateSnapshots ?? false
+            })
+          }),
+          remote,
+          browser: options.runner === "browser" && browserBridge ? {
+            bridge: browserBridge,
+            driver: browserDriver
+          } : void 0
+        });
+        await context.game.start();
+        await base.definition.setup({
+          game: context.game,
+          players: context.players,
+          seat: context.seat
+        });
+        shadow.clearHistory();
+        await scenario.definition.when(context);
+        if (scenario.definition.phase && shadow.phase() !== scenario.definition.phase) {
+          throw new Error(
+            `Scenario '${scenario.definition.id}' expected phase '${scenario.definition.phase}' but reached '${shadow.phase()}'.`
+          );
+        }
+        if (scenario.definition.stage && shadow.currentStage() !== scenario.definition.stage) {
+          throw new Error(
+            `Scenario '${scenario.definition.id}' expected stage '${scenario.definition.stage}' but reached '${shadow.currentStage() ?? "null"}'.`
+          );
+        }
+        await scenario.definition.then(context);
+        passed += 1;
+        results.push({
+          id: scenario.definition.id,
+          success: true
+        });
+      } catch (error) {
+        failed += 1;
+        results.push({
+          id: scenario.definition.id,
+          success: false,
+          errorCode: isStaleContractArtifactError(error) ? STALE_CONTRACT_ARTIFACT_CODE : void 0,
+          error: error instanceof Error ? formatScenarioErrorForDisplay({
+            error,
+            projectRoot: options.projectRoot,
+            scenarioFilePath: scenario.filePath
+          }) : `Scenario '${scenario.definition.id}' failed.`
+        });
+      }
+    }
+    return { passed, failed, results };
+  } finally {
+    if (browser) {
+      await browser.close();
+    }
+  }
+}
+
+export {
+  formatScenarioErrorForDisplay,
+  isReducerNativeTestingWorkspace,
+  ensureReducerNativeTestingFiles,
+  loadTypedBases,
+  loadTypedScenarios,
+  assertDispatchResultWireContract,
+  createSessionFromScenario,
+  materializeScenarioReducerState,
+  replayScenarioThroughBackend,
+  createScenarioActionPlan,
+  replayActionPlanThroughBackend,
+  createActionPlanReplaySession,
+  replayActionPlanInSession,
+  writeReducerNativeGeneratedFiles,
+  generateReducerNativeArtifacts,
+  runReducerNativeScenarios
+};
+//# sourceMappingURL=chunk-ON62IGWK.mjs.map