dreamboard 0.1.15 → 0.1.17

package/dist/{chunk-6FPQ3S2J.js → chunk-ZLYS5DGK.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>
   );
 }
 `;
@@ -14006,6 +14098,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) {
@@ -14115,6 +14210,45 @@ function resolveDomainChoices(choices, context) {
     disabledReason: choice.disabledReason
   }));
 }
+function resolveDependentDomainChoices(choices, context) {
+  const resolved = typeof choices === "function" ? choices(context) : choices;
+  return resolved.map((choice) => ({
+    value: choice.value,
+    label: choice.label,
+    icon: choice.icon,
+    badge: choice.badge,
+    description: choice.description,
+    disabled: choice.disabled,
+    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;
@@ -14151,7 +14285,13 @@ function resourceMapInput(options) {
     schema: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()),
     ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
     domain: (state, playerId, q, derived) => {
-      const context = { state, playerId, q, derived };
+      const context = {
+        state,
+        playerId,
+        q,
+        derived,
+        values: {}
+      };
       return {
         type: "resourceMap",
         resources: options.resources.map((resource) => ({
@@ -14171,7 +14311,13 @@ function numberInput(options) {
     schema: external_exports.number(),
     ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
     domain: (state, playerId, q, derived) => {
-      const context = { state, playerId, q, derived };
+      const context = {
+        state,
+        playerId,
+        q,
+        derived,
+        values: {}
+      };
       return {
         type: "boundedNumber",
         min: resolveDomainNumber(options.min, context, 0),
@@ -14182,23 +14328,80 @@ function numberInput(options) {
   };
 }
 function choiceInput(options) {
+  const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
   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 } : {},
-    domain: (state, playerId, q, derived) => {
-      const context = { state, playerId, q, derived };
+    ...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: resolveDomainChoices(options.choices, context)
+        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) {
@@ -14210,10 +14413,21 @@ function choiceListInput(options) {
   return {
     kind: "form",
     schema: external_exports.array(external_exports.string()),
-    ...staticDefaultValue ? { defaultValue: staticDefaultValue } : {},
+    ...staticDefaultValue !== void 0 ? { defaultValue: staticDefaultValue } : {},
     domain: (state, playerId, q, derived) => {
-      const context = { state, playerId, q, derived };
-      const choices = resolveDomainChoices(options.choices, context);
+      const context = {
+        state,
+        playerId,
+        q,
+        derived,
+        values: {}
+      };
+      const choices = resolveDomainChoices(options.choices, context).map(
+        (choice) => ({
+          ...choice,
+          value: choice.value
+        })
+      );
       return {
         type: "choiceList",
         choices,
@@ -14240,12 +14454,25 @@ function choiceListInput(options) {
           playerId,
           q,
           derived,
+          values: {},
           choices
         });
       }
     } : {}
   };
 }
+function formInputForState() {
+  return Object.assign(
+    ((schema, options) => baseFormInput(schema, options)),
+    {
+      resourceMap: (options) => resourceMapInput(options),
+      resourceChoices: (options) => formInput.resourceChoices(options),
+      number: (options) => numberInput(options),
+      choice: (options) => choiceInput(options),
+      choiceList: (options) => choiceListInput(options)
+    }
+  );
+}
 var formInput = Object.assign(baseFormInput, {
   resourceMap: resourceMapInput,
   resourceChoices: (options) => ({
@@ -14254,32 +14481,49 @@ var formInput = Object.assign(baseFormInput, {
   }),
   number: numberInput,
   choice: choiceInput,
-  choiceList: choiceListInput
+  choiceList: choiceListInput,
+  forState: formInputForState
 });
 
 // ../../packages/app-sdk/src/reducer/inputs/boardInput.ts
 function makeBoardCollector(kind) {
   return function collector(options) {
     const target = options.target;
+    const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
     return {
       kind,
       schema: external_exports.string(),
-      eligibleTargets: ((state, playerId, q) => target.eligible({
+      eligibleTargets: ((state, playerId, q, values) => target.eligible({
         state,
         playerId,
-        q
+        q,
+        values
       })),
-      validateTarget: ((state, playerId, q, targetId) => target.validate(
+      validateTarget: ((state, playerId, q, targetId, values) => target.validate(
         {
           state,
           playerId,
-          q
+          q,
+          values
         },
         targetId
       )),
+      ...dependsOn ? { dependsOn } : {},
+      domain: dependsOn ? (state, playerId, q, _derived, values) => ({
+        type: "target",
+        targetKind: target.targetKind,
+        boardId: target.boardId,
+        eligibleTargets: target.eligible({
+          state,
+          playerId,
+          q,
+          values
+        }).map(String)
+      }) : void 0,
       meta: {
         targetKind: target.targetKind,
-        boardId: target.boardId
+        boardId: target.boardId,
+        valueKind: target.valueKind
       }
     };
   };
@@ -14296,12 +14540,13 @@ var DEFAULT_MISSING_CANDIDATE_ISSUE = {
 };
 function createTargetRule(candidates, predicates, options = {}) {
   const missingCandidateIssue = options.missingCandidateIssue ?? DEFAULT_MISSING_CANDIDATE_ISSUE;
-  const validate2 = (ctx, id) => {
-    if (!candidates(ctx).includes(id)) {
+  const equals = options.equals ?? Object.is;
+  const validate2 = (ctx, target) => {
+    if (!candidates(ctx).some((candidate) => equals(candidate, target))) {
       return missingCandidateIssue;
     }
     for (const predicate of predicates) {
-      if (!predicate.test({ ...ctx, targetId: id })) {
+      if (!predicate.test({ ...ctx, targetId: target, target })) {
         return {
           errorCode: predicate.errorCode,
           message: predicate.message
@@ -14313,7 +14558,7 @@ function createTargetRule(candidates, predicates, options = {}) {
   const rule = {
     eligible: (ctx) => candidates(ctx).filter((targetId) => validate2(ctx, targetId) == null),
     validate: validate2,
-    isEligible: (ctx, id) => validate2(ctx, id) == null,
+    isEligible: (ctx, target) => validate2(ctx, target) == null,
     bind: (ctx) => ({
       eligible: () => rule.eligible(ctx),
       validate: (id) => rule.validate(ctx, id),
@@ -14337,7 +14582,7 @@ function candidateIdsForKind(q, boardId, targetKind) {
   if (targetKind === "vertex") {
     return idsFromCollection(q.board.tiled(boardId).vertices);
   }
-  return idsFromCollection(q.board.get(boardId).spaces);
+  return idsFromCollection(q.board.get(boardId)?.spaces);
 }
 function idsFromCollection(collection) {
   if (!collection) return [];
@@ -14364,10 +14609,47 @@ function createBoardTargetBuilder(targetKind, boardId) {
         }
       ),
       boardId,
-      targetKind
+      targetKind,
+      valueKind: "board-id"
+    })
+  );
+}
+function createPlayerSpaceTargetBuilder(boardId) {
+  return createTargetRuleBuilder(
+    (predicates) => ({
+      ...createTargetRule(
+        ({ state, q }) => {
+          const spacesForPlayer = (playerId) => candidateIdsForKind(
+            q,
+            `${boardId}:${playerId}`,
+            "space"
+          );
+          return state.table.playerOrder.flatMap(
+            (playerId) => spacesForPlayer(playerId).map((spaceId) => ({
+              boardId,
+              playerId,
+              spaceId
+            }))
+          );
+        },
+        predicates,
+        {
+          missingCandidateIssue: {
+            errorCode: "BOARD_TARGET_NOT_ELIGIBLE",
+            message: "Board target is not eligible."
+          },
+          equals: (left, right) => isPlayerBoardSpaceTarget(left) && isPlayerBoardSpaceTarget(right) && left.boardId === right.boardId && left.playerId === right.playerId && left.spaceId === right.spaceId
+        }
+      ),
+      boardId,
+      targetKind: "space",
+      valueKind: "player-board-space"
     })
   );
 }
+function isPlayerBoardSpaceTarget(value) {
+  return typeof value === "object" && value !== null && "boardId" in value && "playerId" in value && "spaceId" in value;
+}
 function makeBoardTargetFactory(targetKind) {
   return function target(boardId) {
     return createBoardTargetBuilder(targetKind, boardId);
@@ -14377,7 +14659,10 @@ var boardTarget = {
   edge: makeBoardTargetFactory("edge"),
   vertex: makeBoardTargetFactory("vertex"),
   space: makeBoardTargetFactory("space"),
-  tile: makeBoardTargetFactory("tile")
+  tile: makeBoardTargetFactory("tile"),
+  playerSpace(boardId) {
+    return createPlayerSpaceTargetBuilder(boardId);
+  }
 };
 
 // ../../packages/app-sdk/src/reducer/inputs/cardTarget.ts
@@ -14424,22 +14709,38 @@ var cardTarget = {
 // ../../packages/app-sdk/src/reducer/inputs/cardInput.ts
 function cardInput(options) {
   const target = options.target;
+  const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
   return {
     kind: "card",
     schema: external_exports.string(),
-    eligibleTargets: ((state, playerId, q) => target.eligible({
+    eligibleTargets: ((state, playerId, q, values) => target.eligible({
       state,
       playerId,
-      q
+      q,
+      values
     })),
-    validateTarget: ((state, playerId, q, targetId) => target.validate(
+    validateTarget: ((state, playerId, q, targetId, values) => target.validate(
       {
         state,
         playerId,
-        q
+        q,
+        values
       },
       targetId
     )),
+    ...dependsOn ? { dependsOn } : {},
+    domain: dependsOn ? (state, playerId, q, _derived, values) => ({
+      type: "target",
+      targetKind: target.targetKind,
+      zoneId: target.zoneId,
+      zoneIds: target.zoneIds,
+      eligibleTargets: target.eligible({
+        state,
+        playerId,
+        q,
+        values
+      }).map(String)
+    }) : void 0,
     meta: {
       zoneId: target.zoneId,
       zoneIds: target.zoneIds,
@@ -16131,6 +16432,35 @@ function shuffleWithRng(values, rng, operation = "shuffleSharedZone") {
   }
   return { orderedValues, nextRng, consumptions };
 }
+function subsetWithRng(values, count, rng) {
+  if (!Number.isInteger(count) || count < 0) {
+    throw new Error("random.subset count must be a non-negative integer.");
+  }
+  if (count > values.length) {
+    throw new Error(
+      `random.subset count ${count} exceeds source length ${values.length}.`
+    );
+  }
+  const shuffled = shuffleWithRng(values, rng, "randomSubset");
+  return {
+    values: shuffled.orderedValues.slice(0, count),
+    nextRng: shuffled.nextRng,
+    consumptions: shuffled.consumptions
+  };
+}
+function createMutableRandomHelpers(rng) {
+  let current = rng;
+  return {
+    random: {
+      subset(options) {
+        const sampled = subsetWithRng(options.from, options.count, current);
+        current = sampled.nextRng;
+        return sampled.values;
+      }
+    },
+    currentRng: () => current
+  };
+}
 function sampleRngCollectorValue(collector, rng) {
   const meta = collector.meta;
   switch (meta.rng) {
@@ -16579,6 +16909,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;
@@ -16762,6 +17212,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(
@@ -16861,6 +17324,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);
@@ -16909,6 +17413,7 @@ function collectReducerDefinitionIndex(definition) {
       cardActionId,
       {
         ...cardAction,
+        __steps: cardAction.__steps,
         inputs: {
           cardId: cardInput({
             target: cardTarget.zones([cardAction.playFrom]).where({
@@ -16986,7 +17491,7 @@ function buildContext(state, manifest) {
     manifest,
     playerOrder: [...state.table.playerOrder],
     activePlayers: [...state.flow.activePlayers],
-    runtime: state.runtime,
+    runtime: publicRuntime(state.runtime),
     setup: state.runtime.setup ? {
       profileId: state.runtime.setup.profileId,
       optionValues: {
@@ -16995,6 +17500,17 @@ function buildContext(state, manifest) {
     } : null
   };
 }
+function publicRuntime(runtime) {
+  const { rng: _rng, ...rest } = runtime;
+  return rest;
+}
+var DISABLED_RANDOM_HELPERS = {
+  subset() {
+    throw new Error(
+      "random helpers are only available in reducer mutation callbacks."
+    );
+  }
+};
 function buildRuntimeArgs(state, manifest, helpers, toDomainState2, extra, options = {}) {
   const domainState = toDomainState2(state);
   const q = options.q ?? createStateQueries(domainState);
@@ -17004,7 +17520,8 @@ function buildRuntimeArgs(state, manifest, helpers, toDomainState2, extra, optio
     fx: options.fx ?? fxForState(state),
     q,
     derived: options.derived ?? createDerivedResolver(domainState, { q }),
-    runtime: state.runtime,
+    runtime: publicRuntime(state.runtime),
+    random: options.random ?? DISABLED_RANDOM_HELPERS,
     ...extra
   };
 }
@@ -17038,13 +17555,16 @@ var runtimeResultHelpers = {
 // ../../packages/app-sdk/src/reducer/bundle/trusted/trusted-state-codec.ts
 function toDomainState(state) {
   const { runtime: _runtime, ...domain } = state;
+  attachPhaseAccessor(domain);
   return domain;
 }
 function toCombinedState(session) {
-  return {
+  const combined = {
     ...session.domain,
     runtime: session.runtime
   };
+  attachPhaseAccessor(combined);
+  return combined;
 }
 function toSessionState(state, toDomain) {
   return {
@@ -17052,6 +17572,19 @@ function toSessionState(state, toDomain) {
     runtime: state.runtime
   };
 }
+function attachPhaseAccessor(state) {
+  if (!state || typeof state !== "object") return;
+  const candidate = state;
+  const phase = candidate.phase;
+  if (!phase || typeof phase !== "object") return;
+  const descriptor = Object.getOwnPropertyDescriptor(phase, "get");
+  if (descriptor && typeof descriptor.value === "function") return;
+  Object.defineProperty(phase, "get", {
+    enumerable: false,
+    configurable: true,
+    value: (phaseName) => candidate.flow?.currentPhase === phaseName ? phase : null
+  });
+}
 
 // ../../packages/app-sdk/src/reducer/bundle/trusted/trusted-setup-profiles.ts
 function resolveTrustedSetupProfiles(definition) {
@@ -17133,7 +17666,8 @@ function createTrustedRuntimeScope(definition) {
   }
   const helpers = {
     ...runtimeResultHelpers,
-    ops: createReducerOps()
+    ops: createReducerOps(),
+    edit: createReducerEdit()
   };
   function fxForState2(state) {
     return fxForState(state);
@@ -17196,24 +17730,31 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
       }
       const parsed = interactions.parseInteractionParams(
         interaction,
-        input.params
+        input.params,
+        { playerId: input.playerId }
       );
       if (!parsed.ok) {
         return rejectResult("invalid-action-params", parsed.message);
       }
-      return normalizeResult(
+      const random = createMutableRandomHelpers(state.runtime.rng);
+      const result = normalizeResult(
         interaction.reduce(
-          scope.buildRuntimeArgs(state, {
-            ...ctx,
-            state: scope.toDomainState(state),
-            input: {
-              playerId: input.playerId,
-              params: parsed.params
-            }
-          })
+          scope.buildRuntimeArgs(
+            state,
+            {
+              ...ctx,
+              state: scope.toDomainState(state),
+              input: {
+                playerId: input.playerId,
+                params: parsed.params
+              }
+            },
+            { random: random.random }
+          )
         ),
         scope.toDomainState(state)
       );
+      return result.type === "accept" ? { ...result, runtimeRng: random.currentRng() } : result;
     }
     if (input.kind === "continuation") {
       const continuation = scope.continuationById(input.continuationId);
@@ -17223,21 +17764,27 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
           `Continuation '${input.continuationId}' was not registered.`
         );
       }
-      return normalizeResult(
+      const random = createMutableRandomHelpers(state.runtime.rng);
+      const result = normalizeResult(
         continuation.reduce(
-          scope.buildRuntimeArgs(state, {
-            ...ctx,
-            state: scope.toDomainState(state),
-            input: {
-              source: "effect",
-              effectKind: input.effectKind,
-              data: input.resumeData,
-              response: input.response
-            }
-          })
+          scope.buildRuntimeArgs(
+            state,
+            {
+              ...ctx,
+              state: scope.toDomainState(state),
+              input: {
+                source: "effect",
+                effectKind: input.effectKind,
+                data: input.resumeData,
+                response: input.response
+              }
+            },
+            { random: random.random }
+          )
         ),
         scope.toDomainState(state)
       );
+      return result.type === "accept" ? { ...result, runtimeRng: random.currentRng() } : result;
     }
     return scope.runtimeHelpers.accept(scope.toDomainState(state));
   }
@@ -17369,14 +17916,19 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
         }
       ])
     );
+    const random = createMutableRandomHelpers(stateWithSubmission.runtime.rng);
     const resolved = normalizeResult(
       resolve(
-        scope.buildRuntimeArgs(stateWithSubmission, {
-          state: scope.toDomainState(stateWithSubmission),
-          submissions: resolvedSubmissions,
-          submittedPlayerIds: [...actors],
-          waitingPlayerIds: []
-        })
+        scope.buildRuntimeArgs(
+          stateWithSubmission,
+          {
+            state: scope.toDomainState(stateWithSubmission),
+            submissions: resolvedSubmissions,
+            submittedPlayerIds: [...actors],
+            waitingPlayerIds: []
+          },
+          { random: random.random }
+        )
       ),
       scope.toDomainState(stateWithSubmission)
     );
@@ -17387,7 +17939,7 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
       type: "accept",
       state: clearSimultaneousCurrent({
         ...resolved.state,
-        runtime: stateWithSubmission.runtime
+        runtime: { ...stateWithSubmission.runtime, rng: random.currentRng() }
       }),
       instructions: resolved.instructions ?? []
     };
@@ -17409,7 +17961,10 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
       type: "accept",
       state: {
         ...result.state,
-        runtime: sampled.state.runtime
+        runtime: {
+          ...sampled.state.runtime,
+          rng: result.runtimeRng ?? sampled.state.runtime.rng
+        }
       },
       instructions: result.instructions ?? []
     };
@@ -17504,6 +18059,48 @@ function withSelection(domain, collector) {
   if (!collector.selection) return domain;
   return { ...domain, selection: collector.selection };
 }
+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) {
+      throw new Error(
+        `Interaction input '${key}' cannot be used as a dependency because its target domain is not finite.`
+      );
+    }
+    return [...domain.eligibleTargets];
+  }
+  if (domain.type === "choice") {
+    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.`
+  );
+}
+function cartesianDependencyTuples(dependencies, domainsByKey) {
+  return dependencies.reduce(
+    (tuples, key) => {
+      const values = finiteValuesForDependency(key, domainsByKey[key]);
+      return tuples.flatMap(
+        (tuple) => values.map((value) => ({ ...tuple, [key]: value }))
+      );
+    },
+    [{}]
+  );
+}
+function withoutDependentProjection(domain) {
+  const {
+    dependsOn: _dependsOn,
+    dependentCases: _dependentCases,
+    ...rest
+  } = domain;
+  return rest;
+}
 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.`
@@ -17552,19 +18149,74 @@ function collectInputDomains(interaction, domainState, playerId, eligibleTargets
   const derived = () => derivedLazy ??= createDerivedResolver(domainState, { q: queries() });
   const result = {};
   for (const [key, collector] of Object.entries(collectors)) {
-    if (collector.kind === "rng" || collector.kind === "prompt") {
+    if (collector.kind === "rng") {
+      continue;
+    }
+    if (collector.kind === "prompt") {
+      const optionFactory = collector.meta?.options;
+      if (!optionFactory) continue;
+      result[key] = {
+        type: "choice",
+        choices: optionFactory(domainState, playerId, queries()).map(
+          (option) => ({
+            value: String(option.id),
+            label: option.label ?? String(option.id),
+            ...(() => {
+              const issue = collector.validateTarget?.(
+                domainState,
+                playerId,
+                queries(),
+                String(option.id)
+              );
+              return issue ? {
+                disabled: true,
+                disabledReason: issue.message ?? issue.errorCode
+              } : {};
+            })()
+          })
+        )
+      };
       continue;
     }
     if (collector.domain) {
-      result[key] = withSelection(
+      const dependencies = collector.dependsOn ?? [];
+      const baseDomain = withSelection(
         collector.domain(
           domainState,
           playerId,
           queries(),
-          derived()
+          derived(),
+          {}
         ),
         collector
       );
+      if (dependencies.length === 0) {
+        result[key] = baseDomain;
+        continue;
+      }
+      const dependentCases = cartesianDependencyTuples(
+        dependencies,
+        result
+      ).map((values) => ({
+        when: values,
+        domain: withoutDependentProjection(
+          withSelection(
+            collector.domain?.(
+              domainState,
+              playerId,
+              queries(),
+              derived(),
+              values
+            ),
+            collector
+          )
+        )
+      }));
+      result[key] = {
+        ...baseDomain,
+        dependsOn: dependencies,
+        dependentCases
+      };
       continue;
     }
     const targets = eligibleTargets[key];
@@ -17586,7 +18238,17 @@ function collectInputDomains(interaction, domainState, playerId, eligibleTargets
 }
 function collectInteractionInputs(interaction, domainState, playerId, options = {}) {
   const collectors = interactionInputsOf(interaction);
-  const eligibleTargets = options.includeEligibleTargets === false ? {} : collectEligibleTargets(interaction, domainState, playerId, options);
+  const dependencyKeys = new Set(
+    Object.values(collectors).flatMap((collector) => [
+      ...collector.dependsOn ?? []
+    ])
+  );
+  const collectedEligibleTargets = options.includeEligibleTargets === false && dependencyKeys.size === 0 ? {} : collectEligibleTargets(interaction, domainState, playerId, options);
+  const eligibleTargets = options.includeEligibleTargets === false ? Object.fromEntries(
+    Object.entries(collectedEligibleTargets).filter(
+      ([key]) => dependencyKeys.has(key)
+    )
+  ) : collectedEligibleTargets;
   const domainsByKey = collectInputDomains(
     interaction,
     domainState,
@@ -17601,10 +18263,13 @@ function collectInteractionInputs(interaction, domainState, playerId, options =
   let derivedLazy = options.derived ?? null;
   const derived = () => derivedLazy ??= createDerivedResolver(domainState, { q: queries() });
   return Object.entries(collectors).flatMap(([key, collector]) => {
-    if (collector.kind === "rng" || collector.kind === "prompt") {
+    if (collector.kind === "rng") {
       return [];
     }
     const domain = domainsByKey[key];
+    if (!domain && collector.kind === "prompt") {
+      return [];
+    }
     if (!domain) {
       throw unsupportedDefaultInputError(key, collector);
     }
@@ -17651,7 +18316,7 @@ function collectCardZoneIds(interaction) {
 function collectPromptOptions(interaction, domainState, playerId, queries) {
   for (const collector of Object.values(interaction.inputs)) {
     if (collector.kind !== "prompt") continue;
-    const factory = collector.meta?.eligibleOptions;
+    const factory = collector.meta?.options;
     if (!factory) continue;
     return factory(domainState, playerId, queries).map((option) => ({
       id: String(option.id),
@@ -17677,7 +18342,12 @@ function parseInteractionParams(interaction, rawParams, options = {}) {
   const issues = [];
   for (const [key, collector] of Object.entries(collectors)) {
     if (collector.kind === "rng" && options.skipRng) continue;
-    const rawValue = record[key] === void 0 && "defaultValue" in collector ? collector.defaultValue : record[key];
+    const rawValueBase = record[key] === void 0 && "defaultValue" in collector ? collector.defaultValue : record[key];
+    const rawValue = collector.kind === "board-space" && collector.meta?.valueKind === "player-board-space" && typeof rawValueBase === "string" && options.playerId ? {
+      boardId: collector.meta.boardId,
+      playerId: options.playerId,
+      spaceId: rawValueBase
+    } : rawValueBase;
     const result = collector.schema.safeParse(rawValue);
     if (!result.success) {
       for (const issue of result.error.issues) {
@@ -17739,7 +18409,7 @@ function validateCollectorTargets(interaction, domainState, playerId, params) {
         domainState,
         playerId,
         queries(),
-        String(value)
+        value
       );
       if (issue) {
         return makeValidationError(issue.errorCode, issue.message);
@@ -17951,11 +18621,14 @@ function deriveCommitPolicy(inputs, explicit) {
   if (hasManyCollector) {
     return { mode: "manual" };
   }
+  if (collectors.some(isDefaultRenderableFormCollector)) {
+    return { mode: "manual" };
+  }
   if (collectors.length === 0 || !collectors.some(isTargetCollector2)) {
     return { mode: "manual" };
   }
   return collectors.every(
-    (collector) => isTargetCollector2(collector) || isDefaultRenderableFormCollector(collector) || collector.kind === "rng"
+    (collector) => isTargetCollector2(collector) || collector.kind === "rng"
   ) ? { mode: "autoWhenReady" } : { mode: "manual" };
 }
 function projectInteractionMetadata(interaction) {
@@ -17971,7 +18644,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 : ""),
@@ -17979,7 +18652,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: {
@@ -18099,7 +18781,10 @@ function createInteractionDecisionResolver(scope, stages, authorization) {
     }
     const trustedInteractionId = interactionId;
     const parseForSubmit = mode === "submit";
-    const parsed = parseForSubmit ? parseInteractionParams(interaction, params, { skipRng: true }) : {
+    const parsed = parseForSubmit ? parseInteractionParams(interaction, params, {
+      skipRng: true,
+      playerId
+    }) : {
       ok: true,
       params: prepareInteractionProjectionParams(interaction, params)
     };
@@ -18359,10 +19044,7 @@ function createStageResolver(scope) {
     return allowlist;
   }
   function isInteractionAllowedInStep(state, interaction, projection) {
-    const allowedSteps = [
-      ...interaction.step !== void 0 ? [interaction.step] : [],
-      ...interaction.steps ?? []
-    ];
+    const allowedSteps = interaction.__steps ?? [];
     if (allowedSteps.length === 0) {
       return true;
     }
@@ -18491,16 +19173,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)];
@@ -18510,16 +19191,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) {
@@ -18830,7 +19510,11 @@ function createLifecycleRunner(scope, interactions) {
     }) : safeParseOrThrow(phase.state, {}, `phase:${phaseName}:initialState`);
     return {
       ...state,
-      phase: safeParseOrThrow(phase.state, phaseState, `phase:${phaseName}`),
+      phase: safeParseOrThrow(
+        phase.state,
+        phaseState,
+        `phase:${phaseName}`
+      ),
       flow: {
         ...state.flow,
         currentPhase: phaseName
@@ -18848,12 +19532,17 @@ function createLifecycleRunner(scope, interactions) {
     let nextState = workingState;
     const instructions = [];
     if (phase.enter) {
+      const random = createMutableRandomHelpers(workingState.runtime.rng);
       const entered = normalizeResult(
         phase.enter(
-          scope.buildRuntimeArgs(workingState, {
-            event,
-            state: scope.toDomainState(workingState)
-          })
+          scope.buildRuntimeArgs(
+            workingState,
+            {
+              event,
+              state: scope.toDomainState(workingState)
+            },
+            { random: random.random }
+          )
         ),
         scope.toDomainState(workingState)
       );
@@ -18864,18 +19553,23 @@ function createLifecycleRunner(scope, interactions) {
       }
       nextState = {
         ...entered.state,
-        runtime: workingState.runtime
+        runtime: { ...workingState.runtime, rng: random.currentRng() }
       };
       if (entered.instructions) instructions.push(...entered.instructions);
     }
     const activeStage = interactions.resolveActiveStage(nextState, phaseName);
     if (activeStage?.stage.onEnter) {
+      const random = createMutableRandomHelpers(nextState.runtime.rng);
       const stageEntered = normalizeResult(
         activeStage.stage.onEnter(
-          scope.buildRuntimeArgs(nextState, {
-            event,
-            state: scope.toDomainState(nextState)
-          })
+          scope.buildRuntimeArgs(
+            nextState,
+            {
+              event,
+              state: scope.toDomainState(nextState)
+            },
+            { random: random.random }
+          )
         ),
         scope.toDomainState(nextState)
       );
@@ -18886,7 +19580,7 @@ function createLifecycleRunner(scope, interactions) {
       }
       nextState = {
         ...stageEntered.state,
-        runtime: nextState.runtime
+        runtime: { ...nextState.runtime, rng: random.currentRng() }
       };
       if (stageEntered.instructions) {
         instructions.push(...stageEntered.instructions);
@@ -19939,6 +20633,11 @@ function toWireDispatchResult(result, serializeState) {
 function createReducerBundle(definition) {
   const trustedBundle = createTrustedReducerBundle(definition);
   const codec = createIngressRuntimeCodec(definition);
+  function parseTrustedState(state) {
+    return codec.parseState(
+      state
+    );
+  }
   function parseRuntimePlayerId(playerId) {
     if (typeof playerId !== "string") {
       throw new Error("Expected a string playerId.");
@@ -19971,7 +20670,7 @@ function createReducerBundle(definition) {
       );
     },
     async initializePhase({ state, to }) {
-      const decodedState = codec.parseState(state);
+      const decodedState = parseTrustedState(state);
       return codec.serializeState(
         await trustedBundle.initializePhase({
           state: decodedState,
@@ -19983,7 +20682,7 @@ function createReducerBundle(definition) {
       const validatedWire = codec.parseInput(input);
       const routed = routeInteraction(validatedWire);
       return trustedBundle.validateInput({
-        state: codec.parseState(state),
+        state: parseTrustedState(state),
         input: routed
       });
     },
@@ -19994,7 +20693,7 @@ function createReducerBundle(definition) {
       const validatedWire = codec.parseInput(input);
       const routed = routeInteraction(validatedWire);
       const result = await trustedBundle.reduce({
-        state: codec.parseState(state),
+        state: parseTrustedState(state),
         input: routed
       });
       return toWireReduceResult(
@@ -20009,7 +20708,7 @@ function createReducerBundle(definition) {
       const validatedWire = codec.parseInput(input);
       const routed = routeInteraction(validatedWire);
       const result = await trustedBundle.dispatch({
-        state: codec.parseState(state),
+        state: parseTrustedState(state),
         input: routed
       });
       return toWireDispatchResult(
@@ -20036,7 +20735,7 @@ function createReducerBundle(definition) {
       playerIds,
       viewId = "player"
     }) {
-      const parsedState = codec.parseState(state);
+      const parsedState = parseTrustedState(state);
       const parsedPlayerIds = playerIds.map((pid) => codec.parsePlayerId(pid));
       return trustedBundle.projectSeatsDynamic({
         state: parsedState,
@@ -20045,9 +20744,7 @@ function createReducerBundle(definition) {
       });
     },
     projectSeatViewDynamic({ state, playerId, viewId = "player" }) {
-      const parsedState = codec.parseState(
-        state
-      );
+      const parsedState = parseTrustedState(state);
       return trustedBundle.projectSeatViewDynamic({
         state: parsedState,
         playerId: parseRuntimePlayerId(playerId),
@@ -20076,7 +20773,7 @@ function createReducerBundle(definition) {
           });
         },
         hydrate({ state: snapshot }) {
-          state = codec.parseState(snapshot);
+          state = parseTrustedState(snapshot);
         },
         async dispatch({ input }) {
           const validatedWire = codec.parseInput(
@@ -21316,6 +22013,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 +22318,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 +26830,4 @@ export {
   test_default,
   runDreamboardCli
 };
-//# sourceMappingURL=chunk-6FPQ3S2J.js.map
+//# sourceMappingURL=chunk-ZLYS5DGK.js.map