dreamboard 0.1.14 → 0.1.16

package/dist/{chunk-6FPQ3S2J.js → chunk-WDTE6OFH.js}

@@ -5509,7 +5509,7 @@ function renderCardPropertiesSchemaByCardSetId(cardSets) {
       `  ${quote(cardSet.id)}: ${toPascalCase(cardSet.id)}CardPropertiesSchema,`
     ];
   });
-  return `const cardPropertiesSchemaByCardSetId: Record<string, z.ZodTypeAny> = {
+  return `const cardPropertiesSchemaByCardSetId: Record<string, z.ZodType<unknown>> = {
 ${entries.join("\n")}
 };`;
 }
@@ -5715,7 +5715,7 @@ function renderCardStateSchemaById(analysis) {
   return `z.object(
   Object.fromEntries(
     literals.cardIds.map((cardId) => [cardId, createCardStateSchema(cardId)]),
-  ) as Record<CardId, z.ZodTypeAny>,
+  ) as Record<CardId, z.ZodType<unknown>>,
 )`;
 }
 function renderCardStateSchemaFactory(analysis) {
@@ -5793,8 +5793,17 @@ function renderGenericBoardStateSchema(board, runtimeBoardId) {
     playerId: ${playerId ? `z.literal(${quote(playerId)})` : "ids.playerId.nullable().optional()"},
     templateId: z.string().nullable().optional(),
     fields: ${`${boardFieldsTypeName(board.board.id)}Schema`},
+    // T220: per-board state.spaces is loose-keyed by string. The
+    // canonical narrow id (\`ids.spaceId\`) is a Zod enum of EVERY
+    // space id across every board, which makes a strict
+    // \`z.record(enum, \u2026)\` reject any board whose spaces are a
+    // proper subset of that enum. Loose keying matches the JSON wire
+    // shape (\`additionalProperties\`); the inner \`id: ids.spaceId\`
+    // narrows the value's spaceId at parse time. A future per-board
+    // branded-id refactor (option B) can re-tighten this without a
+    // wire change.
     spaces: z.record(
-      ids.spaceId,
+      z.string(),
       z.object({
         id: ids.spaceId,
         name: z.string().nullable().optional(),
@@ -5840,8 +5849,9 @@ function renderHexBoardStateSchema(board, runtimeBoardId) {
     playerId: ${playerId ? `z.literal(${quote(playerId)})` : "ids.playerId.nullable().optional()"},
     templateId: z.string().nullable().optional(),
     fields: ${`${boardFieldsTypeName(board.board.id)}Schema`},
+    // T220: see generic-board comment on the loose-keying choice.
     spaces: z.record(
-      ids.spaceId,
+      z.string(),
       z.object({
         id: ids.spaceId,
         name: z.string().nullable().optional(),
@@ -5897,8 +5907,9 @@ function renderSquareBoardStateSchema(board, runtimeBoardId) {
     playerId: ${playerId ? `z.literal(${quote(playerId)})` : "ids.playerId.nullable().optional()"},
     templateId: z.string().nullable().optional(),
     fields: ${`${boardFieldsTypeName(board.board.id)}Schema`},
+    // T220: see generic-board comment on the loose-keying choice.
     spaces: z.record(
-      ids.spaceId,
+      z.string(),
       z.object({
         id: ids.spaceId,
         name: z.string().nullable().optional(),
@@ -7611,7 +7622,11 @@ const runtimeGenericBoardStateSchema = z.object({
   playerId: ids.playerId.nullable().optional(),
   templateId: z.string().nullable().optional(),
   fields: unknownRecordSchema,
-  spaces: z.record(ids.spaceId, boardSpaceStateSchema),
+  // T220: per-board state.spaces is loose-keyed by string. See the
+  // codegen-template comment in renderGenericBoardStateSchema for
+  // the rationale; the wire shape is unchanged (additionalProperties
+  // JSON), and the inner id field narrows at parse time.
+  spaces: z.record(z.string(), boardSpaceStateSchema),
   relations: z.array(boardRelationStateSchema),
   containers: z.record(ids.boardContainerId, boardContainerStateSchema),
 });
@@ -7641,7 +7656,8 @@ const squareVertexStateSchema = z.object({
 });
 const runtimeHexBoardStateSchema = runtimeGenericBoardStateSchema.extend({
   layout: z.literal("hex"),
-  spaces: z.record(ids.spaceId, hexSpaceStateSchema),
+  // T220: loose-keyed by string \u2014 see comment above.
+  spaces: z.record(z.string(), hexSpaceStateSchema),
   relations: z.array(boardRelationStateSchema),
   containers: z.object({}),
   orientation: z.enum(["pointy-top", "flat-top"]),
@@ -7650,7 +7666,8 @@ const runtimeHexBoardStateSchema = runtimeGenericBoardStateSchema.extend({
 });
 const runtimeSquareBoardStateSchema = runtimeGenericBoardStateSchema.extend({
   layout: z.literal("square"),
-  spaces: z.record(ids.spaceId, squareSpaceStateSchema),
+  // T220: loose-keyed by string \u2014 see comment above.
+  spaces: z.record(z.string(), squareSpaceStateSchema),
   relations: z.array(boardRelationStateSchema),
   containers: z.record(ids.boardContainerId, boardContainerStateSchema),
   edges: z.array(hexEdgeStateSchema),
@@ -7862,11 +7879,11 @@ export const schemas = {
 } as const;
 
 export function createGameStateSchema<
-  PhaseNameSchema extends z.ZodTypeAny,
-  PublicSchema extends z.ZodTypeAny,
-  PrivateSchema extends z.ZodTypeAny,
-  HiddenSchema extends z.ZodTypeAny,
-  PhasesSchema extends z.ZodTypeAny,
+  PhaseNameSchema extends z.ZodType<unknown>,
+  PublicSchema extends z.ZodType<unknown>,
+  PrivateSchema extends z.ZodType<unknown>,
+  HiddenSchema extends z.ZodType<unknown>,
+  PhasesSchema extends z.ZodType<unknown>,
 >({
   phaseNameSchema,
   publicSchema,
@@ -8050,6 +8067,27 @@ import { literals } from "./manifest-literals";
 import type { PlayerId as PublicPlayerId, TableState as PublicTableState } from "./manifest-types";
 
 const unknownRecordSchema`
+  ).replaceAll(
+    "literals.playerIds as unknown as readonly PlayerId[]",
+    "literals.playerIds"
+  ).replaceAll(
+    "cardId: cardIdSchema as unknown as z.ZodType<CardId>,",
+    "cardId: assumeManifestSchema<CardId>(cardIdSchema),"
+  ).replaceAll(
+    "deckId: deckIdSchema as unknown as z.ZodType<DeckId>,",
+    "deckId: assumeManifestSchema<DeckId>(deckIdSchema),"
+  ).replaceAll(
+    "handId: handIdSchema as unknown as z.ZodType<HandId>,",
+    "handId: assumeManifestSchema<HandId>(handIdSchema),"
+  ).replace(
+    /export const staticBoards = ([\s\S]*?) as const;\n\nconst baseInitialTable = /,
+    "export const staticBoards = $1 as const satisfies StaticBoards<PublicTableState>;\n\nconst baseInitialTable = "
+  ).replace(
+    /const baseInitialTable = ([\s\S]*?) as const as unknown as TableState;\nconst baseDeckCardsByZoneId:/,
+    "const baseInitialTable = cloneManifestDefault<PublicTableState>($1);\nconst baseDeckCardsByZoneId:"
+  ).replace(
+    "staticBoards: staticBoards as unknown as StaticBoards<TableState>,",
+    "staticBoards,"
   ).replace(
     `export const manifestContract: ReducerManifestContract<
   RuntimeTableRecord,`,
@@ -8071,12 +8109,14 @@ const unknownRecordSchema`
     .min(1)
     .transform((value) => asPlayerId(value)),
 );`,
-    `const playerIdSchema = markManifestScopedSchema(
-  z
-    .string()
-    .min(1)
-    .transform((value) => asPlayerId(value)),
-) as unknown as z.ZodType<PublicPlayerId>;`
+    `const playerIdSchema = assumeManifestSchema<PublicPlayerId>(
+  markManifestScopedSchema(
+    z
+      .string()
+      .min(1)
+      .transform((value) => asPlayerId(value)),
+  ),
+);`
   );
 }
 function renderCardSetTypeSections(analysis) {
@@ -9157,9 +9197,9 @@ import {
   createClientParamSchemasByPhase,
 } from "@dreamboard/app-sdk/reducer";
 import type {
-  ClientParamsOfInteractionOfDefinition,
-  DefaultedClientParamKeysOfInteractionOfDefinition,
-  InteractionIdOfDefinition,
+	  ClientParamsOfInteractionOfDefinition,
+	  DefaultedClientParamKeysOfInteractionOfDefinition,
+	  InteractionIdOfDefinition,
   InteractionIdOfDefinitionPhase,
   PhaseNamesOfDefinition,
   StageNamesOfDefinitionPhase,
@@ -9167,35 +9207,38 @@ import type {
   ViewOfDefinition,
 } from "@dreamboard/app-sdk/reducer";
 import {
-  createDreamboardUI,
-  createHexBoardView,
-  InteractionField as InteractionFieldGeneric,
-  InteractionForm as InteractionFormGeneric,
-  useActivePlayers as useActivePlayersGeneric,
-  useBoardInteractions as useBoardInteractionsGeneric,
-  useGameView as useGameViewGeneric,
-  useInteractionByKey as useInteractionByKeyGeneric,
-  usePlayerTurnOrder as usePlayerTurnOrderGeneric,
-  type BoardInteractionsContext,
-  type BoardInteractionsOptions,
-  type BoardSpaceIdOf,
-  type ClientParamSchemaMap,
-  type HexBoardView,
-  type InteractionDescriptor,
-  type InteractionFieldProps as InteractionFieldPropsGeneric,
-  type InteractionFieldRenderMap,
-  type InteractionFormProps as InteractionFormPropsGeneric,
-  type InteractionHandle,
-  type DreamboardUI,
-  type UIContract,
-} from "@dreamboard/ui-sdk";
-import { createElement, useMemo, type ReactElement } from "react";
-import {
-  literals,
-  staticBoards,
-  type CardId,
-  type EdgeId,
+	  createDreamboardUI,
+	  createResourceCounter,
+	  type BoardHexGridProps as BoardHexGridPropsGeneric,
+	  type BoardHexViewProps as BoardHexViewPropsGeneric,
+	  type BoardSpaceIdOf,
+	  type ClientParamSchemaMap,
+	  type InteractionDescriptor,
+	  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 PlayerId,
+  type ResourceId,
   type SpaceId,
   type VertexId,
   type ZoneId as ManifestZoneId,
@@ -9294,8 +9337,7 @@ export type InteractionDescriptorFor<Key extends InteractionKey> =
 
 /**
  * Params shape for a phase-qualified interaction key. Drives strong typing
- * for \`useInteractionByKey\`'s draft,
- * \`submit\`, and \`setInput\`.
+ * for component-first interaction state, forms, and submits.
  */
 export type InteractionParamsOf<Key extends InteractionKey> =
   InteractionParams<PhaseOfInteractionKey<Key>, IdOfInteractionKey<Key>>;
@@ -9318,6 +9360,50 @@ type InteractionHandleDefaultedKeys<Key extends InteractionKey> = Extract<
   keyof InteractionParamsShape<Key> & string
 >;
 
+type RequiredInteractionInputKeysOf<Key extends InteractionKey> = Exclude<
+  InteractionInputKeysOf<Key>,
+  InteractionHandleDefaultedKeys<Key>
+>;
+
+export type RequiredInteractionInputKey<Key extends InteractionKey> =
+  RequiredInteractionInputKeysOf<Key>;
+
+export type ZeroInputInteractionKey = {
+  [K in InteractionKey]: InteractionInputKeysOf<K> extends never
+    ? K
+    : never;
+}[InteractionKey];
+
+export type InputInteractionKey = Exclude<
+  InteractionKey,
+  ZeroInputInteractionKey
+>;
+
+export type InteractionRouteRenderState<Key extends InteractionKey> =
+  Omit<InteractionSwitchRenderState<Key>, "descriptor"> & {
+    descriptor: InteractionDescriptorFor<Key>;
+  };
+
+export type InteractionRouteMap = {
+  [K in InteractionKey]: (state: InteractionRouteRenderState<K>) => ReactNode;
+};
+
+type ExactInteractionRoutes<Routes extends InteractionRouteMap> = Routes &
+  Record<Exclude<keyof Routes, keyof InteractionRouteMap>, never>;
+
+export function defineInteractionRoutes<const Routes extends InteractionRouteMap>(
+  routes: ExactInteractionRoutes<Routes>,
+): InteractionRouteMap {
+  return routes;
+}
+
+type InteractionSwitchProps = Omit<
+  InteractionSwitchPropsGeneric<InteractionKey>,
+  "routes"
+> & {
+  routes: InteractionRouteMap;
+};
+
 type InteractionInputKeyOf<Key extends InteractionKey> =
   Key extends InteractionKey ? InteractionInputKeysOf<Key> : never;
 
@@ -9349,6 +9435,10 @@ type UIPromptOptionRegistry = {
   [K in PromptOptionValue]: { value: K };
 };
 
+type UIPlayerRegistry = {
+  [K in PlayerId & string]: { player: K };
+};
+
 type UIZoneRegistry = {
   [K in ZoneId & string]: { zone: K };
 };
@@ -9370,6 +9460,7 @@ export const uiContract = {
   inputs: {} as UIInputRegistry,
   prompts: {} as UIPromptRegistry,
   promptOptions: {} as UIPromptOptionRegistry,
+  players: {} as UIPlayerRegistry,
   zones: {} as UIZoneRegistry,
   cards: {} as UICardRegistry,
   phases: {} as UIPhaseRegistry,
@@ -9383,142 +9474,6 @@ declare module "@dreamboard/ui-sdk" {
   }
 }
 
-type WorkspaceUI = DreamboardUI<typeof uiContract>;
-
-export const UI: WorkspaceUI = createDreamboardUI(uiContract);
-export const Interaction = UI.Interaction;
-export const Prompt = UI.Prompt;
-export const PromptInbox = UI.PromptInbox;
-export const PromptDialogHost = UI.PromptDialogHost;
-export const PlayerRoster: WorkspaceUI["PlayerRoster"] = UI.PlayerRoster;
-export const Phase = UI.Phase;
-export const Zone = UI.Zone;
-export const Board = UI.Board;
-
-export type InteractionFieldRenderers<Key extends InteractionKey> =
-  InteractionFieldRenderMap<InteractionParamsShape<Key>>;
-
-export type InteractionFormProps<Key extends InteractionKey> = Omit<
-  InteractionFormPropsGeneric<
-    InteractionParamsShape<Key>,
-    InteractionHandleDefaultedKeys<Key>
-  >,
-  "descriptor" | "handle"
-> & {
-  descriptor: InteractionDescriptorFor<Key>;
-  handle: InteractionHandle<
-    InteractionParamsShape<Key>,
-    InteractionHandleDefaultedKeys<Key>
-  >;
-  renderFields?: InteractionFieldRenderers<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;
-
-/**
- * Workspace-typed wrapper over \`@dreamboard/ui-sdk\`'s generic
- * \`useInteractionByKey\`. The \`key\` argument is constrained to the
- * generated {@link InteractionKey} union (typos are compile errors), and
- * the returned {@link InteractionHandle} is parameterised on
- * {@link InteractionParamsOf} so \`handle.draft\`, \`handle.submit\`, and
- * \`handle.setInput\` are statically typed against the interaction's
- * declared inputs.
- *
- * \`\`\`ts
- * const handle = useInteractionByKey("play.placeThingCard");
- * if (!handle) return null;
- * handle.setInput("cardId", card.id); // inferred as ThingsDeckCardId
- * await handle.submit(); // params typed from the reducer contract
- * \`\`\`
- */
-export function useInteractionByKey<Key extends InteractionKey>(
-  key: Key | null | undefined,
-): InteractionHandle<
-  InteractionParamsShape<Key>,
-  InteractionHandleDefaultedKeys<Key>
-> | null {
-  return useInteractionByKeyGeneric<
-    Key,
-    InteractionParamsShape<Key>,
-    InteractionHandleDefaultedKeys<Key>
-  >(key);
-}
-
-export function InteractionForm<Key extends InteractionKey>(
-  props: InteractionFormProps<Key>,
-): ReactElement {
-  return createElement(
-    InteractionFormGeneric<
-      InteractionParamsShape<Key>,
-      InteractionHandleDefaultedKeys<Key>
-    >,
-    props,
-  );
-}
-
-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,
-  );
-}
-
-/**
- * Workspace-typed wrapper over \`@dreamboard/ui-sdk\`'s
- * \`useBoardInteractions\`. Returns a {@link BoardInteractionsContext}
- * narrowed to this workspace's board-interaction union for exhaustive
- * downstream logic.
- *
- * \`\`\`tsx
- * const board = useBoardInteractions();
- * <HexGrid interactiveVertices={board.targetLayers.vertex()} />
- * \`\`\`
- *
- * Reach for this whenever a screen keeps more than one board target
- * interaction live simultaneously and dispatch is target-driven instead of
- * armed-then-clicked. Ambiguous unarmed overlaps should be resolved in the UI
- * by arming an explicit interaction/input route.
- */
-export function useBoardInteractions(
-  options?: BoardInteractionsOptions,
-): BoardInteractionsContext<BoardInteractions> {
-  return useBoardInteractionsGeneric<BoardInteractions>(options);
-}
-
-/** Workspace-typed active-player hook. */
-export function useActivePlayers(): readonly PlayerId[] {
-  return useActivePlayersGeneric() as readonly PlayerId[];
-}
-
-/** Workspace-typed reducer-native player view hook. */
-export function useGameView(): GameView {
-  return useGameViewGeneric() as GameView;
-}
-
-/** Workspace-typed player turn order hook. */
-export function usePlayerTurnOrder(): readonly PlayerId[] {
-  return usePlayerTurnOrderGeneric() as readonly PlayerId[];
-}
-
 // -------------------------------------------------------------------------
 // Typed hex-board view adapter
 // -------------------------------------------------------------------------
@@ -9537,49 +9492,176 @@ export type HexBoardSpaceId<Id extends HexBoardId> = BoardSpaceIdOf<
   HexBoardTopology<Id>
 >;
 
-/**
- * Workspace-typed wrapper over \`@dreamboard/ui-sdk\`'s
- * \`createHexBoardView\`. Joins the static topology of the named hex
- * board with a per-space view overlay and returns a value ready for
- * \`<HexGrid board={...} />\`. Each rendered tile carries a \`view\`
- * field typed as the matched overlay row.
- *
- * Strict by construction: every static space must have exactly one
- * overlay; missing, duplicate, or unknown overlay ids throw.
- *
- * \`\`\`tsx
- * const island = useHexBoardView("island", { spaces: view.spaces });
- *
- * <HexGrid
- *   board={island}
- *   renderTile={(tile) => {
- *     const terrain = tile.view.terrain;
- *     // ...
- *   }}
- * />
- * \`\`\`
- */
-export function useHexBoardView<
-  const Id extends HexBoardId,
-  const TSpaceView extends { id: HexBoardSpaceId<Id> },
->(
-  boardId: Id,
-  options: { spaces: ReadonlyArray<TSpaceView> },
-): HexBoardView<HexBoardTopology<Id>, TSpaceView> {
-  const board = hexStaticBoards[boardId];
-  const { spaces } = options;
-  return useMemo(
-    () => createHexBoardView<HexBoardTopology<Id>, TSpaceView>(board, { spaces }),
-    [board, spaces],
-  );
-}
+export type HexBoardViewProps<
+  Id extends HexBoardId,
+  TSpaceView extends { id: HexBoardSpaceId<Id> },
+> = Omit<BoardHexViewPropsGeneric<HexBoardTopology<Id>, TSpaceView>, "board"> & {
+  board: Id;
+};
+
+export type HexBoardGridProps<
+  Id extends HexBoardId,
+  TSpaceView extends { id: HexBoardSpaceId<Id> },
+> = Omit<
+  BoardHexGridPropsGeneric<HexBoardTopology<Id>, TSpaceView>,
+  "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"> & {
+  HexView<
+    const Id extends HexBoardId,
+    const TSpaceView extends { id: HexBoardSpaceId<Id> },
+  >(props: HexBoardViewProps<Id, TSpaceView>): ReactElement;
+  HexGrid<
+    const Id extends HexBoardId,
+    const TSpaceView extends { id: HexBoardSpaceId<Id> },
+  >(props: HexBoardGridProps<Id, TSpaceView>): ReactElement;
+};
+
+type WorkspaceCardProperties = CardProperties extends Record<string, unknown>
+  ? CardProperties
+  : Record<string, unknown>;
+type WorkspaceZoneId = [ZoneId] extends [never] ? string : ZoneId;
+type WorkspaceCardId = [CardId] extends [never] ? string : CardId;
+type WorkspaceCardType = [CardType] extends [never] ? string : CardType;
+
+// ZoneCardRenderItem is a discriminated union (hidden: true | false).
+// A bare Omit<..., "zone"> would collapse the union to its common keys and
+// strip cardType / properties from the hydrated branch, defeating the
+// discriminated-union narrowing the SDK contract promises. Distribute Omit
+// across the union so each branch keeps its own shape.
+type WorkspaceZoneCard = ZoneCardRenderItem<
+  WorkspaceCardId & string,
+  WorkspaceCardType & string,
+  WorkspaceCardProperties
+> extends infer Item
+  ? Item extends { zone: string }
+    ? Omit<Item, "zone"> & { zone: WorkspaceZoneId }
+    : 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 WorkspaceUI = Omit<
+  DreamboardUI<typeof uiContract>,
+  "Root" | "Game" | "Interaction" | "Board" | "Zone"
+> & {
+  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 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 }>
+>;
+
+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 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 const clientParamSchemasByPhase = createClientParamSchemasByPhase(
+  game,
+) as ClientParamSchemaMap;
 `;
 }
 function generateReducerSupportSeed() {
   return `import {
-  createReducerOps,
+  createReducerEdit,
   createStateQueries,
-  pipe,
 } from "@dreamboard/app-sdk/reducer";
 import type { GameState } from "./game-contract";
 
@@ -9598,16 +9680,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);
@@ -9688,7 +9766,7 @@ function generateReducerGameContractSeed() {
 import { ids, manifestContract } from "../shared/manifest-contract";
 import { defineGameContract, type GameStateOf } from "@dreamboard/app-sdk/reducer";
 
-// Contract files should stay focused on schemas, phase names, and exported
+// Contract files should stay focused on schemas, phases, and exported
 // state types. Put reducers in app/phases/* and pure computations in
 // app/derived.ts or app/rules/*.
 const publicStateSchema = z.object({
@@ -9700,15 +9778,14 @@ const hiddenStateSchema = z.object({});
 
 export const gameContract = defineGameContract({
   manifest: manifestContract,
-  // Keep this list in sync with the keys of the \`phases\` record in ./phases.
-  // Declaring phase names here narrows \`fx.transition(...)\`, \`phase.dispatch\`,
-  // and the flow state's \`currentPhase\` to a literal union.
-  phaseNames: ["setup"] as const,
   state: {
     public: publicStateSchema,
     private: privateStateSchema,
     hidden: hiddenStateSchema,
   },
+  phases: {
+    setup: z.object({}),
+  },
 });
 
 export type GameContract = typeof gameContract;
@@ -9809,8 +9886,10 @@ function generateAppFrameworkTsConfig() {
         moduleResolution: "bundler",
         strict: true,
         esModuleInterop: true,
-        skipLibCheck: true,
+        skipLibCheck: false,
+        types: [],
         declaration: false,
+        rootDir: "..",
         outDir: "./dist",
         paths: {
           "@dreamboard/manifest-contract": ["../shared/manifest-contract.ts"],
@@ -9832,48 +9911,57 @@ function generateAppFrameworkTsConfig() {
 `;
 }
 function generateUiFrameworkTsConfig() {
-  return `{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "jsx": "react-jsx",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "paths": {
-      "@dreamboard/manifest-contract": [
-        "../shared/manifest-contract.ts"
-      ],
-      "@dreamboard/ui-contract": [
-        "../shared/generated/ui-contract.ts"
-      ],
-      "@shared/*": [
-        "../shared/*"
-      ]
-    }
-  },
-  "include": [
-    "./**/*.ts",
-    "./**/*.tsx",
-    "../shared/**/*.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}
+  return `${JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2020",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        jsx: "react-jsx",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: false,
+        types: [],
+        paths: {
+          "@dreamboard/manifest-contract": ["../shared/manifest-contract.ts"],
+          "@dreamboard/ui-contract": ["../shared/generated/ui-contract.ts"],
+          "@shared/*": ["../shared/*"]
+        }
+      },
+      include: ["./**/*.ts", "./**/*.tsx", "../shared/**/*.ts"],
+      exclude: ["node_modules", "dist"]
+    },
+    null,
+    2
+  )}
 `;
 }
 function generateReducerUiAppContent() {
-  return `import { Phase, PromptInbox } from "@dreamboard/ui-contract";
+  return `import { Game, Phase, Prompt, PromptInbox } from "@dreamboard/ui-contract";
 
 function SetupPhase() {
   return (
     <main>
       <PromptInbox.Root>
         <PromptInbox.Empty>No available prompts.</PromptInbox.Empty>
-        <PromptInbox.Items />
+        <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>
+          )}
+        </PromptInbox.Items>
       </PromptInbox.Root>
     </main>
   );
@@ -9881,11 +9969,15 @@ function SetupPhase() {
 
 export default function App() {
   return (
-    <Phase.Switch
-      routes={{
-        setup: () => <SetupPhase />,
-      }}
-    />
+    <Game.Root>
+      {() => (
+        <Phase.Switch
+          routes={{
+            setup: () => <SetupPhase />,
+          }}
+        />
+      )}
+    </Game.Root>
   );
 }
 `;
@@ -21316,6 +21408,11 @@ var ShadowReducerRuntime = class {
     this.version = version;
     this.started = true;
   }
+  patchState(mutator) {
+    const next = structuredClone(this.rawState());
+    mutator(next);
+    this.hydrate(next, this.version + 1);
+  }
   projectAllSeats() {
     const projection = this.runtime.projectSeatsDynamic({
       playerIds: this.playerIds
@@ -21616,6 +21713,15 @@ async function createScenarioContext(options) {
         await assertLiveMatchesShadow("browser", options.shadow, live);
       }
     },
+    patchState: async (mutator) => {
+      await api.start();
+      if (options.live || options.embedded || options.browser || options.actionPlan) {
+        throw new Error(
+          "game.patchState is only supported for reducer snapshot scenarios. Use it to materialize a state before --from-scenario or reducer tests, not inside live replay/browser runners."
+        );
+      }
+      options.shadow.patchState(mutator);
+    },
     submit: async (playerId, interactionId, params) => {
       await api.start();
       const interactionParams = params ?? {};
@@ -26119,4 +26225,4 @@ export {
   test_default,
   runDreamboardCli
 };
-//# sourceMappingURL=chunk-6FPQ3S2J.js.map
+//# sourceMappingURL=chunk-WDTE6OFH.js.map