@dreamboard-games/workspace-codegen 0.1.0

package/src/seeds.ts

@@ -0,0 +1,800 @@
+import type { GameTopologyManifest } from "@dreamboard/sdk-types";
+
+export const SETUP_PROFILES_SEED_MARKER =
+  "Generated by dreamboard setup-profiles scaffold.";
+
+function generateUiContractContent(): string {
+  return `/**
+ * Generated file.
+ * Do not edit directly.
+ */
+
+import game from "../../app/game";
+import {
+  createClientParamSchemasByPhase,
+} from "@dreamboard/app-sdk/reducer";
+import type {
+  ClientParamsOfInteractionOfDefinition,
+  DefaultedClientParamKeysOfInteractionOfDefinition,
+  InteractionIdOfDefinition,
+  InteractionIdOfDefinitionPhase,
+  PhaseNamesOfDefinition,
+  StageNamesOfDefinitionPhase,
+  ViewNamesOfDefinition,
+  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,
+  type PlayerId,
+  type SpaceId,
+  type VertexId,
+  type ZoneId as ManifestZoneId,
+} from "../manifest-contract";
+
+type GameDefinition = typeof game;
+
+export type ViewName = ViewNamesOfDefinition<GameDefinition>;
+export type InferView<Name extends ViewName> = ViewOfDefinition<
+  GameDefinition,
+  Name
+>;
+export type GameView = Extract<"player", ViewName> extends never
+  ? never
+  : InferView<Extract<"player", ViewName>>;
+
+export type PhaseName = PhaseNamesOfDefinition<GameDefinition>;
+
+// -------------------------------------------------------------------------
+// Interaction / Stage / Zone types (authored via defineInteraction/Stage/zones)
+// -------------------------------------------------------------------------
+
+/** Union of all interaction ids across phases. */
+export type InteractionId = InteractionIdOfDefinition<GameDefinition>;
+
+/** Interactions declared in a specific phase. */
+export type InteractionIdForPhase<Phase extends PhaseName> =
+  InteractionIdOfDefinitionPhase<GameDefinition, Phase>;
+
+/**
+ * Client-facing params type for an interaction, inferred from its input
+ * collectors. Engine-sampled collectors (e.g. \`rngInput.*\`) are omitted
+ * — the trusted reducer bundle fills those fields during submit, so the
+ * client never supplies them.
+ */
+export type InteractionParams<
+  Phase extends PhaseName,
+  Id extends InteractionIdForPhase<Phase>,
+> = ClientParamsOfInteractionOfDefinition<GameDefinition, Phase, Id>;
+
+/** Client-facing params with authored input defaults. */
+export type InteractionDefaultedKeys<
+  Phase extends PhaseName,
+  Id extends InteractionIdForPhase<Phase>,
+> = DefaultedClientParamKeysOfInteractionOfDefinition<GameDefinition, Phase, Id>;
+
+/** Phase-qualified interaction key for a specific phase. */
+export type InteractionKeyForPhase<Phase extends PhaseName> =
+  \`\${Phase}.\${InteractionIdForPhase<Phase>}\`;
+
+/** Phase-qualified union of every client/UI interaction key. */
+export type InteractionKey = {
+  [P in PhaseName]: InteractionKeyForPhase<P>;
+}[PhaseName];
+
+type PhaseOfInteractionKey<Key extends InteractionKey> =
+  Key extends \`\${infer P}.\${string}\` ? Extract<P, PhaseName> : never;
+
+type IdOfInteractionKey<Key extends InteractionKey> =
+  Key extends \`\${infer P}.\${infer I}\`
+    ? P extends PhaseName
+      ? Extract<I, InteractionIdForPhase<P>>
+      : never
+    : never;
+
+export type BoardInteractions = InteractionKey;
+
+/** Stage names declared in a phase. */
+export type StageName<Phase extends PhaseName> = StageNamesOfDefinitionPhase<
+  GameDefinition,
+  Phase
+>;
+
+/** Union of zone ids authored in the workspace manifest. */
+export type ZoneId = ManifestZoneId;
+
+type CamelCase<S extends string> = S extends \`\${infer Head}-\${infer Tail}\`
+  ? \`\${Head}\${Capitalize<CamelCase<Tail>>}\`
+  : S;
+
+/** JS-friendly keys for authored zones, e.g. "dev-hand" -> "devHand". */
+export type WorkspaceZoneKey = CamelCase<ZoneId>;
+
+type PlayerCardZoneId = {
+  [Z in (typeof literals.playerZoneIds)[number]]: (typeof literals.cardSetIdsByPlayerZoneId)[Z] extends readonly []
+    ? never
+    : Z;
+}[(typeof literals.playerZoneIds)[number]];
+
+/** JS-friendly keys for per-player zones that can contain cards. */
+export type WorkspacePlayerCardZoneKey = CamelCase<PlayerCardZoneId>;
+
+/** Interaction descriptor specialised to a concrete phase-qualified key. */
+export type InteractionDescriptorFor<Key extends InteractionKey> =
+  InteractionDescriptor<Key>;
+
+/**
+ * Params shape for a phase-qualified interaction key. Drives strong typing
+ * for \`useInteractionByKey\`'s draft,
+ * \`submit\`, and \`setInput\`.
+ */
+export type InteractionParamsOf<Key extends InteractionKey> =
+  InteractionParams<PhaseOfInteractionKey<Key>, IdOfInteractionKey<Key>>;
+
+export type InteractionDefaultedKeysOf<Key extends InteractionKey> =
+  InteractionDefaultedKeys<PhaseOfInteractionKey<Key>, IdOfInteractionKey<Key>>;
+
+type InteractionParamsShape<Key extends InteractionKey> =
+  InteractionParamsOf<Key> extends Record<string, unknown>
+    ? InteractionParamsOf<Key>
+    : Record<string, unknown>;
+
+type InteractionInputKeysOf<Key extends InteractionKey> =
+  string extends keyof InteractionParamsOf<Key>
+    ? never
+    : keyof InteractionParamsOf<Key> & string;
+
+type InteractionHandleDefaultedKeys<Key extends InteractionKey> = Extract<
+  InteractionDefaultedKeysOf<Key>,
+  keyof InteractionParamsShape<Key> & string
+>;
+
+type InteractionInputKeyOf<Key extends InteractionKey> =
+  Key extends InteractionKey ? InteractionInputKeysOf<Key> : never;
+
+export type InteractionInputKey = InteractionInputKeyOf<InteractionKey>;
+
+export type PromptKey = InteractionKey;
+
+export type PromptOptionValue = string;
+
+export type BoardTargetId = SpaceId | EdgeId | VertexId;
+
+type UIInteractionRegistry = {
+  [K in InteractionKey]: {
+    interaction: K;
+    phase: PhaseOfInteractionKey<K>;
+    id: IdOfInteractionKey<K>;
+  };
+};
+
+type UIInputRegistry = {
+  [K in InteractionInputKey]: { input: K };
+};
+
+type UIPromptRegistry = {
+  [K in PromptKey]: { interaction: K };
+};
+
+type UIPromptOptionRegistry = {
+  [K in PromptOptionValue]: { value: K };
+};
+
+type UIZoneRegistry = {
+  [K in ZoneId & string]: { zone: K };
+};
+
+type UICardRegistry = {
+  [K in CardId & string]: { card: K };
+};
+
+type UIPhaseRegistry = {
+  [K in PhaseName & string]: { phase: K };
+};
+
+type UIBoardTargetRegistry = {
+  [K in BoardTargetId & string]: { target: K };
+};
+
+export const uiContract = {
+  interactions: {} as UIInteractionRegistry,
+  inputs: {} as UIInputRegistry,
+  prompts: {} as UIPromptRegistry,
+  promptOptions: {} as UIPromptOptionRegistry,
+  zones: {} as UIZoneRegistry,
+  cards: {} as UICardRegistry,
+  phases: {} as UIPhaseRegistry,
+  boardTargets: {} as UIBoardTargetRegistry,
+} satisfies UIContract;
+
+declare module "@dreamboard/ui-sdk" {
+  interface DreamboardUIRegister {
+    contract: GameDefinition;
+    ui: typeof uiContract;
+  }
+}
+
+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
+// -------------------------------------------------------------------------
+
+/** Generated hex-board topology source, keyed by hex-board id. */
+const hexStaticBoards = staticBoards.hex;
+
+/** Union of authored hex-board ids in this workspace's manifest. */
+export type HexBoardId = keyof typeof hexStaticBoards & string;
+
+/** Topology object for the named hex board, drawn from \`staticBoards.hex\`. */
+export type HexBoardTopology<Id extends HexBoardId> = (typeof hexStaticBoards)[Id];
+
+/** Space id type for the named hex board. */
+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],
+  );
+}
+`;
+}
+
+function generateReducerSupportSeed(): string {
+  return `import {
+  createReducerOps,
+  createStateQueries,
+  pipe,
+} from "@dreamboard/app-sdk/reducer";
+import type { GameState } from "./game-contract";
+
+/**
+ * Small, SDK-shaped reducer helpers belong here.
+ *
+ * Keep schema and contract declarations in app/game-contract.ts.
+ * Keep initial state callbacks and defineGame wiring in app/game.ts.
+ * Keep memoized aggregates (winner checks, VP totals, longest-road,
+ * largest-army) in app/derived.ts via \`defineDerived\`.
+ * Keep phase files focused on one game-flow state.
+ *
+ * When this file starts collecting real game rules, split them by domain
+ * under app/rules/ instead, for example app/rules/board.ts,
+ * app/rules/resources.ts, or app/rules/scoring.ts.
+ *
+ * Recommended authoring pattern inside a phase reducer:
+ *
+ *   const next = pipe(
+ *     state,
+ *     ops.setActivePlayers([q.players.order()[0]]),
+ *   );
+ *   return accept(next);
+ */
+
+export const ops = createReducerOps<GameState>();
+
+export { pipe };
+
+export function stateQueries(state: GameState) {
+  return createStateQueries(state);
+}
+`;
+}
+
+function generateAppReadmeSeed(): string {
+  return `# App organization
+
+This directory owns the reducer: game state schemas, phases, interactions,
+derived values, player views, and reducer helpers.
+
+Use this layout while the game is small:
+
+\`\`\`txt
+app/
+  game-contract.ts
+  game.ts
+  derived.ts
+  reducer-support.ts
+  phases/
+    setup.ts
+\`\`\`
+
+When a phase grows beyond a single idea, make the phase directory the table of
+contents and split the implementation by game concept:
+
+\`\`\`txt
+app/phases/player-turn/
+  index.ts          # definePhase assembly only
+  state.ts          # phase-local constants and types
+  inputs.ts         # shared input and presentation helpers
+  build.ts          # build interactions
+  trade.ts          # trade interactions
+  end-turn.ts       # end-turn interaction
+\`\`\`
+
+Split a phase when it has multiple action families, shared input helpers, card
+actions, or is roughly 250-300 lines. Keep \`index.ts\` as the assembly point
+that imports interactions and registers them with \`definePhase\`.
+
+Do not turn \`reducer-support.ts\` into a catch-all rule module. Keep it small
+for shared reducer plumbing; put real game rules under \`app/rules/*\` once
+there is more than one domain.
+`;
+}
+
+function generateReducerDerivedSeed(): string {
+  return `// Memoized, pure projections of reducer state. Read them from reducer
+// callbacks and view projections via the injected \`derived\` helper:
+//
+//   reduce({ state, derived, accept }) {
+//     const winner = derived(winnerOf);
+//     return accept({ ...state, publicState: { ...state.publicState, winnerPlayerId: winner } });
+//   }
+//
+// Do NOT mirror derived values back into \`publicState\`. Keep the raw
+// inputs (component locations, zone contents, counters) in state and
+// express aggregates here.
+//
+// Uncomment the example below once you have something to derive.
+
+// import { defineDerived } from "@dreamboard/app-sdk/reducer";
+// import type { GameContract } from "./game-contract";
+//
+// export const winnerOf = defineDerived<GameContract>()({
+//   name: "winnerOf",
+//   compute: ({ state }) => {
+//     // Example: return the first player at or above the VP target.
+//     return state.publicState.winnerPlayerId ?? null;
+//   },
+// });
+
+export {};
+`;
+}
+
+function generateReducerGameContractSeed(): string {
+  return `import { z } from "zod";
+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
+// state types. Put reducers in app/phases/* and pure computations in
+// app/derived.ts or app/rules/*.
+const publicStateSchema = z.object({
+  currentPlayerId: ids.playerId.nullable(),
+  notesByPlayerId: z.partialRecord(ids.playerId, z.string()).default({}),
+});
+const privateStateSchema = z.object({});
+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,
+  },
+});
+
+export type GameContract = typeof gameContract;
+export type GameState = GameStateOf<GameContract>;
+`;
+}
+
+function generateReducerGameSeed(): string {
+  return `import { defineGame } from "@dreamboard/app-sdk/reducer";
+import { gameContract } from "./game-contract";
+import { phases } from "./phases";
+import setupProfiles from "./setup-profiles";
+
+// Keep this file as the defineGame assembly point. Put rules in phases,
+// projections in views/derived modules, and reusable domain helpers in
+// app/rules/* once reducer-support.ts is no longer small.
+export default defineGame({
+  contract: gameContract,
+  initial: {
+    public: ({ playerIds }) => ({
+      currentPlayerId: playerIds[0] ?? null,
+      notesByPlayerId: {},
+    }),
+    private: () => ({}),
+    hidden: () => ({}),
+  },
+  initialPhase: "setup",
+  setupProfiles,
+  phases,
+  views: {},
+});
+`;
+}
+
+function generateSetupProfilesSeed(manifest: GameTopologyManifest): string {
+  const setupProfiles = manifest.setupProfiles ?? [];
+  const setupProfileEntries =
+    setupProfiles.length === 0
+      ? ""
+      : `{\n${setupProfiles
+          .map((profile) => `  ${JSON.stringify(profile.id)}: {},`)
+          .join("\n")}\n}`;
+
+  return `// ${SETUP_PROFILES_SEED_MARKER}
+import { setupProfiles } from "../shared/manifest-contract";
+
+export default setupProfiles(${setupProfileEntries || "{}"});
+`;
+}
+
+export function isFrameworkOwnedSetupProfilesSeed(
+  content: string | null | undefined,
+): boolean {
+  if (content === null || content === undefined) {
+    return false;
+  }
+  const trimmed = content.trim();
+  if (trimmed.length === 0) {
+    return true;
+  }
+  if (trimmed.includes(SETUP_PROFILES_SEED_MARKER)) {
+    return true;
+  }
+  return false;
+}
+
+function generateSetupPhaseSeed(): string {
+  return `import { z } from "zod";
+import type { GameContract } from "../game-contract";
+import { definePhase } from "@dreamboard/app-sdk/reducer";
+
+// A single phase file is fine while the phase is small. When a phase grows
+// multiple action families, move it to app/phases/<phase>/index.ts and split
+// interactions into neighboring concept files.
+export const setup = definePhase<GameContract>()({
+  kind: "auto",
+  state: z.object({}),
+  initialState: () => ({}),
+  enter({ state, accept }) {
+    return accept(state);
+  },
+});
+`;
+}
+
+function generatePhaseIndexSeed(): string {
+  return `import { setup } from "./setup";
+import type { GameContract } from "../game-contract";
+import type { PhaseMapOf } from "@dreamboard/app-sdk/reducer";
+
+export const phases = {
+  setup,
+} satisfies PhaseMapOf<GameContract>;
+`;
+}
+
+function generateReducerAppIndex(): string {
+  return `import game from "./game";
+import { createReducerBundle } from "@dreamboard/app-sdk/reducer";
+
+export default createReducerBundle(game);
+`;
+}
+
+function generateAppFrameworkTsConfig(): string {
+  return `${JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES2020",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        declaration: false,
+        outDir: "./dist",
+        paths: {
+          "@dreamboard/manifest-contract": ["../shared/manifest-contract.ts"],
+          "@dreamboard/ui-contract": ["../shared/generated/ui-contract.ts"],
+          "@shared/*": ["../shared/*"],
+        },
+      },
+      include: [
+        "./**/*.ts",
+        "./**/*.d.ts",
+        "../shared/manifest-*.ts",
+        "../shared/manifest-*.d.ts",
+      ],
+      exclude: ["node_modules", "dist", "../shared/generated"],
+    },
+    null,
+    2,
+  )}\n`;
+}
+
+function generateUiFrameworkTsConfig(): string {
+  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"
+  ]
+}
+`;
+}
+
+function generateReducerUiAppContent(): string {
+  return `import { Phase, PromptInbox } from "@dreamboard/ui-contract";
+
+function SetupPhase() {
+  return (
+    <main>
+      <PromptInbox.Root>
+        <PromptInbox.Empty>No available prompts.</PromptInbox.Empty>
+        <PromptInbox.Items />
+      </PromptInbox.Root>
+    </main>
+  );
+}
+
+export default function App() {
+  return (
+    <Phase.Switch
+      routes={{
+        setup: () => <SetupPhase />,
+      }}
+    />
+  );
+}
+`;
+}
+
+export function generateSeedFiles(
+  manifest: GameTopologyManifest,
+): Record<string, string> {
+  return {
+    "app/README.md": generateAppReadmeSeed(),
+    "ui/App.tsx": generateReducerUiAppContent(),
+    "app/game-contract.ts": generateReducerGameContractSeed(),
+    "app/game.ts": generateReducerGameSeed(),
+    "app/setup-profiles.ts": generateSetupProfilesSeed(manifest),
+    "app/reducer-support.ts": generateReducerSupportSeed(),
+    "app/derived.ts": generateReducerDerivedSeed(),
+    "app/phases/setup.ts": generateSetupPhaseSeed(),
+    "app/phases/index.ts": generatePhaseIndexSeed(),
+  };
+}
+
+export function generateAuthoritativeIndexFile(
+  _manifest: GameTopologyManifest,
+): string {
+  return generateReducerAppIndex();
+}
+
+export function generateFrameworkFiles(
+  manifest: GameTopologyManifest,
+): Record<string, string> {
+  return {
+    "app/tsconfig.framework.json": generateAppFrameworkTsConfig(),
+    "ui/tsconfig.framework.json": generateUiFrameworkTsConfig(),
+    "shared/generated/ui-contract.ts": generateUiContractContent(),
+    "app/index.ts": generateAuthoritativeIndexFile(manifest),
+  };
+}