dreamboard 0.1.25 → 0.1.26

package/dist/{chunk-MG6EVR7P.js → chunk-VRJ4FOH2.js}

@@ -32,7 +32,7 @@ import {
 } from "./chunk-4S67A2YA.js";
 import {
   createClient
-} from "./chunk-H3O43F5P.js";
+} from "./chunk-3JGO32FA.js";
 import {
   CLIENT_PROBLEM_TYPES,
   SERVER_PROBLEM_TYPES,
@@ -72,7 +72,7 @@ import {
   validatePlayerAction,
   zGameTopologyManifest,
   zProblemDetails
-} from "./chunk-2RCUHMGL.js";
+} from "./chunk-YI5DUODD.js";
 import {
   __export
 } from "./chunk-D4HDZEJT.js";
@@ -1660,6 +1660,7 @@ function normalizeProjectConfig(config) {
   return {
     gameId: config.gameId,
     slug: config.slug,
+    environment: config.environment,
     authoring: config.authoring,
     compile: config.compile,
     localMaintainerRegistry: config.localMaintainerRegistry,
@@ -1859,6 +1860,191 @@ function getAccessTokenExpiry(accessToken) {
   }
 }
 
+// src/auth/local-dev-session.ts
+var DEFAULT_DEV_EMAIL = "test@test.com";
+var DEFAULT_DEV_PASSWORD = "dreamboard-local-dev-password";
+var DEFAULT_LOCAL_SERVICE_ROLE_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZS1kZW1vIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImV4cCI6MTk4MzgxMjk5Nn0.EGIM96RAZx35lJzdJsyH-qQwv8Hdp7fsn3W0YpN81IU";
+async function repairLocalDevSession() {
+  const localConfig = ENVIRONMENT_CONFIGS.local;
+  if (!localConfig?.supabaseUrl || !localConfig.supabaseAnonKey) {
+    return null;
+  }
+  if (!isLocalSupabaseUrl(localConfig.supabaseUrl)) {
+    return null;
+  }
+  const email = valueOrUndefined(process.env.DREAMBOARD_DEV_EMAIL) ?? DEFAULT_DEV_EMAIL;
+  const password = valueOrUndefined(process.env.DREAMBOARD_DEV_PASSWORD) ?? DEFAULT_DEV_PASSWORD;
+  const serviceRoleKey = valueOrUndefined(process.env.SUPABASE_SERVICE_ROLE_KEY) ?? valueOrUndefined(process.env.DREAMBOARD_LOCAL_SUPABASE_SERVICE_ROLE_KEY) ?? DEFAULT_LOCAL_SERVICE_ROLE_KEY;
+  const authBaseUrl = `${localConfig.supabaseUrl.replace(/\/$/, "")}/auth/v1`;
+  const authHeaders = {
+    apikey: localConfig.supabaseAnonKey,
+    "Content-Type": "application/json"
+  };
+  const adminHeaders = {
+    apikey: serviceRoleKey,
+    Authorization: `Bearer ${serviceRoleKey}`,
+    "Content-Type": "application/json"
+  };
+  let session = await signIn({
+    authBaseUrl,
+    headers: authHeaders,
+    email,
+    password
+  });
+  if (!session) {
+    await ensureLocalUser({
+      authBaseUrl,
+      headers: adminHeaders,
+      email,
+      password
+    });
+    session = await signIn({
+      authBaseUrl,
+      headers: authHeaders,
+      email,
+      password
+    });
+  }
+  if (!session?.access_token || !session.refresh_token) {
+    return null;
+  }
+  const credentials = {
+    accessToken: session.access_token,
+    refreshToken: session.refresh_token
+  };
+  await setCredentials(credentials);
+  const globalConfig = await loadGlobalConfig();
+  await saveGlobalConfig({
+    ...globalConfig,
+    environment: "local"
+  });
+  return credentials;
+}
+function shouldRepairLocalDevSession(options) {
+  const localConfig = ENVIRONMENT_CONFIGS.local;
+  if (!localConfig) {
+    return false;
+  }
+  return Boolean(options.supabaseUrl && isLocalSupabaseUrl(options.supabaseUrl)) && options.apiBaseUrl === localConfig.apiBaseUrl;
+}
+async function signIn(options) {
+  const response = await postAuth(options, "/token?grant_type=password", {
+    email: options.email,
+    password: options.password
+  });
+  return response.ok ? response.data : null;
+}
+async function ensureLocalUser(options) {
+  const existing = await findAdminUserByEmail(options);
+  if (existing?.id) {
+    await updateAdminUser(options, existing.id);
+    return;
+  }
+  const created = await adminFetch(options, "/admin/users", {
+    method: "POST",
+    body: JSON.stringify({
+      email: options.email,
+      password: options.password,
+      email_confirm: true,
+      user_metadata: {
+        display_name: "Dreamboard Local Dev"
+      }
+    })
+  });
+  if (created.ok) {
+    return;
+  }
+  const retried = await findAdminUserByEmail(options);
+  if (retried?.id) {
+    await updateAdminUser(options, retried.id);
+    return;
+  }
+  throw new Error(
+    `Failed to create local Supabase user ${options.email} (${created.status}): ${JSON.stringify(
+      created.data
+    )}`
+  );
+}
+async function updateAdminUser(options, userId) {
+  const updated = await adminFetch(
+    options,
+    `/admin/users/${encodeURIComponent(userId)}`,
+    {
+      method: "PUT",
+      body: JSON.stringify({
+        password: options.password,
+        email_confirm: true,
+        user_metadata: {
+          display_name: "Dreamboard Local Dev"
+        }
+      })
+    }
+  );
+  if (!updated.ok) {
+    throw new Error(
+      `Failed to update local Supabase user ${options.email} (${updated.status}): ${JSON.stringify(
+        updated.data
+      )}`
+    );
+  }
+}
+async function findAdminUserByEmail(options) {
+  const response = await adminFetch(
+    options,
+    "/admin/users?page=1&per_page=200",
+    {
+      method: "GET"
+    }
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Failed to list local Supabase users (${response.status}): ${JSON.stringify(
+        response.data
+      )}`
+    );
+  }
+  const users = response.data?.users ?? [];
+  return users.find(
+    (user) => user.email?.toLowerCase() === options.email.toLowerCase()
+  ) ?? null;
+}
+async function postAuth(options, path29, body) {
+  const response = await fetch(`${options.authBaseUrl}${path29}`, {
+    method: "POST",
+    headers: options.headers,
+    body: JSON.stringify(body)
+  });
+  return {
+    ok: response.ok,
+    status: response.status,
+    data: await readJson(response)
+  };
+}
+async function adminFetch(options, path29, init2) {
+  const response = await fetch(`${options.authBaseUrl}${path29}`, {
+    ...init2,
+    headers: options.headers
+  });
+  return {
+    ok: response.ok,
+    status: response.status,
+    data: await readJson(response)
+  };
+}
+async function readJson(response) {
+  const text = await response.text();
+  if (text.trim().length === 0) return null;
+  return JSON.parse(text);
+}
+function isLocalSupabaseUrl(rawUrl) {
+  const url = new URL(rawUrl);
+  return url.hostname === "127.0.0.1" || url.hostname === "localhost";
+}
+function valueOrUndefined(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+
 // src/config/resolve.ts
 var LOGIN_HINT = "Run `dreamboard login` to authenticate again.";
 function resolveConfig(globalConfig, flags, project, credentials) {
@@ -1866,14 +2052,15 @@ function resolveConfig(globalConfig, flags, project, credentials) {
     assertPublicRuntimeFlags(flags);
   }
   const envEnvironment = IS_PUBLISHED_BUILD ? void 0 : environmentFromProcess();
-  const environment = IS_PUBLISHED_BUILD ? PUBLISHED_ENVIRONMENT : flags.env || envEnvironment || globalConfig.environment || "dev";
+  const projectEnvironment = IS_PUBLISHED_BUILD ? void 0 : project?.environment;
+  const environment = IS_PUBLISHED_BUILD ? PUBLISHED_ENVIRONMENT : flags.env || envEnvironment || projectEnvironment || globalConfig.environment || "dev";
   const envConfig = ENVIRONMENT_CONFIGS[environment];
   const publishedEnvConfig = ENVIRONMENT_CONFIGS[PUBLISHED_ENVIRONMENT];
-  const hasExplicitEnvironmentOverride = !IS_PUBLISHED_BUILD && Boolean(flags.env || envEnvironment);
+  const hasExplicitEnvironmentOverride = !IS_PUBLISHED_BUILD && Boolean(flags.env || envEnvironment || projectEnvironment);
   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 apiBaseUrl = valueOrUndefined2(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;
-  const webBaseUrl = valueOrUndefined(process.env.DREAMBOARD_WEB_BASE_URL) ?? resolvedWebBaseUrl;
+  const webBaseUrl = valueOrUndefined2(process.env.DREAMBOARD_WEB_BASE_URL) ?? resolvedWebBaseUrl;
   const supabaseUrl = envConfig?.supabaseUrl;
   const supabaseAnonKey = envConfig?.supabaseAnonKey;
   const snapshot = buildCredentialSnapshot(flags, credentials);
@@ -1889,10 +2076,10 @@ function resolveConfig(globalConfig, flags, project, credentials) {
   };
 }
 function buildCredentialSnapshot(flags, storedCredentials) {
-  const flagToken = valueOrUndefined(flags.token);
-  const agentEnvToken = valueOrUndefined(process.env.DREAMBOARD_AGENT_TOKEN);
-  const envToken = valueOrUndefined(process.env.DREAMBOARD_TOKEN);
-  const envRefreshToken = valueOrUndefined(
+  const flagToken = valueOrUndefined2(flags.token);
+  const agentEnvToken = valueOrUndefined2(process.env.DREAMBOARD_AGENT_TOKEN);
+  const envToken = valueOrUndefined2(process.env.DREAMBOARD_TOKEN);
+  const envRefreshToken = valueOrUndefined2(
     process.env.DREAMBOARD_REFRESH_TOKEN
   );
   if (IS_PUBLISHED_BUILD) {
@@ -1924,7 +2111,7 @@ function buildCredentialSnapshot(flags, storedCredentials) {
   };
 }
 function environmentFromProcess() {
-  const value = valueOrUndefined(process.env.DREAMBOARD_ENV);
+  const value = valueOrUndefined2(process.env.DREAMBOARD_ENV);
   if (!value) return void 0;
   if (value === "local" || value === "dev" || value === "prod") {
     return value;
@@ -1940,7 +2127,7 @@ function assertPublicRuntimeFlags(flags) {
       "The published Dreamboard CLI is production-only and does not accept `--env`."
     );
   }
-  if (valueOrUndefined(flags.token) || argv2.includes("--token")) {
+  if (valueOrUndefined2(flags.token) || argv2.includes("--token")) {
     throw new Error(
       "Direct JWT injection is not supported in the published Dreamboard CLI. Use `dreamboard login` so the CLI can store and refresh your session."
     );
@@ -1981,6 +2168,12 @@ async function ensureEffectiveAccessToken(config) {
         const expiry = getAccessTokenExpiry(config.authToken);
         const isExpired = expiry !== null && expiry.getTime() <= Date.now();
         if (isExpired) {
+          if (shouldRepairLocalDevSession(config)) {
+            const repaired = await repairLocalDevSession();
+            if (repaired) {
+              return repaired.accessToken;
+            }
+          }
           throw new Error(
             `Access token refresh failed: ${result.message}. ${LOGIN_HINT}`
           );
@@ -1993,6 +2186,12 @@ async function ensureEffectiveAccessToken(config) {
     }
   } catch (error) {
     if (error instanceof PermanentRefreshError) {
+      if (shouldRepairLocalDevSession(config)) {
+        const repaired = await repairLocalDevSession();
+        if (repaired) {
+          return repaired.accessToken;
+        }
+      }
       throw new Error(formatStoredSessionInvalidMessage(error.message));
     }
     throw error;
@@ -2029,7 +2228,7 @@ function requireAuth(config) {
     );
   }
 }
-function valueOrUndefined(value) {
+function valueOrUndefined2(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
 function isInvalidRefreshTokenMessage(message) {
@@ -2122,7 +2321,8 @@ var joinCommandArgsSchema = configFlagsSchema.extend({
 });
 var loginCommandArgsSchema = configFlagsSchema;
 var configCommandArgsSchema = configFlagsSchema.extend({
-  action: external_exports.string().optional().default("show")
+  action: external_exports.string().optional().default("show"),
+  scope: external_exports.enum(["global", "workspace"]).optional().default("global")
 });
 var authCommandArgsSchema = external_exports.object({
   action: external_exports.enum(["set", "clear", "login", "env", "status"]),
@@ -8724,7 +8924,7 @@ function validateSlotHostsAndHomes(manifest) {
     }
     slotIdsByHostKey.set(`die:${seed.id}`, new Set(slotIds));
   }
-  const validateHome = (home, path28) => {
+  const validateHome = (home, path29) => {
     if (home?.type !== "slot") {
       return;
     }
@@ -8732,13 +8932,13 @@ function validateSlotHostsAndHomes(manifest) {
     const slotIds = slotIdsByHostKey.get(hostKey);
     if (!slotIds) {
       issues.push(
-        `${path28}.host: Unknown strict slot host '${home.host.kind}:${home.host.id}'. Hosts must be singleton piece/die seeds whose type declares slots.`
+        `${path29}.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(
-        `${path28}.slotId: Unknown slot '${home.slotId}' for host '${home.host.kind}:${home.host.id}'.`
+        `${path29}.slotId: Unknown slot '${home.slotId}' for host '${home.host.kind}:${home.host.id}'.`
       );
     }
   };
@@ -8804,20 +9004,20 @@ function validatePlayerScopedSeedHomes(manifest) {
   const zoneScopeById = new Map(
     (manifest.zones ?? []).map((zone) => [zone.id, zone.scope])
   );
-  const validateSeedHome = (seed, path28, label) => {
+  const validateSeedHome = (seed, path29, label) => {
     const authoredId = seed.id ?? seed.typeId;
     if (seed.ownerId) {
       return;
     }
     if (homeTargetsBoard(seed.home) && boardScopeById.get(seed.home.boardId) === "perPlayer") {
       issues.push(
-        `${path28}.boardId: ${label} '${authoredId}' requires ownerId because board '${seed.home.boardId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
+        `${path29}.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(
-        `${path28}.zoneId: ${label} '${authoredId}' requires ownerId because zone '${seed.home.zoneId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
+        `${path29}.zoneId: ${label} '${authoredId}' requires ownerId because zone '${seed.home.zoneId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
       );
     }
   };
@@ -9265,7 +9465,11 @@ var WORKSPACE_CODEGEN_OWNERSHIP = {
       "app/game.ts",
       "app/setup-profiles.ts",
       "app/reducer-support.ts",
-      "app/derived.ts"
+      "app/derived.ts",
+      "ui/interaction-routes.tsx",
+      "ui/setup-screen.tsx",
+      "ui/styles.ts",
+      "ui/ui-contract-typing-smoke.tsx"
     ],
     seedFilePatterns: [{ prefix: "app/phases/", suffix: ".ts" }]
   },
@@ -9293,30 +9497,30 @@ function normalizeProjectPath(filePath) {
   return filePath.replace(/^\.\//, "").replace(/^\/+/, "").replace(/\\/g, "/");
 }
 function isAllowedGamePath(filePath) {
-  const path28 = normalizeProjectPath(filePath);
-  if (WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.rootFiles.includes(path28)) {
+  const path29 = normalizeProjectPath(filePath);
+  if (WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.rootFiles.includes(path29)) {
     return true;
   }
   return WORKSPACE_CODEGEN_OWNERSHIP.allowedPaths.directoryPrefixes.some(
-    (prefix) => path28.startsWith(prefix)
+    (prefix) => path29.startsWith(prefix)
   );
 }
 function isAuthoritativeGeneratedPath(filePath) {
-  const path28 = normalizeProjectPath(filePath);
-  return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.generatedFiles.includes(path28);
+  const path29 = normalizeProjectPath(filePath);
+  return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.generatedFiles.includes(path29);
 }
 function isDynamicSeedPath(filePath) {
-  const path28 = normalizeProjectPath(filePath);
-  if (WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFiles.includes(path28)) {
+  const path29 = normalizeProjectPath(filePath);
+  if (WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFiles.includes(path29)) {
     return true;
   }
   return WORKSPACE_CODEGEN_OWNERSHIP.dynamic.seedFilePatterns.some(
-    (pattern) => path28.startsWith(pattern.prefix) && path28.endsWith(pattern.suffix)
+    (pattern) => path29.startsWith(pattern.prefix) && path29.endsWith(pattern.suffix)
   );
 }
 function isLibraryPath(filePath) {
-  const path28 = normalizeProjectPath(filePath);
-  return isAuthoritativeGeneratedPath(path28);
+  const path29 = normalizeProjectPath(filePath);
+  return isAuthoritativeGeneratedPath(path29);
 }
 
 // ../../packages/workspace-codegen/src/seeds.ts
@@ -9332,9 +9536,11 @@ import {
   createClientParamSchemasByPhase,
 } from "@dreamboard/app-sdk/reducer";
 import type {
-	  ClientParamsOfInteractionOfDefinition,
-	  DefaultedClientParamKeysOfInteractionOfDefinition,
-	  InteractionIdOfDefinition,
+  CardInputZoneIdsOfDefinition,
+  ClientParamsOfInteractionOfDefinition,
+  DefaultedClientParamKeysOfInteractionOfDefinition,
+  InputKeysWithCollectorKindOfDefinition,
+  InteractionIdOfDefinition,
   InteractionIdOfDefinitionPhase,
   PhaseNamesOfDefinition,
   StageNamesOfDefinitionPhase,
@@ -9342,42 +9548,47 @@ import type {
   ViewOfDefinition,
 } from "@dreamboard/app-sdk/reducer";
 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,
-	  type InteractionSwitchRenderState,
-	  type DreamboardUI,
-	  type ResourceCounterComponents,
-	  type ResourceDisplayConfig,
-	  type TypedGame,
-	  type UIContract,
-	  type UIRootProps,
-	  type ZoneCardAtProps,
-	  type ZoneCardRenderItem,
-	  type ZoneListProps,
-	  type ZonePileCardsProps,
-	} from "@dreamboard/ui-sdk";
-	import { createElement, type ReactElement, type ReactNode } from "react";
-	import {
-	  literals,
-	  staticBoards,
-	  type CardId,
-	  type CardProperties,
-	  type CardType,
-	  type EdgeId,
+  type BoardSpaceIdOf,
+  type InteractionDescriptor,
+} from "@dreamboard/ui-sdk";
+import {
+  createWorkspaceUIContract,
+  type BoardHexGridProps as BoardHexGridPropsGeneric,
+  type BoardHexViewProps as BoardHexViewPropsGeneric,
+  type BoardSpaceTargetProps as BoardSpaceTargetPropsGeneric,
+  type ClientParamSchemaMap,
+  type DreamboardUI,
+  type ResourceCounterComponents,
+  type TypedGame,
+  type UIContract,
+  type UIRootProps,
+  type WorkspaceBoardSurface,
+  type WorkspaceBoardTargetInputSlot,
+  type WorkspaceCardCollectionSurface,
+  type WorkspaceCardInputSlot,
+  type WorkspaceFormInputSlot,
+  type WorkspaceHandSurface,
+  type WorkspaceInteractionSlotComponent,
+  type WorkspacePileSurface,
+  type ZoneCardRenderItem,
+  type ZoneListProps,
+} from "@dreamboard/ui-sdk/workspace-contract";
+import { type ButtonHTMLAttributes, type ReactElement, type ReactNode } from "react";
+import {
+  boardHelpers,
+  literals,
+  staticBoards,
+  type BoardBaseId,
+  type CardId,
+  type CardProperties,
+  type CardType,
+  type EdgeId,
   type PlayerId,
   type ResourceId,
   type SpaceId,
+  type TiledBoardId,
+  type TiledEdgeState,
+  type TiledVertexState,
   type VertexId,
   type ZoneId as ManifestZoneId,
 } from "../manifest-contract";
@@ -9466,6 +9677,14 @@ type PlayerCardZoneId = {
     : Z;
 }[(typeof literals.playerZoneIds)[number]];
 
+type SharedCardZoneId = {
+  [Z in (typeof literals.sharedZoneIds)[number]]: (typeof literals.cardSetIdsBySharedZoneId)[Z] extends readonly []
+    ? never
+    : Z;
+}[(typeof literals.sharedZoneIds)[number]];
+
+type CardZoneId = PlayerCardZoneId | SharedCardZoneId;
+
 /** JS-friendly keys for per-player zones that can contain cards. */
 export type WorkspacePlayerCardZoneKey = CamelCase<PlayerCardZoneId>;
 
@@ -9473,6 +9692,11 @@ export type WorkspacePlayerCardZoneKey = CamelCase<PlayerCardZoneId>;
 export type InteractionDescriptorFor<Key extends InteractionKey> =
   InteractionDescriptor<Key>;
 
+export type InteractionItem<Key extends InteractionKey> = {
+  readonly interaction: Key;
+  readonly descriptor: InteractionDescriptorFor<Key>;
+};
+
 /**
  * Params shape for a phase-qualified interaction key. Drives strong typing
  * for component-first interaction state, forms, and submits.
@@ -9488,60 +9712,528 @@ type InteractionParamsShape<Key extends InteractionKey> =
     ? InteractionParamsOf<Key>
     : Record<string, unknown>;
 
+type InteractionCollectorKind =
+  | "form"
+  | "board-vertex"
+  | "board-edge"
+  | "board-tile"
+  | "board-space"
+  | "card"
+  | "prompt";
+
+type AuthoredInteractionInputKeysOf<Key extends InteractionKey> =
+  InputKeysWithCollectorKindOfDefinition<
+    GameDefinition,
+    PhaseOfInteractionKey<Key>,
+    IdOfInteractionKey<Key>,
+    InteractionCollectorKind
+  > extends infer Input
+    ? string extends Input
+      ? never
+      : Input & string
+    : never;
+
 type InteractionInputKeysOf<Key extends InteractionKey> =
-  string extends keyof InteractionParamsOf<Key>
-    ? never
-    : keyof InteractionParamsOf<Key> & string;
+  | (string extends keyof InteractionParamsOf<Key>
+      ? never
+      : keyof InteractionParamsOf<Key> & string)
+  | AuthoredInteractionInputKeysOf<Key>
+  | (InteractionDefaultedKeysOf<Key> & string);
 
 type InteractionHandleDefaultedKeys<Key extends InteractionKey> = Extract<
   InteractionDefaultedKeysOf<Key>,
   keyof InteractionParamsShape<Key> & string
 >;
 
-type RequiredInteractionInputKeysOf<Key extends InteractionKey> = Exclude<
-  InteractionInputKeysOf<Key>,
-  InteractionHandleDefaultedKeys<Key>
->;
+type RequiredInteractionInputKeysOf<Key extends InteractionKey> =
+  InteractionInputKeysOf<Key>;
 
 export type RequiredInteractionInputKey<Key extends InteractionKey> =
   RequiredInteractionInputKeysOf<Key>;
 
-export type ZeroInputInteractionKey = {
-  [K in InteractionKey]: InteractionInputKeysOf<K> extends never
-    ? K
+type InteractionSlotComponent<Props = object> = (
+  props: Props extends { children: unknown }
+    ? Props
+    : Props & { children?: ReactNode },
+) => ReactElement | null;
+
+type InteractionDefaultInputSlot = {
+  readonly Default: InteractionSlotComponent;
+};
+
+type InteractionValueInputSlot<Value = unknown> = {
+  readonly Value: InteractionSlotComponent<{
+    children: (value: unknown | undefined) => ReactNode;
+  }>;
+};
+
+type InteractionFormInputSlot<Value = unknown> = {
+  readonly Field: InteractionSlotComponent;
+  readonly Options: InteractionSlotComponent<{
+    children: (option: { value: Value; label: string }) => ReactNode;
+  }>;
+};
+
+type DreamboardSlotBrand<Meta> = {
+  readonly __dreamboardSlot: Meta;
+};
+
+type InteractionCardTargetInputSlot<Card extends string = string> = {
+  readonly Card: InteractionSlotComponent<
+    { value: string; swipe?: "auto" | "off" } & Omit<
+      ButtonHTMLAttributes<HTMLButtonElement>,
+      | "children"
+      | "disabled"
+      | "aria-disabled"
+      | "aria-pressed"
+      | "onClick"
+      | "type"
+      | "value"
+    >
+  >;
+  readonly Cards: InteractionSlotComponent<{
+    children: (card: { id: Card }) => ReactNode;
+  }>;
+};
+
+type InteractionBoardTargetInputSlot<Target extends string = string> = {
+  readonly Target: InteractionSlotComponent<
+    { value: string } & Omit<
+      ButtonHTMLAttributes<HTMLButtonElement>,
+      | "children"
+      | "disabled"
+      | "aria-disabled"
+      | "aria-pressed"
+      | "onClick"
+      | "type"
+      | "value"
+    >
+  >;
+};
+
+type InteractionBoardSpaceTargetInputSlot<Space extends string = string> =
+  InteractionBoardTargetInputSlot<Space>;
+
+type InteractionBoardEdgeTargetInputSlot<Edge extends string = string> =
+  InteractionBoardTargetInputSlot<Edge>;
+
+type InteractionBoardVertexTargetInputSlot<Vertex extends string = string> =
+  InteractionBoardTargetInputSlot<Vertex>;
+
+type InteractionBoardTileTargetInputSlot<Tile extends string = string> =
+  InteractionBoardTargetInputSlot<Tile>;
+
+type InteractionSubmitSlot = {
+  readonly Button: InteractionSlotComponent<
+    Omit<
+      ButtonHTMLAttributes<HTMLButtonElement>,
+      "children" | "disabled" | "type" | "value"
+    >
+  >;
+};
+
+type InteractionInputValue<
+  Key extends InteractionKey,
+  Input extends InteractionInputKeysOf<Key>,
+> = InteractionParamsShape<Key>[Input & keyof InteractionParamsShape<Key>];
+
+type InteractionSlotValue<Value> = Value extends readonly (infer Item)[]
+  ? InteractionSlotValue<Item>
+  : Value extends { spaceId: infer Space extends string }
+    ? Space
+    : Value extends { edgeId: infer Edge extends string }
+      ? Edge
+      : Value extends { vertexId: infer Vertex extends string }
+        ? Vertex
+        : Value extends { tileId: infer Tile extends string }
+          ? Tile
+          : Value extends { cardId: infer Card extends string }
+            ? Card
+            : Value;
+
+type InteractionSlotStringValue<Value> = Extract<
+  InteractionSlotValue<Value>,
+  string
+>;
+
+type FormInteractionInputKey<Key extends InteractionKey> =
+  InputKeysWithCollectorKindOfDefinition<
+    GameDefinition,
+    PhaseOfInteractionKey<Key>,
+    IdOfInteractionKey<Key>,
+    "form" | "prompt"
+  > &
+    InteractionInputKeysOf<Key>;
+
+type CardTargetInteractionInputKey<Key extends InteractionKey> =
+  InputKeysWithCollectorKindOfDefinition<
+    GameDefinition,
+    PhaseOfInteractionKey<Key>,
+    IdOfInteractionKey<Key>,
+    "card"
+  > &
+    InteractionInputKeysOf<Key>;
+
+type CardTargetZoneIds<
+  Key extends InteractionKey,
+  Input extends InteractionInputKeysOf<Key>,
+> =
+  CardInputZoneIdsOfDefinition<
+    GameDefinition,
+    PhaseOfInteractionKey<Key>,
+    IdOfInteractionKey<Key>,
+    Input & string
+  > extends infer Zone extends string
+    ? Extract<Zone, WorkspaceZoneId>
+    : never;
+
+type BoardSpaceTargetInteractionInputKey<Key extends InteractionKey> =
+  InputKeysWithCollectorKindOfDefinition<
+    GameDefinition,
+    PhaseOfInteractionKey<Key>,
+    IdOfInteractionKey<Key>,
+    "board-space"
+  > &
+    InteractionInputKeysOf<Key>;
+
+type BoardEdgeTargetInteractionInputKey<Key extends InteractionKey> =
+  InputKeysWithCollectorKindOfDefinition<
+    GameDefinition,
+    PhaseOfInteractionKey<Key>,
+    IdOfInteractionKey<Key>,
+    "board-edge"
+  > &
+    InteractionInputKeysOf<Key>;
+
+type BoardVertexTargetInteractionInputKey<Key extends InteractionKey> =
+  InputKeysWithCollectorKindOfDefinition<
+    GameDefinition,
+    PhaseOfInteractionKey<Key>,
+    IdOfInteractionKey<Key>,
+    "board-vertex"
+  > &
+    InteractionInputKeysOf<Key>;
+
+type BoardTileTargetInteractionInputKey<Key extends InteractionKey> =
+  InputKeysWithCollectorKindOfDefinition<
+    GameDefinition,
+    PhaseOfInteractionKey<Key>,
+    IdOfInteractionKey<Key>,
+    "board-tile"
+  > &
+    InteractionInputKeysOf<Key>;
+
+type InteractionDefaultSlotFor<
+  Key extends InteractionKey,
+  Input extends InteractionInputKeysOf<Key>,
+> = Input extends InteractionHandleDefaultedKeys<Key>
+  ? InteractionDefaultInputSlot
+  : object;
+
+export type InteractionInputSlot<
+  Key extends InteractionKey,
+  Input extends InteractionInputKeysOf<Key>,
+> = InteractionValueInputSlot<InteractionInputValue<Key, Input>> &
+  InteractionDefaultSlotFor<Key, Input> &
+  (Input extends CardTargetInteractionInputKey<Key>
+    ? InteractionCardTargetInputSlot<
+        InteractionSlotStringValue<InteractionInputValue<Key, Input>>
+      >
+    : Input extends BoardSpaceTargetInteractionInputKey<Key>
+      ? InteractionBoardSpaceTargetInputSlot<
+          InteractionSlotStringValue<InteractionInputValue<Key, Input>>
+        >
+      : Input extends BoardEdgeTargetInteractionInputKey<Key>
+        ? InteractionBoardEdgeTargetInputSlot<
+            InteractionSlotStringValue<InteractionInputValue<Key, Input>>
+          >
+        : Input extends BoardVertexTargetInteractionInputKey<Key>
+          ? InteractionBoardVertexTargetInputSlot<
+              InteractionSlotStringValue<InteractionInputValue<Key, Input>>
+            >
+          : Input extends BoardTileTargetInteractionInputKey<Key>
+            ? InteractionBoardTileTargetInputSlot<
+                InteractionSlotStringValue<InteractionInputValue<Key, Input>>
+              >
+            : Input extends FormInteractionInputKey<Key>
+              ? InteractionFormInputSlot<InteractionInputValue<Key, Input>>
+              : never);
+
+type FormSurfaceInputSlot<
+  Key extends InteractionKey,
+  Input extends FormInteractionInputKey<Key>,
+> = InteractionValueInputSlot<InteractionInputValue<Key, Input>> &
+  InteractionDefaultSlotFor<Key, Input> &
+  InteractionFormInputSlot<InteractionInputValue<Key, Input>> &
+  DreamboardSlotBrand<{
+    readonly kind: "form";
+    readonly interaction: Key;
+    readonly input: Input;
+  }>;
+
+type CardSurfaceInputSlot<Zones extends string> =
+  InteractionValueInputSlot<unknown> &
+    InteractionCardTargetInputSlot<WorkspaceCardId & string> &
+    DreamboardSlotBrand<{
+      readonly kind: "card";
+      readonly zones: Zones;
+      readonly selection: "one" | "many";
+    }>;
+
+type BoardSurfaceInputSlot<
+  Kind extends "space" | "edge" | "vertex" | "tile",
+  Target extends string = string,
+> =
+  InteractionValueInputSlot<unknown> &
+    InteractionBoardTargetInputSlot<Target> &
+    DreamboardSlotBrand<{
+      readonly kind: "board";
+      readonly targetKind: Kind;
+    }>;
+
+type InteractionCollectorSlot<
+  Key extends InteractionKey,
+  Input extends InteractionInputKeysOf<Key>,
+> = Input extends CardTargetInteractionInputKey<Key>
+  ? CardSurfaceInputSlot<CardTargetZoneIds<Key, Input>>
+  : Input extends BoardSpaceTargetInteractionInputKey<Key>
+    ? BoardSurfaceInputSlot<"space", string>
+    : Input extends BoardEdgeTargetInteractionInputKey<Key>
+      ? BoardSurfaceInputSlot<"edge", string>
+      : Input extends BoardVertexTargetInteractionInputKey<Key>
+        ? BoardSurfaceInputSlot<"vertex", string>
+        : Input extends BoardTileTargetInteractionInputKey<Key>
+          ? BoardSurfaceInputSlot<"tile", string>
+          : Input extends FormInteractionInputKey<Key>
+            ? FormSurfaceInputSlot<Key, Input>
+            : never;
+
+type InteractionKeysWithInput<Input extends InteractionInputKey> = {
+  [Key in InteractionKey]: Input extends InteractionInputKeysOf<Key>
+    ? Key
     : never;
 }[InteractionKey];
 
-export type InputInteractionKey = Exclude<
-  InteractionKey,
-  ZeroInputInteractionKey
+type InteractionInputSlotByName<Input extends InteractionInputKey> =
+  InteractionInputSlot<
+    InteractionKeysWithInput<Input>,
+    Input & InteractionInputKeysOf<InteractionKeysWithInput<Input>>
+  >;
+
+type InteractionFormInputSlotByName<Input extends InteractionInputKey> =
+  InteractionInputSlot<
+    {
+      [Key in InteractionKey]: Input extends FormInteractionInputKey<Key>
+        ? Key
+        : never;
+    }[InteractionKey],
+    Input &
+      InteractionInputKeysOf<
+        {
+          [Key in InteractionKey]: Input extends FormInteractionInputKey<Key>
+            ? Key
+            : never;
+        }[InteractionKey]
+      >
+  >;
+
+type InteractionInputsForCollectorKind<
+  Key extends InteractionKey,
+  CollectorKind extends InteractionCollectorKind,
+> = {
+  [Input in InteractionInputKeysOf<Key>]: CollectorKind extends "form"
+    ? Input extends FormInteractionInputKey<Key>
+      ? Input
+      : never
+    : CollectorKind extends "card"
+      ? Input extends CardTargetInteractionInputKey<Key>
+        ? Input
+        : never
+      : CollectorKind extends "board-space"
+        ? Input extends BoardSpaceTargetInteractionInputKey<Key>
+          ? Input
+          : never
+        : CollectorKind extends "board-edge"
+          ? Input extends BoardEdgeTargetInteractionInputKey<Key>
+            ? Input
+            : never
+          : CollectorKind extends "board-vertex"
+            ? Input extends BoardVertexTargetInteractionInputKey<Key>
+              ? Input
+              : never
+            : CollectorKind extends "board-tile"
+              ? Input extends BoardTileTargetInteractionInputKey<Key>
+                ? Input
+                : never
+              : never;
+}[InteractionInputKeysOf<Key>];
+
+type InteractionKeysForCollectorKind<
+  CollectorKind extends InteractionCollectorKind,
+> = {
+  [Key in InteractionKey]: InteractionInputsForCollectorKind<
+    Key,
+    CollectorKind
+  > extends never
+    ? never
+    : Key;
+}[InteractionKey];
+
+type InteractionInputSlotByCollectorKind<
+  CollectorKind extends InteractionCollectorKind,
+> = InteractionInputSlot<
+  InteractionKeysForCollectorKind<CollectorKind>,
+  InteractionInputsForCollectorKind<
+    InteractionKeysForCollectorKind<CollectorKind>,
+    CollectorKind
+  >
 >;
 
-export type InteractionRouteRenderState<Key extends InteractionKey> =
-  Omit<InteractionSwitchRenderState<Key>, "descriptor"> & {
-    descriptor: InteractionDescriptorFor<Key>;
+export type InteractionFormSurface<Key extends InteractionKey> = {
+  readonly Root: InteractionSlotComponent;
+  readonly Form: DreamboardUI<typeof uiContract>["Interaction"]["Form"];
+  readonly Dialog: DreamboardUI<typeof uiContract>["Interaction"]["Dialog"];
+  readonly State: DreamboardUI<typeof uiContract>["Interaction"]["State"];
+  readonly Arm: DreamboardUI<typeof uiContract>["Interaction"]["Trigger"];
+  readonly Submit: DreamboardUI<typeof uiContract>["Interaction"]["Submit"];
+  readonly Field: <Input extends FormInteractionInputKey<Key>>(
+    props: { input: Input; children?: ReactNode },
+  ) => ReactElement | null;
+  readonly slot: {
+    readonly [Input in FormInteractionInputKey<Key>]: FormSurfaceInputSlot<
+      Key,
+      Input
+    >;
   };
+};
+
+type BoardSurfaceSpaceProps<Target extends string> = {
+  value: Target;
+  children?: ReactNode;
+} & Omit<BoardSpaceTargetPropsGeneric<Target>, "value" | "children">;
+
+export type BoardSurfaceBoardId = BoardBaseId & string;
 
-export type InteractionRouteMap = {
-  [K in InteractionKey]: (state: InteractionRouteRenderState<K>) => ReactNode;
+type BoardSurfaceRuntimeBoardId<Board extends BoardSurfaceBoardId> =
+  ReturnType<typeof boardHelpers.boardIdsForBase<Board>>[number] & string;
+
+type BoardSurfaceSpaceId<Board extends BoardSurfaceBoardId> =
+  ReturnType<
+    typeof boardHelpers.spaceIds<BoardSurfaceRuntimeBoardId<Board>>
+  >[number] &
+    string;
+
+type BoardSurfaceTiledBoardId<Board extends BoardSurfaceBoardId> = Extract<
+  BoardSurfaceRuntimeBoardId<Board>,
+  TiledBoardId
+>;
+
+type BoardSurfaceEdgeId<Board extends BoardSurfaceBoardId> =
+  TiledEdgeState<BoardSurfaceTiledBoardId<Board>> extends { id: infer Id }
+    ? Id & string
+    : EdgeId & string;
+
+type BoardSurfaceVertexId<Board extends BoardSurfaceBoardId> =
+  TiledVertexState<BoardSurfaceTiledBoardId<Board>> extends { id: infer Id }
+    ? Id & string
+    : VertexId & string;
+
+export type BoardSurface<Board extends BoardSurfaceBoardId = BoardSurfaceBoardId> = {
+  readonly Root: InteractionSlotComponent;
+  readonly Space: <Target extends BoardSurfaceSpaceId<Board>>(
+    props: BoardSurfaceSpaceProps<Target>,
+  ) => ReactElement;
+  readonly slot: {
+    readonly space: BoardSurfaceInputSlot<
+      "space",
+      BoardSurfaceSpaceId<Board>
+    >;
+    readonly playerSpace: BoardSurfaceInputSlot<
+      "space",
+      BoardSurfaceSpaceId<Board>
+    >;
+    readonly edge: BoardSurfaceInputSlot<"edge", BoardSurfaceEdgeId<Board>>;
+    readonly vertex: BoardSurfaceInputSlot<
+      "vertex",
+      BoardSurfaceVertexId<Board>
+    >;
+    readonly tile: BoardSurfaceInputSlot<"tile", BoardSurfaceSpaceId<Board>>;
+  };
 };
 
-type ExactInteractionRoutes<Routes extends InteractionRouteMap> = Routes &
-  Record<Exclude<keyof Routes, keyof InteractionRouteMap>, never>;
+type ZoneCardsComponent = InteractionSlotComponent<
+    Omit<ZoneListProps, "children" | "empty"> & {
+      empty?: ReactNode;
+      children: (card: WorkspaceZoneCard) => ReactNode;
+    }
+  >;
 
-export function defineInteractionRoutes<const Routes extends InteractionRouteMap>(
-  routes: ExactInteractionRoutes<Routes>,
-): InteractionRouteMap {
-  return routes;
-}
+type ZoneCardComponent = InteractionSlotComponent<
+    Omit<ButtonHTMLAttributes<HTMLButtonElement>, "type" | "value"> & {
+      card: WorkspaceZoneCard;
+      swipe?: "auto" | "off";
+    }
+  >;
 
-type InteractionSwitchProps = Omit<
-  InteractionSwitchPropsGeneric<InteractionKey>,
-  "routes"
-> & {
-  routes: InteractionRouteMap;
+export type HandSurface<Zones extends readonly WorkspaceZoneId[] = readonly WorkspaceZoneId[]> = {
+  readonly Hand: ZoneCardsComponent;
+  readonly Card: ZoneCardComponent;
+  readonly slot: {
+    readonly card: CardSurfaceInputSlot<Zones[number] & string>;
+  };
+};
+
+export type PileSurface<Zones extends readonly WorkspaceZoneId[] = readonly WorkspaceZoneId[]> = {
+  readonly Pile: ZoneCardsComponent;
+  readonly Card: ZoneCardComponent;
+};
+
+export type CardCollectionSurface<Zones extends readonly WorkspaceZoneId[] = readonly WorkspaceZoneId[]> = {
+  readonly Collection: ZoneCardsComponent;
+  readonly Card: ZoneCardComponent;
+  readonly slot: {
+    readonly card: CardSurfaceInputSlot<Zones[number] & string>;
+  };
+};
+
+export type InteractionFormInputs<Key extends InteractionKey> = {
+  [Input in InteractionInputKeysOf<Key>]: (
+    slot: InteractionInputSlot<Key, Input>,
+  ) => ReactNode;
+};
+
+export type InteractionCollectSlots<Key extends InteractionKey> = {
+  [Input in RequiredInteractionInputKeysOf<Key>]: InteractionCollectorSlot<
+    Key,
+    Input
+  >;
 };
 
+export type InteractionRoute<Key extends InteractionKey> = {
+  readonly collect: InteractionCollectSlots<Key>;
+};
+
+export type InteractionRoutes = {
+  [Key in InteractionKey]: InteractionRoute<Key>;
+};
+
+export type InteractionRoutesProps = {
+  routes: InteractionRoutes;
+  fallback?: ReactNode;
+  includeUnavailable?: boolean | null;
+};
+
+export type ZeroInputInteractionKey = {
+  [K in InteractionKey]: InteractionInputKeysOf<K> extends never
+    ? K
+    : never;
+}[InteractionKey];
+
+export type InputInteractionKey = Exclude<
+  InteractionKey,
+  ZeroInputInteractionKey
+>;
+
 type InteractionInputKeyOf<Key extends InteractionKey> =
   Key extends InteractionKey ? InteractionInputKeysOf<Key> : never;
 
@@ -9645,17 +10337,14 @@ export type HexBoardGridProps<
   "board" | "interactions"
 > & {
   board: Id;
-  interactions?:
-    | "auto"
-    | false
-    | {
-        edge?: readonly InteractionKey[];
-        vertex?: readonly InteractionKey[];
-        space?: readonly InteractionKey[];
-      };
 };
 
-type WorkspaceBoard = Omit<DreamboardUI<typeof uiContract>["Board"], "HexView" | "HexGrid"> & {
+type WorkspaceBoard = {
+  useSurface(name: string): BoardSurface;
+  useSurface<const Board extends BoardSurfaceBoardId>(
+    name: string,
+    options: { board: Board },
+  ): BoardSurface<Board>;
   HexView<
     const Id extends HexBoardId,
     const TSpaceView extends { id: HexBoardSpaceId<Id> },
@@ -9688,146 +10377,96 @@ type WorkspaceZoneCard = ZoneCardRenderItem<
     : never
   : never;
 
-type WorkspaceZone = Omit<
-  DreamboardUI<typeof uiContract>["Zone"],
-  "CardAt" | "TopCard" | "List" | "PileCards"
-> & {
-  CardAt(
-    props: Omit<ZoneCardAtProps<WorkspaceZoneId>, "zone" | "children"> & {
-      zone?: WorkspaceZoneId;
-      children?: ReactNode | ((card: WorkspaceZoneCard) => ReactNode);
-    },
-  ): ReactElement | null;
-  TopCard(
-    props: Omit<
-      ZoneCardAtProps<WorkspaceZoneId>,
-      "zone" | "index" | "children"
-    > & {
-      zone?: WorkspaceZoneId;
-      children?: ReactNode | ((card: WorkspaceZoneCard) => ReactNode);
-    },
-  ): ReactElement | null;
-  List(
-    props: Omit<ZoneListProps, "children"> & {
-      children?: ReactNode | ((card: WorkspaceZoneCard) => ReactNode);
-    },
-  ): ReactElement;
-  PileCards(
-    props: Omit<ZonePileCardsProps, "renderCard"> & {
-      renderCard: (card: WorkspaceZoneCard) => ReactNode;
-    },
-  ): ReactElement | null;
+type HandRole = "primary" | "auxiliary" | "task";
+
+type WorkspaceZone = {
+  useHand<const Zone extends PlayerCardZoneId>(
+    name: string,
+    options: { zone: Zone; role: HandRole; label: string; order?: number },
+  ): HandSurface<readonly [Zone]>;
+  usePile<const Zone extends CardZoneId>(
+    name: string,
+    options: { zone: Zone },
+  ): PileSurface<readonly [Zone]>;
+  useCardCollection<const Zones extends readonly CardZoneId[]>(
+    name: string,
+    options: { zones: Zones; mode?: "all" | "top-card" },
+  ): CardCollectionSurface<Zones>;
 };
 
 type WorkspaceUI = Omit<
   DreamboardUI<typeof uiContract>,
-  "Root" | "Game" | "Interaction" | "Board" | "Zone"
+  "Root" | "Game" | "Interaction" | "Board" | "Zone" | "Prompt" | "PromptInbox"
 > & {
   Root(props: UIRootProps): ReactElement;
   readonly Game: TypedGame<typeof uiContract, GameView, PlayerId, PhaseName>;
-  readonly Interaction: Omit<
-    DreamboardUI<typeof uiContract>["Interaction"],
-    "Switch"
-  > & {
-    Switch(props: InteractionSwitchProps): ReactElement;
+  readonly Interaction: Pick<DreamboardUI<typeof uiContract>["Interaction"], "State" | "Dialog"> & {
+    useForm<Key extends InteractionKey>(interaction: Key): InteractionFormSurface<Key>;
+    Routes(props: InteractionRoutesProps): ReactElement;
   };
   readonly Board: WorkspaceBoard;
   readonly Zone: WorkspaceZone;
   readonly ResourceCounter: ResourceCounterComponents<ResourceId>;
 };
 
-const baseUI = createDreamboardUI(uiContract);
-
-const resourcePresentationById = literals.resourcePresentationById as Partial<
-  Record<string, { label?: string; icon?: string }>
->;
+function formInputKeysForInteraction(interaction: string): Set<string> {
+  const [phase, id] = interaction.split(".", 2);
+  const phaseSpec = phase ? (game.phases as Record<string, unknown>)[phase] : undefined;
+  const phaseRecord = phaseSpec as {
+    interactions?: Record<string, { inputs?: Record<string, { kind?: string }> }>;
+    cardActions?: Record<string, { inputs?: Record<string, { kind?: string }> }>;
+    submit?: { inputs?: Record<string, { kind?: string }> };
+  } | undefined;
+  const spec =
+    (id ? phaseRecord?.interactions?.[id] : undefined) ??
+    (id ? phaseRecord?.cardActions?.[id] : undefined) ??
+    (id === "submit" ? phaseRecord?.submit : undefined);
+  return new Set(
+    Object.entries((spec?.inputs ?? {}) as Record<string, { kind?: string }>)
+      .filter(
+        ([, collector]) =>
+          collector.kind === "form" || collector.kind === "prompt",
+      )
+      .map(([input]) => input),
+  );
+}
 
-const resourceDisplayConfig = literals.resourceIds.map((resource) => {
-  const resourceId = resource as ResourceId;
-  const presentation = resourcePresentationById[resource as string];
-  return {
-    type: resourceId,
-    label: presentation?.label ?? resource,
-    icon: presentation?.icon ?? resource,
-  };
-}) satisfies readonly ResourceDisplayConfig<ResourceId>[];
-
-const resourceCounter = createResourceCounter<ResourceId>(resourceDisplayConfig);
-
-export const Board: WorkspaceUI["Board"] = {
-  ...baseUI.Board,
-	  HexView<
-	    const Id extends HexBoardId,
-	    const TSpaceView extends { id: HexBoardSpaceId<Id> },
-	  >({ board: boardId, ...props }: HexBoardViewProps<Id, TSpaceView>) {
-	    return createElement(baseUI.Board.HexView<HexBoardTopology<Id>, TSpaceView>, {
-	      ...props,
-	      board: hexStaticBoards[boardId],
-	    });
-	  },
-	  HexGrid<
-	    const Id extends HexBoardId,
-	    const TSpaceView extends { id: HexBoardSpaceId<Id> },
-	  >({ board: boardId, ...props }: HexBoardGridProps<Id, TSpaceView>) {
-	    return createElement(baseUI.Board.HexGrid<HexBoardTopology<Id>, TSpaceView>, {
-	      ...props,
-	      board: hexStaticBoards[boardId],
-	    });
-	  },
-	} as WorkspaceUI["Board"];
-
-export const UI: WorkspaceUI = {
-  ...baseUI,
-  Board,
-  ResourceCounter: resourceCounter,
-};
+export const UI = createWorkspaceUIContract<
+  WorkspaceUI,
+  typeof uiContract,
+  ResourceId,
+  WorkspaceZoneCard,
+  typeof hexStaticBoards
+>({
+  uiContract,
+  clientParamSchemasByPhase: createClientParamSchemasByPhase(game) as ClientParamSchemaMap,
+  formInputKeysForInteraction,
+  resourceIds: literals.resourceIds as readonly ResourceId[],
+  resourcePresentationById: literals.resourcePresentationById as Partial<
+    Record<string, { label?: string; icon?: string }>
+  >,
+  hexStaticBoards,
+  cardIdFromZoneCard: (card) => card.id,
+  zoneIdFromZoneCard: (card) => card.zone,
+});
+export const Board: WorkspaceUI["Board"] = UI.Board;
+export const Zone: WorkspaceUI["Zone"] = UI.Zone;
 export const Game: WorkspaceUI["Game"] = UI.Game;
 export const Interaction = UI.Interaction;
-export const Prompt = UI.Prompt;
-export const PromptInbox = UI.PromptInbox;
 export const PlayerRoster: WorkspaceUI["PlayerRoster"] = UI.PlayerRoster;
 export const Dice: WorkspaceUI["Dice"] = UI.Dice;
 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 {
-  createReducerOps,
+  createReducerEdit,
   createStateQueries,
-  pipe,
 } from "@dreamboard/app-sdk/reducer";
 import type { GameState } from "./game-contract";
 
@@ -9846,16 +10485,12 @@ import type { GameState } from "./game-contract";
  *
  * Recommended authoring pattern inside a phase reducer:
  *
- *   const next = pipe(
- *     state,
- *     ops.setActivePlayers([q.players.order()[0]]),
- *   );
- *   return accept(next);
+ *   const tx = edit(state);
+ *   tx.setActivePlayers([q.players.order()[0]]);
+ *   return accept(tx.state);
  */
 
-export const ops = createReducerOps<GameState>();
-
-export { pipe };
+export const edit = createReducerEdit<GameState>();
 
 export function stateQueries(state: GameState) {
   return createStateQueries(state);
@@ -10014,18 +10649,48 @@ function isFrameworkOwnedSetupProfilesSeed(content) {
 }
 function generateSetupPhaseSeed() {
   return `import { z } from "zod";
-import type { GameContract } from "../game-contract";
-import { definePhase } from "@dreamboard/app-sdk/reducer";
+import type { GameContract, GameState } from "../game-contract";
+import {
+  defineInteraction,
+  definePhase,
+  formInput,
+} from "@dreamboard/app-sdk/reducer";
+import { edit } from "../reducer-support";
+
+const setupMoodChoices = [
+  { value: "ready", label: "Ready" },
+  { value: "exploring", label: "Exploring" },
+] as const;
+type SetupMood = (typeof setupMoodChoices)[number]["value"];
+const setupPhaseStateSchema = z.object({});
 
 // A single phase file is fine while the phase is small. When a phase grows
 // multiple action families, move it to app/phases/<phase>/index.ts and split
 // interactions into neighboring concept files.
 export const setup = definePhase<GameContract>()({
-  kind: "auto",
-  state: z.object({}),
+  kind: "player",
+  state: setupPhaseStateSchema,
   initialState: () => ({}),
-  enter({ state, accept }) {
-    return accept(state);
+  actor: ({ state }) => state.publicState.currentPlayerId,
+  interactions: {
+    submit: defineInteraction<GameContract, typeof setupPhaseStateSchema>()({
+      inputs: {
+        mood: formInput.choice<SetupMood, GameState>({
+          choices: setupMoodChoices,
+          defaultValue: "ready",
+        }),
+      },
+      reduce({ state, input, accept }) {
+        const tx = edit(state);
+        tx.patchPublicState({
+          notesByPlayerId: {
+            ...state.publicState.notesByPlayerId,
+            [input.playerId]: input.params.mood,
+          },
+        });
+        return accept(tx.state);
+      },
+    }),
   },
 });
 `;
@@ -10107,55 +10772,142 @@ function generateUiFrameworkTsConfig() {
 `;
 }
 function generateReducerUiAppContent() {
-  return `import { Game, Phase, Prompt, PromptInbox } from "@dreamboard/ui-contract";
+  return `import { ToastProvider } from "@dreamboard/ui-sdk";
+import { Game, Interaction, Phase, UI } from "@dreamboard/ui-contract";
+import { SetupInteractionRoutes } from "./interaction-routes";
+import { SetupScreen } from "./setup-screen";
 
 function SetupPhase() {
+  const setupForm = Interaction.useForm("setup.submit");
+
   return (
-    <main>
-      <PromptInbox.Root>
-        <PromptInbox.Empty>No available prompts.</PromptInbox.Empty>
-        <PromptInbox.Items>
-          {(prompt) => (
-            <Prompt.Root
-              key={prompt.interactionKey}
-              interaction={prompt.interactionKey}
-            >
-              <Prompt.Title />
-              <Prompt.Message />
-              <Prompt.Options>
-                {(option) => (
-                  <Prompt.Option value={option.id}>
-                    {option.label ?? option.id}
-                  </Prompt.Option>
-                )}
-              </Prompt.Options>
-            </Prompt.Root>
+    <>
+      <SetupScreen />
+      <SetupInteractionRoutes form={setupForm} />
+    </>
+  );
+}
+
+export default function App() {
+  return (
+    <ToastProvider>
+      <UI.Root>
+        <Game.Root>
+          {() => (
+            <Phase.Switch
+              routes={{
+                setup: () => <SetupPhase />,
+              }}
+            />
           )}
-        </PromptInbox.Items>
-      </PromptInbox.Root>
+        </Game.Root>
+      </UI.Root>
+    </ToastProvider>
+  );
+}
+`;
+}
+function generateReducerUiSetupScreenContent() {
+  return `import { PANEL_CLASS, SHELL_CLASS } from "./styles";
+
+export function SetupScreen() {
+  return (
+    <main className={SHELL_CLASS}>
+      <section className={PANEL_CLASS}>
+        <p className="text-xs font-bold uppercase tracking-[0.14em] text-slate-500">
+          Setup
+        </p>
+        <h1 className="text-2xl font-bold text-slate-950">Your game starts here</h1>
+        <p className="max-w-prose text-sm leading-6 text-slate-600">
+          Replace this screen with your board, hands, mats, and table state.
+          Keep interaction wiring in the route file so visual components stay
+          focused on layout and styling.
+        </p>
+      </section>
     </main>
   );
 }
+`;
+}
+function generateReducerUiInteractionRoutesContent() {
+  return `import {
+  Interaction,
+  type InteractionFormSurface,
+} from "@dreamboard/ui-contract";
+import { ACTION_BUTTON_CLASS, PANEL_CLASS } from "./styles";
 
-export default function App() {
+export function SetupInteractionRoutes({
+  form,
+}: {
+  form: InteractionFormSurface<"setup.submit">;
+}) {
   return (
-    <Game.Root>
-      {() => (
-        <Phase.Switch
-          routes={{
-            setup: () => <SetupPhase />,
-          }}
-        />
-      )}
-    </Game.Root>
+    <>
+      <Interaction.Routes
+        routes={{
+          "setup.submit": {
+            collect: {
+              mood: form.slot.mood,
+            },
+          },
+        }}
+      />
+      <aside className={PANEL_CLASS}>
+        <div className="grid gap-2">
+          <p className="text-sm font-bold text-slate-950">Ready check</p>
+          <form.slot.mood.Field />
+          <form.Submit className={ACTION_BUTTON_CLASS}>
+            Start building
+          </form.Submit>
+        </div>
+      </aside>
+    </>
   );
 }
 `;
 }
+function generateReducerUiStylesContent() {
+  return `export const SHELL_CLASS =
+  "min-h-screen bg-[#f8fafc] p-6 text-slate-950";
+
+export const PANEL_CLASS =
+  "mx-auto grid max-w-3xl gap-4 rounded-lg border border-slate-200 bg-white p-5 shadow-sm";
+
+export const ACTION_BUTTON_CLASS =
+  "rounded-md bg-slate-950 px-4 py-2 text-sm font-bold text-white disabled:cursor-not-allowed disabled:opacity-50";
+`;
+}
+function generateReducerUiContractTypingSmokeContent() {
+  return `import { Interaction } from "@dreamboard/ui-contract";
+
+export function UiContractTypingSmoke() {
+  const form = Interaction.useForm("setup.submit");
+
+  return (
+    <Interaction.Routes
+      routes={{
+        "setup.submit": {
+          collect: {
+            mood: form.slot.mood,
+          },
+        },
+      }}
+    />
+  );
+}
+
+// @ts-expect-error generated contracts hide legacy interaction roots.
+Interaction.Root({ interaction: "setup.submit", children: null });
+`;
+}
 function generateSeedFiles(manifest) {
   return {
     "app/README.md": generateAppReadmeSeed(),
     "ui/App.tsx": generateReducerUiAppContent(),
+    "ui/interaction-routes.tsx": generateReducerUiInteractionRoutesContent(),
+    "ui/setup-screen.tsx": generateReducerUiSetupScreenContent(),
+    "ui/styles.ts": generateReducerUiStylesContent(),
+    "ui/ui-contract-typing-smoke.tsx": generateReducerUiContractTypingSmokeContent(),
     "app/game-contract.ts": generateReducerGameContractSeed(),
     "app/game.ts": generateReducerGameSeed(),
     "app/setup-profiles.ts": generateSetupProfilesSeed(manifest),
@@ -10315,7 +11067,9 @@ function resolveRepoLocalPackageSource(specifier, options) {
   } catch {
     return null;
   }
-  const packageInfo = readPackageInfos(repoRoot).get(parsedSpecifier.packageName);
+  const packageInfo = readPackageInfos(repoRoot).get(
+    parsedSpecifier.packageName
+  );
   if (!packageInfo) {
     return null;
   }
@@ -10723,8 +11477,10 @@ type InteractionKeyForId<Id extends InteractionId> = Extract<
   InteractionKey,
   \`\${string}.\${Id}\`
 >;
+type InteractionParamsForKey<Key extends InteractionKey> =
+  Key extends InteractionKey ? InteractionParamsOf<Key> : never;
 type InteractionParamsOfId<Id extends InteractionId> =
-  InteractionParamsOf<InteractionKeyForId<Id>>;
+  InteractionParamsForKey<InteractionKeyForId<Id>>;
 
 export interface BrowserRunnerSnapshot {
   sessionId: string | null;
@@ -11573,11 +12329,29 @@ function setLatestCompileAttempt(projectConfig, attempt) {
 function updateProjectLocalMaintainerRegistry(projectConfig, localMaintainerRegistry) {
   return {
     ...projectConfig,
-    localMaintainerRegistry
+    localMaintainerRegistry: sanitizeProjectLocalMaintainerRegistry(
+      localMaintainerRegistry
+    )
+  };
+}
+function sanitizeProjectLocalMaintainerRegistry(localMaintainerRegistry) {
+  if (!localMaintainerRegistry?.packages.dreamboard) {
+    return localMaintainerRegistry;
+  }
+  const { dreamboard: _dreamboard, ...packages } = localMaintainerRegistry.packages;
+  return {
+    ...localMaintainerRegistry,
+    packages
   };
 }
 
 // src/services/project/workspace-codegen.ts
+var STARTER_UI_SEED_FILES = /* @__PURE__ */ new Set([
+  "ui/interaction-routes.tsx",
+  "ui/setup-screen.tsx",
+  "ui/styles.ts",
+  "ui/ui-contract-typing-smoke.tsx"
+]);
 async function applyWorkspaceCodegen(options) {
   const { projectRoot, manifest } = options;
   const authoritativeFiles = generateAuthoritativeFiles(manifest);
@@ -11585,6 +12359,10 @@ async function applyWorkspaceCodegen(options) {
   const written = [];
   const skipped = [];
   const merged = [];
+  const existingUiAppBeforeSeeds = await readTextFileIfExists(
+    `${projectRoot}/ui/App.tsx`
+  );
+  const shouldWriteStarterUiSeedFiles = existingUiAppBeforeSeeds === null || existingUiAppBeforeSeeds.trim().length === 0;
   for (const [relativePath, content] of Object.entries(authoritativeFiles)) {
     const filePath = `${projectRoot}/${relativePath}`;
     const existingContent = await readTextFileIfExists(filePath);
@@ -11596,6 +12374,10 @@ async function applyWorkspaceCodegen(options) {
   for (const [relativePath, content] of Object.entries(seedFiles)) {
     const filePath = `${projectRoot}/${relativePath}`;
     const existingContent = await readTextFileIfExists(filePath);
+    if (STARTER_UI_SEED_FILES.has(relativePath) && !shouldWriteStarterUiSeedFiles && existingContent === null) {
+      skipped.push(relativePath);
+      continue;
+    }
     const shouldRefreshFrameworkSeed = relativePath === "app/setup-profiles.ts" && isFrameworkOwnedSetupProfilesSeed(existingContent);
     if (shouldRefreshFrameworkSeed) {
       await writeTextFile(filePath, content);
@@ -11845,7 +12627,7 @@ function buildRemoteAlignedSnapshotFiles(options) {
 
 // src/services/project/local-maintainer-registry.ts
 import { spawn } from "child_process";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import path10 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
@@ -11884,16 +12666,34 @@ function getCliPackageRoot() {
       "dreamboard-cli"
     );
   } catch {
-    return path10.resolve(MODULE_DIR, "../../..");
+    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;
   }
 }
 function getScriptInvocation() {
   const cliPackageRoot = getCliPackageRoot();
-  const scriptPath = path10.join(
-    cliPackageRoot,
-    "scripts",
-    "local-maintainer-registry.ts"
-  );
+  const scriptPath = getLocalMaintainerScriptPath(cliPackageRoot);
   if (!existsSync4(scriptPath)) {
     throw new Error(
       [
@@ -11911,6 +12711,17 @@ function getScriptInvocation() {
     cwd: cliPackageRoot
   };
 }
+function getLocalMaintainerScriptPath(cliPackageRoot) {
+  return path10.join(cliPackageRoot, "scripts", "local-maintainer-registry.ts");
+}
+function isInstalledCliPackageRoot(cliPackageRoot) {
+  return cliPackageRoot.split(path10.sep).includes("node_modules");
+}
+function shouldSkipLocalMaintainerHelper() {
+  const cliPackageRoot = getCliPackageRoot();
+  const scriptPath = getLocalMaintainerScriptPath(cliPackageRoot);
+  return !existsSync4(scriptPath) && isInstalledCliPackageRoot(cliPackageRoot);
+}
 function buildScriptSetupError(options) {
   return new Error(
     [
@@ -11922,6 +12733,15 @@ ${options.stderr.trim()}` : null
     ].filter(Boolean).join("\n")
   );
 }
+function parseJsonPayload(output) {
+  const payload = output.trim().split(/\r?\n/).map((line) => line.trim()).reverse().find(
+    (line) => line === "null" || line.startsWith("{") || line.startsWith("[")
+  );
+  if (!payload) {
+    throw new Error("completed without returning a JSON payload");
+  }
+  return JSON.parse(payload);
+}
 async function runLocalMaintainerScript(args) {
   const invocation = getScriptInvocation();
   return new Promise((resolve, reject) => {
@@ -11975,7 +12795,7 @@ async function runLocalMaintainerScript(args) {
         return;
       }
       try {
-        resolve(JSON.parse(trimmedStdout));
+        resolve(parseJsonPayload(trimmedStdout));
       } catch (error) {
         reject(
           buildScriptSetupError({
@@ -11992,6 +12812,9 @@ async function ensureLocalMaintainerSnapshot(apiBaseUrl) {
   if (!isLocalMaintainerRegistryEnabled(apiBaseUrl)) {
     return null;
   }
+  if (shouldSkipLocalMaintainerHelper()) {
+    return null;
+  }
   return runLocalMaintainerScript([
     "ensure-snapshot",
     "--api-base-url",
@@ -11999,6 +12822,9 @@ async function ensureLocalMaintainerSnapshot(apiBaseUrl) {
   ]);
 }
 async function readWorkspaceLocalMaintainerRegistry(projectRoot, fallbackRegistryUrl = LOCAL_REGISTRY_URL) {
+  if (shouldSkipLocalMaintainerHelper()) {
+    return null;
+  }
   return runLocalMaintainerScript([
     "read-workspace",
     "--project-root",
@@ -13008,6 +13834,11 @@ var config_default = defineCommand({
       token: {
         type: "string",
         description: "Auth token (Supabase JWT)"
+      },
+      scope: {
+        type: "string",
+        description: "Config scope: global | workspace",
+        default: "global"
       }
     }
   },
@@ -13017,10 +13848,12 @@ var config_default = defineCommand({
     const globalConfig = await loadGlobalConfig();
     if (action === "show") {
       const storedSession = await getStoredSession();
+      const projectRoot = await findProjectRoot(process.cwd());
+      const projectConfig = projectRoot ? await loadProjectConfig(projectRoot).catch(() => void 0) : void 0;
       const config = resolveConfig(
         globalConfig,
         parsedArgs,
-        void 0,
+        projectConfig,
         storedSession
       );
       console.log(
@@ -13033,7 +13866,9 @@ var config_default = defineCommand({
           } : {
             configPath: getGlobalConfigPath(),
             authPath: getGlobalAuthPath(),
-            environment: parsedArgs.env || globalConfig.environment || "dev",
+            environment: parsedArgs.env || projectConfig?.environment || globalConfig.environment || "dev",
+            workspaceConfigPath: projectRoot ? `${projectRoot}/.dreamboard/project.json` : void 0,
+            workspaceEnvironment: projectConfig?.environment,
             apiBaseUrl: config.apiBaseUrl,
             webBaseUrl: config.webBaseUrl,
             authenticated: Boolean(config.authToken),
@@ -13051,10 +13886,24 @@ var config_default = defineCommand({
           "The published Dreamboard CLI does not support config overrides. Use `dreamboard login` to authenticate."
         );
       }
-      const updated = { ...globalConfig };
-      if (parsedArgs.env) updated.environment = parsedArgs.env;
-      await saveGlobalConfig(updated);
-      const overrideToken = valueOrUndefined(parsedArgs.token);
+      if (parsedArgs.scope === "workspace") {
+        const projectRoot = await findProjectRoot(process.cwd());
+        if (!projectRoot) {
+          throw new Error(
+            "Workspace-scoped config requires a Dreamboard project (.dreamboard/project.json)."
+          );
+        }
+        const projectConfig = await loadProjectConfig(projectRoot);
+        await updateProjectState(projectRoot, {
+          ...projectConfig,
+          ...parsedArgs.env ? { environment: parsedArgs.env } : {}
+        });
+      } else {
+        const updated = { ...globalConfig };
+        if (parsedArgs.env) updated.environment = parsedArgs.env;
+        await saveGlobalConfig(updated);
+      }
+      const overrideToken = valueOrUndefined2(parsedArgs.token);
       if (overrideToken) {
         await setAccessOnlySession(overrideToken);
       }
@@ -13068,7 +13917,7 @@ var config_default = defineCommand({
 });
 
 // src/commands/dev.ts
-import path24 from "path";
+import path25 from "path";
 import { createHash as createHash3 } from "crypto";
 
 // ../../packages/ui-host-runtime/src/actor-principal.ts
@@ -13540,11 +14389,32 @@ async function resolveDevBearer(config) {
       case "unchanged":
       case "rotated":
         return { kind: "ok", token: result.credentials.accessToken };
-      case "transient_failure":
+      case "transient_failure": {
+        const expiry = getAccessTokenExpiry(config.authToken);
+        const isExpired = expiry !== null && expiry.getTime() <= Date.now();
+        if (isExpired) {
+          if (shouldRepairLocalDevSession(config)) {
+            const repaired = await repairLocalDevSession();
+            if (repaired) {
+              return { kind: "ok", token: repaired.accessToken };
+            }
+          }
+          return {
+            kind: "permanent_invalid",
+            message: `Access token refresh failed: ${result.message}. Run \`dreamboard login\` to authenticate again.`
+          };
+        }
         return { kind: "ok", token: config.authToken ?? null };
+      }
     }
   } catch (err) {
     if (err instanceof PermanentRefreshError) {
+      if (shouldRepairLocalDevSession(config)) {
+        const repaired = await repairLocalDevSession();
+        if (repaired) {
+          return { kind: "ok", token: repaired.accessToken };
+        }
+      }
       return { kind: "permanent_invalid", message: err.message };
     }
     throw err;
@@ -14227,7 +15097,7 @@ function extractQueryParam(req, name) {
   );
   return value?.trim() || null;
 }
-function appendQuery(path28, query) {
+function appendQuery(path29, query) {
   const params = new URLSearchParams();
   for (const [key, value] of Object.entries(query)) {
     if (value) {
@@ -14235,7 +15105,7 @@ function appendQuery(path28, query) {
     }
   }
   const serialized = params.toString();
-  return serialized ? `${path28}?${serialized}` : path28;
+  return serialized ? `${path29}?${serialized}` : path29;
 }
 async function loadCurrentSession(options) {
   if (!await exists(options.sessionFilePath)) {
@@ -14254,12 +15124,12 @@ async function persistSessionId(sessionFilePath, sessionId) {
     createPersistedDevSession({ sessionId })
   );
 }
-async function fetchBackendJson(config, path28, options = {}) {
+async function fetchBackendJson(config, path29, options = {}) {
   const bearer = await resolveDevBearer(config);
   if (bearer.kind === "permanent_invalid") {
     throw new HttpError(401, bearer.message);
   }
-  const response = await fetch(`${config.apiBaseUrl}${path28}`, {
+  const response = await fetch(`${config.apiBaseUrl}${path29}`, {
     method: options.method ?? "GET",
     headers: {
       ...bearer.token ? { authorization: `Bearer ${bearer.token}` } : {},
@@ -14401,6 +15271,37 @@ function prepareFallbackStylesheet(options) {
   return generatedPath;
 }
 
+// src/dev-host/dev-hmr-guard-plugin.ts
+import path18 from "path";
+function createDevHmrGuardPlugin(options) {
+  return {
+    name: "dreamboard-dev-hmr-guard",
+    handleHotUpdate(context) {
+      if (shouldHandleProjectHotUpdate(options.projectRoot, context.file)) {
+        return void 0;
+      }
+      context.server.config.logger.info(
+        `[dreamboard] ignored HMR outside project: ${path18.relative(
+          options.projectRoot,
+          context.file
+        )}`
+      );
+      return [];
+    }
+  };
+}
+function shouldHandleProjectHotUpdate(projectRoot, file) {
+  const normalizedProjectRoot = path18.resolve(projectRoot);
+  const normalizedFile = path18.resolve(file);
+  const relativePath = path18.relative(normalizedProjectRoot, normalizedFile);
+  const isInsideProject = relativePath === "" || relativePath.length > 0 && !relativePath.startsWith("..") && !path18.isAbsolute(relativePath);
+  if (!isInsideProject) {
+    return false;
+  }
+  const pathSegments = relativePath.split(path18.sep);
+  return !pathSegments.includes(".dreamboard") && !pathSegments.includes("node_modules");
+}
+
 // src/dev-host/start-dev-server.ts
 var require2 = createRequire2(import.meta.url);
 var tailwindCssEntry = require2.resolve("tailwindcss/index.css");
@@ -14423,6 +15324,7 @@ async function startDreamboardDevServer(options) {
     root: platform2.devHostRoot,
     appType: "spa",
     plugins: [
+      createDevHmrGuardPlugin({ projectRoot }),
       react(),
       createVirtualDevModulesPlugin({
         projectRoot,
@@ -14493,11 +15395,11 @@ function getBoundPort(server) {
 }
 
 // src/services/testing/reducer-native-test-harness.ts
-import path21 from "path";
+import path22 from "path";
 import {
   existsSync as existsSync8,
   mkdirSync as mkdirSync2,
-  readFileSync as readFileSync3,
+  readFileSync as readFileSync4,
   rmSync as rmSync2,
   writeFileSync as writeFileSync2
 } from "fs";
@@ -14606,6 +15508,9 @@ 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) {
@@ -14727,6 +15632,33 @@ 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;
@@ -14810,38 +15742,76 @@ function choiceInput(options) {
   if (Array.isArray(options.choices) && options.choices.length === 0) {
     throw new Error("formInput.choice requires at least one choice.");
   }
-  const schema = Array.isArray(options.choices) ? external_exports.enum(
-    options.choices.map((choice) => choice.value)
-  ) : external_exports.string();
+  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;
   return {
     kind: "form",
     schema,
-    ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
+    ...hasStaticDefault ? { defaultValue: staticDefault } : {},
     ...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: dependsOn ? resolveDependentDomainChoices(
-          options.choices,
-          {
-            state,
-            playerId,
-            q,
-            derived,
-            values: values ?? {}
-          }
-        ) : resolveDomainChoices(
-          options.choices,
-          {
-            state,
-            playerId,
-            q,
-            derived,
-            values: {}
-          }
-        )
+        choices
       };
-    }
+    },
+    ...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) {
@@ -14862,7 +15832,12 @@ function choiceListInput(options) {
         derived,
         values: {}
       };
-      const choices = resolveDomainChoices(options.choices, context);
+      const choices = resolveDomainChoices(options.choices, context).map(
+        (choice) => ({
+          ...choice,
+          value: choice.value
+        })
+      );
       return {
         type: "choiceList",
         choices,
@@ -14944,17 +15919,19 @@ function makeBoardCollector(kind) {
         targetId
       )),
       ...dependsOn ? { dependsOn } : {},
-      domain: dependsOn ? (state, playerId, q, _derived, values) => ({
-        type: "target",
+      domain: (state, playerId, q, _derived, values) => ({
+        type: "boardTarget",
+        projection: "resolved",
         targetKind: target.targetKind,
         boardId: target.boardId,
+        valueKind: target.valueKind,
         eligibleTargets: target.eligible({
           state,
           playerId,
           q,
           values
         }).map(String)
-      }) : void 0,
+      }),
       meta: {
         targetKind: target.targetKind,
         boardId: target.boardId,
@@ -15129,8 +16106,8 @@ function createCardTargetBuilder(zoneIds) {
           }
         }
       ),
-      zoneIds: [...zoneIds],
-      zoneId: zoneIds[0] ?? "",
+      zoneIds,
+      zoneId: zoneIds[0],
       targetKind: "card"
     })
   );
@@ -15164,10 +16141,10 @@ function cardInput(options) {
       targetId
     )),
     ...dependsOn ? { dependsOn } : {},
-    domain: dependsOn ? (state, playerId, q, _derived, values) => ({
-      type: "target",
+    domain: (state, playerId, q, _derived, values) => ({
+      type: "cardTarget",
+      projection: "resolved",
       targetKind: target.targetKind,
-      zoneId: target.zoneId,
       zoneIds: target.zoneIds,
       eligibleTargets: target.eligible({
         state,
@@ -15175,7 +16152,7 @@ function cardInput(options) {
         q,
         values
       }).map(String)
-    }) : void 0,
+    }),
     meta: {
       zoneId: target.zoneId,
       zoneIds: target.zoneIds,
@@ -17344,6 +18321,126 @@ 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;
@@ -17527,6 +18624,19 @@ 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(
@@ -17626,6 +18736,47 @@ 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);
@@ -17927,7 +19078,8 @@ function createTrustedRuntimeScope(definition) {
   }
   const helpers = {
     ...runtimeResultHelpers,
-    ops: createReducerOps()
+    ops: createReducerOps(),
+    edit: createReducerEdit()
   };
   function fxForState2(state) {
     return fxForState(state);
@@ -18264,10 +19416,10 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
 
 // ../../packages/app-sdk/src/reducer/parse-utils.ts
 function formatIssue(label, issue) {
-  const path28 = issue.path.map(
+  const path29 = issue.path.map(
     (segment) => typeof segment === "symbol" ? segment.toString() : String(segment)
   ).join(".");
-  return `${path28 || label}: ${issue.message}`;
+  return `${path29 || label}: ${issue.message}`;
 }
 function safeParseOrThrow(schema, value, label) {
   const parsed = schema.safeParse(value);
@@ -18288,6 +19440,7 @@ function makeValidationError(errorCode, message) {
 }
 
 // ../../packages/app-sdk/src/reducer/bundle/trusted/interaction-collectors.ts
+var MAX_EAGER_DEPENDENT_DOMAIN_CASES = 64;
 function collectTargetDomainMetadata(collector) {
   switch (collector.kind) {
     case "card": {
@@ -18305,28 +19458,63 @@ function collectTargetDomainMetadata(collector) {
       const meta = collector.meta ?? {};
       return {
         targetKind: meta.targetKind ?? collector.kind.replace("board-", ""),
-        boardId: meta.boardId
+        boardId: meta.boardId,
+        valueKind: meta.valueKind
       };
     }
     default:
       return {};
   }
 }
-function isTargetCollector(collector) {
-  return collector.kind === "card" || collector.kind === "board-edge" || collector.kind === "board-space" || collector.kind === "board-tile" || collector.kind === "board-vertex";
-}
 function withSelection(domain, collector) {
   if (!collector.selection) return domain;
   return { ...domain, selection: collector.selection };
 }
+function lazyTargetDomainFromCollectorMetadata(key, collector, dependencies) {
+  const metadata = collectTargetDomainMetadata(collector);
+  if (collector.kind === "card") {
+    return withSelection(
+      {
+        type: "cardTarget",
+        projection: "lazy",
+        targetKind: "card",
+        zoneIds: metadata.zoneIds ?? (metadata.zoneId === void 0 ? [] : [metadata.zoneId]),
+        dependencies: {
+          mode: "lazy",
+          dependsOn: dependencies,
+          resolver: { inputKey: key }
+        }
+      },
+      collector
+    );
+  }
+  if (collector.kind === "board-edge" || collector.kind === "board-space" || collector.kind === "board-tile" || collector.kind === "board-vertex") {
+    return withSelection(
+      {
+        type: "boardTarget",
+        projection: "lazy",
+        targetKind: metadata.targetKind ?? collector.kind.replace("board-", ""),
+        boardId: metadata.boardId ?? "",
+        ...metadata.valueKind ? { valueKind: metadata.valueKind } : {},
+        dependencies: {
+          mode: "lazy",
+          dependsOn: dependencies,
+          resolver: { inputKey: key }
+        }
+      },
+      collector
+    );
+  }
+  return null;
+}
 function finiteValuesForDependency(key, domain) {
   if (!domain) {
     throw new Error(
       `Interaction input '${key}' is declared as a dependency before it has a projected domain.`
     );
   }
-  if (domain.type === "target") {
-    if (!domain.eligibleTargets) {
+  if (domain.type === "cardTarget" || domain.type === "boardTarget") {
+    if (domain.projection !== "resolved") {
       throw new Error(
         `Interaction input '${key}' cannot be used as a dependency because its target domain is not finite.`
       );
@@ -18334,7 +19522,9 @@ function finiteValuesForDependency(key, domain) {
     return [...domain.eligibleTargets];
   }
   if (domain.type === "choice") {
-    return domain.choices.map((choice) => choice.value);
+    return domain.choices.flatMap(
+      (choice) => choice.value === null ? [] : [choice.value]
+    );
   }
   throw new Error(
     `Interaction input '${key}' cannot be used as a dependency. V1 supports finite target and choice dependencies only.`
@@ -18352,13 +19542,44 @@ function cartesianDependencyTuples(dependencies, domainsByKey) {
   );
 }
 function withoutDependentProjection(domain) {
-  const {
-    dependsOn: _dependsOn,
-    dependentCases: _dependentCases,
-    ...rest
-  } = domain;
+  const { dependencies: _dependencies, ...rest } = domain;
   return rest;
 }
+function toLazyTargetDomain(key, domain, dependencies) {
+  if (domain.type === "cardTarget") {
+    return {
+      type: "cardTarget",
+      projection: "lazy",
+      targetKind: "card",
+      zoneIds: domain.zoneIds,
+      ...domain.selection ? { selection: domain.selection } : {},
+      dependencies: {
+        mode: "lazy",
+        dependsOn: dependencies,
+        resolver: { inputKey: key }
+      }
+    };
+  }
+  if (domain.type === "boardTarget") {
+    return {
+      type: "boardTarget",
+      projection: "lazy",
+      targetKind: domain.targetKind,
+      boardId: domain.boardId,
+      ...domain.valueKind ? { valueKind: domain.valueKind } : {},
+      ...domain.selection ? { selection: domain.selection } : {},
+      dependencies: {
+        mode: "lazy",
+        dependsOn: dependencies,
+        resolver: { inputKey: key }
+      }
+    };
+  }
+  return null;
+}
+function dependencyCaseCount(dependencies, domainsByKey) {
+  return dependencies.map((key) => finiteValuesForDependency(key, domainsByKey[key]).length).reduce((total, count) => total * count, 1);
+}
 function unsupportedDefaultInputError(key, collector) {
   return new Error(
     `Interaction input '${key}' uses a '${collector.kind}' collector without a default-renderable domain or target metadata. Use formInput.choice(...), formInput.choiceList(...), formInput.number(...), formInput.resourceMap(...), cardInput(...), or boardInput(...). For custom payloads, use a custom interaction surface with paramsSchema instead of the default InteractionForm.`
@@ -18437,9 +19658,21 @@ function collectInputDomains(interaction, domainState, playerId, eligibleTargets
       continue;
     }
     if (collector.domain) {
+      const domainProjector = collector.domain;
       const dependencies = collector.dependsOn ?? [];
+      if (options.includeEligibleTargets === false && !Object.prototype.hasOwnProperty.call(eligibleTargets, key)) {
+        const lazyDomain2 = lazyTargetDomainFromCollectorMetadata(
+          key,
+          collector,
+          dependencies
+        );
+        if (lazyDomain2) {
+          result[key] = lazyDomain2;
+          continue;
+        }
+      }
       const baseDomain = withSelection(
-        collector.domain(
+        domainProjector(
           domainState,
           playerId,
           queries(),
@@ -18452,6 +19685,12 @@ function collectInputDomains(interaction, domainState, playerId, eligibleTargets
         result[key] = baseDomain;
         continue;
       }
+      const caseCount = dependencyCaseCount(dependencies, result);
+      const lazyDomain = caseCount > MAX_EAGER_DEPENDENT_DOMAIN_CASES ? toLazyTargetDomain(key, baseDomain, dependencies) : null;
+      if (lazyDomain) {
+        result[key] = lazyDomain;
+        continue;
+      }
       const dependentCases = cartesianDependencyTuples(
         dependencies,
         result
@@ -18459,7 +19698,7 @@ function collectInputDomains(interaction, domainState, playerId, eligibleTargets
         when: values,
         domain: withoutDependentProjection(
           withSelection(
-            collector.domain?.(
+            domainProjector(
               domainState,
               playerId,
               queries(),
@@ -18472,24 +19711,13 @@ function collectInputDomains(interaction, domainState, playerId, eligibleTargets
       }));
       result[key] = {
         ...baseDomain,
-        dependsOn: dependencies,
-        dependentCases
+        dependencies: {
+          mode: "eager",
+          dependentCases
+        }
       };
       continue;
     }
-    const targets = eligibleTargets[key];
-    const targetMetadata = collectTargetDomainMetadata(collector);
-    if (isTargetCollector(collector) || Boolean(collector.eligibleTargets) || Boolean(collector.validateTarget) || targets || Object.keys(targetMetadata).length > 0) {
-      result[key] = withSelection(
-        {
-          type: "target",
-          ...targetMetadata,
-          ...targets ? { eligibleTargets: targets } : {}
-        },
-        collector
-      );
-      continue;
-    }
     throw unsupportedDefaultInputError(key, collector);
   }
   return result;
@@ -18538,16 +19766,50 @@ function collectInteractionInputs(interaction, domainState, playerId, options =
       derived(),
       domain
     );
+    const defaultValue = "defaultValue" in collector ? collector.defaultValue : dynamicDefault;
+    warnConcreteDependentChoiceDefault({
+      inputKey: key,
+      collector,
+      domain,
+      defaultValue,
+      dependencyKeys
+    });
     return [
       {
         key,
         kind: collector.kind,
         domain,
-        ..."defaultValue" in collector ? { defaultValue: collector.defaultValue } : dynamicDefault !== void 0 ? { defaultValue: dynamicDefault } : {}
+        ...defaultValue !== void 0 ? { defaultValue } : {}
       }
     ];
   });
 }
+var concreteDependentChoiceDefaultWarnings = /* @__PURE__ */ new Set();
+function shouldEmitAuthoringWarning() {
+  const env2 = globalThis.process?.env;
+  return env2?.NODE_ENV !== "production" && env2?.DREAMBOARD_SUPPRESS_AUTHORING_WARNINGS !== "1";
+}
+function warnConcreteDependentChoiceDefault({
+  inputKey,
+  collector,
+  domain,
+  defaultValue,
+  dependencyKeys
+}) {
+  if (!shouldEmitAuthoringWarning() || !dependencyKeys.has(inputKey) || collector.kind !== "form" || domain.type !== "choice" || defaultValue === void 0 || defaultValue === null) {
+    return;
+  }
+  const warningKey = `${inputKey}:${String(defaultValue)}`;
+  if (concreteDependentChoiceDefaultWarnings.has(warningKey)) {
+    return;
+  }
+  concreteDependentChoiceDefaultWarnings.add(warningKey);
+  console.warn(
+    `[dreamboard] Form choice input "${inputKey}" feeds another collector and defaulted to "${String(
+      defaultValue
+    )}". Dependent choices that select the object an action applies to should usually use defaultValue: () => undefined so collection stays explicit.`
+  );
+}
 function collectFirstCardZoneId(interaction) {
   const collectors = interactionInputsOf(interaction);
   for (const collector of Object.values(collectors)) {
@@ -18661,13 +19923,18 @@ function validateCollectorTargets(interaction, domainState, playerId, params) {
     if (!collector.validateTarget) continue;
     const rawTarget = params[key];
     if (rawTarget === null || rawTarget === void 0) continue;
-    const values = valuesForCollectorValidation(collector.selection, rawTarget);
-    for (const value of values) {
+    const dependencyValues = dependencyValuesForCollector(collector, params);
+    const targetValues = valuesForCollectorValidation(
+      collector.selection,
+      rawTarget
+    );
+    for (const value of targetValues) {
       const issue = collector.validateTarget(
         domainState,
         playerId,
         queries(),
-        value
+        value,
+        dependencyValues
       );
       if (issue) {
         return makeValidationError(issue.errorCode, issue.message);
@@ -18676,6 +19943,13 @@ function validateCollectorTargets(interaction, domainState, playerId, params) {
   }
   return { valid: true };
 }
+function dependencyValuesForCollector(collector, params) {
+  const dependencies = collector.dependsOn ?? [];
+  if (dependencies.length === 0) return void 0;
+  return Object.fromEntries(
+    dependencies.map((dependencyKey) => [dependencyKey, params[dependencyKey]])
+  );
+}
 function valuesForCollectorValidation(selection, value) {
   if (selection?.mode === "many") {
     return Array.isArray(value) ? value : [];
@@ -18847,7 +20121,7 @@ function deriveInteractionKind(inputs) {
   }
   return "action";
 }
-function isTargetCollector2(collector) {
+function isTargetCollector(collector) {
   switch (collector.kind) {
     case "card":
     case "board-edge":
@@ -18862,8 +20136,19 @@ function isTargetCollector2(collector) {
 function isManyCollector(collector) {
   return collector.selection?.mode === "many";
 }
-function isDefaultRenderableFormCollector(collector) {
-  return collector.kind === "form" && collector.domain !== void 0;
+function terminalCollectorsForInputs(inputs) {
+  const terminalKeys = new Set(Object.keys(inputs));
+  for (const collector of Object.values(inputs)) {
+    for (const dependencyKey of collector.dependsOn ?? []) {
+      terminalKeys.delete(dependencyKey);
+    }
+  }
+  const collectors = [];
+  for (const key of terminalKeys) {
+    const collector = inputs[key];
+    if (collector) collectors.push(collector);
+  }
+  return collectors;
 }
 function deriveCommitPolicy(inputs, explicit) {
   const collectors = Object.values(inputs);
@@ -18879,15 +20164,16 @@ function deriveCommitPolicy(inputs, explicit) {
   if (hasManyCollector) {
     return { mode: "manual" };
   }
-  if (collectors.some(isDefaultRenderableFormCollector)) {
+  if (collectors.length === 0 || !collectors.some(isTargetCollector)) {
     return { mode: "manual" };
   }
-  if (collectors.length === 0 || !collectors.some(isTargetCollector2)) {
+  const terminalCollectors = terminalCollectorsForInputs(inputs);
+  if (terminalCollectors.length === 0) {
     return { mode: "manual" };
   }
-  return collectors.every(
-    (collector) => isTargetCollector2(collector) || collector.kind === "rng"
-  ) ? { mode: "autoWhenReady" } : { mode: "manual" };
+  return terminalCollectors.every(
+    (collector) => isTargetCollector(collector) || collector.kind === "rng"
+  ) && terminalCollectors.some(isTargetCollector) ? { mode: "autoWhenReady" } : { mode: "manual" };
 }
 function projectInteractionMetadata(interaction) {
   return {
@@ -18902,7 +20188,7 @@ function enrichResourceInputPresentation(inputs, manifest) {
   }
   const resources = presentationById;
   const enrichChoice = (choice) => {
-    const presentation = resources[choice.value];
+    const presentation = choice.value === null ? void 0 : 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 : ""),
@@ -18910,7 +20196,16 @@ function enrichResourceInputPresentation(inputs, manifest) {
     };
   };
   return inputs.map((input) => {
-    if (input.domain.type === "choice" || input.domain.type === "choiceList") {
+    if (input.domain.type === "choice") {
+      return {
+        ...input,
+        domain: {
+          ...input.domain,
+          choices: input.domain.choices.map(enrichChoice)
+        }
+      };
+    }
+    if (input.domain.type === "choiceList") {
       return {
         ...input,
         domain: {
@@ -18936,6 +20231,23 @@ function enrichResourceInputPresentation(inputs, manifest) {
     };
   });
 }
+function interactionAvailabilityFromDecision(decision) {
+  if (decision.available) return { status: "available" };
+  if (decision.unavailableReason === "Not your turn") {
+    return { status: "notYourTurn", reason: decision.unavailableReason };
+  }
+  if (decision.unavailableReason === "INSUFFICIENT_RESOURCES") {
+    return {
+      status: "insufficientResources",
+      reason: decision.unavailableReason,
+      missingResources: { ...decision.missingResources ?? {} }
+    };
+  }
+  return {
+    status: "blocked",
+    reason: decision.unavailableReason ?? "Interaction unavailable"
+  };
+}
 function createInteractionDecisionResolver(scope, stages, authorization) {
   function evaluateInteractionCost(state, interaction, playerId, params, projection) {
     if (!interaction.cost) {
@@ -18969,15 +20281,15 @@ function createInteractionDecisionResolver(scope, stages, authorization) {
     const queries = options.projection?.q ?? createStateQueries(domainState);
     const derived = options.projection?.derived;
     const shouldMaterializeInputDomains = decision.available || decision.unavailableReason !== "Not your turn";
-    const promptContext = metadata.kind === "prompt" && shouldMaterializeInputDomains ? {
+    const promptContext = metadata.kind === "prompt" ? {
       to: playerId,
       title: humanizeInteractionId(interactionId),
-      options: collectPromptOptions(
+      options: shouldMaterializeInputDomains ? collectPromptOptions(
         { inputs: interactionInputs },
         domainState,
         playerId,
         queries
-      )
+      ) : void 0
     } : void 0;
     const inputs = shouldMaterializeInputDomains ? enrichResourceInputPresentation(
       collectInteractionInputs(interaction, domainState, playerId, {
@@ -18991,11 +20303,11 @@ function createInteractionDecisionResolver(scope, stages, authorization) {
       }),
       scope.definition.contract.manifest
     ) : [];
-    return {
+    const baseDescriptor = {
       phaseName,
       interactionKey: `${phaseName}.${interactionId}`,
       interactionId,
-      ...metadata,
+      commit: metadata.commit,
       zoneId: collectFirstCardZoneId(interaction),
       zoneIds: collectCardZoneIds(interaction),
       inputs,
@@ -19003,10 +20315,21 @@ function createInteractionDecisionResolver(scope, stages, authorization) {
       currentResources: decision.cost ? {
         ...queries.player.resources(playerId)
       } : void 0,
-      missingResources: decision.missingResources,
-      available: decision.available,
-      unavailableReason: decision.unavailableReason,
-      context: promptContext
+      availability: interactionAvailabilityFromDecision(decision)
+    };
+    if (metadata.kind === "prompt") {
+      return {
+        ...baseDescriptor,
+        kind: "prompt",
+        context: promptContext ?? {
+          to: playerId,
+          title: humanizeInteractionId(interactionId)
+        }
+      };
+    }
+    return {
+      ...baseDescriptor,
+      kind: "action"
     };
   }
   function resolveInteractionDecision({
@@ -19422,16 +20745,15 @@ function resolveContainerRef(table, ref) {
       throw new Error(`Unknown board '${ref.boardId}'.`);
     }
     const space2 = board2?.spaces[ref.spaceId];
-    if (!space2?.zoneId) {
+    if (!space2) {
       throw new Error(
-        `Board space '${ref.spaceId}' on board '${ref.boardId}' has no container zone.`
+        `Unknown board space '${ref.spaceId}' on board '${ref.boardId}'.`
       );
     }
     return {
       kind: "space",
       boardId: board2.id,
-      spaceId: ref.spaceId,
-      zoneId: space2.zoneId
+      spaceId: ref.spaceId
     };
   }
   const board = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId, ref.playerId)];
@@ -19441,16 +20763,15 @@ function resolveContainerRef(table, ref) {
     );
   }
   const space = board?.spaces[ref.spaceId];
-  if (!space?.zoneId) {
+  if (!space) {
     throw new Error(
-      `Board space '${ref.spaceId}' on board '${ref.boardId}' for '${ref.playerId}' has no container zone.`
+      `Unknown board space '${ref.spaceId}' on board '${ref.boardId}' for '${ref.playerId}'.`
     );
   }
   return {
     kind: "space",
     boardId: board.id,
-    spaceId: ref.spaceId,
-    zoneId: space.zoneId
+    spaceId: ref.spaceId
   };
 }
 function readContainerComponents(table, ref) {
@@ -20072,7 +21393,7 @@ function createProjectionBuilder(scope, interactions) {
           });
           if (!decision.found || !decision.visible) continue;
           const cardDomain = cardKey ? decision.descriptor.inputs.find((input) => input.key === cardKey)?.domain : void 0;
-          const cardTargets = cardDomain?.type === "target" ? cardDomain.eligibleTargets : void 0;
+          const cardTargets = cardDomain?.type === "cardTarget" && cardDomain.projection === "resolved" ? cardDomain.eligibleTargets : void 0;
           if (cardKey && !cardTargets?.includes(cardId)) {
             continue;
           }
@@ -20881,6 +22202,9 @@ function toWireDispatchResult(result, serializeState) {
     trace
   };
 }
+function toWireDispatchTrace(result) {
+  return toWireDispatchResult(result, (state) => state).trace;
+}
 function createReducerBundle(definition) {
   const trustedBundle = createTrustedReducerBundle(definition);
   const codec = createIngressRuntimeCodec(definition);
@@ -21043,7 +22367,11 @@ function createReducerBundle(definition) {
             };
           }
           state = result.state;
-          return { kind: "accept" };
+          return {
+            kind: "accept",
+            state: codec.serializeState(state),
+            trace: toWireDispatchTrace(result)
+          };
         },
         projectSeatViewDynamic({ playerId, viewId = "player" }) {
           return trustedBundle.projectSeatViewDynamic({
@@ -21077,7 +22405,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 path18 from "path";
+import path19 from "path";
 import { pathToFileURL as pathToFileURL2 } from "url";
 import { build as build2 } from "esbuild";
 var ESBUILD_EXTERNALS = [
@@ -21091,14 +22419,14 @@ function resolveSourceCheckoutBuildContext() {
     const repoRoot = resolveCliRepoRoot(import.meta.url);
     return {
       nodePaths: [
-        path18.join(repoRoot, "apps", "dreamboard-cli", "node_modules"),
-        path18.join(repoRoot, "node_modules")
+        path19.join(repoRoot, "apps", "dreamboard-cli", "node_modules"),
+        path19.join(repoRoot, "node_modules")
       ],
       plugins: [createRepoLocalPackageResolutionPlugin({ repoRoot })]
     };
   } catch {
     return {
-      nodePaths: [path18.join(process.cwd(), "node_modules")],
+      nodePaths: [path19.join(process.cwd(), "node_modules")],
       plugins: []
     };
   }
@@ -21124,10 +22452,10 @@ async function bundleTypeScriptModuleText(entryPath, options = {}) {
   return output.text;
 }
 async function importTypeScriptModule(entryPath) {
-  const tempDir = await mkdtemp2(path18.join(tmpdir2(), "dreamboard-ts-module-"));
-  const outfile = path18.join(
+  const tempDir = await mkdtemp2(path19.join(tmpdir2(), "dreamboard-ts-module-"));
+  const outfile = path19.join(
     tempDir,
-    `${path18.basename(entryPath).replace(/\.[^.]+$/u, "")}.mjs`
+    `${path19.basename(entryPath).replace(/\.[^.]+$/u, "")}.mjs`
   );
   try {
     const bundledText = await bundleTypeScriptModuleText(entryPath);
@@ -21152,7 +22480,7 @@ import {
   symlink
 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import path19 from "path";
+import path20 from "path";
 import { createInterface } from "readline";
 import { fileURLToPath as fileURLToPath7 } from "url";
 var READY_PREFIX = "HARNESS_READY ";
@@ -21160,15 +22488,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 = path19.dirname(fileURLToPath7(import.meta.url));
-var REPO_ROOT3 = path19.resolve(MODULE_DIR4, "../../../../..");
-var PROJECT_DEPENDENCY_NODE_MODULES = path19.join(
+var MODULE_DIR4 = path20.dirname(fileURLToPath7(import.meta.url));
+var REPO_ROOT3 = path20.resolve(MODULE_DIR4, "../../../../..");
+var PROJECT_DEPENDENCY_NODE_MODULES = path20.join(
   REPO_ROOT3,
   "apps",
   "dreamboard-cli",
   "node_modules"
 );
-var UI_SDK_NODE_MODULES = path19.join(
+var UI_SDK_NODE_MODULES = path20.join(
   REPO_ROOT3,
   "packages",
   "ui-sdk",
@@ -21178,8 +22506,8 @@ async function startEmbeddedHarnessSession(options) {
   const repoRoot = await resolveRepoRoot2(options.projectRoot);
   const gradlew = await resolveGradleLauncher(repoRoot);
   const fixture = await prepareLocalHarnessFixture(options);
-  const logDir = path19.join(options.projectRoot, "test", "generated");
-  const logFilePath = path19.join(logDir, "embedded-harness.log");
+  const logDir = path20.join(options.projectRoot, "test", "generated");
+  const logFilePath = path20.join(logDir, "embedded-harness.log");
   await mkdir2(logDir, { recursive: true });
   const previousClientConfig = client.getConfig();
   const child = spawn5(
@@ -21188,7 +22516,7 @@ async function startEmbeddedHarnessSession(options) {
       ...gradlew.args,
       "--console=plain",
       ":apps:backend:runEmbeddedHarness",
-      `-PharnessManifestPath=${path19.join(options.projectRoot, MATERIALIZED_MANIFEST_FILE)}`,
+      `-PharnessManifestPath=${path20.join(options.projectRoot, MATERIALIZED_MANIFEST_FILE)}`,
       `-PharnessBundlePath=${fixture.bundleRoot}`,
       `-PharnessGameId=${fixture.gameId}`,
       `-PharnessManifestId=${fixture.manifestId}`,
@@ -21255,7 +22583,7 @@ async function ensureSymlink(targetPath, linkPath) {
   if (await pathExists3(linkPath)) {
     return;
   }
-  await mkdir2(path19.dirname(linkPath), { recursive: true });
+  await mkdir2(path20.dirname(linkPath), { recursive: true });
   await symlink(
     targetPath,
     linkPath,
@@ -21266,13 +22594,13 @@ async function ensureEmbeddedHarnessDependencies(projectRoot) {
   if (await pathExists3(PROJECT_DEPENDENCY_NODE_MODULES)) {
     await ensureSymlink(
       PROJECT_DEPENDENCY_NODE_MODULES,
-      path19.join(projectRoot, "node_modules")
+      path20.join(projectRoot, "node_modules")
     );
   }
   if (await pathExists3(UI_SDK_NODE_MODULES)) {
     await ensureSymlink(
       UI_SDK_NODE_MODULES,
-      path19.join(projectRoot, "ui", "node_modules")
+      path20.join(projectRoot, "ui", "node_modules")
     );
   }
 }
@@ -21282,15 +22610,15 @@ async function prepareLocalHarnessFixture(options) {
   const manifestContent = await readMaterializedManifestText(
     options.projectRoot
   );
-  const appEntryPath = path19.join(options.projectRoot, "app", "index.ts");
+  const appEntryPath = path20.join(options.projectRoot, "app", "index.ts");
   if (!await exists(appEntryPath)) {
     throw new Error(
-      `Embedded harness requires ${path19.relative(options.projectRoot, appEntryPath)}.`
+      `Embedded harness requires ${path20.relative(options.projectRoot, appEntryPath)}.`
     );
   }
-  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 bundleRoot = await mkdtemp3(path20.join(tmpdir3(), "dreamboard-harness-"));
+  const bundleEntryPath = path20.join(bundleRoot, "src", "app", "index.js");
+  await mkdir2(path20.dirname(bundleEntryPath), { recursive: true });
   const bunExecutable = await resolveBunExecutable();
   if (!bunExecutable) {
     await rm5(bundleRoot, { recursive: true, force: true });
@@ -21327,7 +22655,7 @@ async function prepareLocalHarnessFixture(options) {
   const bundleContent = await readFile3(bundleEntryPath, "utf8");
   const manifestHash = hashContent(manifestContent);
   const bundleHash = hashContent(bundleContent);
-  const gameSlug = options.projectConfig.slug || path19.basename(options.projectRoot);
+  const gameSlug = options.projectConfig.slug || path20.basename(options.projectRoot);
   const authoring = getProjectAuthoringState(options.projectConfig);
   return {
     bundleRoot,
@@ -21347,14 +22675,14 @@ async function prepareLocalHarnessFixture(options) {
   };
 }
 async function resolveBunExecutable() {
-  const currentExecutable = path19.basename(process.execPath).toLowerCase();
+  const currentExecutable = path20.basename(process.execPath).toLowerCase();
   if (currentExecutable === "bun" || currentExecutable === "bun.exe") {
     return process.execPath;
   }
   const candidatePaths = [
-    ...(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") : []
+    ...(process.env.PATH ?? "").split(path20.delimiter).filter((directory) => directory.length > 0).flatMap((directory) => executableCandidates(directory, "bun")),
+    ...process.env.BUN_INSTALL ? executableCandidates(path20.join(process.env.BUN_INSTALL, "bin"), "bun") : [],
+    ...process.env.HOME ? executableCandidates(path20.join(process.env.HOME, ".bun", "bin"), "bun") : []
   ];
   for (const candidate of candidatePaths) {
     try {
@@ -21370,11 +22698,11 @@ function executableCandidates(directory, executableName) {
     return [];
   }
   if (process.platform !== "win32") {
-    return [path19.join(directory, executableName)];
+    return [path20.join(directory, executableName)];
   }
   const extensions = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";").filter((extension) => extension.length > 0);
   return extensions.map(
-    (extension) => path19.join(directory, `${executableName}${extension.toLowerCase()}`)
+    (extension) => path20.join(directory, `${executableName}${extension.toLowerCase()}`)
   );
 }
 async function waitForExitCode(child) {
@@ -21532,13 +22860,13 @@ async function waitForExit(child, timeoutMs) {
 }
 async function resolveGradleLauncher(repoRoot) {
   if (process.platform === "win32") {
-    const gradleBat = path19.join(repoRoot, "gradlew.bat");
+    const gradleBat = path20.join(repoRoot, "gradlew.bat");
     if (!await exists(gradleBat)) {
       throw new Error(`Missing Gradle launcher at ${gradleBat}`);
     }
     return { command: gradleBat, args: [] };
   }
-  const gradleShell = path19.join(repoRoot, "gradlew");
+  const gradleShell = path20.join(repoRoot, "gradlew");
   if (!await exists(gradleShell)) {
     throw new Error(`Missing Gradle launcher at ${gradleShell}`);
   }
@@ -21546,7 +22874,7 @@ async function resolveGradleLauncher(repoRoot) {
 }
 async function resolveRepoRoot2(projectRoot) {
   const currentFile = fileURLToPath7(import.meta.url);
-  const searchRoots = [path19.dirname(currentFile), projectRoot, process.cwd()];
+  const searchRoots = [path20.dirname(currentFile), projectRoot, process.cwd()];
   for (const root of searchRoots) {
     const repoRoot = await findSourceCheckoutRepoRoot(root);
     if (repoRoot) {
@@ -21558,12 +22886,12 @@ async function resolveRepoRoot2(projectRoot) {
   );
 }
 async function findSourceCheckoutRepoRoot(startDir) {
-  let currentDir = path19.resolve(startDir);
+  let currentDir = path20.resolve(startDir);
   while (true) {
     if (await isSourceCheckoutRepoRoot(currentDir)) {
       return currentDir;
     }
-    const parentDir = path19.dirname(currentDir);
+    const parentDir = path20.dirname(currentDir);
     if (parentDir === currentDir) {
       return null;
     }
@@ -21571,7 +22899,7 @@ async function findSourceCheckoutRepoRoot(startDir) {
   }
 }
 async function isSourceCheckoutRepoRoot(rootDir) {
-  return await exists(path19.join(rootDir, "gradlew")) && await exists(path19.join(rootDir, "apps", "backend", "build.gradle.kts"));
+  return await exists(path20.join(rootDir, "gradlew")) && await exists(path20.join(rootDir, "apps", "backend", "build.gradle.kts"));
 }
 function normalizeUuid(candidate, fallbackSeed) {
   if (candidate && UUID_PATTERN.test(candidate)) {
@@ -21623,7 +22951,7 @@ async function subscribeToCliSessionEvents(options) {
 
 // src/ui/playwright-runner.ts
 import os2 from "os";
-import path20 from "path";
+import path21 from "path";
 function configurePlaywrightBrowsersPath() {
   if (process.env.PLAYWRIGHT_BROWSERS_PATH) {
     return;
@@ -21635,10 +22963,10 @@ function configurePlaywrightBrowsersPath() {
   } catch {
     return;
   }
-  if (!runtimeHome || path20.resolve(runtimeHome) === path20.resolve(realHome)) {
+  if (!runtimeHome || path21.resolve(runtimeHome) === path21.resolve(realHome)) {
     return;
   }
-  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");
+  const browserCachePath = process.platform === "darwin" ? path21.join(realHome, "Library", "Caches", "ms-playwright") : process.platform === "win32" ? path21.join(realHome, "AppData", "Local", "ms-playwright") : path21.join(realHome, ".cache", "ms-playwright");
   process.env.PLAYWRIGHT_BROWSERS_PATH = browserCachePath;
 }
 async function buildBrowserAuthInitScript(config) {
@@ -21647,7 +22975,7 @@ async function buildBrowserAuthInitScript(config) {
     return `(function(){localStorage.setItem('supabase_token',${JSON.stringify(config.authToken)});})();`;
   }
   try {
-    const { createClient: createClient2 } = await import("./dist-FRURQI7Q.js");
+    const { createClient: createClient2 } = await import("./dist-JNA2CLKS.js");
     const supabase = createClient2(config.supabaseUrl, config.supabaseAnonKey);
     let sessionData = null;
     if (!sessionData) {
@@ -21741,9 +23069,42 @@ 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 = path22.resolve(options.scenarioFilePath);
+  const relativePath = path22.relative(options.projectRoot, absolutePath);
+  const normalizedRelativePath = relativePath.split(path22.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(path22.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("./dist-FEPN3BDN.js").then(
+  testingExpectApiFactoryPromise ??= import("./dist-JO2OGKJD.js").then(
     (module) => module.createExpectApi
   );
   return testingExpectApiFactoryPromise;
@@ -21783,7 +23144,7 @@ async function discoverFiles(root, suffix) {
   const entries = await readdir3(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const entryPath = path21.join(root, entry.name);
+    const entryPath = path22.join(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await discoverFiles(entryPath, suffix));
       continue;
@@ -21832,38 +23193,38 @@ function parseTypedScenarioDefinition(value) {
   };
 }
 async function isReducerNativeTestingWorkspace(projectRoot) {
-  return await exists(path21.join(projectRoot, "app", "game.ts")) && await exists(
-    path21.join(projectRoot, "shared", "generated", "ui-contract.ts")
+  return await exists(path22.join(projectRoot, "app", "game.ts")) && await exists(
+    path22.join(projectRoot, "shared", "generated", "ui-contract.ts")
   );
 }
 async function ensureReducerNativeTestingFiles(projectRoot) {
-  const testingTypesPath = path21.join(projectRoot, "test", "testing-types.ts");
-  const testingContractPath = path21.join(
+  const testingTypesPath = path22.join(projectRoot, "test", "testing-types.ts");
+  const testingContractPath = path22.join(
     projectRoot,
     "test",
     "generated",
     "testing-contract.ts"
   );
-  const baseStatesPath = path21.join(
+  const baseStatesPath = path22.join(
     projectRoot,
     "test",
     "generated",
     "base-states.generated.ts"
   );
-  const baseStatesDtsPath = path21.join(
+  const baseStatesDtsPath = path22.join(
     projectRoot,
     "test",
     "generated",
     "base-states.generated.d.ts"
   );
-  const scenarioManifestPath = path21.join(
+  const scenarioManifestPath = path22.join(
     projectRoot,
     "test",
     "generated",
     "scenario-manifest.generated.ts"
   );
-  await ensureDir(path21.dirname(testingTypesPath));
-  await ensureDir(path21.dirname(testingContractPath));
+  await ensureDir(path22.dirname(testingTypesPath));
+  await ensureDir(path22.dirname(testingContractPath));
   const existingTestingTypes = await readTextFileIfExists(testingTypesPath);
   if (shouldRefreshReducerTestingTypes(existingTestingTypes)) {
     await writeTextFile(
@@ -21907,7 +23268,7 @@ var DEFAULT_REJECTION_CODES2 = [
 ];
 async function collectKnownRejectionCodes(projectRoot) {
   const knownCodes = new Set(DEFAULT_REJECTION_CODES2);
-  const gamePath = path21.join(projectRoot, "app", "game.ts");
+  const gamePath = path22.join(projectRoot, "app", "game.ts");
   if (!await exists(gamePath)) {
     return Array.from(knownCodes).sort(
       (left, right) => left.localeCompare(right)
@@ -21934,7 +23295,7 @@ async function collectKnownRejectionCodes(projectRoot) {
 }
 async function loadTypedBases(projectRoot) {
   const baseFiles = await discoverFiles(
-    path21.join(projectRoot, "test", "bases"),
+    path22.join(projectRoot, "test", "bases"),
     BASE_SUFFIX
   );
   const loaded = [];
@@ -21953,8 +23314,8 @@ async function loadTypedBases(projectRoot) {
   return loaded;
 }
 async function loadTypedScenarios(projectRoot, options) {
-  const scenarioFiles = options.scenarioPath ? [path21.resolve(projectRoot, options.scenarioPath)] : await discoverFiles(
-    path21.join(projectRoot, "test", "scenarios"),
+  const scenarioFiles = options.scenarioPath ? [path22.resolve(projectRoot, options.scenarioPath)] : await discoverFiles(
+    path22.join(projectRoot, "test", "scenarios"),
     SCENARIO_SUFFIX
   );
   const loaded = [];
@@ -21973,8 +23334,8 @@ async function loadTypedScenarios(projectRoot, options) {
   return loaded;
 }
 function reducerNativeTestHelperExternals(projectRoot, filePath) {
-  const testingTypesPath = path21.join(projectRoot, "test", "testing-types");
-  const relative = path21.relative(path21.dirname(filePath), testingTypesPath).replaceAll("\\", "/");
+  const testingTypesPath = path22.join(projectRoot, "test", "testing-types");
+  const relative = path22.relative(path22.dirname(filePath), testingTypesPath).replaceAll("\\", "/");
   const specifier = relative.startsWith(".") ? relative : `./${relative}`;
   return [specifier, `${specifier}.ts`];
 }
@@ -22479,7 +23840,7 @@ async function assertLiveMatchesShadow(runner, shadow, live) {
   }
 }
 async function loadBrowserDriver(projectRoot) {
-  const filePath = path21.join(projectRoot, "test", "browser-driver.ts");
+  const filePath = path22.join(projectRoot, "test", "browser-driver.ts");
   if (!await exists(filePath)) {
     return null;
   }
@@ -22507,7 +23868,7 @@ function sanitizeSnapshotSegment(value) {
 function createScenarioSnapshotMatcher(options) {
   return (filename, actual) => {
     const suffix = filename ? `.${sanitizeSnapshotSegment(filename)}` : "";
-    const snapshotPath = path21.join(
+    const snapshotPath = path22.join(
       options.projectRoot,
       "test",
       "generated",
@@ -22519,15 +23880,15 @@ function createScenarioSnapshotMatcher(options) {
     };
     const serialized = `${JSON.stringify(wrappedValue, null, 2)}
 `;
-    mkdirSync2(path21.dirname(snapshotPath), { recursive: true });
+    mkdirSync2(path22.dirname(snapshotPath), { recursive: true });
     if (!existsSync8(snapshotPath) || options.updateSnapshots) {
       writeFileSync2(snapshotPath, serialized, "utf8");
       return;
     }
-    const previous = JSON.parse(readFileSync3(snapshotPath, "utf8"));
+    const previous = JSON.parse(readFileSync4(snapshotPath, "utf8"));
     if (!deepEqual(previous.value, actual)) {
       throw new Error(
-        `Snapshot mismatch for scenario '${options.scenarioId}'. Re-run with --update-snapshots to refresh ${path21.relative(options.projectRoot, snapshotPath)}.`
+        `Snapshot mismatch for scenario '${options.scenarioId}'. Re-run with --update-snapshots to refresh ${path22.relative(options.projectRoot, snapshotPath)}.`
       );
     }
   };
@@ -22788,7 +24149,7 @@ async function createSessionFromScenario(options) {
 }
 var MATERIALIZED_SCENARIO_CACHE_VERSION = 1;
 function materializedScenarioCachePath(options) {
-  return path21.join(
+  return path22.join(
     options.projectRoot,
     PROJECT_DIR_NAME,
     "dev",
@@ -22816,7 +24177,7 @@ async function readMaterializedScenarioCache(options) {
 }
 async function writeMaterializedScenarioCache(options) {
   const cachePath = materializedScenarioCachePath(options);
-  await ensureDir(path21.dirname(cachePath));
+  await ensureDir(path22.dirname(cachePath));
   await writeJsonFile(cachePath, {
     cacheVersion: MATERIALIZED_SCENARIO_CACHE_VERSION,
     fingerprintHash: options.fingerprintHash,
@@ -22913,10 +24274,10 @@ async function materializeScenarioReducerState(options) {
   }
   const [gameModule, manifestContractModule] = await Promise.all([
     importTypeScriptModule(
-      path21.join(options.projectRoot, "app", "game.ts")
+      path22.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path21.join(options.projectRoot, "shared", "manifest-contract.ts")
+      path22.join(options.projectRoot, "shared", "manifest-contract.ts")
     )
   ]);
   const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
@@ -22998,10 +24359,10 @@ async function createScenarioActionPlan(options) {
     loadGeneratedBaseStates(options.projectRoot),
     loadManifest(options.projectRoot),
     importTypeScriptModule(
-      path21.join(options.projectRoot, "app", "game.ts")
+      path22.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path21.join(options.projectRoot, "shared", "manifest-contract.ts")
+      path22.join(options.projectRoot, "shared", "manifest-contract.ts")
     )
   ]);
   const matchingScenarios = scenarios.filter(
@@ -23268,7 +24629,7 @@ function sortBasesForArtifacts(bases, basesById) {
   return ordered;
 }
 function writeProjectionSnapshots(options) {
-  const projectionDir = path21.join(
+  const projectionDir = path22.join(
     options.projectRoot,
     "test",
     "generated",
@@ -23279,7 +24640,7 @@ function writeProjectionSnapshots(options) {
   mkdirSync2(projectionDir, { recursive: true });
   const projection = options.shadow.projectAllSeats();
   for (const [playerId, seatProjection] of Object.entries(projection.seats)) {
-    const outputPath = path21.join(projectionDir, `${playerId}.projection.json`);
+    const outputPath = path22.join(projectionDir, `${playerId}.projection.json`);
     writeFileSync2(
       outputPath,
       `${JSON.stringify(
@@ -23299,7 +24660,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) => path21.relative(process.cwd(), scenario.filePath) + ` -> '${scenario.definition.from}'`
+    (scenario) => path22.relative(process.cwd(), scenario.filePath) + ` -> '${scenario.definition.from}'`
   );
   if (invalid.length > 0) {
     throw new Error(
@@ -23313,23 +24674,23 @@ async function writeReducerNativeGeneratedFiles(options) {
   const manifestHash = hashContent(JSON.stringify(manifest));
   const appBundleHash = hashContent(
     await bundleTypeScriptModuleText(
-      path21.join(options.projectRoot, "app", "game.ts")
+      path22.join(options.projectRoot, "app", "game.ts")
     )
   );
   const uiContractHash = hashContent(
     await bundleTypeScriptModuleText(
-      path21.join(options.projectRoot, "shared", "generated", "ui-contract.ts")
+      path22.join(options.projectRoot, "shared", "generated", "ui-contract.ts")
     )
   );
-  const generatedDir = path21.join(options.projectRoot, "test", "generated");
+  const generatedDir = path22.join(options.projectRoot, "test", "generated");
   await ensureDir(generatedDir);
   const baseStates = {};
   const [gameModule, manifestContractModule] = await Promise.all([
     importTypeScriptModule(
-      path21.join(options.projectRoot, "app", "game.ts")
+      path22.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path21.join(options.projectRoot, "shared", "manifest-contract.ts")
+      path22.join(options.projectRoot, "shared", "manifest-contract.ts")
     )
   ]);
   const createInitialTable = typeof manifestContractModule.createInitialTable === "function" ? manifestContractModule.createInitialTable : null;
@@ -23417,21 +24778,21 @@ async function writeReducerNativeGeneratedFiles(options) {
   }
   const header = "// Generated by dreamboard test generate. Do not edit by hand.\n";
   await writeTextFile(
-    path21.join(generatedDir, "base-states.generated.ts"),
+    path22.join(generatedDir, "base-states.generated.ts"),
     `${header}export const BASE_STATES = ${JSON.stringify(baseStates, null, 2)} as const;
 `
   );
   await writeTextFile(
-    path21.join(generatedDir, "base-states.generated.d.ts"),
+    path22.join(generatedDir, "base-states.generated.d.ts"),
     `${header}export declare const BASE_STATES: Record<string, unknown>;
 `
   );
   await writeTextFile(
-    path21.join(generatedDir, "scenario-manifest.generated.ts"),
+    path22.join(generatedDir, "scenario-manifest.generated.ts"),
     `${header}export const SCENARIO_MANIFEST = ${JSON.stringify(
       options.scenarios.map((scenario) => ({
         id: scenario.definition.id,
-        filePath: path21.relative(generatedDir, scenario.filePath),
+        filePath: path22.relative(generatedDir, scenario.filePath),
         base: scenario.definition.from,
         runners: normalizeScenarioRunners(scenario.definition.runners)
       })),
@@ -23440,14 +24801,14 @@ async function writeReducerNativeGeneratedFiles(options) {
     )} as const;
 `
   );
-  await writeJsonFile(path21.join(generatedDir, ".generation-meta.json"), {
+  await writeJsonFile(path22.join(generatedDir, ".generation-meta.json"), {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     scenarioCount: options.scenarios.length,
     baseStateCount: options.bases.length
   });
 }
 async function loadGeneratedBaseStates(projectRoot) {
-  const filePath = path21.join(
+  const filePath = path22.join(
     projectRoot,
     "test",
     "generated",
@@ -23460,7 +24821,7 @@ async function loadGeneratedBaseStates(projectRoot) {
   return module.BASE_STATES ?? null;
 }
 async function loadGeneratedScenarioManifest(projectRoot) {
-  const filePath = path21.join(
+  const filePath = path22.join(
     projectRoot,
     "test",
     "generated",
@@ -23550,12 +24911,12 @@ async function currentFingerprint(options) {
     manifestHash: hashContent(JSON.stringify(manifest)),
     appBundleHash: hashContent(
       await bundleTypeScriptModuleText(
-        path21.join(options.projectRoot, "app", "game.ts")
+        path22.join(options.projectRoot, "app", "game.ts")
       )
     ),
     uiContractHash: hashContent(
       await bundleTypeScriptModuleText(
-        path21.join(options.projectRoot, "shared", "generated", "ui-contract.ts")
+        path22.join(options.projectRoot, "shared", "generated", "ui-contract.ts")
       )
     ),
     setupProfileId: effectiveSetup.setupProfileId,
@@ -23602,10 +24963,10 @@ async function runReducerNativeScenarios(options) {
     loadGeneratedBaseStates(options.projectRoot),
     loadManifest(options.projectRoot),
     importTypeScriptModule(
-      path21.join(options.projectRoot, "app", "game.ts")
+      path22.join(options.projectRoot, "app", "game.ts")
     ),
     importTypeScriptModule(
-      path21.join(options.projectRoot, "shared", "manifest-contract.ts")
+      path22.join(options.projectRoot, "shared", "manifest-contract.ts")
     )
   ]);
   let generatedBaseStates = initialGeneratedBaseStates;
@@ -23823,7 +25184,11 @@ async function runReducerNativeScenarios(options) {
         results.push({
           id: scenario.definition.id,
           success: false,
-          error: error instanceof Error ? error.message : `Scenario '${scenario.definition.id}' failed.`
+          error: error instanceof Error ? formatScenarioErrorForDisplay({
+            error,
+            projectRoot: options.projectRoot,
+            scenarioFilePath: scenario.filePath
+          }) : `Scenario '${scenario.definition.id}' failed.`
         });
       }
     }
@@ -23839,8 +25204,8 @@ async function runReducerNativeScenarios(options) {
 }
 
 // src/services/project/reducer-contract-preflight.ts
-import path22 from "path";
-var GAME_CONTRACT_ENTRY_PATH = path22.join("app", "game-contract.ts");
+import path23 from "path";
+var GAME_CONTRACT_ENTRY_PATH = path23.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";
@@ -23849,7 +25214,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 = path22.join(projectRoot, GAME_CONTRACT_ENTRY_PATH);
+  const entryPath = path23.join(projectRoot, GAME_CONTRACT_ENTRY_PATH);
   try {
     await importTypeScriptModule(entryPath);
   } catch (error) {
@@ -23875,8 +25240,8 @@ async function assertReducerContractPreflight(projectRoot) {
 }
 
 // src/services/project/reducer-bundle-preflight.ts
-import path23 from "path";
-var REDUCER_BUNDLE_ENTRY_PATH = path23.join("app", "index.ts");
+import path24 from "path";
+var REDUCER_BUNDLE_ENTRY_PATH = path24.join("app", "index.ts");
 var PREFLIGHT_RNG_SEED = 1337;
 function buildPlayerIds(playerCount) {
   const ids = [];
@@ -24064,7 +25429,7 @@ async function runReducerBundleSmoke(options) {
   if (scenarios.length === 0) {
     return [];
   }
-  const entryPath = path23.join(projectRoot, REDUCER_BUNDLE_ENTRY_PATH);
+  const entryPath = path24.join(projectRoot, REDUCER_BUNDLE_ENTRY_PATH);
   let module;
   try {
     module = await importTypeScriptModule(
@@ -24249,9 +25614,9 @@ var dev_default = defineCommand({
       env: parsedArgs.env ?? "dev",
       debug: parsedArgs.debug
     });
-    const devDir = path24.join(projectRoot, PROJECT_DIR_NAME, "dev");
+    const devDir = path25.join(projectRoot, PROJECT_DIR_NAME, "dev");
     await ensureDir(devDir);
-    const sessionFilePath = path24.join(devDir, "session.json");
+    const sessionFilePath = path25.join(devDir, "session.json");
     const requestedResumeSessionId = parsedArgs.resume?.trim() || null;
     const requestedScenarioId = parsedArgs["from-scenario"]?.trim() || null;
     if (requestedResumeSessionId && parsedArgs["new-session"]) {
@@ -24431,26 +25796,32 @@ async function ensureDevCompiledResult(options) {
   const localMaintainerEnabled = isLocalMaintainerRegistryEnabled(
     options.config.apiBaseUrl
   );
-  const localMaintainerRegistry = localMaintainerEnabled ? await runLoggedStep(
+  const existingLocalMaintainerRegistry = getProjectLocalMaintainerRegistry(
+    options.projectConfig
+  );
+  const refreshedLocalMaintainerRegistry = localMaintainerEnabled ? await runLoggedStep(
     "Checking local SDK snapshot...",
     () => ensureLocalMaintainerSnapshot(options.config.apiBaseUrl)
   ) : await ensureLocalMaintainerSnapshot(options.config.apiBaseUrl);
-  if (localMaintainerRegistry) {
+  const localMaintainerRegistry = refreshedLocalMaintainerRegistry ?? (localMaintainerEnabled ? existingLocalMaintainerRegistry ?? null : null);
+  if (refreshedLocalMaintainerRegistry) {
     if (didLocalMaintainerSnapshotChange(
-      getProjectLocalMaintainerRegistry(options.projectConfig),
-      localMaintainerRegistry
+      existingLocalMaintainerRegistry,
+      refreshedLocalMaintainerRegistry
     )) {
       await updateProjectState(
         options.projectRoot,
         updateProjectLocalMaintainerRegistry(
           options.projectConfig,
-          localMaintainerRegistry
+          refreshedLocalMaintainerRegistry
         )
       );
       consola.info("Local SDK snapshot refreshed.");
     } else {
       consola.info("Using existing local SDK snapshot.");
     }
+  } else if (localMaintainerRegistry) {
+    consola.info("Using workspace-pinned local SDK snapshot.");
   }
   await runLoggedStep(
     "Refreshing static scaffold...",
@@ -24586,7 +25957,7 @@ async function resolveBackendVersionMetadata() {
 }
 async function readWorkspacePackageJson(projectRoot) {
   try {
-    const raw = await readTextFile(path24.join(projectRoot, "package.json"));
+    const raw = await readTextFile(path25.join(projectRoot, "package.json"));
     const parsed = JSON.parse(raw);
     return {
       dependencies: Object.fromEntries(
@@ -24724,7 +26095,7 @@ function extractUserIdFromJwt(token) {
 }
 
 // src/commands/join.ts
-import path25 from "path";
+import path26 from "path";
 
 // src/services/join/jsonl-bot-session.ts
 import { createInterface as createInterface2 } from "readline";
@@ -25104,17 +26475,20 @@ function actionCacheFromGameplay(gameplay) {
   };
 }
 function compactActionFromDescriptor(descriptor) {
+  const availability = descriptor.availability;
+  const unavailableReason = availability.status === "available" ? void 0 : availability.reason;
+  const missingResources = availability.status === "insufficientResources" ? availability.missingResources : void 0;
   return compactObject({
     interactionId: descriptor.interactionId,
     interactionKey: descriptor.interactionKey,
     kind: descriptor.kind,
-    available: descriptor.available ?? false,
-    unavailableReason: descriptor.unavailableReason,
+    available: availability.status === "available",
+    unavailableReason,
     inputs: normalizeUnknownJson(descriptor.inputs),
     cost: normalizeUnknownJson(descriptor.cost),
     currentResources: normalizeUnknownJson(descriptor.currentResources),
-    missingResources: descriptor.missingResources,
-    context: normalizeUnknownJson(descriptor.context)
+    missingResources,
+    context: descriptor.kind === "prompt" ? normalizeUnknownJson(descriptor.context) : void 0
   });
 }
 function compactGameplayEvent(options) {
@@ -25646,7 +27020,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 = path25.join(
+  const sessionFilePath = path26.join(
     projectRoot,
     PROJECT_DIR_NAME,
     "dev",
@@ -25758,7 +27132,7 @@ var logout_default = defineCommand({
 });
 
 // src/commands/new.ts
-import path26 from "path";
+import path27 from "path";
 var new_default = defineCommand({
   meta: {
     name: "new",
@@ -25879,7 +27253,7 @@ var new_default = defineCommand({
         ruleId
       );
       consola.start("Scaffolding local workspace...");
-      const targetDir = path26.resolve(process.cwd(), normalizedSlug);
+      const targetDir = path27.resolve(process.cwd(), normalizedSlug);
       await ensureDir(targetDir);
       await writeManifest(targetDir, blankManifest);
       await writeRule(targetDir, "");
@@ -26104,7 +27478,8 @@ var status_default = defineCommand({
     let remoteHeadId = null;
     let authoredRelation = "unknown";
     let compileRelation = "never_compiled";
-    let completionLights = null;
+    let verified = null;
+    let verifiedAt = null;
     if (config.authToken) {
       await configureClient(config);
       const remoteHead = await getAuthoringHeadSdk(projectConfig.gameId);
@@ -26113,7 +27488,8 @@ var status_default = defineCommand({
         path: { gameId: projectConfig.gameId }
       });
       if (game) {
-        completionLights = game.completionLights;
+        verified = game.verified;
+        verifiedAt = game.verifiedAt ?? null;
       }
       const hasLocalDiff = diff.modified.length > 0 || diff.added.length > 0 || diff.deleted.length > 0;
       if (pendingSync) {
@@ -26168,7 +27544,10 @@ var status_default = defineCommand({
               deleted: diff.deleted.length
             },
             localDiffPaths: diff,
-            completionLights
+            verification: {
+              verified,
+              verifiedAt
+            }
           },
           null,
           2
@@ -26184,14 +27563,10 @@ var status_default = defineCommand({
     if (diff.added.length > 0) consola.log(`Added: ${diff.added.join(", ")}`);
     if (diff.deleted.length > 0)
       consola.log(`Deleted: ${diff.deleted.join(", ")}`);
-    if (completionLights) {
-      const lightSummary = [
-        `rules:${completionLights.rules}`,
-        `manifest:${completionLights.manifest}`,
-        `phases:${completionLights.phases}`,
-        `ui:${completionLights.ui}`
-      ].join("  ");
-      consola.info(`Completion lights: ${lightSummary}`);
+    if (verified !== null) {
+      consola.info(
+        `Verification: ${verified ? "verified" : "unverified"}${verifiedAt ? ` at ${verifiedAt}` : ""}`
+      );
     }
     if (!config.authToken) {
       consola.warn("Remote status unavailable (no auth token).");
@@ -26235,9 +27610,9 @@ function buildSourceChanges(options) {
   if (mode === "replace") {
     return Object.entries(localFiles).filter(
       ([filePath]) => isSourceRevisionPath(filePath) || shouldAlwaysUpsertSourcePath(filePath)
-    ).sort(([left], [right]) => left.localeCompare(right)).map(([path28, content]) => ({
+    ).sort(([left], [right]) => left.localeCompare(right)).map(([path29, content]) => ({
       kind: "upsert",
-      path: path28,
+      path: path29,
       content
     }));
   }
@@ -26404,22 +27779,26 @@ var sync_default = defineCommand({
     const localMaintainerEnabled = isLocalMaintainerRegistryEnabled(
       config.apiBaseUrl
     );
-    const localMaintainerRegistry = localMaintainerEnabled ? await runLoggedStep2(
+    const existingLocalMaintainerRegistry = getProjectLocalMaintainerRegistry(projectConfig);
+    const refreshedLocalMaintainerRegistry = localMaintainerEnabled ? await runLoggedStep2(
       "Checking local SDK snapshot...",
       () => ensureLocalMaintainerSnapshot(config.apiBaseUrl)
     ) : await ensureLocalMaintainerSnapshot(config.apiBaseUrl);
+    const localMaintainerRegistry = refreshedLocalMaintainerRegistry ?? (localMaintainerEnabled ? existingLocalMaintainerRegistry ?? null : null);
     const localMaintainerSnapshotChanged = didLocalMaintainerSnapshotChange(
-      getProjectLocalMaintainerRegistry(projectConfig),
-      localMaintainerRegistry
+      existingLocalMaintainerRegistry,
+      refreshedLocalMaintainerRegistry
     );
-    if (localMaintainerRegistry) {
+    if (refreshedLocalMaintainerRegistry) {
       nextProjectConfig = updateProjectLocalMaintainerRegistry(
         nextProjectConfig,
-        localMaintainerRegistry
+        refreshedLocalMaintainerRegistry
       );
       consola.info(
         localMaintainerSnapshotChanged ? "Local SDK snapshot refreshed." : "Using existing local SDK snapshot."
       );
+    } else if (localMaintainerRegistry) {
+      consola.info("Using workspace-pinned local SDK snapshot.");
     }
     await runLoggedStep2(
       "Refreshing static scaffold...",
@@ -26791,7 +28170,7 @@ var sync_default = defineCommand({
 
 // src/commands/test.ts
 import { readFile as readFile4 } from "fs/promises";
-import path27 from "path";
+import path28 from "path";
 
 // src/services/testing/runtime-mode.ts
 function isRemoteTestEnvironment(environment) {
@@ -26855,7 +28234,7 @@ async function uploadGeneratedPreviewProjection(options) {
   if (!previewBase) {
     return;
   }
-  const projectionPath = path27.join(
+  const projectionPath = path28.join(
     options.projectRoot,
     "test",
     "generated",
@@ -27115,7 +28494,7 @@ function runDreamboardCli(internalSubCommands = {}) {
   const main = defineCommand({
     meta: {
       name: "dreamboard",
-      version: "0.1.25",
+      version: "0.1.26",
       description: "Dreamboard CLI \u2014 game development platform"
     },
     subCommands
@@ -27171,4 +28550,4 @@ export {
   test_default,
   runDreamboardCli
 };
-//# sourceMappingURL=chunk-MG6EVR7P.js.map
+//# sourceMappingURL=chunk-VRJ4FOH2.js.map