dreamboard 0.1.21 → 0.1.22

package/dist/{chunk-MOVHYB6E.js → chunk-AQ5UUNJS.js}

@@ -32,7 +32,7 @@ import {
 } from "./chunk-4S67A2YA.js";
 import {
   createClient
-} from "./chunk-BMYC6772.js";
+} from "./chunk-H3O43F5P.js";
 import {
   CLIENT_PROBLEM_TYPES,
   SERVER_PROBLEM_TYPES,
@@ -50,7 +50,6 @@ import {
   ensureDevCompile,
   external_exports,
   findManifests,
-  gameIdFromGameSource,
   getApiVersion,
   getAuthoringHead,
   getCompiledResult,
@@ -69,15 +68,16 @@ import {
   startGame,
   submitPlayerAction,
   subscribeToSessionEvents,
+  uploadInitialProjection,
   validatePlayerAction,
   zGameTopologyManifest,
   zProblemDetails
-} from "./chunk-EYYWGWTO.js";
+} from "./chunk-2RCUHMGL.js";
 import {
   __export
 } from "./chunk-D4HDZEJT.js";
 
-// ../../node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/_chunks/libs/scule.mjs
+// ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/_chunks/libs/scule.mjs
 var NUMBER_CHAR_RE = /\d/;
 var STR_SPLITTERS = [
   "-",
@@ -142,8 +142,11 @@ function camelCase(str, opts) {
 function kebabCase(str, joiner) {
   return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
 }
+function snakeCase(str) {
+  return kebabCase(str || "", "_");
+}
 
-// ../../node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/index.mjs
+// ../../node_modules/.pnpm/citty@0.2.2/node_modules/citty/dist/index.mjs
 import { parseArgs as parseArgs$1 } from "util";
 function toArray(val) {
   if (Array.isArray(val)) return val;
@@ -190,6 +193,12 @@ function parseRawArgs(args = [], opts = {}) {
     for (const alias of aliases) if (booleans.has(alias)) return "boolean";
     return "string";
   }
+  function isStringType(name) {
+    if (strings.has(name)) return true;
+    const aliases = mainToAliases.get(name) || [];
+    for (const alias of aliases) if (strings.has(alias)) return true;
+    return false;
+  }
   const allOptions = /* @__PURE__ */ new Set([
     ...booleans,
     ...strings,
@@ -233,7 +242,12 @@ function parseRawArgs(args = [], opts = {}) {
   }
   const out = { _: [] };
   out._ = parsed.positionals;
-  for (const [key, value] of Object.entries(parsed.values)) out[key] = value;
+  for (const [key, value] of Object.entries(parsed.values)) {
+    let coerced = value;
+    if (getType(key) === "boolean" && typeof value === "string") coerced = value !== "false";
+    else if (isStringType(key) && typeof value === "boolean") coerced = "";
+    out[key] = coerced;
+  }
   for (const [name] of Object.entries(negatedFlags)) {
     out[name] = false;
     const mainName = aliasToMain.get(name);
@@ -244,6 +258,7 @@ function parseRawArgs(args = [], opts = {}) {
   for (const [alias, main] of aliasToMain.entries()) {
     if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
     if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
+    if (out[alias] !== out[main] && defaults[main] === out[main]) out[main] = out[alias];
   }
   return out;
 }
@@ -305,6 +320,9 @@ function resolveArgs(argsDef) {
   });
   return args;
 }
+async function resolvePlugins(plugins) {
+  return Promise.all(plugins.map((p) => resolveValue(p)));
+}
 function defineCommand(def) {
   return def;
 }
@@ -317,35 +335,92 @@ async function runCommand(cmd, opts) {
     data: opts.data,
     cmd
   };
-  if (typeof cmd.setup === "function") await cmd.setup(context);
+  const plugins = await resolvePlugins(cmd.plugins ?? []);
   let result;
+  let runError;
   try {
+    for (const plugin of plugins) await plugin.setup?.(context);
+    if (typeof cmd.setup === "function") await cmd.setup(context);
     const subCommands = await resolveValue(cmd.subCommands);
     if (subCommands && Object.keys(subCommands).length > 0) {
-      const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
-      const subCommandName = opts.rawArgs[subCommandArgIndex];
-      if (subCommandName) {
-        if (!subCommands[subCommandName]) throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
-        const subCommand = await resolveValue(subCommands[subCommandName]);
-        if (subCommand) await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
-      } else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+      const subCommandArgIndex = findSubCommandIndex(opts.rawArgs, cmdArgs);
+      const explicitName = opts.rawArgs[subCommandArgIndex];
+      if (explicitName) {
+        const subCommand = await _findSubCommand(subCommands, explicitName);
+        if (!subCommand) throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
+        await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+      } else {
+        const defaultSubCommand = await resolveValue(cmd.default);
+        if (defaultSubCommand) {
+          if (cmd.run) throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
+          const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
+          if (!subCommand) throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
+          await runCommand(subCommand, { rawArgs: opts.rawArgs });
+        } else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
+      }
     }
     if (typeof cmd.run === "function") result = await cmd.run(context);
-  } finally {
-    if (typeof cmd.cleanup === "function") await cmd.cleanup(context);
+  } catch (error) {
+    runError = error;
+  }
+  const cleanupErrors = [];
+  if (typeof cmd.cleanup === "function") try {
+    await cmd.cleanup(context);
+  } catch (error) {
+    cleanupErrors.push(error);
   }
+  for (const plugin of [...plugins].reverse()) try {
+    await plugin.cleanup?.(context);
+  } catch (error) {
+    cleanupErrors.push(error);
+  }
+  if (runError) throw runError;
+  if (cleanupErrors.length === 1) throw cleanupErrors[0];
+  if (cleanupErrors.length > 1) throw new Error("Multiple cleanup errors", { cause: cleanupErrors });
   return { result };
 }
 async function resolveSubCommand(cmd, rawArgs, parent) {
   const subCommands = await resolveValue(cmd.subCommands);
   if (subCommands && Object.keys(subCommands).length > 0) {
-    const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith("-"));
+    const subCommandArgIndex = findSubCommandIndex(rawArgs, await resolveValue(cmd.args || {}));
     const subCommandName = rawArgs[subCommandArgIndex];
-    const subCommand = await resolveValue(subCommands[subCommandName]);
+    const subCommand = await _findSubCommand(subCommands, subCommandName);
     if (subCommand) return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
   }
   return [cmd, parent];
 }
+async function _findSubCommand(subCommands, name) {
+  if (name in subCommands) return resolveValue(subCommands[name]);
+  for (const sub of Object.values(subCommands)) {
+    const resolved = await resolveValue(sub);
+    const meta = await resolveValue(resolved?.meta);
+    if (meta?.alias) {
+      if (toArray(meta.alias).includes(name)) return resolved;
+    }
+  }
+}
+function findSubCommandIndex(rawArgs, argsDef) {
+  for (let i2 = 0; i2 < rawArgs.length; i2++) {
+    const arg = rawArgs[i2];
+    if (arg === "--") return -1;
+    if (arg.startsWith("-")) {
+      if (!arg.includes("=") && _isValueFlag(arg, argsDef)) i2++;
+      continue;
+    }
+    return i2;
+  }
+  return -1;
+}
+function _isValueFlag(flag, argsDef) {
+  const name = flag.replace(/^-{1,2}/, "");
+  const normalized = camelCase(name);
+  for (const [key, def] of Object.entries(argsDef)) {
+    if (def.type !== "string" && def.type !== "enum") continue;
+    if (normalized === camelCase(key)) return true;
+    if ((Array.isArray(def.alias) ? def.alias : def.alias ? [def.alias] : []).includes(name)) return true;
+  }
+  return false;
+}
 async function showUsage(cmd, parent) {
   try {
     console.log(await renderUsage(cmd, parent) + "\n");
@@ -366,22 +441,17 @@ async function renderUsage(cmd, parent) {
   for (const arg of cmdArgs) if (arg.type === "positional") {
     const name = arg.name.toUpperCase();
     const isRequired = arg.required !== false && arg.default === void 0;
-    const defaultHint = arg.default ? `="${arg.default}"` : "";
-    posLines.push([
-      cyan(name + defaultHint),
-      arg.description || "",
-      arg.valueHint ? `<${arg.valueHint}>` : ""
-    ]);
+    posLines.push([cyan(name + renderValueHint(arg)), renderDescription(arg, isRequired)]);
     usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
   } else {
     const isRequired = arg.required === true && arg.default === void 0;
-    const argStr = [...(arg.alias || []).map((a2) => `-${a2}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
-    argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
+    const argStr = [...(arg.alias || []).map((a2) => `-${a2}`), `--${arg.name}`].join(", ") + renderValueHint(arg);
+    argLines.push([cyan(argStr), renderDescription(arg, isRequired)]);
     if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
       const negativeArgStr = [...(arg.alias || []).map((a2) => `--no-${a2}`), `--no-${arg.name}`].join(", ");
-      argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
+      argLines.push([cyan(negativeArgStr), [arg.negativeDescription, isRequired ? gray("(Required)") : ""].filter(Boolean).join(" ")]);
     }
-    if (isRequired) usageLine.push(argStr);
+    if (isRequired) usageLine.push(`--${arg.name}` + renderValueHint(arg));
   }
   if (cmd.subCommands) {
     const commandNames = [];
@@ -389,8 +459,10 @@ async function renderUsage(cmd, parent) {
     for (const [name, sub] of Object.entries(subCommands)) {
       const meta = await resolveValue((await resolveValue(sub))?.meta);
       if (meta?.hidden) continue;
-      commandsLines.push([cyan(name), meta?.description || ""]);
-      commandNames.push(name);
+      const aliases = toArray(meta?.alias);
+      const label = [name, ...aliases].join(", ");
+      commandsLines.push([cyan(label), meta?.description || ""]);
+      commandNames.push(name, ...aliases);
     }
     usageLine.push(commandNames.join("|"));
   }
@@ -416,14 +488,31 @@ async function renderUsage(cmd, parent) {
   }
   return usageLines.filter((l2) => typeof l2 === "string").join("\n");
 }
+function renderValueHint(arg) {
+  const valueHint = arg.valueHint ? `=<${arg.valueHint}>` : "";
+  const fallbackValueHint = valueHint || `=<${snakeCase(arg.name)}>`;
+  if (!arg.type || arg.type === "positional" || arg.type === "boolean") return valueHint;
+  if (arg.type === "enum" && arg.options?.length) return `=<${arg.options.join("|")}>`;
+  return fallbackValueHint;
+}
+function renderDescription(arg, required) {
+  const requiredHint = required ? gray("(Required)") : "";
+  const defaultHint = arg.default === void 0 ? "" : gray(`(Default: ${arg.default})`);
+  return [
+    arg.description,
+    requiredHint,
+    defaultHint
+  ].filter(Boolean).join(" ");
+}
 async function runMain(cmd, opts = {}) {
   const rawArgs = opts.rawArgs || process.argv.slice(2);
   const showUsage$1 = opts.showUsage || showUsage;
   try {
-    if (rawArgs.includes("--help") || rawArgs.includes("-h")) {
+    const builtinFlags = await _resolveBuiltinFlags(cmd);
+    if (builtinFlags.help.length > 0 && rawArgs.some((arg) => builtinFlags.help.includes(arg))) {
       await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
       process.exit(0);
-    } else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
+    } else if (rawArgs.length === 1 && builtinFlags.version.includes(rawArgs[0])) {
       const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
       if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
       console.log(meta.version);
@@ -436,6 +525,24 @@ async function runMain(cmd, opts = {}) {
     process.exit(1);
   }
 }
+async function _resolveBuiltinFlags(cmd) {
+  const argsDef = await resolveValue(cmd.args || {});
+  const userNames = /* @__PURE__ */ new Set();
+  const userAliases = /* @__PURE__ */ new Set();
+  for (const [name, def] of Object.entries(argsDef)) {
+    userNames.add(name);
+    for (const alias of toArray(def.alias)) userAliases.add(alias);
+  }
+  return {
+    help: _getBuiltinFlags("help", "h", userNames, userAliases),
+    version: _getBuiltinFlags("version", "v", userNames, userAliases)
+  };
+}
+function _getBuiltinFlags(long, short, userNames, userAliases) {
+  if (userNames.has(long) || userAliases.has(long)) return [];
+  if (userNames.has(short) || userAliases.has(short)) return [`--${long}`];
+  return [`--${long}`, `-${short}`];
+}
 
 // ../../node_modules/.pnpm/consola@3.4.2/node_modules/consola/dist/core.mjs
 var LogLevels = {
@@ -1758,10 +1865,11 @@ function resolveConfig(globalConfig, flags, project, credentials) {
   if (IS_PUBLISHED_BUILD) {
     assertPublicRuntimeFlags(flags);
   }
-  const environment = IS_PUBLISHED_BUILD ? PUBLISHED_ENVIRONMENT : flags.env || globalConfig.environment || "dev";
+  const envEnvironment = IS_PUBLISHED_BUILD ? void 0 : environmentFromProcess();
+  const environment = IS_PUBLISHED_BUILD ? PUBLISHED_ENVIRONMENT : flags.env || envEnvironment || globalConfig.environment || "dev";
   const envConfig = ENVIRONMENT_CONFIGS[environment];
   const publishedEnvConfig = ENVIRONMENT_CONFIGS[PUBLISHED_ENVIRONMENT];
-  const hasExplicitEnvironmentOverride = !IS_PUBLISHED_BUILD && Boolean(flags.env);
+  const hasExplicitEnvironmentOverride = !IS_PUBLISHED_BUILD && Boolean(flags.env || envEnvironment);
   const resolvedApiBaseUrl = IS_PUBLISHED_BUILD ? publishedEnvConfig?.apiBaseUrl ?? DEFAULT_API_BASE_URL : hasExplicitEnvironmentOverride ? envConfig?.apiBaseUrl || DEFAULT_API_BASE_URL : project?.apiBaseUrl || envConfig?.apiBaseUrl || DEFAULT_API_BASE_URL;
   const apiBaseUrl = valueOrUndefined(process.env.DREAMBOARD_API_BASE_URL) ?? resolvedApiBaseUrl;
   const resolvedWebBaseUrl = IS_PUBLISHED_BUILD ? publishedEnvConfig?.webBaseUrl ?? DEFAULT_WEB_BASE_URL : hasExplicitEnvironmentOverride ? envConfig?.webBaseUrl || DEFAULT_WEB_BASE_URL : project?.webBaseUrl || envConfig?.webBaseUrl || DEFAULT_WEB_BASE_URL;
@@ -1815,6 +1923,16 @@ function buildCredentialSnapshot(flags, storedCredentials) {
     refreshTokenSource
   };
 }
+function environmentFromProcess() {
+  const value = valueOrUndefined(process.env.DREAMBOARD_ENV);
+  if (!value) return void 0;
+  if (value === "local" || value === "dev" || value === "prod") {
+    return value;
+  }
+  throw new Error(
+    `Invalid DREAMBOARD_ENV '${value}'. Valid options: local, dev, prod`
+  );
+}
 function assertPublicRuntimeFlags(flags) {
   const argv2 = process.argv.slice(2);
   if (flags.env || argv2.includes("--env")) {
@@ -1993,7 +2111,9 @@ var devCommandArgsSchema = configFlagsSchema.extend({
   "from-scenario": external_exports.string().optional(),
   "new-session": external_exports.boolean().default(false),
   open: external_exports.boolean().default(false),
-  port: external_exports.string().optional()
+  port: external_exports.string().optional(),
+  host: external_exports.union([external_exports.string(), external_exports.boolean()]).optional(),
+  "allowed-host": external_exports.string().optional()
 });
 var joinCommandArgsSchema = configFlagsSchema.extend({
   session: external_exports.string().min(1).optional(),
@@ -2571,6 +2691,21 @@ async function saveRuleSdk(gameId, ruleText) {
   return { ruleId: data.ruleId };
 }
 
+// src/services/api/preview-api.ts
+async function uploadInitialProjectionSdk(gameId, projectionJson) {
+  const { error, response } = await uploadInitialProjection({
+    path: { gameId },
+    body: { projectionJson }
+  });
+  if (error) {
+    throw toDreamboardApiError(
+      error,
+      response,
+      "Failed to upload initial preview projection"
+    );
+  }
+}
+
 // ../../packages/api-client/src/source-revisions.ts
 var textEncoder = new TextEncoder();
 function bytesToHex(bytes) {
@@ -8589,7 +8724,7 @@ function validateSlotHostsAndHomes(manifest) {
     }
     slotIdsByHostKey.set(`die:${seed.id}`, new Set(slotIds));
   }
-  const validateHome = (home, path26) => {
+  const validateHome = (home, path28) => {
     if (home?.type !== "slot") {
       return;
     }
@@ -8597,13 +8732,13 @@ function validateSlotHostsAndHomes(manifest) {
     const slotIds = slotIdsByHostKey.get(hostKey);
     if (!slotIds) {
       issues.push(
-        `${path26}.host: Unknown strict slot host '${home.host.kind}:${home.host.id}'. Hosts must be singleton piece/die seeds whose type declares slots.`
+        `${path28}.host: Unknown strict slot host '${home.host.kind}:${home.host.id}'. Hosts must be singleton piece/die seeds whose type declares slots.`
       );
       return;
     }
     if (!slotIds.has(home.slotId)) {
       issues.push(
-        `${path26}.slotId: Unknown slot '${home.slotId}' for host '${home.host.kind}:${home.host.id}'.`
+        `${path28}.slotId: Unknown slot '${home.slotId}' for host '${home.host.kind}:${home.host.id}'.`
       );
     }
   };
@@ -8669,20 +8804,20 @@ function validatePlayerScopedSeedHomes(manifest) {
   const zoneScopeById = new Map(
     (manifest.zones ?? []).map((zone) => [zone.id, zone.scope])
   );
-  const validateSeedHome = (seed, path26, label) => {
+  const validateSeedHome = (seed, path28, label) => {
     const authoredId = seed.id ?? seed.typeId;
     if (seed.ownerId) {
       return;
     }
     if (homeTargetsBoard(seed.home) && boardScopeById.get(seed.home.boardId) === "perPlayer") {
       issues.push(
-        `${path26}.boardId: ${label} '${authoredId}' requires ownerId because board '${seed.home.boardId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
+        `${path28}.boardId: ${label} '${authoredId}' requires ownerId because board '${seed.home.boardId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
       );
       return;
     }
     if (seed.home?.type === "zone" && zoneScopeById.get(seed.home.zoneId) === "perPlayer") {
       issues.push(
-        `${path26}.zoneId: ${label} '${authoredId}' requires ownerId because zone '${seed.home.zoneId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
+        `${path28}.zoneId: ${label} '${authoredId}' requires ownerId because zone '${seed.home.zoneId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
       );
     }
   };
@@ -9158,30 +9293,30 @@ function normalizeProjectPath(filePath) {
   return filePath.replace(/^\.\//, "").replace(/^\/+/, "").replace(/\\/g, "/");
 }
 function isAllowedGamePath(filePath) {
-  const path26 = normalizeProjectPath(filePath);
-  if (WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.rootFiles.includes(path26)) {
+  const path28 = normalizeProjectPath(filePath);
+  if (WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.rootFiles.includes(path28)) {
     return true;
   }
   return WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.directoryPrefixes.some(
-    (prefix) => path26.startsWith(prefix)
+    (prefix) => path28.startsWith(prefix)
   );
 }
 function isAuthoritativeGeneratedPath(filePath) {
-  const path26 = normalizeProjectPath(filePath);
-  return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.generatedFiles.includes(path26);
+  const path28 = normalizeProjectPath(filePath);
+  return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.generatedFiles.includes(path28);
 }
 function isDynamicSeedPath(filePath) {
-  const path26 = normalizeProjectPath(filePath);
-  if (WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFiles.includes(path26)) {
+  const path28 = normalizeProjectPath(filePath);
+  if (WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFiles.includes(path28)) {
     return true;
   }
   return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFilePatterns.some(
-    (pattern) => path26.startsWith(pattern.prefix) && path26.endsWith(pattern.suffix)
+    (pattern) => path28.startsWith(pattern.prefix) && path28.endsWith(pattern.suffix)
   );
 }
 function isLibraryPath(filePath) {
-  const path26 = normalizeProjectPath(filePath);
-  return isAuthoritativeGeneratedPath(path26);
+  const path28 = normalizeProjectPath(filePath);
+  return isAuthoritativeGeneratedPath(path28);
 }
 
 // ../../packages/workspace-codegen/src/seeds.ts
@@ -9209,11 +9344,14 @@ import type {
 import {
 	  createDreamboardUI,
 	  createResourceCounter,
+	  InteractionField as InteractionFieldGeneric,
 	  type BoardHexGridProps as BoardHexGridPropsGeneric,
 	  type BoardHexViewProps as BoardHexViewPropsGeneric,
 	  type BoardSpaceIdOf,
 	  type ClientParamSchemaMap,
 	  type InteractionDescriptor,
+	  type InteractionFieldProps as InteractionFieldPropsGeneric,
+	  type InteractionFieldRenderMap,
 	  type InteractionHandle,
 	  type InteractionRouteMap as InteractionRouteMapGeneric,
 	  type InteractionSwitchProps as InteractionSwitchPropsGeneric,
@@ -9653,15 +9791,43 @@ export const Phase = UI.Phase;
 export const Zone = UI.Zone;
 export const ResourceCounter: WorkspaceUI["ResourceCounter"] = UI.ResourceCounter;
 
+export type InteractionFieldRenderers<Key extends InteractionKey> =
+  InteractionFieldRenderMap<InteractionParamsShape<Key>>;
+
+export type InteractionFieldProps<
+  Key extends InteractionKey,
+  InputKey extends keyof InteractionParamsShape<Key> & string,
+> = Omit<
+  InteractionFieldPropsGeneric<InteractionParamsShape<Key>, InputKey>,
+  "descriptor" | "handle"
+> & {
+  descriptor: InteractionDescriptorFor<Key>;
+  handle: InteractionHandle<
+    InteractionParamsShape<Key>,
+    InteractionHandleDefaultedKeys<Key>
+  >;
+};
+
 export const clientParamSchemasByPhase = createClientParamSchemasByPhase(
   game,
 ) as ClientParamSchemaMap;
+
+export function InteractionField<
+  Key extends InteractionKey,
+  InputKey extends keyof InteractionParamsShape<Key> & string,
+>(props: InteractionFieldProps<Key, InputKey>): ReactElement | null {
+  return createElement(
+    InteractionFieldGeneric<InteractionParamsShape<Key>, InputKey>,
+    props,
+  );
+}
 `;
 }
 function generateReducerSupportSeed() {
   return `import {
-  createReducerEdit,
+  createReducerOps,
   createStateQueries,
+  pipe,
 } from "@dreamboard/app-sdk/reducer";
 import type { GameState } from "./game-contract";
 
@@ -9680,12 +9846,16 @@ import type { GameState } from "./game-contract";
  *
  * Recommended authoring pattern inside a phase reducer:
  *
- *   const tx = edit(state);
- *   tx.setActivePlayers([q.players.order()[0]]);
- *   return accept(tx.state);
+ *   const next = pipe(
+ *     state,
+ *     ops.setActivePlayers([q.players.order()[0]]),
+ *   );
+ *   return accept(next);
  */
 
-export const edit = createReducerEdit<GameState>();
+export const ops = createReducerOps<GameState>();
+
+export { pipe };
 
 export function stateQueries(state: GameState) {
   return createStateQueries(state);
@@ -10237,7 +10407,7 @@ async function evaluateManifestSource(projectRoot) {
       target: ["node20"],
       write: false,
       logLevel: "silent",
-      plugins: repoLocalPackageResolutionPlugins()
+      plugins: [createRepoLocalPackageResolutionPlugin()]
     });
     outputText = buildResult.outputFiles[0]?.text;
   } catch (error) {
@@ -10272,14 +10442,6 @@ async function evaluateManifestSource(projectRoot) {
   }
   return moduleRecord.default;
 }
-function repoLocalPackageResolutionPlugins() {
-  try {
-    const repoRoot = resolveCliRepoRoot(import.meta.url);
-    return [createRepoLocalPackageResolutionPlugin({ repoRoot })];
-  } catch {
-    return [];
-  }
-}
 function renderManifestSource(manifest) {
   return [
     'import { defineTopologyManifest } from "@dreamboard/sdk-types";',
@@ -10441,6 +10603,7 @@ var REDUCER_TESTING_TYPES_WRAPPER_CONTENT = `// Generated by dreamboard \u2014 d
 import game from "../app/game";
 import { createReducerBundle } from "@dreamboard/app-sdk/reducer";
 import { createTestRuntime as createDreamboardTestRuntime } from "@dreamboard/testing";
+import type { CreateTestRuntimeOptions } from "@dreamboard/testing";
 import { literals } from "../shared/manifest-contract";
 import type { PhaseName } from "../shared/generated/ui-contract";
 import { BASE_STATES } from "./generated/base-states.generated";
@@ -10484,17 +10647,17 @@ export function createTestRuntime(options: {
   controllingPlayerId?: (typeof literals.playerIds)[number];
   userId?: string | null;
 }) {
-  const reducerBundle = createReducerBundle(game);
+  const reducerBundle =
+    createReducerBundle(game) satisfies CreateTestRuntimeOptions["bundle"];
+  const baseStates =
+    BASE_STATES satisfies CreateTestRuntimeOptions["baseStates"];
   const runtime = createDreamboardTestRuntime({
     baseId: options.baseId,
-    baseStates:
-      BASE_STATES as unknown as Parameters<
-        typeof createDreamboardTestRuntime
-      >[0]["baseStates"],
-    bundle: reducerBundle as never,
+    baseStates,
+    bundle: reducerBundle,
     phase: options.phase,
     userId: options.userId ?? "test-user",
-    playerIds: (literals.playerIds as readonly string[]).slice(
+    playerIds: literals.playerIds.slice(
       0,
       BASE_STATES[options.baseId]?.fingerprint.players ?? literals.playerIds.length,
     ),
@@ -10589,6 +10752,13 @@ export interface BrowserRunnerDriver {
 
 export interface ScenarioGameApi {
   start(): Promise<void>;
+  /**
+   * Patch the reducer snapshot for deterministic setup-heavy scenarios.
+   * This is limited to reducer snapshot materialization and is rejected by
+   * live replay/browser runners so authored gameplay verification still
+   * submits real interactions.
+   */
+  patchState(mutator: (state: Record<string, unknown>) => void): Promise<void>;
   /**
    * Submit a player interaction (action-kind or prompt-kind) to the game.
    * The \`interactionId\` matches an \`InteractionId\` from the generated
@@ -10674,6 +10844,18 @@ export type {
 `;
 }
 
+// src/services/project/framework-dependencies.ts
+var FRAMEWORK_REACT_VERSION = "19.2.6";
+var FRAMEWORK_ZOD_VERSION = "4.4.3";
+var FRAMEWORK_REACT_DEPENDENCIES = {
+  react: FRAMEWORK_REACT_VERSION,
+  "react-dom": FRAMEWORK_REACT_VERSION
+};
+var FRAMEWORK_PNPM_OVERRIDES = {
+  ...FRAMEWORK_REACT_DEPENDENCIES,
+  zod: FRAMEWORK_ZOD_VERSION
+};
+
 // src/services/project/static-scaffold.ts
 var DREAMBOARD_SYNC_COMMAND = "dreamboard sync";
 var TESTING_TYPES_STUB = "export function defineScenario(scenario) { return scenario; }\n";
@@ -10734,14 +10916,10 @@ var FRAMEWORK_SCRIPTS = {
   "typecheck:ui": "tsc --noEmit -p ui/tsconfig.json"
 };
 var SHARED_DEPENDENCIES = {
-  react: "^19.2.0",
-  "react-dom": "^19.2.0"
+  ...FRAMEWORK_REACT_DEPENDENCIES
 };
 var ROOT_APP_DEPENDENCIES = {
-  zod: "4.4.3"
-};
-var FRAMEWORK_PNPM_OVERRIDES = {
-  zod: "4.4.3"
+  zod: FRAMEWORK_ZOD_VERSION
 };
 var SHARED_DEV_DEPENDENCIES = {
   typescript: "^5.9.2",
@@ -11272,13 +11450,6 @@ function readPackagedSdkDependencyRange(packageName, importMetaUrl = import.meta
   return packagedRange.trim();
 }
 function resolveSdkDependencyRange(packageName, importMetaUrl = import.meta.url) {
-  const packagedRange = readPackagedSdkDependencyRange(
-    packageName,
-    importMetaUrl
-  );
-  if (packagedRange) {
-    return packagedRange;
-  }
   try {
     const repoRoot = resolveCliRepoRoot(importMetaUrl);
     const packageJsonPath = path7.join(
@@ -11291,6 +11462,13 @@ function resolveSdkDependencyRange(packageName, importMetaUrl = import.meta.url)
     }
   } catch {
   }
+  const packagedRange = readPackagedSdkDependencyRange(
+    packageName,
+    importMetaUrl
+  );
+  if (packagedRange) {
+    return packagedRange;
+  }
   return DEFAULT_SDK_DEPENDENCY_RANGES[packageName];
 }
 function normalizeImportPath(relativePath) {
@@ -11391,19 +11569,7 @@ function setLatestCompileAttempt(projectConfig, attempt) {
 function updateProjectLocalMaintainerRegistry(projectConfig, localMaintainerRegistry) {
   return {
     ...projectConfig,
-    localMaintainerRegistry: sanitizeProjectLocalMaintainerRegistry(
-      localMaintainerRegistry
-    )
-  };
-}
-function sanitizeProjectLocalMaintainerRegistry(localMaintainerRegistry) {
-  if (!localMaintainerRegistry?.packages.dreamboard) {
-    return localMaintainerRegistry;
-  }
-  const { dreamboard: _dreamboard, ...packages } = localMaintainerRegistry.packages;
-  return {
-    ...localMaintainerRegistry,
-    packages
+    localMaintainerRegistry
   };
 }
 
@@ -11675,7 +11841,7 @@ function buildRemoteAlignedSnapshotFiles(options) {
 
 // src/services/project/local-maintainer-registry.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import path10 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
@@ -11714,29 +11880,7 @@ function getCliPackageRoot() {
       "dreamboard-cli"
     );
   } catch {
-    return resolveInstalledCliPackageRoot(MODULE_DIR);
-  }
-}
-function resolveInstalledCliPackageRoot(moduleDir) {
-  let current = moduleDir;
-  while (true) {
-    const packageJsonPath = path10.join(current, "package.json");
-    if (existsSync4(packageJsonPath)) {
-      try {
-        const packageJson = JSON.parse(
-          readFileSync3(packageJsonPath, "utf8")
-        );
-        if (packageJson.name === "dreamboard" || packageJson.name === "dreamboard-cli") {
-          return current;
-        }
-      } catch {
-      }
-    }
-    const parent = path10.dirname(current);
-    if (parent === current) {
-      return moduleDir;
-    }
-    current = parent;
+    return path10.resolve(MODULE_DIR, "../../..");
   }
 }
 function getScriptInvocation() {
@@ -11911,9 +12055,6 @@ var CLI_ROOT = path11.resolve(MODULE_DIR2, "../../..");
 var REPO_ROOT = path11.resolve(CLI_ROOT, "../..");
 var REPO_PACKAGE_JSON_PATH = path11.join(REPO_ROOT, "package.json");
 var DEFAULT_PACKAGE_MANAGER = "pnpm@10.4.1";
-var FRAMEWORK_PNPM_OVERRIDES2 = {
-  zod: "4.4.3"
-};
 var DEPENDENCY_INSTALL_METADATA_PATH_SEGMENTS = [
   ".dreamboard",
   "dependency-install.json"
@@ -11927,6 +12068,8 @@ var LockfileGenerationError = class extends Error {
     this.details = details;
     this.name = "LockfileGenerationError";
   }
+  binary;
+  details;
 };
 async function installWorkspaceDependencies(projectRoot, _options = {}) {
   const result = await reconcileWorkspaceDependencies(projectRoot);
@@ -12044,7 +12187,7 @@ function mergePnpmConfig2(existingPnpm) {
     ...existingPnpm ?? {},
     overrides: {
       ...existingOverrides,
-      ...FRAMEWORK_PNPM_OVERRIDES2
+      ...FRAMEWORK_PNPM_OVERRIDES
     }
   };
 }
@@ -12350,31 +12493,142 @@ var clone_default = defineCommand({
   }
 });
 
+// src/services/project/dependency-portability.ts
+import path13 from "path";
+var DEPENDENCY_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies"
+];
+var UNPORTABLE_SPECIFIER_PATTERN = /^(file|link|portal|workspace):/;
+async function buildSourceDependencyProfile(options) {
+  const packageJson = await readProjectPackageJson(options.projectRoot);
+  const packages = collectDreamboardPackageSpecifiers(packageJson);
+  return {
+    kind: "npm-registry",
+    packageManager: packageJson.packageManager,
+    dreamboardRegistryUrl: await readDreamboardRegistryFromNpmrc(options.projectRoot) ?? options.projectConfig?.localMaintainerRegistry?.registryUrl,
+    localSnapshotId: options.projectConfig?.localMaintainerRegistry?.snapshotId,
+    packages
+  };
+}
+async function assertCompilerPortableDependencies(options) {
+  const packageJson = await readProjectPackageJson(options.projectRoot);
+  const problems = collectUnportableDreamboardSpecifiers(packageJson);
+  if (problems.length > 0) {
+    const details = problems.map(
+      (problem) => `${problem.location} ${problem.packageName} -> ${problem.specifier}`
+    ).join("; ");
+    throw new Error(
+      [
+        "Compiler-bound workspaces must install Dreamboard packages from a registry.",
+        `Found unportable Dreamboard dependency specifier(s): ${details}.`,
+        "Run `dreamboard sync` from a workspace that uses registry-pinned @dreamboard/* and dreamboard versions before compiling."
+      ].join(" ")
+    );
+  }
+  const profile = await buildSourceDependencyProfile(options);
+  const hasLocalSnapshotPackage = Object.values(profile.packages).some(
+    (value) => value.includes("-local.")
+  );
+  if (hasLocalSnapshotPackage && !profile.dreamboardRegistryUrl) {
+    throw new Error(
+      "This workspace references local Dreamboard snapshot versions but has no @dreamboard registry configured. Run `dreamboard sync --env local` to refresh .npmrc before compiling."
+    );
+  }
+  return profile;
+}
+async function readProjectPackageJson(projectRoot) {
+  return readJsonFile(
+    path13.join(projectRoot, "package.json")
+  );
+}
+function collectDreamboardPackageSpecifiers(packageJson) {
+  const packages = {};
+  for (const field of DEPENDENCY_FIELDS) {
+    const dependencies = packageJson[field];
+    if (!dependencies) continue;
+    for (const [packageName, specifier] of Object.entries(dependencies)) {
+      if (isDreamboardPackage(packageName)) {
+        packages[packageName] = specifier;
+      }
+    }
+  }
+  const overrides = packageJson.pnpm?.overrides;
+  if (overrides) {
+    for (const [packageName, specifier] of Object.entries(overrides)) {
+      if (isDreamboardPackage(packageName) && typeof specifier === "string" && packages[packageName] === void 0) {
+        packages[packageName] = specifier;
+      }
+    }
+  }
+  return packages;
+}
+function collectUnportableDreamboardSpecifiers(packageJson) {
+  const problems = [];
+  for (const field of DEPENDENCY_FIELDS) {
+    const dependencies = packageJson[field];
+    if (!dependencies) continue;
+    for (const [packageName, specifier] of Object.entries(dependencies)) {
+      if (isDreamboardPackage(packageName) && UNPORTABLE_SPECIFIER_PATTERN.test(specifier)) {
+        problems.push({ location: field, packageName, specifier });
+      }
+    }
+  }
+  const overrides = packageJson.pnpm?.overrides;
+  if (overrides) {
+    for (const [packageName, specifier] of Object.entries(overrides)) {
+      if (isDreamboardPackage(packageName) && typeof specifier === "string" && UNPORTABLE_SPECIFIER_PATTERN.test(specifier)) {
+        problems.push({
+          location: "pnpm.overrides",
+          packageName,
+          specifier
+        });
+      }
+    }
+  }
+  return problems;
+}
+function isDreamboardPackage(packageName) {
+  return packageName === "dreamboard" || packageName.startsWith("@dreamboard/");
+}
+async function readDreamboardRegistryFromNpmrc(projectRoot) {
+  const npmrc = await readTextFileIfExists(path13.join(projectRoot, ".npmrc"));
+  if (!npmrc) return void 0;
+  for (const line of npmrc.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("@dreamboard:registry=")) continue;
+    return trimmed.slice("@dreamboard:registry=".length).trim() || void 0;
+  }
+  return void 0;
+}
+
 // src/services/project/local-typecheck.ts
 import { spawn as spawn3 } from "child_process";
 import { lstat as lstat2 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-var MODULE_DIR3 = path13.dirname(fileURLToPath5(import.meta.url));
-var REPO_ROOT2 = path13.resolve(MODULE_DIR3, "../../../../..");
-var TYPESCRIPT_NODE_MODULES = path13.join(REPO_ROOT2, "node_modules");
+var MODULE_DIR3 = path14.dirname(fileURLToPath5(import.meta.url));
+var REPO_ROOT2 = path14.resolve(MODULE_DIR3, "../../../../..");
+var TYPESCRIPT_NODE_MODULES = path14.join(REPO_ROOT2, "node_modules");
 var TYPESCRIPT_BIN_PATH_SEGMENTS = [
   "node_modules",
   "typescript",
   "bin",
   "tsc"
 ];
-var TYPESCRIPT_CLI = path13.join(
+var TYPESCRIPT_CLI = path14.join(
   TYPESCRIPT_NODE_MODULES,
   "typescript",
   "bin",
   "tsc"
 );
 function getProjectNodeModules(projectRoot) {
-  return path13.join(projectRoot, "node_modules");
+  return path14.join(projectRoot, "node_modules");
 }
 function getProjectTypescriptCli(projectRoot) {
-  return path13.join(projectRoot, ...TYPESCRIPT_BIN_PATH_SEGMENTS);
+  return path14.join(projectRoot, ...TYPESCRIPT_BIN_PATH_SEGMENTS);
 }
 async function pathExists2(targetPath) {
   try {
@@ -12565,6 +12819,7 @@ var compile_default = defineCommand({
   async run({ args }) {
     const parsedArgs = parseCompileCommandArgs(args);
     const { projectRoot, projectConfig } = await resolveProjectContext(parsedArgs);
+    await assertCompilerPortableDependencies({ projectRoot, projectConfig });
     const diff = await getLocalDiff(projectRoot);
     await assertCliStaticScaffoldComplete(projectRoot, diff.deleted);
     if (diff.modified.length > 0 || diff.added.length > 0 || diff.deleted.length > 0) {
@@ -12809,9 +13064,137 @@ var config_default = defineCommand({
 });
 
 // src/commands/dev.ts
-import path23 from "path";
+import path24 from "path";
 import { createHash as createHash3 } from "crypto";
 
+// ../../packages/ui-host-runtime/src/actor-principal.ts
+function gameIdFromGameSource(source) {
+  if (source.kind === "USER_COMPILED") {
+    return source.gameId;
+  }
+  return `demo:${source.slug}:${source.revisionId}`;
+}
+
+// ../../packages/ui-host-runtime/src/plugin-messages.ts
+var InitMessageSchema = external_exports.object({
+  type: external_exports.literal("init"),
+  sessionId: external_exports.string(),
+  controllablePlayerIds: external_exports.array(external_exports.string()),
+  controllingPlayerId: external_exports.string(),
+  userId: external_exports.string().nullable()
+});
+var PingMessageSchema = external_exports.object({
+  type: external_exports.literal("ping")
+});
+var StateSyncMessageSchema = external_exports.object({
+  type: external_exports.literal("state-sync"),
+  syncId: external_exports.number(),
+  state: external_exports.custom((data) => {
+    return typeof data === "object" && data !== null && "session" in data && "notifications" in data;
+  })
+});
+var SubmitResultMessageSchema = external_exports.object({
+  type: external_exports.literal("submit-result"),
+  messageId: external_exports.string(),
+  accepted: external_exports.boolean(),
+  errorCode: external_exports.string().optional(),
+  message: external_exports.string().optional()
+});
+var MainToPluginMessageSchema = external_exports.discriminatedUnion("type", [
+  InitMessageSchema,
+  PingMessageSchema,
+  StateSyncMessageSchema,
+  SubmitResultMessageSchema
+]);
+var ReadyMessageSchema = external_exports.object({
+  type: external_exports.literal("ready")
+});
+var InteractionMessageSchema = external_exports.object({
+  type: external_exports.literal("interaction"),
+  messageId: external_exports.string(),
+  playerId: external_exports.string(),
+  interactionId: external_exports.string(),
+  params: external_exports.unknown(),
+  // Optional client-minted correlation id (UUID) that lets the whole
+  // click-to-render path be stitched across plugin iframe, web host,
+  // backend spans/logs and SSE. Added for Tier-0 input-latency
+  // observability; the backend rides it through as an HTTP header
+  // (`X-Dreamboard-Client-Action-Id`) but no wire contract changed.
+  clientActionId: external_exports.string().optional(),
+  // Plugin-iframe `Date.now()` captured right before the postMessage
+  // is sent, used as the `t0_click` timestamp on the host-side perf
+  // buffer. Date.now() is intentional: the iframe and the host share
+  // a wall-clock base, but not a `performance.now()` origin.
+  clientSubmittedAtMs: external_exports.number().optional()
+});
+var ValidateInteractionMessageSchema = external_exports.object({
+  type: external_exports.literal("validate-interaction"),
+  playerId: external_exports.string(),
+  interactionId: external_exports.string(),
+  params: external_exports.unknown(),
+  messageId: external_exports.string()
+});
+var ValidateInteractionResultMessageSchema = external_exports.object({
+  type: external_exports.literal("validate-interaction-result"),
+  messageId: external_exports.string(),
+  result: external_exports.object({
+    valid: external_exports.boolean(),
+    errorCode: external_exports.string().optional(),
+    message: external_exports.string().optional()
+  })
+});
+var PluginErrorMessageSchema = external_exports.object({
+  type: external_exports.literal("error"),
+  message: external_exports.string(),
+  code: external_exports.string().optional()
+});
+var PongMessageSchema = external_exports.object({
+  type: external_exports.literal("pong")
+});
+var SwitchPlayerMessageSchema = external_exports.object({
+  type: external_exports.literal("switch-player"),
+  playerId: external_exports.string()
+});
+var StateAckMessageSchema = external_exports.object({
+  type: external_exports.literal("state-ack"),
+  syncId: external_exports.number(),
+  // Plugin-iframe `Date.now()` captured when the state-sync message
+  // was received. Threaded so the host-side perf HUD can compute the
+  // `t7_state_sync_received` mark without needing perf to be enabled
+  // inside the plugin iframe itself.
+  clientReceivedAtMs: external_exports.number().optional()
+});
+var StateRenderedMessageSchema = external_exports.object({
+  type: external_exports.literal("state-rendered"),
+  syncId: external_exports.number(),
+  clientReceivedAtMs: external_exports.number(),
+  clientRenderedAtMs: external_exports.number()
+});
+var MarkNotificationReadMessageSchema = external_exports.object({
+  type: external_exports.literal("mark-notification-read"),
+  notificationId: external_exports.string()
+});
+var RestoreHistoryMessageSchema = external_exports.object({
+  type: external_exports.literal("restore-history"),
+  entryId: external_exports.string()
+});
+var PluginToMainMessageSchema = external_exports.discriminatedUnion("type", [
+  ReadyMessageSchema,
+  InteractionMessageSchema,
+  ValidateInteractionMessageSchema,
+  PluginErrorMessageSchema,
+  PongMessageSchema,
+  SwitchPlayerMessageSchema,
+  StateAckMessageSchema,
+  StateRenderedMessageSchema,
+  MarkNotificationReadMessageSchema,
+  RestoreHistoryMessageSchema
+]);
+
+// ../../packages/ui-host-runtime/src/unified-session-store.ts
+import { createStore } from "zustand/vanilla";
+import { subscribeWithSelector } from "zustand/middleware";
+
 // src/utils/dev-session.ts
 import { randomInt } from "crypto";
 var DEFAULT_DEV_SEED = 1337;
@@ -13011,6 +13394,7 @@ function openBrowser(url) {
 // src/dev-host/start-dev-server.ts
 import { rmSync } from "fs";
 import { createRequire as createRequire2 } from "module";
+import os from "os";
 import react from "@vitejs/plugin-react";
 import tailwindcssPostcss from "@tailwindcss/postcss";
 import { createServer as createServer2 } from "vite";
@@ -13085,12 +13469,7 @@ function createStreamingProxy(target) {
     },
     web(req, res, _options, callback) {
       const upstreamUrl = new URL(req.url ?? "/", targetUrl);
-      const headers = {
-        ...req.headers,
-        host: targetUrl.host,
-        "x-forwarded-host": req.headers.host,
-        "x-forwarded-proto": targetUrl.protocol.replace(":", "")
-      };
+      const headers = createForwardHeaders(req, targetUrl);
       const client2 = targetUrl.protocol === "https:" ? https : http;
       const upstreamReq = client2.request(
         upstreamUrl,
@@ -13128,6 +13507,16 @@ function createStreamingProxy(target) {
   };
   return proxy;
 }
+function createForwardHeaders(req, targetUrl) {
+  const headers = { ...req.headers };
+  delete headers.origin;
+  delete headers["access-control-request-headers"];
+  delete headers["access-control-request-method"];
+  headers.host = targetUrl.host;
+  headers["x-forwarded-host"] = req.headers.host;
+  headers["x-forwarded-proto"] = targetUrl.protocol.replace(":", "");
+  return headers;
+}
 async function resolveDevBearer(config) {
   if (!usesStoredSession2(config)) {
     return { kind: "ok", token: config.authToken ?? null };
@@ -13210,7 +13599,7 @@ function formatUnknown(value) {
 
 // src/dev-host/dev-runtime-platform.ts
 import { createRequire } from "module";
-import path14 from "path";
+import path15 from "path";
 import { fileURLToPath as fileURLToPath6 } from "url";
 import { existsSync as existsSync6 } from "fs";
 
@@ -13229,6 +13618,36 @@ function createDevRuntimePlatform(options) {
   const repoRoot = resolveRepoRoot(cliRoot);
   const require3 = createRequire(options.importMetaUrl);
   const diagnosticsLevel = resolveDevDiagnosticsLevel(options.debug);
+  const uiSdkRoot = resolvePackageRoot(
+    require3,
+    cliRoot,
+    "@dreamboard/ui-sdk",
+    "@dreamboard-games/ui-sdk",
+    "packages/ui-sdk"
+  );
+  const apiClientClientGen = resolvePackageSubpath(
+    require3,
+    "@dreamboard/api-client/client.gen",
+    "@dreamboard-games/api-client/client.gen"
+  );
+  const uiHostRuntimeRoot = resolveWorkspaceOrPackagedSource(
+    repoRoot,
+    cliRoot,
+    "packages/ui-host-runtime",
+    "dist/runtime-packages/ui-host-runtime"
+  );
+  const uiRoot = resolveWorkspaceOrPackagedSource(
+    repoRoot,
+    cliRoot,
+    "packages/ui",
+    "dist/runtime-packages/ui"
+  );
+  const tailwindConfigRoot = resolveWorkspaceOrPackagedSource(
+    repoRoot,
+    cliRoot,
+    "packages/tailwind-config",
+    "dist/runtime-packages/tailwind-config"
+  );
   return {
     devHostRoot,
     repoRoot,
@@ -13236,11 +13655,12 @@ function createDevRuntimePlatform(options) {
     diagnosticsLevel,
     viteLogLevel: diagnosticsLevel === "verbose" ? "info" : "warn",
     serverConfig: {
-      host: "localhost",
-      port: options.port ?? 5173,
+      host: options.host ?? "localhost",
+      allowedHosts: options.allowedHosts,
+      port: options.port ?? 5352,
       strictPort: false,
       watch: {
-        ignored: [/[\\/]\.dreamboard[\\/]/]
+        ignored: createProjectOnlyWatchIgnored(options.projectRoot)
       },
       headers: {
         "Access-Control-Allow-Origin": "*",
@@ -13304,11 +13724,11 @@ function createDevRuntimePlatform(options) {
       },
       {
         find: /^@dreamboard\/ui-sdk$/,
-        replacement: path14.resolve(repoRoot, "packages/ui-sdk/src/index.ts")
+        replacement: path15.resolve(uiSdkRoot, "src/index.ts")
       },
       {
         find: /^@dreamboard\/ui-sdk\/reducer$/,
-        replacement: path14.resolve(repoRoot, "packages/ui-sdk/src/reducer.ts")
+        replacement: path15.resolve(uiSdkRoot, "src/reducer.ts")
       },
       {
         // Must resolve to the same source tree as the `@dreamboard/ui-sdk`
@@ -13317,91 +13737,110 @@ function createDevRuntimePlatform(options) {
         // `useRuntimeContext` on the workspace-source copy will never find
         // the provider that's set up via the dist copy (and vice versa).
         find: /^@dreamboard\/ui-sdk\/components$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/components/index.ts"
-        )
+        replacement: path15.resolve(uiSdkRoot, "src/components/index.ts")
+      },
+      {
+        // Keep generated workspace adapters and legacy internal imports on the
+        // same source instance as PluginRuntime so React context identity stays
+        // shared in dev.
+        find: /^@dreamboard\/ui-sdk\/internal$/,
+        replacement: path15.resolve(uiSdkRoot, "src/internal.ts")
+      },
+      {
+        find: /^@dreamboard\/ui-sdk\/workspace-contract$/,
+        replacement: path15.resolve(uiSdkRoot, "src/workspace-contract.ts")
       },
       {
         find: /^@dreamboard\/ui-sdk\/internal\/runtime-context$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/context/RuntimeContext.tsx"
+        replacement: path15.resolve(
+          uiSdkRoot,
+          "src/context/RuntimeContext.tsx"
         )
       },
       {
         find: /^@dreamboard\/ui-sdk\/internal\/usePluginRuntime$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/hooks/usePluginRuntime.ts"
+        replacement: path15.resolve(
+          uiSdkRoot,
+          "src/hooks/usePluginRuntime.ts"
         )
       },
       {
         find: /^@dreamboard\/ui-sdk\/internal\/createPluginRuntimeAPI$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/runtime/createPluginRuntimeAPI.ts"
+        replacement: path15.resolve(
+          uiSdkRoot,
+          "src/runtime/createPluginRuntimeAPI.ts"
         )
       },
       {
         find: /^@dreamboard\/ui-sdk\/internal\/useHandLayout$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/hooks/useHandLayout.ts"
-        )
+        replacement: path15.resolve(uiSdkRoot, "src/hooks/useHandLayout.ts")
       },
       {
         find: /^@dreamboard\/ui-sdk\/internal\/usePanZoom$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/hooks/usePanZoom.ts"
-        )
+        replacement: path15.resolve(uiSdkRoot, "src/hooks/usePanZoom.ts")
       },
       {
         find: /^@dreamboard\/ui-sdk\/internal\/useIsMobile$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/hooks/useIsMobile.ts"
-        )
+        replacement: path15.resolve(uiSdkRoot, "src/hooks/useIsMobile.ts")
       },
       {
         find: /^@dreamboard\/ui-sdk\/internal\/player-state$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/types/player-state.ts"
+        replacement: path15.resolve(
+          uiSdkRoot,
+          "src/types/player-state.ts"
         )
       },
       {
         find: /^@dreamboard\/ui-sdk\/internal\/tiled-board$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/types/tiled-board.ts"
+        replacement: path15.resolve(
+          uiSdkRoot,
+          "src/types/tiled-board.ts"
         )
       },
       {
         find: /^@dreamboard\/ui-sdk\/internal\/plugin-state$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/types/plugin-state.ts"
+        replacement: path15.resolve(
+          uiSdkRoot,
+          "src/types/plugin-state.ts"
         )
       },
       {
         find: /^@dreamboard\/ui-sdk\/types\/runtime-api$/,
-        replacement: path14.resolve(
-          repoRoot,
-          "packages/ui-sdk/src/types/runtime-api.ts"
+        replacement: path15.resolve(
+          uiSdkRoot,
+          "src/types/runtime-api.ts"
         )
       },
+      {
+        find: /^@dreamboard\/ui-host-runtime\/components$/,
+        replacement: path15.resolve(uiHostRuntimeRoot, "src/components/index.ts")
+      },
+      {
+        find: /^@dreamboard\/ui-host-runtime\/runtime$/,
+        replacement: path15.resolve(uiHostRuntimeRoot, "src/runtime/index.ts")
+      },
+      {
+        find: /^@dreamboard\/ui\/components\/(.*)$/,
+        replacement: path15.resolve(uiRoot, "src/components/$1.tsx")
+      },
+      {
+        find: /^@dreamboard\/ui\/lib\/(.*)$/,
+        replacement: path15.resolve(uiRoot, "src/lib/$1.ts")
+      },
+      {
+        find: /^@dreamboard\/tailwind-config$/,
+        replacement: path15.resolve(tailwindConfigRoot, "shared-styles.css")
+      },
       {
         find: /^@dreamboard\/manifest-contract$/,
-        replacement: path14.resolve(
+        replacement: path15.resolve(
           options.projectRoot,
           "shared/manifest-contract.ts"
         )
       },
       {
         find: /^@dreamboard\/ui-contract$/,
-        replacement: path14.resolve(
+        replacement: path15.resolve(
           options.projectRoot,
           "shared/generated/ui-contract.ts"
         )
@@ -13415,9 +13854,13 @@ function createDevRuntimePlatform(options) {
           "packages/ui-sdk/src/plugin-styles.css"
         )
       },
+      {
+        find: /^@dreamboard\/api-client\/client\.gen$/,
+        replacement: apiClientClientGen
+      },
       {
         find: /^@shared\/(.*)$/,
-        replacement: path14.resolve(options.projectRoot, "shared/$1")
+        replacement: path15.resolve(options.projectRoot, "shared/$1")
       },
       {
         find: /^tailwindcss$/,
@@ -13429,33 +13872,72 @@ function createDevRuntimePlatform(options) {
     // older local snapshot after `dreamboard sync`.
     optimizeDepsExclude: [
       "@dreamboard/ui-sdk",
+      "@dreamboard/ui-sdk/workspace-contract",
       "@dreamboard/app-sdk",
       "@dreamboard/app-sdk/reducer",
       "@dreamboard/sdk-types"
     ]
   };
 }
+function createProjectOnlyWatchIgnored(projectRoot) {
+  const normalizedProjectRoot = path15.resolve(projectRoot);
+  return (file) => {
+    const normalizedFile = path15.resolve(file);
+    const relativePath = path15.relative(normalizedProjectRoot, normalizedFile);
+    const isInsideProject = relativePath === "" || relativePath.length > 0 && !relativePath.startsWith("..") && !path15.isAbsolute(relativePath);
+    if (!isInsideProject) {
+      return true;
+    }
+    const pathSegments = relativePath.split(path15.sep);
+    return pathSegments.includes(".dreamboard") || pathSegments.includes("node_modules");
+  };
+}
+function resolveWorkspaceOrPackagedSource(repoRoot, cliRoot, workspaceRelativePath, packagedRelativePath) {
+  const workspacePath = path15.resolve(repoRoot, workspaceRelativePath);
+  if (existsSync6(workspacePath)) return workspacePath;
+  return path15.resolve(cliRoot, packagedRelativePath);
+}
+function resolvePackageRoot(require3, cliRoot, specifier, publicSpecifier, fallbackRelativePath) {
+  try {
+    return path15.dirname(require3.resolve(`${specifier}/package.json`));
+  } catch {
+    try {
+      return path15.dirname(require3.resolve(`${publicSpecifier}/package.json`));
+    } catch {
+      return path15.resolve(cliRoot, "..", "..", fallbackRelativePath);
+    }
+  }
+}
+function resolvePackageSubpath(require3, specifier, publicSpecifier) {
+  try {
+    return require3.resolve(specifier);
+  } catch {
+    return require3.resolve(publicSpecifier);
+  }
+}
 function resolveCliDependency(require3, cliRoot, specifier, fallbackRelativePath) {
   try {
     return require3.resolve(specifier);
   } catch {
-    return path14.resolve(cliRoot, fallbackRelativePath);
+    return path15.resolve(cliRoot, fallbackRelativePath);
   }
 }
 function resolveDevHostRoot(importMetaUrl) {
-  const currentDir = path14.dirname(fileURLToPath6(importMetaUrl));
-  const sourceDirCandidate = path14.resolve(currentDir, "../src/dev-host");
+  const currentDir = path15.dirname(fileURLToPath6(importMetaUrl));
+  const packagedDirCandidate = path15.resolve(currentDir, "dev-host");
+  if (existsSync6(packagedDirCandidate)) return packagedDirCandidate;
+  const sourceDirCandidate = path15.resolve(currentDir, "../src/dev-host");
   return existsSync6(sourceDirCandidate) ? sourceDirCandidate : currentDir;
 }
 function resolveCliRoot(importMetaUrl) {
-  let currentDir = path14.dirname(fileURLToPath6(importMetaUrl));
+  let currentDir = path15.dirname(fileURLToPath6(importMetaUrl));
   while (true) {
-    if (existsSync6(path14.join(currentDir, "package.json"))) {
+    if (existsSync6(path15.join(currentDir, "package.json"))) {
       return currentDir;
     }
-    const parentDir = path14.dirname(currentDir);
+    const parentDir = path15.dirname(currentDir);
     if (parentDir === currentDir) {
-      return path14.resolve(resolveDevHostRoot(importMetaUrl), "../..");
+      return path15.resolve(resolveDevHostRoot(importMetaUrl), "../..");
     }
     currentDir = parentDir;
   }
@@ -13463,10 +13945,10 @@ function resolveCliRoot(importMetaUrl) {
 function resolveRepoRoot(cliRoot) {
   let currentDir = cliRoot;
   while (true) {
-    if (existsSync6(path14.join(currentDir, "pnpm-workspace.yaml"))) {
+    if (existsSync6(path15.join(currentDir, "pnpm-workspace.yaml"))) {
       return currentDir;
     }
-    const parentDir = path14.dirname(currentDir);
+    const parentDir = path15.dirname(currentDir);
     if (parentDir === currentDir) {
       return cliRoot;
     }
@@ -13475,15 +13957,15 @@ function resolveRepoRoot(cliRoot) {
 }
 
 // src/dev-host/dev-virtual-modules-plugin.ts
-import path15 from "path";
+import path16 from "path";
 import { normalizePath } from "vite";
 function createVirtualDevModulesPlugin(options) {
   const configModuleId = "virtual:dreamboard-dev-config";
   const resolvedConfigModuleId = `\0${configModuleId}`;
   const projectEntryModuleId = "virtual:dreamboard-project-entry";
   const resolvedProjectEntryModuleId = `\0${projectEntryModuleId}`;
-  const projectAppPath = path15.resolve(options.projectRoot, "ui/App.tsx");
-  const projectStylePath = path15.resolve(options.projectRoot, "ui/style.css");
+  const projectAppPath = path16.resolve(options.projectRoot, "ui/App.tsx");
+  const projectStylePath = path16.resolve(options.projectRoot, "ui/style.css");
   return {
     name: "dreamboard-dev-virtual-modules",
     resolveId(id) {
@@ -13741,7 +14223,7 @@ function extractQueryParam(req, name) {
   );
   return value?.trim() || null;
 }
-function appendQuery(path26, query) {
+function appendQuery(path28, query) {
   const params = new URLSearchParams();
   for (const [key, value] of Object.entries(query)) {
     if (value) {
@@ -13749,7 +14231,7 @@ function appendQuery(path26, query) {
     }
   }
   const serialized = params.toString();
-  return serialized ? `${path26}?${serialized}` : path26;
+  return serialized ? `${path28}?${serialized}` : path28;
 }
 async function loadCurrentSession(options) {
   if (!await exists(options.sessionFilePath)) {
@@ -13768,12 +14250,12 @@ async function persistSessionId(sessionFilePath, sessionId) {
     createPersistedDevSession({ sessionId })
   );
 }
-async function fetchBackendJson(config, path26, options = {}) {
+async function fetchBackendJson(config, path28, options = {}) {
   const bearer = await resolveDevBearer(config);
   if (bearer.kind === "permanent_invalid") {
     throw new HttpError(401, bearer.message);
   }
-  const response = await fetch(`${config.apiBaseUrl}${path26}`, {
+  const response = await fetch(`${config.apiBaseUrl}${path28}`, {
     method: options.method ?? "GET",
     headers: {
       ...bearer.token ? { authorization: `Bearer ${bearer.token}` } : {},
@@ -13827,6 +14309,7 @@ var HttpError = class extends Error {
     super(message);
     this.statusCode = statusCode;
   }
+  statusCode;
 };
 function parsePersistedSessionPointer(value, runtimeConfig) {
   if (!value || typeof value !== "object") {
@@ -13876,29 +14359,29 @@ function formatUnknown2(value) {
 // src/dev-host/dev-fallback-stylesheet.ts
 import { createHash, randomUUID } from "crypto";
 import { existsSync as existsSync7, mkdirSync, writeFileSync } from "fs";
-import path16 from "path";
+import path17 from "path";
 import { normalizePath as normalizePath2 } from "vite";
 function prepareFallbackStylesheet(options) {
-  const projectStylePath = path16.resolve(options.projectRoot, "ui/style.css");
+  const projectStylePath = path17.resolve(options.projectRoot, "ui/style.css");
   if (existsSync7(projectStylePath)) {
     return null;
   }
-  const generatedDir = path16.resolve(options.repoRoot, ".dreamboard-dev");
+  const generatedDir = path17.resolve(options.repoRoot, ".dreamboard-dev");
   mkdirSync(generatedDir, { recursive: true });
   const fingerprint = createHash("sha256").update(options.projectRoot, "utf8").digest("hex").slice(0, 8);
   const instanceId = randomUUID().replaceAll("-", "").slice(0, 8);
-  const generatedPath = path16.join(
+  const generatedPath = path17.join(
     generatedDir,
     `plugin-styles-${fingerprint}-${instanceId}.css`
   );
   const sharedStylesPath = normalizePath2(
-    path16.resolve(options.repoRoot, "packages/ui-sdk/src/plugin-styles.css")
+    path17.resolve(options.repoRoot, "packages/ui-sdk/src/plugin-styles.css")
   );
   const uiSourcePath = normalizePath2(
-    path16.resolve(options.projectRoot, "ui/**/*.{ts,tsx}")
+    path17.resolve(options.projectRoot, "ui/**/*.{ts,tsx}")
   );
   const sharedSourcePath = normalizePath2(
-    path16.resolve(options.projectRoot, "shared/**/*.{ts,tsx}")
+    path17.resolve(options.projectRoot, "shared/**/*.{ts,tsx}")
   );
   writeFileSync(
     generatedPath,
@@ -13918,12 +14401,14 @@ function prepareFallbackStylesheet(options) {
 var require2 = createRequire2(import.meta.url);
 var tailwindCssEntry = require2.resolve("tailwindcss/index.css");
 async function startDreamboardDevServer(options) {
-  const { projectRoot, port, runtimeConfig, config } = options;
+  const { projectRoot, port, host, allowedHosts, runtimeConfig, config } = options;
   const platform2 = createDevRuntimePlatform({
     importMetaUrl: import.meta.url,
     projectRoot,
     debug: runtimeConfig.debug,
     port,
+    host,
+    allowedHosts,
     tailwindCssEntry
   });
   const generatedFallbackStylesheetPath = prepareFallbackStylesheet({
@@ -13965,8 +14450,10 @@ async function startDreamboardDevServer(options) {
   });
   await server.listen();
   const resolvedPort = getBoundPort(server);
+  const url = `http://localhost:${resolvedPort}/index.html`;
   return {
-    url: `http://localhost:${resolvedPort}/index.html`,
+    url,
+    networkUrls: getNetworkUrls(host, resolvedPort),
     close: async () => {
       await server.close();
       if (generatedFallbackStylesheetPath) {
@@ -13976,6 +14463,23 @@ async function startDreamboardDevServer(options) {
     server
   };
 }
+function getNetworkUrls(host, port) {
+  if (!host) return [];
+  if (typeof host === "string" && isLoopbackHost(host)) return [];
+  const hosts = host === true || host === "0.0.0.0" || host === "::" ? getLanIpv4Addresses() : [host];
+  return hosts.map(
+    (value) => `http://${formatUrlHost(value)}:${port}/index.html`
+  );
+}
+function isLoopbackHost(host) {
+  return host === "localhost" || host === "127.0.0.1" || host === "::1";
+}
+function getLanIpv4Addresses() {
+  return Object.values(os.networkInterfaces()).flatMap((interfaces) => interfaces ?? []).filter((details) => details.family === "IPv4" && !details.internal).map((details) => details.address);
+}
+function formatUrlHost(host) {
+  return host.includes(":") ? `[${host}]` : host;
+}
 function getBoundPort(server) {
   const address = server.httpServer?.address();
   if (!address || typeof address === "string") {
@@ -13985,11 +14489,11 @@ function getBoundPort(server) {
 }
 
 // src/services/testing/reducer-native-test-harness.ts
-import path20 from "path";
+import path21 from "path";
 import {
   existsSync as existsSync8,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync3,
   rmSync as rmSync2,
   writeFileSync as writeFileSync2
 } from "fs";
@@ -14098,9 +14602,6 @@ var ProjectSeatsDynamicRequestSchema = external_exports.object({ "state": Reduce
 var BoardStaticProjectionSchema = external_exports.object({ "view": JsonValueSchema, "hash": external_exports.string().min(1), "manifestVersion": external_exports.string() }).strict();
 
 // ../../packages/app-sdk/src/reducer/per-player.ts
-function asPlayerId(raw) {
-  return raw;
-}
 function perPlayerGet(value, id) {
   for (const [candidate, v] of value.entries) {
     if (candidate === id) {
@@ -14222,33 +14723,6 @@ function resolveDependentDomainChoices(choices, context) {
     disabledReason: choice.disabledReason
   }));
 }
-function choiceValuesInclude(choices, value) {
-  return choices.some((choice) => Object.is(choice.value, value));
-}
-function assertChoiceDefaultInChoices(inputName, choices, defaultValue) {
-  if (choiceValuesInclude(choices, defaultValue)) return;
-  const printable = defaultValue === null ? "null" : `'${defaultValue}'`;
-  throw new Error(
-    `${inputName} defaultValue ${printable} must be one of its choices. If null is a valid value, add an explicit { value: null, label: ... } choice.`
-  );
-}
-function choiceSchema(choices) {
-  const values = choices.map((choice) => choice.value);
-  const stringValues = values.filter(
-    (value) => value !== null
-  );
-  const hasNull = values.some((value) => value === null);
-  if (stringValues.length === 0) {
-    return external_exports.null();
-  }
-  const stringSchema = external_exports.enum(
-    stringValues
-  );
-  if (hasNull) {
-    return external_exports.union([stringSchema, external_exports.null()]);
-  }
-  return stringSchema;
-}
 function resolveResourceMapChoices(choices, context) {
   const resources = context.state.table.resources;
   const firstResourceMap = isPerPlayer(resources) && resources.entries.length > 0 ? resources.entries[0]?.[1] : resources;
@@ -14332,76 +14806,38 @@ function choiceInput(options) {
   if (Array.isArray(options.choices) && options.choices.length === 0) {
     throw new Error("formInput.choice requires at least one choice.");
   }
-  const staticChoices = Array.isArray(options.choices) ? options.choices : null;
-  const hasStaticDefault = typeof options.defaultValue !== "function";
-  const staticDefault = options.defaultValue;
-  if (staticChoices && hasStaticDefault) {
-    assertChoiceDefaultInChoices(
-      "formInput.choice",
-      staticChoices,
-      staticDefault
-    );
-  }
-  const schema = staticChoices ? choiceSchema(staticChoices) : external_exports.string().nullable();
-  const dynamicDefault = typeof options.defaultValue === "function" ? options.defaultValue : void 0;
+  const schema = Array.isArray(options.choices) ? external_exports.enum(
+    options.choices.map((choice) => choice.value)
+  ) : external_exports.string();
   return {
     kind: "form",
     schema,
-    ...hasStaticDefault ? { defaultValue: staticDefault } : {},
+    ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
     ...dependsOn ? { dependsOn } : {},
     domain: (state, playerId, q, derived, values) => {
-      const context = {
-        state,
-        playerId,
-        q,
-        derived
-      };
-      const choices = dependsOn ? resolveDependentDomainChoices(
-        options.choices,
-        {
-          ...context,
-          values: values ?? {}
-        }
-      ) : resolveDomainChoices(options.choices, {
-        ...context,
-        values: {}
-      });
-      if (hasStaticDefault) {
-        assertChoiceDefaultInChoices(
-          "formInput.choice",
-          choices,
-          staticDefault
-        );
-      }
       return {
         type: "choice",
-        choices
+        choices: dependsOn ? resolveDependentDomainChoices(
+          options.choices,
+          {
+            state,
+            playerId,
+            q,
+            derived,
+            values: values ?? {}
+          }
+        ) : resolveDomainChoices(
+          options.choices,
+          {
+            state,
+            playerId,
+            q,
+            derived,
+            values: {}
+          }
+        )
       };
-    },
-    ...dynamicDefault ? {
-      resolveDefaultValue: (state, playerId, q, derived, domain) => {
-        const choices = domain.type === "choice" ? domain.choices.map((choice) => ({
-          value: choice.value,
-          label: choice.label,
-          icon: choice.icon,
-          badge: choice.badge,
-          description: choice.description,
-          disabled: choice.disabled,
-          disabledReason: choice.disabledReason
-        })) : [];
-        const resolved = dynamicDefault({
-          state,
-          playerId,
-          q,
-          derived,
-          values: {},
-          choices
-        });
-        if (resolved === void 0) return void 0;
-        assertChoiceDefaultInChoices("formInput.choice", choices, resolved);
-        return resolved;
-      }
-    } : {}
+    }
   };
 }
 function choiceListInput(options) {
@@ -14422,12 +14858,7 @@ function choiceListInput(options) {
         derived,
         values: {}
       };
-      const choices = resolveDomainChoices(options.choices, context).map(
-        (choice) => ({
-          ...choice,
-          value: choice.value
-        })
-      );
+      const choices = resolveDomainChoices(options.choices, context);
       return {
         type: "choiceList",
         choices,
@@ -16909,126 +17340,6 @@ function createReducerFx(_state) {
 function updateTable(state, nextTable) {
   return { ...state, table: nextTable };
 }
-function computePlayerZoneVisibility(table, zoneId, playerId) {
-  const mode = table.handVisibility[zoneId];
-  if (mode === "all" || mode === "public") {
-    return { faceUp: true };
-  }
-  return { faceUp: false, visibleTo: [playerId] };
-}
-function readPlayerZoneCards(table, zoneId, playerId) {
-  const zone = table.zones.perPlayer[zoneId] ?? table.hands[zoneId];
-  if (!zone) {
-    throw new Error(`Player zone '${zoneId}' does not exist.`);
-  }
-  return perPlayerGet(zone, asPlayerId(playerId)) ?? [];
-}
-function writePlayerZoneCards(table, zoneId, playerId, cards) {
-  const currentZone = table.zones.perPlayer[zoneId];
-  const currentHand = table.hands[zoneId];
-  const player = asPlayerId(playerId);
-  if (currentZone) {
-    table.zones.perPlayer[zoneId] = perPlayerSet(
-      currentZone,
-      player,
-      [...cards]
-    );
-  }
-  if (currentHand) {
-    table.hands[zoneId] = perPlayerSet(
-      currentHand,
-      player,
-      [...cards]
-    );
-  }
-}
-function assertCardAllowedInPlayerZone(table, zoneId, cardId) {
-  const allowedCardSetIds = table.zones.cardSetIdsByZoneId?.[zoneId];
-  if (!allowedCardSetIds || allowedCardSetIds.length === 0) {
-    return;
-  }
-  const card = table.cards[cardId];
-  if (!card) {
-    throw new Error(`Card '${cardId}' does not exist.`);
-  }
-  if (!allowedCardSetIds.includes(card.cardSetId)) {
-    throw new Error(
-      `Card '${cardId}' from set '${card.cardSetId}' is not allowed in player zone '${zoneId}'.`
-    );
-  }
-}
-function rotatePlayerZoneTable(options) {
-  const nextTable = cloneRuntimeTable(options.table);
-  const zoneId = options.zoneId;
-  if (!nextTable.zones.perPlayer[zoneId] && !nextTable.hands[zoneId]) {
-    throw new Error(`Player zone '${zoneId}' does not exist.`);
-  }
-  const players = [...options.players ?? nextTable.playerOrder];
-  if (players.length === 0) {
-    return nextTable;
-  }
-  const playerSet = new Set(nextTable.playerOrder);
-  for (const playerId of players) {
-    if (!playerSet.has(playerId)) {
-      throw new Error(
-        `Cannot rotate player zone '${zoneId}': player '${playerId}' is not in player order.`
-      );
-    }
-  }
-  const selectedByPlayer = /* @__PURE__ */ new Map();
-  for (const playerId of players) {
-    const sourceCards = readPlayerZoneCards(nextTable, zoneId, playerId);
-    const selected = options.cardIdsByPlayer?.[playerId] ?? sourceCards;
-    for (const cardId of selected) {
-      if (!sourceCards.includes(cardId)) {
-        throw new Error(
-          `Cannot rotate player zone '${zoneId}': card '${cardId}' is not in zone for player '${playerId}'.`
-        );
-      }
-      assertCardAllowedInPlayerZone(nextTable, zoneId, cardId);
-    }
-    selectedByPlayer.set(playerId, [...selected]);
-  }
-  const removeByPlayer = /* @__PURE__ */ new Map();
-  for (const playerId of players) {
-    const selected = new Set(selectedByPlayer.get(playerId) ?? []);
-    removeByPlayer.set(
-      playerId,
-      readPlayerZoneCards(nextTable, zoneId, playerId).filter(
-        (cardId) => !selected.has(cardId)
-      )
-    );
-  }
-  const additionsByPlayer = new Map(
-    players.map((playerId) => [playerId, []])
-  );
-  for (const [index, fromPlayerId] of players.entries()) {
-    const offset = options.direction === "left" ? 1 : -1;
-    const recipient = players[(index + offset + players.length) % players.length];
-    additionsByPlayer.get(recipient).push(...selectedByPlayer.get(fromPlayerId) ?? []);
-  }
-  for (const playerId of players) {
-    const remaining = removeByPlayer.get(playerId) ?? [];
-    const additions = additionsByPlayer.get(playerId) ?? [];
-    const nextCards = options.position === "top" ? [...additions, ...remaining] : [...remaining, ...additions];
-    writePlayerZoneCards(nextTable, zoneId, playerId, nextCards);
-    for (const [position, cardId] of nextCards.entries()) {
-      nextTable.componentLocations[cardId] = {
-        type: "InHand",
-        handId: zoneId,
-        playerId,
-        position
-      };
-      nextTable.ownerOfCard[cardId] = playerId;
-      nextTable.visibility[cardId] = computePlayerZoneVisibility(
-        nextTable,
-        zoneId,
-        playerId
-      );
-    }
-  }
-  return nextTable;
-}
 var moveComponentToEdgeInternal = moveComponentToEdge;
 var moveComponentToVertexInternal = moveComponentToVertex;
 var dealCardsFromDeckToHandInternal = dealCardsFromDeckToHand;
@@ -17212,19 +17523,6 @@ function createReducerOps() {
         return updateTable(state, nextTable);
       };
     },
-    rotatePlayerZone(args) {
-      return (state) => {
-        const nextTable = rotatePlayerZoneTable({
-          table: state.table,
-          zoneId: args.zoneId,
-          direction: args.direction,
-          players: args.players,
-          cardIdsByPlayer: args.cardIdsByPlayer,
-          position: args.position ?? "bottom"
-        });
-        return updateTable(state, nextTable);
-      };
-    },
     moveComponentToSpace(args) {
       return (state) => {
         const nextTable = moveComponentToSpace(
@@ -17324,47 +17622,6 @@ function createReducerOps() {
   return impl;
 }
 
-// ../../packages/app-sdk/src/reducer/transaction.ts
-function createReducerTransaction(initialState, ops = createReducerOps()) {
-  let currentState = initialState;
-  let currentQueries = createStateQueries(currentState);
-  const refresh = (nextState) => {
-    currentState = nextState;
-    currentQueries = createStateQueries(currentState);
-    return currentState;
-  };
-  const apply = (op) => refresh(op(currentState));
-  const base = {
-    get state() {
-      return currentState;
-    },
-    get q() {
-      return currentQueries;
-    },
-    apply
-  };
-  return new Proxy(base, {
-    get(target, property, receiver) {
-      if (property in target) {
-        return Reflect.get(target, property, receiver);
-      }
-      const opFactory = ops[property];
-      if (typeof opFactory !== "function") {
-        return void 0;
-      }
-      return (...args) => {
-        const op = opFactory(
-          ...args
-        );
-        return apply(op);
-      };
-    }
-  });
-}
-function createReducerEdit(ops = createReducerOps()) {
-  return (state) => createReducerTransaction(state, ops);
-}
-
 // ../../packages/app-sdk/src/reducer/definition-index.ts
 function phaseEntriesOf(definition) {
   return Object.entries(definition.phases);
@@ -17666,8 +17923,7 @@ function createTrustedRuntimeScope(definition) {
   }
   const helpers = {
     ...runtimeResultHelpers,
-    ops: createReducerOps(),
-    edit: createReducerEdit()
+    ops: createReducerOps()
   };
   function fxForState2(state) {
     return fxForState(state);
@@ -18004,10 +18260,10 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
 
 // ../../packages/app-sdk/src/reducer/parse-utils.ts
 function formatIssue(label, issue) {
-  const path26 = issue.path.map(
+  const path28 = issue.path.map(
     (segment) => typeof segment === "symbol" ? segment.toString() : String(segment)
   ).join(".");
-  return `${path26 || label}: ${issue.message}`;
+  return `${path28 || label}: ${issue.message}`;
 }
 function safeParseOrThrow(schema, value, label) {
   const parsed = schema.safeParse(value);
@@ -18074,9 +18330,7 @@ function finiteValuesForDependency(key, domain) {
     return [...domain.eligibleTargets];
   }
   if (domain.type === "choice") {
-    return domain.choices.flatMap(
-      (choice) => choice.value === null ? [] : [choice.value]
-    );
+    return domain.choices.map((choice) => choice.value);
   }
   throw new Error(
     `Interaction input '${key}' cannot be used as a dependency. V1 supports finite target and choice dependencies only.`
@@ -18644,7 +18898,7 @@ function enrichResourceInputPresentation(inputs, manifest) {
   }
   const resources = presentationById;
   const enrichChoice = (choice) => {
-    const presentation = choice.value === null ? void 0 : resources[choice.value];
+    const presentation = resources[choice.value];
     return {
       ...choice,
       label: typeof presentation?.label === "string" && (!choice.label || choice.label === choice.value) ? presentation.label : choice.label || (typeof presentation?.label === "string" ? presentation.label : ""),
@@ -18652,16 +18906,7 @@ function enrichResourceInputPresentation(inputs, manifest) {
     };
   };
   return inputs.map((input) => {
-    if (input.domain.type === "choice") {
-      return {
-        ...input,
-        domain: {
-          ...input.domain,
-          choices: input.domain.choices.map(enrichChoice)
-        }
-      };
-    }
-    if (input.domain.type === "choiceList") {
+    if (input.domain.type === "choice" || input.domain.type === "choiceList") {
       return {
         ...input,
         domain: {
@@ -19173,15 +19418,16 @@ function resolveContainerRef(table, ref) {
       throw new Error(`Unknown board '${ref.boardId}'.`);
     }
     const space2 = board2?.spaces[ref.spaceId];
-    if (!space2) {
+    if (!space2?.zoneId) {
       throw new Error(
-        `Unknown board space '${ref.spaceId}' on board '${ref.boardId}'.`
+        `Board space '${ref.spaceId}' on board '${ref.boardId}' has no container zone.`
       );
     }
     return {
       kind: "space",
       boardId: board2.id,
-      spaceId: ref.spaceId
+      spaceId: ref.spaceId,
+      zoneId: space2.zoneId
     };
   }
   const board = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId, ref.playerId)];
@@ -19191,15 +19437,16 @@ function resolveContainerRef(table, ref) {
     );
   }
   const space = board?.spaces[ref.spaceId];
-  if (!space) {
+  if (!space?.zoneId) {
     throw new Error(
-      `Unknown board space '${ref.spaceId}' on board '${ref.boardId}' for '${ref.playerId}'.`
+      `Board space '${ref.spaceId}' on board '${ref.boardId}' for '${ref.playerId}' has no container zone.`
     );
   }
   return {
     kind: "space",
     boardId: board.id,
-    spaceId: ref.spaceId
+    spaceId: ref.spaceId,
+    zoneId: space.zoneId
   };
 }
 function readContainerComponents(table, ref) {
@@ -20150,7 +20397,7 @@ function materializeAccept(pending) {
 }
 
 // ../../packages/reducer-contract/generated/version.ts
-var REDUCER_CONTRACT_VERSION = "7.0.1";
+var REDUCER_CONTRACT_VERSION = "7.0.0";
 
 // ../../packages/app-sdk/src/reducer/ingress/runtime-payload.ts
 var runtimePayloadSchema = external_exports.lazy(
@@ -20826,7 +21073,7 @@ function createReducerBundle(definition) {
 // src/utils/ts-module-loader.ts
 import { mkdtemp as mkdtemp2, rm as rm4, writeFile as writeFile3 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import path17 from "path";
+import path18 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { build as build2 } from "esbuild";
 var ESBUILD_EXTERNALS = [
@@ -20840,14 +21087,14 @@ function resolveSourceCheckoutBuildContext() {
     const repoRoot = resolveCliRepoRoot(import.meta.url);
     return {
       nodePaths: [
-        path17.join(repoRoot, "apps", "dreamboard-cli", "node_modules"),
-        path17.join(repoRoot, "node_modules")
+        path18.join(repoRoot, "apps", "dreamboard-cli", "node_modules"),
+        path18.join(repoRoot, "node_modules")
       ],
       plugins: [createRepoLocalPackageResolutionPlugin({ repoRoot })]
     };
   } catch {
     return {
-      nodePaths: [path17.join(process.cwd(), "node_modules")],
+      nodePaths: [path18.join(process.cwd(), "node_modules")],
       plugins: []
     };
   }
@@ -20873,10 +21120,10 @@ async function bundleTypeScriptModuleText(entryPath, options = {}) {
   return output.text;
 }
 async function importTypeScriptModule(entryPath) {
-  const tempDir = await mkdtemp2(path17.join(tmpdir2(), "dreamboard-ts-module-"));
-  const outfile = path17.join(
+  const tempDir = await mkdtemp2(path18.join(tmpdir2(), "dreamboard-ts-module-"));
+  const outfile = path18.join(
     tempDir,
-    `${path17.basename(entryPath).replace(/\.[^.]+$/u, "")}.mjs`
+    `${path18.basename(entryPath).replace(/\.[^.]+$/u, "")}.mjs`
   );
   try {
     const bundledText = await bundleTypeScriptModuleText(entryPath);
@@ -20901,7 +21148,7 @@ import {
   symlink
 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path18 from "path";
+import path19 from "path";
 import { createInterface } from "readline";
 import { fileURLToPath as fileURLToPath7 } from "url";
 var READY_PREFIX = "HARNESS_READY ";
@@ -20909,15 +21156,15 @@ var HARNESS_START_IDLE_TIMEOUT_MS = 18e4;
 var HARNESS_START_MAX_TIMEOUT_MS = 6e5;
 var HARNESS_STOP_TIMEOUT_MS = 1e4;
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-var MODULE_DIR4 = path18.dirname(fileURLToPath7(import.meta.url));
-var REPO_ROOT3 = path18.resolve(MODULE_DIR4, "../../../../..");
-var PROJECT_DEPENDENCY_NODE_MODULES = path18.join(
+var MODULE_DIR4 = path19.dirname(fileURLToPath7(import.meta.url));
+var REPO_ROOT3 = path19.resolve(MODULE_DIR4, "../../../../..");
+var PROJECT_DEPENDENCY_NODE_MODULES = path19.join(
   REPO_ROOT3,
   "apps",
   "dreamboard-cli",
   "node_modules"
 );
-var UI_SDK_NODE_MODULES = path18.join(
+var UI_SDK_NODE_MODULES = path19.join(
   REPO_ROOT3,
   "packages",
   "ui-sdk",
@@ -20927,8 +21174,8 @@ async function startEmbeddedHarnessSession(options) {
   const repoRoot = await resolveRepoRoot2(options.projectRoot);
   const gradlew = await resolveGradleLauncher(repoRoot);
   const fixture = await prepareLocalHarnessFixture(options);
-  const logDir = path18.join(options.projectRoot, "test", "generated");
-  const logFilePath = path18.join(logDir, "embedded-harness.log");
+  const logDir = path19.join(options.projectRoot, "test", "generated");
+  const logFilePath = path19.join(logDir, "embedded-harness.log");
   await mkdir2(logDir, { recursive: true });
   const previousClientConfig = client.getConfig();
   const child = spawn5(
@@ -20937,7 +21184,7 @@ async function startEmbeddedHarnessSession(options) {
       ...gradlew.args,
       "--console=plain",
       ":apps:backend:runEmbeddedHarness",
-      `-PharnessManifestPath=${path18.join(options.projectRoot, MATERIALIZED_MANIFEST_FILE)}`,
+      `-PharnessManifestPath=${path19.join(options.projectRoot, MATERIALIZED_MANIFEST_FILE)}`,
       `-PharnessBundlePath=${fixture.bundleRoot}`,
       `-PharnessGameId=${fixture.gameId}`,
       `-PharnessManifestId=${fixture.manifestId}`,
@@ -21004,7 +21251,7 @@ async function ensureSymlink(targetPath, linkPath) {
   if (await pathExists3(linkPath)) {
     return;
   }
-  await mkdir2(path18.dirname(linkPath), { recursive: true });
+  await mkdir2(path19.dirname(linkPath), { recursive: true });
   await symlink(
     targetPath,
     linkPath,
@@ -21015,13 +21262,13 @@ async function ensureEmbeddedHarnessDependencies(projectRoot) {
   if (await pathExists3(PROJECT_DEPENDENCY_NODE_MODULES)) {
     await ensureSymlink(
       PROJECT_DEPENDENCY_NODE_MODULES,
-      path18.join(projectRoot, "node_modules")
+      path19.join(projectRoot, "node_modules")
     );
   }
   if (await pathExists3(UI_SDK_NODE_MODULES)) {
     await ensureSymlink(
       UI_SDK_NODE_MODULES,
-      path18.join(projectRoot, "ui", "node_modules")
+      path19.join(projectRoot, "ui", "node_modules")
     );
   }
 }
@@ -21031,15 +21278,15 @@ async function prepareLocalHarnessFixture(options) {
   const manifestContent = await readMaterializedManifestText(
     options.projectRoot
   );
-  const appEntryPath = path18.join(options.projectRoot, "app", "index.ts");
+  const appEntryPath = path19.join(options.projectRoot, "app", "index.ts");
   if (!await exists(appEntryPath)) {
     throw new Error(
-      `Embedded harness requires ${path18.relative(options.projectRoot, appEntryPath)}.`
+      `Embedded harness requires ${path19.relative(options.projectRoot, appEntryPath)}.`
     );
   }
-  const bundleRoot = await mkdtemp3(path18.join(tmpdir3(), "dreamboard-harness-"));
-  const bundleEntryPath = path18.join(bundleRoot, "src", "app", "index.js");
-  await mkdir2(path18.dirname(bundleEntryPath), { recursive: true });
+  const bundleRoot = await mkdtemp3(path19.join(tmpdir3(), "dreamboard-harness-"));
+  const bundleEntryPath = path19.join(bundleRoot, "src", "app", "index.js");
+  await mkdir2(path19.dirname(bundleEntryPath), { recursive: true });
   const bunExecutable = await resolveBunExecutable();
   if (!bunExecutable) {
     await rm5(bundleRoot, { recursive: true, force: true });
@@ -21076,7 +21323,7 @@ async function prepareLocalHarnessFixture(options) {
   const bundleContent = await readFile3(bundleEntryPath, "utf8");
   const manifestHash = hashContent(manifestContent);
   const bundleHash = hashContent(bundleContent);
-  const gameSlug = options.projectConfig.slug || path18.basename(options.projectRoot);
+  const gameSlug = options.projectConfig.slug || path19.basename(options.projectRoot);
   const authoring = getProjectAuthoringState(options.projectConfig);
   return {
     bundleRoot,
@@ -21096,14 +21343,14 @@ async function prepareLocalHarnessFixture(options) {
   };
 }
 async function resolveBunExecutable() {
-  const currentExecutable = path18.basename(process.execPath).toLowerCase();
+  const currentExecutable = path19.basename(process.execPath).toLowerCase();
   if (currentExecutable === "bun" || currentExecutable === "bun.exe") {
     return process.execPath;
   }
   const candidatePaths = [
-    ...(process.env.PATH ?? "").split(path18.delimiter).filter((directory) => directory.length > 0).flatMap((directory) => executableCandidates(directory, "bun")),
-    ...process.env.BUN_INSTALL ? executableCandidates(path18.join(process.env.BUN_INSTALL, "bin"), "bun") : [],
-    ...process.env.HOME ? executableCandidates(path18.join(process.env.HOME, ".bun", "bin"), "bun") : []
+    ...(process.env.PATH ?? "").split(path19.delimiter).filter((directory) => directory.length > 0).flatMap((directory) => executableCandidates(directory, "bun")),
+    ...process.env.BUN_INSTALL ? executableCandidates(path19.join(process.env.BUN_INSTALL, "bin"), "bun") : [],
+    ...process.env.HOME ? executableCandidates(path19.join(process.env.HOME, ".bun", "bin"), "bun") : []
   ];
   for (const candidate of candidatePaths) {
     try {
@@ -21119,11 +21366,11 @@ function executableCandidates(directory, executableName) {
     return [];
   }
   if (process.platform !== "win32") {
-    return [path18.join(directory, executableName)];
+    return [path19.join(directory, executableName)];
   }
   const extensions = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter((extension) => extension.length > 0);
   return extensions.map(
-    (extension) => path18.join(directory, `${executableName}${extension.toLowerCase()}`)
+    (extension) => path19.join(directory, `${executableName}${extension.toLowerCase()}`)
   );
 }
 async function waitForExitCode(child) {
@@ -21281,13 +21528,13 @@ async function waitForExit(child, timeoutMs) {
 }
 async function resolveGradleLauncher(repoRoot) {
   if (process.platform === "win32") {
-    const gradleBat = path18.join(repoRoot, "gradlew.bat");
+    const gradleBat = path19.join(repoRoot, "gradlew.bat");
     if (!await exists(gradleBat)) {
       throw new Error(`Missing Gradle launcher at ${gradleBat}`);
     }
     return { command: gradleBat, args: [] };
   }
-  const gradleShell = path18.join(repoRoot, "gradlew");
+  const gradleShell = path19.join(repoRoot, "gradlew");
   if (!await exists(gradleShell)) {
     throw new Error(`Missing Gradle launcher at ${gradleShell}`);
   }
@@ -21295,7 +21542,7 @@ async function resolveGradleLauncher(repoRoot) {
 }
 async function resolveRepoRoot2(projectRoot) {
   const currentFile = fileURLToPath7(import.meta.url);
-  const searchRoots = [path18.dirname(currentFile), projectRoot, process.cwd()];
+  const searchRoots = [path19.dirname(currentFile), projectRoot, process.cwd()];
   for (const root of searchRoots) {
     const repoRoot = await findSourceCheckoutRepoRoot(root);
     if (repoRoot) {
@@ -21307,12 +21554,12 @@ async function resolveRepoRoot2(projectRoot) {
   );
 }
 async function findSourceCheckoutRepoRoot(startDir) {
-  let currentDir = path18.resolve(startDir);
+  let currentDir = path19.resolve(startDir);
   while (true) {
     if (await isSourceCheckoutRepoRoot(currentDir)) {
       return currentDir;
     }
-    const parentDir = path18.dirname(currentDir);
+    const parentDir = path19.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -21320,7 +21567,7 @@ async function findSourceCheckoutRepoRoot(startDir) {
   }
 }
 async function isSourceCheckoutRepoRoot(rootDir) {
-  return await exists(path18.join(rootDir, "gradlew")) && await exists(path18.join(rootDir, "apps", "backend", "build.gradle.kts"));
+  return await exists(path19.join(rootDir, "gradlew")) && await exists(path19.join(rootDir, "apps", "backend", "build.gradle.kts"));
 }
 function normalizeUuid(candidate, fallbackSeed) {
   if (candidate && UUID_PATTERN.test(candidate)) {
@@ -21371,8 +21618,8 @@ async function subscribeToCliSessionEvents(options) {
 }
 
 // src/ui/playwright-runner.ts
-import os from "os";
-import path19 from "path";
+import os2 from "os";
+import path20 from "path";
 function configurePlaywrightBrowsersPath() {
   if (process.env.PLAYWRIGHT_BROWSERS_PATH) {
     return;
@@ -21380,14 +21627,14 @@ function configurePlaywrightBrowsersPath() {
   const runtimeHome = process.env.HOME;
   let realHome;
   try {
-    realHome = os.userInfo().homedir;
+    realHome = os2.userInfo().homedir;
   } catch {
     return;
   }
-  if (!runtimeHome || path19.resolve(runtimeHome) === path19.resolve(realHome)) {
+  if (!runtimeHome || path20.resolve(runtimeHome) === path20.resolve(realHome)) {
     return;
   }
-  const browserCachePath = process.platform === "darwin" ? path19.join(realHome, "Library", "Caches", "ms-playwright") : process.platform === "win32" ? path19.join(realHome, "AppData", "Local", "ms-playwright") : path19.join(realHome, ".cache", "ms-playwright");
+  const browserCachePath = process.platform === "darwin" ? path20.join(realHome, "Library", "Caches", "ms-playwright") : process.platform === "win32" ? path20.join(realHome, "AppData", "Local", "ms-playwright") : path20.join(realHome, ".cache", "ms-playwright");
   process.env.PLAYWRIGHT_BROWSERS_PATH = browserCachePath;
 }
 async function buildBrowserAuthInitScript(config) {
@@ -21396,7 +21643,7 @@ async function buildBrowserAuthInitScript(config) {
     return `(function(){localStorage.setItem('supabase_token',${JSON.stringify(config.authToken)});})();`;
   }
   try {
-    const { createClient: createClient2 } = await import("./dist-WJRJNFLI.js");
+    const { createClient: createClient2 } = await import("./dist-FRURQI7Q.js");
     const supabase = createClient2(config.supabaseUrl, config.supabaseAnonKey);
     let sessionData = null;
     if (!sessionData) {
@@ -21490,42 +21737,9 @@ var TESTING_TYPES_STUB2 = "export function defineScenario(scenario) { return sce
 var DEFAULT_TIMEOUT_MS = 1e4;
 var BASE_SUFFIX = ".base.ts";
 var SCENARIO_SUFFIX = ".scenario.ts";
-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 = path20.resolve(options.scenarioFilePath);
-  const relativePath = path20.relative(options.projectRoot, absolutePath);
-  const normalizedRelativePath = relativePath.split(path20.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(path20.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("./src-CUL7EGGG.js").then(
+  testingExpectApiFactoryPromise ??= import("./dist-FEPN3BDN.js").then(
     (module) => module.createExpectApi
   );
   return testingExpectApiFactoryPromise;
@@ -21565,7 +21779,7 @@ async function discoverFiles(root, suffix) {
   const entries = await readdir3(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const entryPath = path20.join(root, entry.name);
+    const entryPath = path21.join(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await discoverFiles(entryPath, suffix));
       continue;
@@ -21614,38 +21828,38 @@ function parseTypedScenarioDefinition(value) {
   };
 }
 async function isReducerNativeTestingWorkspace(projectRoot) {
-  return await exists(path20.join(projectRoot, "app", "game.ts")) && await exists(
-    path20.join(projectRoot, "shared", "generated", "ui-contract.ts")
+  return await exists(path21.join(projectRoot, "app", "game.ts")) && await exists(
+    path21.join(projectRoot, "shared", "generated", "ui-contract.ts")
   );
 }
 async function ensureReducerNativeTestingFiles(projectRoot) {
-  const testingTypesPath = path20.join(projectRoot, "test", "testing-types.ts");
-  const testingContractPath = path20.join(
+  const testingTypesPath = path21.join(projectRoot, "test", "testing-types.ts");
+  const testingContractPath = path21.join(
     projectRoot,
     "test",
     "generated",
     "testing-contract.ts"
   );
-  const baseStatesPath = path20.join(
+  const baseStatesPath = path21.join(
     projectRoot,
     "test",
     "generated",
     "base-states.generated.ts"
   );
-  const baseStatesDtsPath = path20.join(
+  const baseStatesDtsPath = path21.join(
     projectRoot,
     "test",
     "generated",
     "base-states.generated.d.ts"
   );
-  const scenarioManifestPath = path20.join(
+  const scenarioManifestPath = path21.join(
     projectRoot,
     "test",
     "generated",
     "scenario-manifest.generated.ts"
   );
-  await ensureDir(path20.dirname(testingTypesPath));
-  await ensureDir(path20.dirname(testingContractPath));
+  await ensureDir(path21.dirname(testingTypesPath));
+  await ensureDir(path21.dirname(testingContractPath));
   const existingTestingTypes = await readTextFileIfExists(testingTypesPath);
   if (shouldRefreshReducerTestingTypes(existingTestingTypes)) {
     await writeTextFile(
@@ -21689,7 +21903,7 @@ var DEFAULT_REJECTION_CODES2 = [
 ];
 async function collectKnownRejectionCodes(projectRoot) {
   const knownCodes = new Set(DEFAULT_REJECTION_CODES2);
-  const gamePath = path20.join(projectRoot, "app", "game.ts");
+  const gamePath = path21.join(projectRoot, "app", "game.ts");
   if (!await exists(gamePath)) {
     return Array.from(knownCodes).sort(
       (left, right) => left.localeCompare(right)
@@ -21716,7 +21930,7 @@ async function collectKnownRejectionCodes(projectRoot) {
 }
 async function loadTypedBases(projectRoot) {
   const baseFiles = await discoverFiles(
-    path20.join(projectRoot, "test", "bases"),
+    path21.join(projectRoot, "test", "bases"),
     BASE_SUFFIX
   );
   const loaded = [];
@@ -21735,8 +21949,8 @@ async function loadTypedBases(projectRoot) {
   return loaded;
 }
 async function loadTypedScenarios(projectRoot, options) {
-  const scenarioFiles = options.scenarioPath ? [path20.resolve(projectRoot, options.scenarioPath)] : await discoverFiles(
-    path20.join(projectRoot, "test", "scenarios"),
+  const scenarioFiles = options.scenarioPath ? [path21.resolve(projectRoot, options.scenarioPath)] : await discoverFiles(
+    path21.join(projectRoot, "test", "scenarios"),
     SCENARIO_SUFFIX
   );
   const loaded = [];
@@ -21755,8 +21969,8 @@ async function loadTypedScenarios(projectRoot, options) {
   return loaded;
 }
 function reducerNativeTestHelperExternals(projectRoot, filePath) {
-  const testingTypesPath = path20.join(projectRoot, "test", "testing-types");
-  const relative = path20.relative(path20.dirname(filePath), testingTypesPath).replaceAll("\\", "/");
+  const testingTypesPath = path21.join(projectRoot, "test", "testing-types");
+  const relative = path21.relative(path21.dirname(filePath), testingTypesPath).replaceAll("\\", "/");
   const specifier = relative.startsWith(".") ? relative : `./${relative}`;
   return [specifier, `${specifier}.ts`];
 }
@@ -21957,6 +22171,13 @@ var ShadowReducerRuntime = class {
       (_2, index) => `player-${index + 1}`
     );
   }
+  manifest;
+  gameModuleDefault;
+  createInitialTable;
+  seed;
+  players;
+  setupProfileId;
+  debug;
   bundle;
   runtime;
   playerIds;
@@ -22101,6 +22322,8 @@ var EmbeddedGameplayTracker = class {
     this.playerId = playerId;
     this.state.playerId = playerId;
   }
+  sessionId;
+  playerId;
   abortController = new AbortController();
   state = {
     version: -1,
@@ -22252,7 +22475,7 @@ async function assertLiveMatchesShadow(runner, shadow, live) {
   }
 }
 async function loadBrowserDriver(projectRoot) {
-  const filePath = path20.join(projectRoot, "test", "browser-driver.ts");
+  const filePath = path21.join(projectRoot, "test", "browser-driver.ts");
   if (!await exists(filePath)) {
     return null;
   }
@@ -22280,7 +22503,7 @@ function sanitizeSnapshotSegment(value) {
 function createScenarioSnapshotMatcher(options) {
   return (filename, actual) => {
     const suffix = filename ? `.${sanitizeSnapshotSegment(filename)}` : "";
-    const snapshotPath = path20.join(
+    const snapshotPath = path21.join(
       options.projectRoot,
       "test",
       "generated",
@@ -22292,15 +22515,15 @@ function createScenarioSnapshotMatcher(options) {
     };
     const serialized = `${JSON.stringify(wrappedValue, null, 2)}
 `;
-    mkdirSync2(path20.dirname(snapshotPath), { recursive: true });
+    mkdirSync2(path21.dirname(snapshotPath), { recursive: true });
     if (!existsSync8(snapshotPath) || options.updateSnapshots) {
       writeFileSync2(snapshotPath, serialized, "utf8");
       return;
     }
-    const previous = JSON.parse(readFileSync4(snapshotPath, "utf8"));
+    const previous = JSON.parse(readFileSync3(snapshotPath, "utf8"));
     if (!deepEqual(previous.value, actual)) {
       throw new Error(
-        `Snapshot mismatch for scenario '${options.scenarioId}'. Re-run with --update-snapshots to refresh ${path20.relative(options.projectRoot, snapshotPath)}.`
+        `Snapshot mismatch for scenario '${options.scenarioId}'. Re-run with --update-snapshots to refresh ${path21.relative(options.projectRoot, snapshotPath)}.`
       );
     }
   };
@@ -22561,7 +22784,7 @@ async function createSessionFromScenario(options) {
 }
 var MATERIALIZED_SCENARIO_CACHE_VERSION = 1;
 function materializedScenarioCachePath(options) {
-  return path20.join(
+  return path21.join(
     options.projectRoot,
     PROJECT_DIR_NAME,
     "dev",
@@ -22589,7 +22812,7 @@ async function readMaterializedScenarioCache(options) {
 }
 async function writeMaterializedScenarioCache(options) {
   const cachePath = materializedScenarioCachePath(options);
-  await ensureDir(path20.dirname(cachePath));
+  await ensureDir(path21.dirname(cachePath));
   await writeJsonFile(cachePath, {
     cacheVersion: MATERIALIZED_SCENARIO_CACHE_VERSION,
     fingerprintHash: options.fingerprintHash,
@@ -22686,10 +22909,10 @@ async function materializeScenarioReducerState(options) {
   }
   const [gameModule, manifestContractModule] = await Promise.all([
     importTypeScriptModule(
-      path20.join(options.projectRoot, "app", "game.ts")
+      path21.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path20.join(options.projectRoot, "shared", "manifest-contract.ts")
+      path21.join(options.projectRoot, "shared", "manifest-contract.ts")
     )
   ]);
   const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
@@ -22771,10 +22994,10 @@ async function createScenarioActionPlan(options) {
     loadGeneratedBaseStates(options.projectRoot),
     loadManifest(options.projectRoot),
     importTypeScriptModule(
-      path20.join(options.projectRoot, "app", "game.ts")
+      path21.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path20.join(options.projectRoot, "shared", "manifest-contract.ts")
+      path21.join(options.projectRoot, "shared", "manifest-contract.ts")
     )
   ]);
   const matchingScenarios = scenarios.filter(
@@ -23041,7 +23264,7 @@ function sortBasesForArtifacts(bases, basesById) {
   return ordered;
 }
 function writeProjectionSnapshots(options) {
-  const projectionDir = path20.join(
+  const projectionDir = path21.join(
     options.projectRoot,
     "test",
     "generated",
@@ -23052,7 +23275,7 @@ function writeProjectionSnapshots(options) {
   mkdirSync2(projectionDir, { recursive: true });
   const projection = options.shadow.projectAllSeats();
   for (const [playerId, seatProjection] of Object.entries(projection.seats)) {
-    const outputPath = path20.join(projectionDir, `${playerId}.projection.json`);
+    const outputPath = path21.join(projectionDir, `${playerId}.projection.json`);
     writeFileSync2(
       outputPath,
       `${JSON.stringify(
@@ -23072,7 +23295,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) => path20.relative(process.cwd(), scenario.filePath) + ` -> '${scenario.definition.from}'`
+    (scenario) => path21.relative(process.cwd(), scenario.filePath) + ` -> '${scenario.definition.from}'`
   );
   if (invalid.length > 0) {
     throw new Error(
@@ -23086,23 +23309,23 @@ async function writeReducerNativeGeneratedFiles(options) {
   const manifestHash = hashContent(JSON.stringify(manifest));
   const appBundleHash = hashContent(
     await bundleTypeScriptModuleText(
-      path20.join(options.projectRoot, "app", "game.ts")
+      path21.join(options.projectRoot, "app", "game.ts")
     )
   );
   const uiContractHash = hashContent(
     await bundleTypeScriptModuleText(
-      path20.join(options.projectRoot, "shared", "generated", "ui-contract.ts")
+      path21.join(options.projectRoot, "shared", "generated", "ui-contract.ts")
     )
   );
-  const generatedDir = path20.join(options.projectRoot, "test", "generated");
+  const generatedDir = path21.join(options.projectRoot, "test", "generated");
   await ensureDir(generatedDir);
   const baseStates = {};
   const [gameModule, manifestContractModule] = await Promise.all([
     importTypeScriptModule(
-      path20.join(options.projectRoot, "app", "game.ts")
+      path21.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path20.join(options.projectRoot, "shared", "manifest-contract.ts")
+      path21.join(options.projectRoot, "shared", "manifest-contract.ts")
     )
   ]);
   const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
@@ -23190,21 +23413,21 @@ async function writeReducerNativeGeneratedFiles(options) {
   }
   const header = "// Generated by dreamboard test generate. Do not edit by hand.\n";
   await writeTextFile(
-    path20.join(generatedDir, "base-states.generated.ts"),
+    path21.join(generatedDir, "base-states.generated.ts"),
     `${header}export const BASE_STATES = ${JSON.stringify(baseStates, null, 2)} as const;
 `
   );
   await writeTextFile(
-    path20.join(generatedDir, "base-states.generated.d.ts"),
+    path21.join(generatedDir, "base-states.generated.d.ts"),
     `${header}export declare const BASE_STATES: Record<string, unknown>;
 `
   );
   await writeTextFile(
-    path20.join(generatedDir, "scenario-manifest.generated.ts"),
+    path21.join(generatedDir, "scenario-manifest.generated.ts"),
     `${header}export const SCENARIO_MANIFEST = ${JSON.stringify(
       options.scenarios.map((scenario) => ({
         id: scenario.definition.id,
-        filePath: path20.relative(generatedDir, scenario.filePath),
+        filePath: path21.relative(generatedDir, scenario.filePath),
         base: scenario.definition.from,
         runners: normalizeScenarioRunners(scenario.definition.runners)
       })),
@@ -23213,14 +23436,14 @@ async function writeReducerNativeGeneratedFiles(options) {
     )} as const;
 `
   );
-  await writeJsonFile(path20.join(generatedDir, ".generation-meta.json"), {
+  await writeJsonFile(path21.join(generatedDir, ".generation-meta.json"), {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     scenarioCount: options.scenarios.length,
     baseStateCount: options.bases.length
   });
 }
 async function loadGeneratedBaseStates(projectRoot) {
-  const filePath = path20.join(
+  const filePath = path21.join(
     projectRoot,
     "test",
     "generated",
@@ -23233,7 +23456,7 @@ async function loadGeneratedBaseStates(projectRoot) {
   return module.BASE_STATES ?? null;
 }
 async function loadGeneratedScenarioManifest(projectRoot) {
-  const filePath = path20.join(
+  const filePath = path21.join(
     projectRoot,
     "test",
     "generated",
@@ -23323,12 +23546,12 @@ async function currentFingerprint(options) {
     manifestHash: hashContent(JSON.stringify(manifest)),
     appBundleHash: hashContent(
       await bundleTypeScriptModuleText(
-        path20.join(options.projectRoot, "app", "game.ts")
+        path21.join(options.projectRoot, "app", "game.ts")
       )
     ),
     uiContractHash: hashContent(
       await bundleTypeScriptModuleText(
-        path20.join(options.projectRoot, "shared", "generated", "ui-contract.ts")
+        path21.join(options.projectRoot, "shared", "generated", "ui-contract.ts")
       )
     ),
     setupProfileId: effectiveSetup.setupProfileId,
@@ -23375,10 +23598,10 @@ async function runReducerNativeScenarios(options) {
     loadGeneratedBaseStates(options.projectRoot),
     loadManifest(options.projectRoot),
     importTypeScriptModule(
-      path20.join(options.projectRoot, "app", "game.ts")
+      path21.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path20.join(options.projectRoot, "shared", "manifest-contract.ts")
+      path21.join(options.projectRoot, "shared", "manifest-contract.ts")
     )
   ]);
   let generatedBaseStates = initialGeneratedBaseStates;
@@ -23596,11 +23819,7 @@ async function runReducerNativeScenarios(options) {
         results.push({
           id: scenario.definition.id,
           success: false,
-          error: error instanceof Error ? formatScenarioErrorForDisplay({
-            error,
-            projectRoot: options.projectRoot,
-            scenarioFilePath: scenario.filePath
-          }) : `Scenario '${scenario.definition.id}' failed.`
+          error: error instanceof Error ? error.message : `Scenario '${scenario.definition.id}' failed.`
         });
       }
     }
@@ -23616,8 +23835,8 @@ async function runReducerNativeScenarios(options) {
 }
 
 // src/services/project/reducer-contract-preflight.ts
-import path21 from "path";
-var GAME_CONTRACT_ENTRY_PATH = path21.join("app", "game-contract.ts");
+import path22 from "path";
+var GAME_CONTRACT_ENTRY_PATH = path22.join("app", "game-contract.ts");
 function normalizeErrorMessage(error) {
   const rawMessage = error instanceof Error ? error.message : String(error ?? "Unknown error");
   return rawMessage.split("\n").map((line) => line.trim()).find(Boolean)?.replace(/^Error:\s*/u, "") ?? "Unknown error";
@@ -23626,7 +23845,7 @@ function isManifestScopedIdBrandingError(message) {
   return message.includes("defineGameContract:") && message.includes("manifest-scoped") && (message.includes("uses a raw z.string()") || message.includes("uses z.array(z.string())"));
 }
 async function assertReducerContractPreflight(projectRoot) {
-  const entryPath = path21.join(projectRoot, GAME_CONTRACT_ENTRY_PATH);
+  const entryPath = path22.join(projectRoot, GAME_CONTRACT_ENTRY_PATH);
   try {
     await importTypeScriptModule(entryPath);
   } catch (error) {
@@ -23652,8 +23871,8 @@ async function assertReducerContractPreflight(projectRoot) {
 }
 
 // src/services/project/reducer-bundle-preflight.ts
-import path22 from "path";
-var REDUCER_BUNDLE_ENTRY_PATH = path22.join("app", "index.ts");
+import path23 from "path";
+var REDUCER_BUNDLE_ENTRY_PATH = path23.join("app", "index.ts");
 var PREFLIGHT_RNG_SEED = 1337;
 function buildPlayerIds(playerCount) {
   const ids = [];
@@ -23841,7 +24060,7 @@ async function runReducerBundleSmoke(options) {
   if (scenarios.length === 0) {
     return [];
   }
-  const entryPath = path22.join(projectRoot, REDUCER_BUNDLE_ENTRY_PATH);
+  const entryPath = path23.join(projectRoot, REDUCER_BUNDLE_ENTRY_PATH);
   let module;
   try {
     module = await importTypeScriptModule(
@@ -23893,6 +24112,64 @@ async function runLoggedStep(message, task) {
   consola.start(message);
   return task();
 }
+function clearPreflightOutput() {
+  if (!process.stdout.isTTY || process.env.CI) return;
+  console.clear();
+}
+function formatDevReadyOutput(options) {
+  const lines = ["Dreamboard dev", "", `Local:   ${options.url}`];
+  for (const networkUrl of options.networkUrls) {
+    lines.push(`Network: ${networkUrl}`);
+  }
+  if (options.networkUrls.length > 0) {
+    lines.push("Access:  LAN only; use trusted networks.");
+  }
+  for (const allowedHost of options.allowedHosts) {
+    lines.push(`Allowed: ${allowedHost}`);
+  }
+  lines.push(
+    `Session: ${options.shortCode} (${options.sessionId}, ${options.sessionStatus})`,
+    `Seed:    ${options.seed}`
+  );
+  if (options.setupProfile) {
+    const label = options.setupProfile.name ? `${options.setupProfile.name} (${options.setupProfile.id})` : options.setupProfile.id;
+    lines.push(`Setup:   ${label}`);
+  }
+  if (options.scenarioId) {
+    lines.push(`Scenario: ${options.scenarioId}`);
+  }
+  if (options.materialization) {
+    lines.push(
+      `Snapshot: ${options.materialization.totalMs}ms total (${options.materialization.reducerHarnessMs}ms reducer, ${options.materialization.backendHydrateMs}ms backend)`
+    );
+  }
+  lines.push(
+    `Backend: ${options.apiBaseUrl}`,
+    "",
+    "UI edits hot-reload. Rule, manifest, and app changes need restart.",
+    `Debug logs: ${options.debug ? "on" : "off (--debug)"}`,
+    ""
+  );
+  return lines.join("\n");
+}
+function parseDevHost(value) {
+  if (value === void 0 || value === false) return void 0;
+  if (value === true) return true;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : true;
+}
+function parseAllowedHosts(value) {
+  if (!value) return [];
+  return value.split(",").map((host) => normalizeAllowedHost(host)).filter((host) => Boolean(host));
+}
+function normalizeAllowedHost(value) {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (trimmed.includes("://")) {
+    return new URL(trimmed).hostname;
+  }
+  return trimmed.split("/")[0]?.replace(/:\d+$/, "") || null;
+}
 var dev_default = defineCommand({
   meta: {
     name: "dev",
@@ -23940,7 +24217,17 @@ var dev_default = defineCommand({
     },
     port: {
       type: "string",
-      description: "Preferred local Vite port (defaults to 5173)"
+      description: "Preferred local Vite port (defaults to 5352)"
+    },
+    host: {
+      type: "string",
+      description: "Expose the local dev host on the network. Pass without a value to bind all interfaces, or provide an address.",
+      valueHint: "address"
+    },
+    "allowed-host": {
+      type: "string",
+      description: "Additional Host header to allow, for example a Cloudflare Tunnel hostname.",
+      valueHint: "hostname"
     },
     ...CONFIG_FLAG_ARGS
   },
@@ -23958,9 +24245,9 @@ var dev_default = defineCommand({
       env: parsedArgs.env ?? "dev",
       debug: parsedArgs.debug
     });
-    const devDir = path23.join(projectRoot, PROJECT_DIR_NAME, "dev");
+    const devDir = path24.join(projectRoot, PROJECT_DIR_NAME, "dev");
     await ensureDir(devDir);
-    const sessionFilePath = path23.join(devDir, "session.json");
+    const sessionFilePath = path24.join(devDir, "session.json");
     const requestedResumeSessionId = parsedArgs.resume?.trim() || null;
     const requestedScenarioId = parsedArgs["from-scenario"]?.trim() || null;
     if (requestedResumeSessionId && parsedArgs["new-session"]) {
@@ -24043,10 +24330,13 @@ var dev_default = defineCommand({
     if (preferredPort !== void 0 && (!Number.isFinite(preferredPort) || preferredPort <= 0)) {
       throw new Error("Invalid --port value. Expected a positive integer.");
     }
+    const allowedHosts = parseAllowedHosts(parsedArgs["allowed-host"]);
     const devServer = await startDreamboardDevServer({
       projectRoot,
       sessionFilePath,
       port: preferredPort,
+      host: parseDevHost(parsedArgs.host),
+      allowedHosts,
       config,
       runtimeConfig: {
         apiBaseUrl: config.apiBaseUrl,
@@ -24066,42 +24356,26 @@ var dev_default = defineCommand({
         }
       }
     });
-    consola.success(`Dreamboard dev host ready at ${devServer.url}`);
-    consola.info(
-      scenarioSeededSession ? `Seeded session ${runSession.shortCode} (${runSession.sessionId}) from scenario ${requestedScenarioId}.` : resumedExistingSession ? `Reusing session ${runSession.shortCode} (${runSession.sessionId}).` : `Created session ${runSession.shortCode} (${runSession.sessionId}).`
-    );
-    if (requestedScenarioId && scenarioSeededSession) {
-      const materialization = runSession.materialization;
-      if (materialization) {
-        consola.info(
-          `Scenario materialization: mode=${materialization.mode} totalMs=${materialization.totalMs} reducerHarnessMs=${materialization.reducerHarnessMs} backendHydrateMs=${materialization.backendHydrateMs}`
-        );
-      }
-    }
-    consola.info(`Backend session id: ${runSession.sessionId}`);
-    consola.info(
-      `RNG seed: ${runSession.seed ?? "unknown"}${parsedArgs.seed ? " (from --seed)." : " (default 1337; change it in the dev host or pass --seed)."}`
-    );
-    if (selectedSetupProfile?.source === "implicit-single") {
-      consola.info(
-        `Using setup profile ${selectedSetupProfileId} (${selectedSetupProfile.name ?? selectedSetupProfileId}) because it is the only declared manifest profile.`
-      );
-    }
-    if (selectedSetupProfile?.source === "implicit-first") {
-      consola.info(
-        `Using setup profile ${selectedSetupProfileId} (${selectedSetupProfile.name ?? selectedSetupProfileId}) because it is the first declared manifest profile.`
-      );
-    }
-    consola.info(
-      parsedArgs.debug ? "Verbose dev logging enabled via --debug." : "Verbose browser and SSE logging is off by default. Pass --debug to enable it."
-    );
-    consola.info(
-      "UI edits will hot-reload in the iframe. Rule, manifest, and app changes require rerunning `dreamboard dev`."
+    clearPreflightOutput();
+    console.log(
+      formatDevReadyOutput({
+        url: devServer.url,
+        networkUrls: devServer.networkUrls,
+        allowedHosts,
+        apiBaseUrl: config.apiBaseUrl,
+        sessionStatus: scenarioSeededSession ? "seeded" : resumedExistingSession ? "reused" : "created",
+        shortCode: runSession.shortCode,
+        sessionId: runSession.sessionId,
+        seed: runSession.seed ?? "unknown",
+        debug: parsedArgs.debug,
+        scenarioId: scenarioSeededSession ? requestedScenarioId : null,
+        materialization: runSession.materialization,
+        setupProfile: selectedSetupProfileId ? {
+          id: selectedSetupProfileId,
+          name: selectedSetupProfile?.name
+        } : null
+      })
     );
-    console.log(`
-Open Dreamboard dev host:
-${devServer.url}
-`);
     if (parsedArgs.open) {
       openBrowser(devServer.url);
     }
@@ -24308,7 +24582,7 @@ async function resolveBackendVersionMetadata() {
 }
 async function readWorkspacePackageJson(projectRoot) {
   try {
-    const raw = await readTextFile(path23.join(projectRoot, "package.json"));
+    const raw = await readTextFile(path24.join(projectRoot, "package.json"));
     const parsed = JSON.parse(raw);
     return {
       dependencies: Object.fromEntries(
@@ -24446,7 +24720,7 @@ function extractUserIdFromJwt(token) {
 }
 
 // src/commands/join.ts
-import path24 from "path";
+import path25 from "path";
 
 // src/services/join/jsonl-bot-session.ts
 import { createInterface as createInterface2 } from "readline";
@@ -24454,6 +24728,7 @@ var JsonlWriter = class {
   constructor(output) {
     this.output = output;
   }
+  output;
   writeChain = Promise.resolve();
   write(envelope) {
     this.writeChain = this.writeChain.then(
@@ -24704,6 +24979,7 @@ var JoinBotState = class {
   constructor(playerId) {
     this.playerId = playerId;
   }
+  playerId;
   hasBootstrap = false;
   latestGameplay;
   latestActions;
@@ -25366,7 +25642,7 @@ async function resolveDefaultSessionId(projectRoot) {
       "No session id provided and this directory is not a Dreamboard project. Pass --session or run from a workspace with .dreamboard/dev/session.json."
     );
   }
-  const sessionFilePath = path24.join(
+  const sessionFilePath = path25.join(
     projectRoot,
     PROJECT_DIR_NAME,
     "dev",
@@ -25478,7 +25754,7 @@ var logout_default = defineCommand({
 });
 
 // src/commands/new.ts
-import path25 from "path";
+import path26 from "path";
 var new_default = defineCommand({
   meta: {
     name: "new",
@@ -25599,7 +25875,7 @@ var new_default = defineCommand({
         ruleId
       );
       consola.start("Scaffolding local workspace...");
-      const targetDir = path25.resolve(process.cwd(), normalizedSlug);
+      const targetDir = path26.resolve(process.cwd(), normalizedSlug);
       await ensureDir(targetDir);
       await writeManifest(targetDir, blankManifest);
       await writeRule(targetDir, "");
@@ -25631,7 +25907,6 @@ var new_default = defineCommand({
         )
       );
       await writeSnapshot(targetDir);
-      await writeTextFile(path25.join(targetDir, "feedback.md"), "");
       consola.success(`Created new game in ${targetDir}`);
       consola.info(
         "Next: edit your files, then run 'dreamboard sync' followed by 'dreamboard compile'."
@@ -25956,9 +26231,9 @@ function buildSourceChanges(options) {
   if (mode === "replace") {
     return Object.entries(localFiles).filter(
       ([filePath]) => isSourceRevisionPath(filePath) || shouldAlwaysUpsertSourcePath(filePath)
-    ).sort(([left], [right]) => left.localeCompare(right)).map(([path26, content]) => ({
+    ).sort(([left], [right]) => left.localeCompare(right)).map(([path28, content]) => ({
       kind: "upsert",
-      path: path26,
+      path: path28,
       content
     }));
   }
@@ -26510,6 +26785,10 @@ var sync_default = defineCommand({
   }
 });
 
+// src/commands/test.ts
+import { readFile as readFile4 } from "fs/promises";
+import path27 from "path";
+
 // src/services/testing/runtime-mode.ts
 function isRemoteTestEnvironment(environment) {
   return environment === "dev" || environment === "prod";
@@ -26559,6 +26838,40 @@ async function resolveLatestCompiledResult(projectRoot, projectConfig) {
 var REDUCER_NATIVE_TEST_WORKSPACE_ERROR = "dreamboard test now requires a reducer-native workspace with app/game.ts, shared/generated/ui-contract.ts, test/bases/*.base.ts, and test/scenarios/*.scenario.ts. Legacy test/base-scenarios.json workspaces are no longer supported.";
 var NO_REDUCER_NATIVE_BASES_FOUND_ERROR = "No bases found under test/bases/*.base.ts";
 var NO_REDUCER_NATIVE_SCENARIOS_FOUND_ERROR = "No scenarios found under test/scenarios/*.scenario.ts";
+function isPreviewProjectionEndpointUnavailable(error) {
+  if (!isDreamboardApiError(error) || error.status !== 404) {
+    return false;
+  }
+  const endpoint = error.problem.instance ?? error.problem.context?.endpoint;
+  const message = error.problem.detail ?? error.problem.title;
+  return endpoint?.includes("/preview/initial-projection") === true && message?.toLowerCase() === "not found";
+}
+async function uploadGeneratedPreviewProjection(options) {
+  const previewBase = options.bases.find((base) => base.definition.id === "initial-turn") ?? options.bases[0];
+  if (!previewBase) {
+    return;
+  }
+  const projectionPath = path27.join(
+    options.projectRoot,
+    "test",
+    "generated",
+    "bases",
+    previewBase.definition.id,
+    "player-1.projection.json"
+  );
+  const projectionJson = await readFile4(projectionPath, "utf8");
+  try {
+    await uploadInitialProjectionSdk(options.gameId, projectionJson);
+  } catch (error) {
+    if (isPreviewProjectionEndpointUnavailable(error)) {
+      consola.warn(
+        "Skipping preview projection upload because the selected backend does not expose the preview projection endpoint."
+      );
+      return;
+    }
+    throw error;
+  }
+}
 function resolveRequestedRunner(value) {
   if (value == null || value === "") {
     return void 0;
@@ -26617,7 +26930,7 @@ var generateCommand = defineCommand({
   async run({ args }) {
     const parsedFlags = parseConfigFlags(args);
     const useRemoteRuntime = shouldUseRemoteTestRuntime(parsedFlags.env);
-    const { projectRoot, projectConfig } = await resolveProjectContext(
+    const { projectRoot, projectConfig, config } = await resolveProjectContext(
       parsedFlags,
       { requireAuth: useRemoteRuntime }
     );
@@ -26640,6 +26953,18 @@ var generateCommand = defineCommand({
     if (scenarios.length === 0) {
       throw new Error(NO_REDUCER_NATIVE_SCENARIOS_FOUND_ERROR);
     }
+    if (config.authToken) {
+      await configureClient(config);
+      await uploadGeneratedPreviewProjection({
+        projectRoot,
+        gameId: runtimeIdentity.gameId,
+        bases
+      });
+    } else {
+      consola.info(
+        "Skipping preview projection upload because this CLI invocation is not authenticated."
+      );
+    }
     consola.success(
       `Generated ${bases.length} base state(s) for ${scenarios.length} scenario(s).`
     );
@@ -26786,7 +27111,7 @@ function runDreamboardCli(internalSubCommands = {}) {
   const main = defineCommand({
     meta: {
       name: "dreamboard",
-      version: "0.1.7",
+      version: "0.1.22",
       description: "Dreamboard CLI \u2014 game development platform"
     },
     subCommands
@@ -26823,6 +27148,7 @@ export {
   getProjectLocalMaintainerRegistry,
   applyWorkspaceCodegen,
   reconcileWorkspaceDependencies,
+  assertCompilerPortableDependencies,
   runLocalTypecheck,
   compile_default,
   startCliAuthServer,
@@ -26841,4 +27167,4 @@ export {
   test_default,
   runDreamboardCli
 };
-//# sourceMappingURL=chunk-MOVHYB6E.js.map
+//# sourceMappingURL=chunk-AQ5UUNJS.js.map