@dreamboard-games/cli 0.1.30-alpha.12 → 0.1.30-alpha.13

package/dist/agent-verifier/{chunk-4GU3PCHV.mjs → chunk-DWLTCUUX.mjs}

@@ -2,19 +2,28 @@
 import {
   bundleTypeScriptModuleText,
   importTypeScriptModule
-} from "./chunk-XKCJBIRY.mjs";
+} from "./chunk-QD4SQNUP.mjs";
 import {
   STALE_CONTRACT_ARTIFACT_CODE,
   isStaleContractArtifactError,
   toDreamboardApiError
-} from "./chunk-COB56ESI.mjs";
+} from "./chunk-G2ECODRB.mjs";
+import {
+  createUserTokenManager,
+  resolveLocalHarnessAccessToken
+} from "./chunk-CO3BRUD6.mjs";
 import {
   loadManifest
-} from "./chunk-UWJIZML3.mjs";
+} from "./chunk-LKQ557TJ.mjs";
 import {
   REDUCER_TESTING_TYPES_WRAPPER_CONTENT,
   buildReducerTestingContractContent
 } from "./chunk-F2DIOJJZ.mjs";
+import {
+  ensureDir,
+  exists,
+  writeJsonFile
+} from "./chunk-RDYXWXXC.mjs";
 import {
   createGameplayCapability,
   createProjectSession,
@@ -22,24 +31,26 @@ import {
   getSessionSnapshot,
   hashContent,
   startGame
-} from "./chunk-6XRC5PWB.mjs";
+} from "./chunk-H3XNWKJU.mjs";
 import {
   external_exports
 } from "./chunk-JZTH3EMV.mjs";
 import {
-  ensureDir,
-  exists,
-  readTextFileIfExists,
-  writeJsonFile,
-  writeTextFile
-} from "./chunk-IAYRNVUC.mjs";
+  readWorkspaceTextFileIfExists,
+  resolveWorkspacePath,
+  workspacePathExists,
+  writeWorkspaceJsonFile,
+  writeWorkspaceTextFile
+} from "./chunk-WAFBU5U7.mjs";
 import {
   PROJECT_DIR_NAME
 } from "./chunk-M7UVBANQ.mjs";
 
 // src/services/testing/reducer-native-test-harness.ts
-import path2 from "path";
+import path3 from "path";
 import { randomUUID as randomUUID2 } from "crypto";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
 import {
   existsSync,
   mkdirSync,
@@ -49,14 +60,35 @@ import {
 } 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/utils/dev-session.ts
+import { randomInt } from "crypto";
+var MIN_SAFE_SEED = BigInt(Number.MIN_SAFE_INTEGER);
+var MAX_SAFE_SEED = BigInt(Number.MAX_SAFE_INTEGER);
+function createPersistedDevSession(input) {
+  return {
+    sessionId: input.sessionId
+  };
+}
+
+// src/utils/jwt.ts
+function extractUserIdFromJwt(token) {
+  if (!token) {
+    return null;
+  }
+  const parts = token.split(".");
+  if (parts.length < 2) {
+    return null;
+  }
+  try {
+    const payload = JSON.parse(
+      Buffer.from(parts[1], "base64url").toString("utf8")
+    );
+    return typeof payload.sub === "string" ? payload.sub : null;
+  } catch {
+    return null;
+  }
+}
 
 // src/services/gameplay-authority-submit.ts
 import { randomUUID } from "crypto";
@@ -657,8 +689,9 @@ function configurePlaywrightBrowsersPath() {
   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)});})();`;
+  const resolvedToken = resolveLocalHarnessAccessToken(config) ?? (await createUserTokenManager(config).resolveApiToken())?.token;
+  if (!resolvedToken) return null;
+  return `(function(){localStorage.setItem('dreamboard_auth_token',${JSON.stringify(resolvedToken)});})();`;
 }
 async function waitForGameReady(page, timeoutMs = 6e4) {
   await page.waitForSelector('iframe[title="Game UI Plugin"]', {
@@ -666,6 +699,79 @@ async function waitForGameReady(page, timeoutMs = 6e4) {
   });
 }
 
+// src/services/dev-host/loader.ts
+import path2 from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+async function loadProjectDevHost(projectRoot) {
+  const requireFromProject = createRequire(path2.join(projectRoot, "package.json"));
+  let packageJsonPath;
+  let entryPath;
+  try {
+    packageJsonPath = requireFromProject.resolve(
+      "@dreamboard-games/dev-host/package.json"
+    );
+    entryPath = requireFromProject.resolve("@dreamboard-games/dev-host");
+  } catch (error) {
+    throw new Error(
+      "Install @dreamboard-games/dev-host in this workspace before running dreamboard dev or browser tests.",
+      { cause: error }
+    );
+  }
+  const packageRoot = path2.dirname(packageJsonPath);
+  if (!isPathInside(packageRoot, entryPath)) {
+    throw new Error(
+      "@dreamboard-games/dev-host resolved outside its installed package."
+    );
+  }
+  const packageJson = requireFromProject(packageJsonPath);
+  if (packageJson.name !== "@dreamboard-games/dev-host" || typeof packageJson.version !== "string" || packageJson.version.length === 0) {
+    throw new Error("Installed @dreamboard-games/dev-host metadata is invalid.");
+  }
+  const loaded = await import(pathToFileURL(entryPath).href);
+  if (loaded.protocolVersion !== 1 || typeof loaded.start !== "function") {
+    throw new Error(
+      "Installed @dreamboard-games/dev-host does not expose DevHostModuleV1."
+    );
+  }
+  return {
+    packageRoot,
+    packageVersion: packageJson.version,
+    module: {
+      protocolVersion: loaded.protocolVersion,
+      start: loaded.start
+    }
+  };
+}
+function isPathInside(parent, candidate) {
+  const relativePath = path2.relative(parent, candidate);
+  return relativePath === "" || !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
+}
+
+// src/services/dev-host/platform.ts
+function createCliDevHostPlatform(config) {
+  return {
+    resolveBearer: () => resolveDevHostBearer(config)
+  };
+}
+async function resolveDevHostBearer(config) {
+  const localHarnessToken = resolveLocalHarnessAccessToken(config);
+  if (localHarnessToken) {
+    return { kind: "ok", token: localHarnessToken };
+  }
+  if (config.refreshTokenSource !== "global") {
+    return { kind: "ok", token: config.authToken ?? null };
+  }
+  if (!config.refreshToken) {
+    return {
+      kind: "permanent_invalid",
+      message: "Stored Dreamboard session is expired or invalid. Run `dreamboard login` to authenticate again."
+    };
+  }
+  const resolved = await createUserTokenManager(config).resolveApiToken();
+  return { kind: "ok", token: resolved?.token ?? null };
+}
+
 // src/services/workflows/resolve-setup-profile.ts
 function resolveSetupProfileSelection(options) {
   const setupProfiles = options.manifest.setupProfiles ?? [];
@@ -751,15 +857,15 @@ 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 absolutePath = path3.resolve(options.scenarioFilePath);
+  const relativePath = path3.relative(options.projectRoot, absolutePath);
+  const normalizedRelativePath = relativePath.split(path3.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 normalizedLine = line.split(path3.sep).join("/");
     const match = normalizedLine.match(absoluteFrame) ?? normalizedLine.match(relativeFrame);
     if (match?.[1] && match?.[2]) {
       return `at ${normalizedRelativePath}:${match[1]}:${match[2]}`;
@@ -770,12 +876,45 @@ function findScenarioStackFrame(options) {
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var testingExpectApiFactoryPromise;
-async function loadTestingExpectApiFactory() {
-  testingExpectApiFactoryPromise ??= import("@dreamboard-games/sdk/testing").then(
-    (module) => module.createExpectApi
+var projectReducerNativeModules = /* @__PURE__ */ new Map();
+function resolveProjectSdkModule(projectRoot, specifier) {
+  const requireFromProject = createRequire2(
+    path3.join(projectRoot, "package.json")
   );
-  return testingExpectApiFactoryPromise;
+  return requireFromProject.resolve(specifier);
+}
+async function importProjectSdkModule(projectRoot, specifier) {
+  const modulePath = resolveProjectSdkModule(projectRoot, specifier);
+  return await import(pathToFileURL2(modulePath).href);
+}
+async function loadProjectReducerNativeModules(projectRoot) {
+  const cacheKey = path3.resolve(projectRoot);
+  const cached = projectReducerNativeModules.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  const promise = Promise.all([
+    importProjectSdkModule(cacheKey, "@dreamboard-games/sdk/reducer"),
+    importProjectSdkModule(cacheKey, "@dreamboard-games/sdk/reducer-contract"),
+    importProjectSdkModule(
+      cacheKey,
+      "@dreamboard-games/sdk/testing"
+    )
+  ]).then(([reducerModule, reducerContractModule, testingModule]) => {
+    if (typeof reducerModule.createReducerBundle !== "function" || typeof reducerModule.contractFingerprint !== "function" || typeof reducerContractModule.materializeManifestTable !== "function" || typeof testingModule.createExpectApi !== "function") {
+      throw new Error(
+        "Installed @dreamboard-games/sdk does not expose the reducer-native test helpers required by this CLI."
+      );
+    }
+    return {
+      createReducerBundle: reducerModule.createReducerBundle,
+      contractFingerprint: reducerModule.contractFingerprint,
+      materializeManifestTable: reducerContractModule.materializeManifestTable,
+      createExpectApi: testingModule.createExpectApi
+    };
+  });
+  projectReducerNativeModules.set(cacheKey, promise);
+  return promise;
 }
 function createSubmissionError(errorCode, message, fallbackMessage) {
   const error = new Error(message ?? fallbackMessage);
@@ -812,7 +951,7 @@ async function discoverFiles(root, suffix) {
   const entries = await readdir(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const entryPath = path2.join(root, entry.name);
+    const entryPath = path3.join(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await discoverFiles(entryPath, suffix));
       continue;
@@ -861,62 +1000,52 @@ function parseTypedScenarioDefinition(value) {
   };
 }
 async function isReducerNativeTestingWorkspace(projectRoot) {
-  return await exists(path2.join(projectRoot, "app", "game.ts")) && await exists(
-    path2.join(projectRoot, "shared", "generated", "ui-contract.ts")
+  return await exists(path3.join(projectRoot, "app", "game.ts")) && await exists(
+    path3.join(projectRoot, "shared", "generated", "ui-contract.ts")
   );
 }
 async function ensureReducerNativeTestingFiles(projectRoot) {
-  const testingTypesPath = path2.join(projectRoot, "test", "testing-types.ts");
-  const testingContractPath = path2.join(
+  const testingTypesPath = "test/testing-types.ts";
+  const testingContractPath = "test/generated/testing-contract.ts";
+  const baseStatesPath = "test/generated/base-states.generated.ts";
+  const baseStatesDtsPath = "test/generated/base-states.generated.d.ts";
+  const scenarioManifestPath = "test/generated/scenario-manifest.generated.ts";
+  await ensureDir(resolveWorkspacePath(projectRoot, "test"));
+  await ensureDir(resolveWorkspacePath(projectRoot, "test/generated"));
+  const existingTestingTypes = await readWorkspaceTextFileIfExists(
     projectRoot,
-    "test",
-    "generated",
-    "testing-contract.ts"
+    testingTypesPath
   );
-  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(
+    await writeWorkspaceTextFile(
+      projectRoot,
       testingTypesPath,
       REDUCER_TESTING_TYPES_WRAPPER_CONTENT
     );
   }
   const rejectionCodes = await collectKnownRejectionCodes(projectRoot);
-  await writeTextFile(
+  await writeWorkspaceTextFile(
+    projectRoot,
     testingContractPath,
     buildReducerTestingContractContent({ rejectionCodes })
   );
   const header = "// Generated by dreamboard test generate. Do not edit by hand.\n";
-  if (!await exists(baseStatesPath)) {
-    await writeTextFile(
+  if (!await workspacePathExists(projectRoot, baseStatesPath)) {
+    await writeWorkspaceTextFile(
+      projectRoot,
       baseStatesPath,
       `${header}export const BASE_STATES = {} as const;
 export const BASE_STATES_CONTRACT_FINGERPRINT = undefined;
 `
     );
   } else {
-    const existingBaseStates = await readTextFileIfExists(baseStatesPath);
+    const existingBaseStates = await readWorkspaceTextFileIfExists(
+      projectRoot,
+      baseStatesPath
+    );
     if (existingBaseStates && !existingBaseStates.includes("BASE_STATES_CONTRACT_FINGERPRINT")) {
-      await writeTextFile(
+      await writeWorkspaceTextFile(
+        projectRoot,
         baseStatesPath,
         `${existingBaseStates.trimEnd()}
 export const BASE_STATES_CONTRACT_FINGERPRINT = undefined;
@@ -924,17 +1053,22 @@ export const BASE_STATES_CONTRACT_FINGERPRINT = undefined;
       );
     }
   }
-  if (!await exists(baseStatesDtsPath)) {
-    await writeTextFile(
+  if (!await workspacePathExists(projectRoot, baseStatesDtsPath)) {
+    await writeWorkspaceTextFile(
+      projectRoot,
       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);
+    const existingBaseStatesDts = await readWorkspaceTextFileIfExists(
+      projectRoot,
+      baseStatesDtsPath
+    );
     if (existingBaseStatesDts && !existingBaseStatesDts.includes("BASE_STATES_CONTRACT_FINGERPRINT")) {
-      await writeTextFile(
+      await writeWorkspaceTextFile(
+        projectRoot,
         baseStatesDtsPath,
         `${existingBaseStatesDts.trimEnd()}
 export declare const BASE_STATES_CONTRACT_FINGERPRINT: string | undefined;
@@ -942,8 +1076,9 @@ export declare const BASE_STATES_CONTRACT_FINGERPRINT: string | undefined;
       );
     }
   }
-  if (!await exists(scenarioManifestPath)) {
-    await writeTextFile(
+  if (!await workspacePathExists(projectRoot, scenarioManifestPath)) {
+    await writeWorkspaceTextFile(
+      projectRoot,
       scenarioManifestPath,
       `${header}export const SCENARIO_MANIFEST = [] as const;
 `
@@ -958,7 +1093,7 @@ var DEFAULT_REJECTION_CODES = [
 ];
 async function collectKnownRejectionCodes(projectRoot) {
   const knownCodes = new Set(DEFAULT_REJECTION_CODES);
-  const gamePath = path2.join(projectRoot, "app", "game.ts");
+  const gamePath = path3.join(projectRoot, "app", "game.ts");
   if (!await exists(gamePath)) {
     return Array.from(knownCodes).sort(
       (left, right) => left.localeCompare(right)
@@ -985,7 +1120,7 @@ async function collectKnownRejectionCodes(projectRoot) {
 }
 async function loadTypedBases(projectRoot) {
   const baseFiles = await discoverFiles(
-    path2.join(projectRoot, "test", "bases"),
+    resolveWorkspacePath(projectRoot, "test/bases"),
     BASE_SUFFIX
   );
   const loaded = [];
@@ -1004,8 +1139,8 @@ async function loadTypedBases(projectRoot) {
   return loaded;
 }
 async function loadTypedScenarios(projectRoot, options) {
-  const scenarioFiles = options.scenarioPath ? [path2.resolve(projectRoot, options.scenarioPath)] : await discoverFiles(
-    path2.join(projectRoot, "test", "scenarios"),
+  const scenarioFiles = options.scenarioPath ? [resolveWorkspacePath(projectRoot, options.scenarioPath)] : await discoverFiles(
+    resolveWorkspacePath(projectRoot, "test/scenarios"),
     SCENARIO_SUFFIX
   );
   const loaded = [];
@@ -1024,8 +1159,8 @@ async function loadTypedScenarios(projectRoot, options) {
   return loaded;
 }
 function reducerNativeTestHelperExternals(projectRoot, filePath) {
-  const testingTypesPath = path2.join(projectRoot, "test", "testing-types");
-  const relative = path2.relative(path2.dirname(filePath), testingTypesPath).replaceAll("\\", "/");
+  const testingTypesPath = path3.join(projectRoot, "test", "testing-types");
+  const relative = path3.relative(path3.dirname(filePath), testingTypesPath).replaceAll("\\", "/");
   const specifier = relative.startsWith(".") ? relative : `./${relative}`;
   return [specifier, `${specifier}.ts`, ...SDK_UI_RUNTIME_EXTERNALS];
 }
@@ -1206,7 +1341,8 @@ function summarizeTableValidationError(manifest, error) {
   ].join("\n");
 }
 var ShadowReducerRuntime = class {
-  constructor(manifest, gameModuleDefault, createInitialTable, seed, players, setupProfileId, debug = false) {
+  constructor(modules, manifest, gameModuleDefault, createInitialTable, seed, players, setupProfileId, debug = false) {
+    this.modules = modules;
     this.manifest = manifest;
     this.gameModuleDefault = gameModuleDefault;
     this.createInitialTable = createInitialTable;
@@ -1219,20 +1355,13 @@ var ShadowReducerRuntime = class {
         "app/game.ts must export a reducer-native game definition."
       );
     }
-    this.bundle = createReducerBundle(gameModuleDefault);
+    this.bundle = this.modules.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;
@@ -1250,7 +1379,7 @@ var ShadowReducerRuntime = class {
         this.createInitialTable?.({
           playerIds: this.playerIds,
           shuffleItems
-        }) ?? materializeManifestTable({
+        }) ?? this.modules.materializeManifestTable({
           manifest: this.manifest,
           playerIds: this.playerIds,
           shuffleItems
@@ -1411,8 +1540,6 @@ var RemoteGameplayTracker = class {
     this.playerId = playerId;
     this.state.playerId = playerId;
   }
-  sessionId;
-  playerId;
   state = {
     version: -1,
     actionSetVersion: "",
@@ -1479,31 +1606,13 @@ function parseSeatView(raw) {
 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
-  );
+  if (typeof result !== "object" || result === null) {
+    throw new Error(
+      "Reducer bundle returned invalid payload for 'dispatch': DispatchResult must be an object."
+    );
+  }
+  return result;
 }
 async function createBrowserBridgeClient(page) {
   const bridgeExists = async () => page.evaluate(
@@ -1575,7 +1684,7 @@ async function assertLiveMatchesShadow(runner, shadow, live) {
   }
 }
 async function loadBrowserDriver(projectRoot) {
-  const filePath = path2.join(projectRoot, "test", "browser-driver.ts");
+  const filePath = path3.join(projectRoot, "test", "browser-driver.ts");
   if (!await exists(filePath)) {
     return null;
   }
@@ -1603,19 +1712,16 @@ function sanitizeSnapshotSegment(value) {
 function createScenarioSnapshotMatcher(options) {
   return (filename, actual) => {
     const suffix = filename ? `.${sanitizeSnapshotSegment(filename)}` : "";
-    const snapshotPath = path2.join(
+    const snapshotPath = resolveWorkspacePath(
       options.projectRoot,
-      "test",
-      "generated",
-      "snapshots",
-      `${sanitizeSnapshotSegment(options.scenarioId)}${suffix}.snapshot.json`
+      `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 });
+    mkdirSync(path3.dirname(snapshotPath), { recursive: true });
     if (!existsSync(snapshotPath) || options.updateSnapshots) {
       writeFileSync(snapshotPath, serialized, "utf8");
       return;
@@ -1623,7 +1729,7 @@ function createScenarioSnapshotMatcher(options) {
     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)}.`
+        `Snapshot mismatch for scenario '${options.scenarioId}'. Re-run with --update-snapshots to refresh ${path3.relative(options.projectRoot, snapshotPath)}.`
       );
     }
   };
@@ -1853,19 +1959,26 @@ async function createSessionFromScenario(options) {
 }
 var MATERIALIZED_SCENARIO_CACHE_VERSION = 1;
 function materializedScenarioCachePath(options) {
-  return path2.join(
-    options.projectRoot,
+  return [
     PROJECT_DIR_NAME,
     "dev",
     "scenario-cache",
     `${sanitizeSnapshotSegment(options.baseId)}.${sanitizeSnapshotSegment(
       options.scenarioId
     )}.${options.fingerprintHash}.json`
+  ].join("/");
+}
+function materializedScenarioCacheFilePath(options) {
+  return resolveWorkspacePath(
+    options.projectRoot,
+    materializedScenarioCachePath(options)
   );
 }
 async function readMaterializedScenarioCache(options) {
-  const cachePath = materializedScenarioCachePath(options);
-  const text = await readTextFileIfExists(cachePath);
+  const text = await readWorkspaceTextFileIfExists(
+    options.projectRoot,
+    materializedScenarioCachePath(options)
+  );
   if (!text) return null;
   try {
     const payload = JSON.parse(
@@ -1880,13 +1993,17 @@ async function readMaterializedScenarioCache(options) {
   }
 }
 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
-  });
+  const cachePath = materializedScenarioCacheFilePath(options);
+  await ensureDir(path3.dirname(cachePath));
+  await writeWorkspaceJsonFile(
+    options.projectRoot,
+    materializedScenarioCachePath(options),
+    {
+      cacheVersion: MATERIALIZED_SCENARIO_CACHE_VERSION,
+      fingerprintHash: options.fingerprintHash,
+      materialized: options.materialized
+    }
+  );
 }
 async function materializeScenarioReducerState(options) {
   await ensureReducerNativeTestingFiles(options.projectRoot);
@@ -1976,13 +2093,14 @@ async function materializeScenarioReducerState(options) {
   if (cached) {
     return cached;
   }
-  const [gameModule, manifestContractModule] = await Promise.all([
+  const [gameModule, manifestContractModule, modules] = await Promise.all([
     importTypeScriptModule(
-      path2.join(options.projectRoot, "app", "game.ts")
+      path3.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
-    )
+      path3.join(options.projectRoot, "shared", "manifest-contract.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
   ]);
   const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
   const resolvedBase = resolveBaseDefinition(base, basesById);
@@ -1992,6 +2110,7 @@ async function materializeScenarioReducerState(options) {
     basesById
   });
   const shadow = new ShadowReducerRuntime(
+    modules,
     manifest,
     gameModule.default,
     createInitialTable,
@@ -2004,7 +2123,7 @@ async function materializeScenarioReducerState(options) {
   const context = await createScenarioContext({
     runner: "reducer",
     shadow,
-    expect: (await loadTestingExpectApiFactory())()
+    expect: modules.createExpectApi()
   });
   shadow.clearHistory();
   await scenario.definition.when(context);
@@ -2056,18 +2175,20 @@ async function replayScenarioThroughBackend(options) {
     generatedBaseStates,
     manifest,
     gameModule,
-    manifestContractModule
+    manifestContractModule,
+    modules
   ] = await Promise.all([
     loadTypedBases(options.projectRoot),
     loadTypedScenarios(options.projectRoot, {}),
     loadGeneratedBaseStates(options.projectRoot),
     loadManifest(options.projectRoot),
     importTypeScriptModule(
-      path2.join(options.projectRoot, "app", "game.ts")
+      path3.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
-    )
+      path3.join(options.projectRoot, "shared", "manifest-contract.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
   ]);
   const matchingScenarios = scenarios.filter(
     (scenario2) => scenario2.definition.id === options.scenarioId
@@ -2110,6 +2231,7 @@ async function replayScenarioThroughBackend(options) {
     basesById
   });
   const shadow = new ShadowReducerRuntime(
+    await loadProjectReducerNativeModules(options.projectRoot),
     manifest,
     gameModule.default,
     createInitialTable,
@@ -2162,7 +2284,7 @@ async function replayScenarioThroughBackend(options) {
   const context = await createScenarioContext({
     runner: "reducer",
     shadow,
-    expect: (await loadTestingExpectApiFactory())(),
+    expect: (await loadProjectReducerNativeModules(options.projectRoot)).createExpectApi(),
     live: {
       sessionId: session.sessionId,
       version: 0,
@@ -2211,18 +2333,20 @@ async function createScenarioActionPlan(options) {
     generatedBaseStates,
     manifest,
     gameModule,
-    manifestContractModule
+    manifestContractModule,
+    modules
   ] = await Promise.all([
     loadTypedBases(options.projectRoot),
     loadTypedScenarios(options.projectRoot, {}),
     loadGeneratedBaseStates(options.projectRoot),
     loadManifest(options.projectRoot),
     importTypeScriptModule(
-      path2.join(options.projectRoot, "app", "game.ts")
+      path3.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
-    )
+      path3.join(options.projectRoot, "shared", "manifest-contract.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
   ]);
   const matchingScenarios = scenarios.filter(
     (scenario2) => scenario2.definition.id === options.scenarioId
@@ -2265,6 +2389,7 @@ async function createScenarioActionPlan(options) {
     basesById
   });
   const shadow = new ShadowReducerRuntime(
+    await loadProjectReducerNativeModules(options.projectRoot),
     manifest,
     gameModule.default,
     createInitialTable,
@@ -2286,7 +2411,7 @@ async function createScenarioActionPlan(options) {
   const context = await createScenarioContext({
     runner: "reducer",
     shadow,
-    expect: (await loadTestingExpectApiFactory())(),
+    expect: (await loadProjectReducerNativeModules(options.projectRoot)).createExpectApi(),
     actionPlan: {
       submitIndex: 0,
       diagnostics
@@ -2509,18 +2634,18 @@ function sortBasesForArtifacts(bases, basesById) {
   return ordered;
 }
 function writeProjectionSnapshots(options) {
-  const projectionDir = path2.join(
+  const projectionDir = resolveWorkspacePath(
     options.projectRoot,
-    "test",
-    "generated",
-    "bases",
-    options.baseId
+    `test/generated/bases/${sanitizeSnapshotSegment(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`);
+    const outputPath = resolveWorkspacePath(
+      options.projectRoot,
+      `test/generated/bases/${sanitizeSnapshotSegment(options.baseId)}/${sanitizeSnapshotSegment(playerId)}.projection.json`
+    );
     writeFileSync(
       outputPath,
       `${JSON.stringify(
@@ -2540,7 +2665,7 @@ function writeProjectionSnapshots(options) {
 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}'`
+    (scenario) => path3.relative(process.cwd(), scenario.filePath) + ` -> '${scenario.definition.from}'`
   );
   if (invalid.length > 0) {
     throw new Error(
@@ -2554,28 +2679,32 @@ async function writeReducerNativeGeneratedFiles(options) {
   const manifestHash = hashContent(JSON.stringify(manifest));
   const appBundleHash = hashContent(
     await bundleTypeScriptModuleText(
-      path2.join(options.projectRoot, "app", "game.ts")
+      path3.join(options.projectRoot, "app", "game.ts")
     )
   );
   const uiContractHash = hashContent(
     await bundleTypeScriptModuleText(
-      path2.join(options.projectRoot, "shared", "generated", "ui-contract.ts"),
+      path3.join(options.projectRoot, "shared", "generated", "ui-contract.ts"),
       { external: SDK_UI_RUNTIME_EXTERNALS }
     )
   );
-  const generatedDir = path2.join(options.projectRoot, "test", "generated");
+  const generatedDir = resolveWorkspacePath(
+    options.projectRoot,
+    "test/generated"
+  );
   await ensureDir(generatedDir);
   const baseStates = {};
-  const [gameModule, manifestContractModule] = await Promise.all([
+  const [gameModule, manifestContractModule, modules] = await Promise.all([
     importTypeScriptModule(
-      path2.join(options.projectRoot, "app", "game.ts")
+      path3.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
-    )
+      path3.join(options.projectRoot, "shared", "manifest-contract.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
   ]);
   const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
-  const contractFingerprintValue = contractFingerprint(
+  const contractFingerprintValue = modules.contractFingerprint(
     gameModule.default
   ).value;
   const basesById = new Map(
@@ -2589,6 +2718,7 @@ async function writeReducerNativeGeneratedFiles(options) {
       basesById
     });
     const shadow = new ShadowReducerRuntime(
+      modules,
       manifest,
       gameModule.default,
       createInitialTable,
@@ -2626,14 +2756,22 @@ async function writeReducerNativeGeneratedFiles(options) {
     const context = await createScenarioContext({
       runner: "reducer",
       shadow,
-      expect: (await loadTestingExpectApiFactory())()
+      expect: modules.createExpectApi()
     });
     await context.game.start();
-    await base.definition.setup({
-      game: context.game,
-      players: context.players,
-      seat: context.seat
-    });
+    try {
+      await base.definition.setup({
+        game: context.game,
+        players: context.players,
+        seat: context.seat
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Base '${base.definition.id}' setup failed with setupProfileId '${effectiveSetup.setupProfileId ?? "none"}': ${message}`,
+        { cause: error instanceof Error ? error : void 0 }
+      );
+    }
     baseStates[baseStateKey(base.definition.id)] = {
       key: baseStateKey(base.definition.id),
       base: base.definition.id,
@@ -2662,24 +2800,27 @@ async function writeReducerNativeGeneratedFiles(options) {
     });
   }
   const header = "// Generated by dreamboard test generate. Do not edit by hand.\n";
-  await writeTextFile(
-    path2.join(generatedDir, "base-states.generated.ts"),
+  await writeWorkspaceTextFile(
+    options.projectRoot,
+    "test/generated/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"),
+  await writeWorkspaceTextFile(
+    options.projectRoot,
+    "test/generated/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"),
+  await writeWorkspaceTextFile(
+    options.projectRoot,
+    "test/generated/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),
+        filePath: path3.relative(generatedDir, scenario.filePath),
         base: scenario.definition.from,
         runners: normalizeScenarioRunners(scenario.definition.runners)
       })),
@@ -2688,15 +2829,19 @@ export declare const BASE_STATES_CONTRACT_FINGERPRINT: string | undefined;
     )} 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
-  });
+  await writeWorkspaceJsonFile(
+    options.projectRoot,
+    "test/generated/.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(
+  const filePath = path3.join(
     projectRoot,
     "test",
     "generated",
@@ -2709,7 +2854,7 @@ async function loadGeneratedBaseStates(projectRoot) {
   return module.BASE_STATES ?? null;
 }
 async function loadGeneratedScenarioManifest(projectRoot) {
-  const filePath = path2.join(
+  const filePath = path3.join(
     projectRoot,
     "test",
     "generated",
@@ -2771,10 +2916,13 @@ function validateGeneratedFingerprint(options) {
 }
 async function currentFingerprint(options) {
   const manifest = await loadManifest(options.projectRoot);
-  const gameModule = await importTypeScriptModule(
-    path2.join(options.projectRoot, "app", "game.ts")
-  );
-  const contractFingerprintValue = contractFingerprint(
+  const [gameModule, modules] = await Promise.all([
+    importTypeScriptModule(
+      path3.join(options.projectRoot, "app", "game.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
+  ]);
+  const contractFingerprintValue = modules.contractFingerprint(
     gameModule.default
   ).value;
   const resolvedBase = resolveBaseDefinition(
@@ -2812,12 +2960,12 @@ async function currentFingerprint(options) {
     manifestHash: hashContent(JSON.stringify(manifest)),
     appBundleHash: hashContent(
       await bundleTypeScriptModuleText(
-        path2.join(options.projectRoot, "app", "game.ts")
+        path3.join(options.projectRoot, "app", "game.ts")
       )
     ),
     uiContractHash: hashContent(
       await bundleTypeScriptModuleText(
-        path2.join(options.projectRoot, "shared", "generated", "ui-contract.ts"),
+        path3.join(options.projectRoot, "shared", "generated", "ui-contract.ts"),
         { external: SDK_UI_RUNTIME_EXTERNALS }
       )
     ),
@@ -2857,7 +3005,8 @@ async function runReducerNativeScenarios(options) {
     initialGeneratedBaseStates,
     manifest,
     gameModule,
-    manifestContractModule
+    manifestContractModule,
+    modules
   ] = await Promise.all([
     loadTypedBases(options.projectRoot),
     loadTypedScenarios(options.projectRoot, {
@@ -2866,11 +3015,12 @@ async function runReducerNativeScenarios(options) {
     loadGeneratedBaseStates(options.projectRoot),
     loadManifest(options.projectRoot),
     importTypeScriptModule(
-      path2.join(options.projectRoot, "app", "game.ts")
+      path3.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path2.join(options.projectRoot, "shared", "manifest-contract.ts")
-    )
+      path3.join(options.projectRoot, "shared", "manifest-contract.ts")
+    ),
+    loadProjectReducerNativeModules(options.projectRoot)
   ]);
   let generatedBaseStates = initialGeneratedBaseStates;
   const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
@@ -2892,228 +3042,261 @@ async function runReducerNativeScenarios(options) {
       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) {
+    browserDriver = await loadBrowserDriver(options.projectRoot);
+  }
+  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(
-        "Browser runner requires a local webBaseUrl. Start the local web stack and configure the project for env local."
+        `Missing typed base '${scenario.definition.from}' for scenario '${scenario.definition.id}'.`
       );
     }
-    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);
+    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."
+      );
+    }
+    let scenarioBrowser = null;
+    let scenarioDevHost = null;
+    try {
+      const resolvedBase = resolveBaseDefinition(base, basesById);
+      const effectiveSetup = resolveEffectiveBaseSetup({
+        manifest,
+        base: base.definition,
+        basesById
+      });
+      const shadow = new ShadowReducerRuntime(
+        modules,
+        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.`
+          );
         }
-        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"
+        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 { 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.");
+        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
           }
-          await page.goto(
-            `${options.webBaseUrl ?? options.projectConfig.webBaseUrl}/_dev/play/${started.context.shortCode}`,
-            { waitUntil: "domcontentloaded" }
+        });
+        if (!session || sessionError) {
+          throw toDreamboardApiError(
+            sessionError,
+            sessionResponse,
+            "Failed to create remote-runner session."
           );
-          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
+        const tracker = new RemoteGameplayTracker(
+          session.sessionId,
+          "player-1"
+        );
+        const { error: startError, response: startResponse } = await startGame({
+          path: { sessionId: session.sessionId }
         });
-        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 (startError) {
+          throw toDreamboardApiError(
+            startError,
+            startResponse,
+            "Failed to start remote-runner session."
           );
         }
-        if (scenario.definition.stage && shadow.currentStage() !== scenario.definition.stage) {
+        await tracker.bootstrap();
+        remote = {
+          sessionId: session.sessionId,
+          tracker
+        };
+      }
+      if (options.runner === "browser") {
+        const compiledResultId = options.compiledResultId ?? options.projectConfig.compile?.latestSuccessful?.resultId;
+        if (!compiledResultId) {
           throw new Error(
-            `Scenario '${scenario.definition.id}' expected stage '${scenario.definition.stage}' but reached '${shadow.currentStage() ?? "null"}'.`
+            "Browser runner requires a compiled result. Compile the workspace first."
           );
         }
-        await scenario.definition.then(context);
-        passed += 1;
-        results.push({
-          id: scenario.definition.id,
-          success: true
+        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
+          }
         });
-      } 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.`
+        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.");
+        }
+        const devDir = path3.join(options.projectRoot, PROJECT_DIR_NAME, "dev");
+        await ensureDir(devDir);
+        const sessionFilePath = path3.join(devDir, "session.json");
+        await writeJsonFile(
+          sessionFilePath,
+          createPersistedDevSession({ sessionId: session.sessionId })
+        );
+        const devHostPlatform = createCliDevHostPlatform(
+          options.resolvedConfig
+        );
+        const bearer = await devHostPlatform.resolveBearer();
+        if (bearer.kind === "permanent_invalid") {
+          throw new Error(bearer.message);
+        }
+        const loadedDevHost = await loadProjectDevHost(options.projectRoot);
+        scenarioDevHost = await loadedDevHost.module.start(
+          {
+            projectRoot: options.projectRoot,
+            sessionFilePath,
+            apiBaseUrl: options.resolvedConfig.apiBaseUrl,
+            runtimeConfig: {
+              apiBaseUrl: options.resolvedConfig.apiBaseUrl,
+              userId: extractUserIdFromJwt(bearer.token),
+              gameId: options.projectConfig.gameId,
+              compiledResultId,
+              setupProfileId: effectiveSetup.setupProfileId ?? null,
+              playerCount: resolvedBase.players,
+              debug: options.debug ?? false,
+              slug: options.projectConfig.slug,
+              autoStartGame: false,
+              initialSession: {
+                sessionId: session.sessionId,
+                shortCode: started.context.shortCode,
+                gameId: options.projectConfig.gameId,
+                seed: resolvedBase.seed
+              }
+            }
+          },
+          devHostPlatform
+        );
+        const opened = await openBrowserPage(
+          scenarioDevHost.url,
+          options.resolvedConfig
+        );
+        scenarioBrowser = opened.browser;
+        const page = opened.page;
+        await waitForGameReady(page);
+        browserBridge = await createBrowserBridgeClient(page);
+        await browserDriver?.onReady?.(browserBridge);
+      }
+      const context = await createScenarioContext({
+        runner: options.runner,
+        shadow,
+        expect: modules.createExpectApi({
+          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.`
+      });
+    } finally {
+      browserBridge = null;
+      if (scenarioBrowser) {
+        await scenarioBrowser.close();
+      }
+      if (scenarioDevHost) {
+        await scenarioDevHost.close();
       }
-    }
-    return { passed, failed, results };
-  } finally {
-    if (browser) {
-      await browser.close();
     }
   }
+  return { passed, failed, results };
 }
 
 export {
@@ -3134,4 +3317,4 @@ export {
   generateReducerNativeArtifacts,
   runReducerNativeScenarios
 };
-//# sourceMappingURL=chunk-4GU3PCHV.mjs.map
+//# sourceMappingURL=chunk-DWLTCUUX.mjs.map