@dreamboard-games/workspace-codegen 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dreamboard-games/workspace-codegen",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Internal Dreamboard workspace source generator",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,8 +20,8 @@
     "test:unit": "bun test --timeout 30000"
   },
   "dependencies": {
-    "@dreamboard/sdk-types": "npm:@dreamboard-games/sdk-types@0.1.1",
-    "@dreamboard/ui-sdk": "npm:@dreamboard-games/ui-sdk@0.0.42"
+    "@dreamboard/sdk-types": "npm:@dreamboard-games/sdk-types@0.1.2",
+    "@dreamboard/ui-sdk": "npm:@dreamboard-games/ui-sdk@0.0.45"
   },
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {

package/src/authoring-benchmark.test.ts

@@ -1,4 +1,12 @@
-import { lstat, mkdir, mkdtemp, readFile, rm, symlink } from "node:fs/promises";
+import {
+  lstat,
+  mkdir,
+  mkdtemp,
+  readFile,
+  readlink,
+  rm,
+  symlink,
+} from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import process from "node:process";
@@ -34,7 +42,8 @@ const EXPECTED_UI_FRAMEWORK_TSCONFIG = `{
     "jsx": "react-jsx",
     "strict": true,
     "esModuleInterop": true,
-    "skipLibCheck": true,
+    "skipLibCheck": false,
+    "types": [],
     "paths": {
       "@dreamboard/manifest-contract": [
         "../shared/manifest-contract.ts"
@@ -59,6 +68,44 @@ const EXPECTED_UI_FRAMEWORK_TSCONFIG = `{
 }
 `;
 
+const EXPECTED_APP_FRAMEWORK_TSCONFIG = `{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": false,
+    "types": [],
+    "declaration": false,
+    "rootDir": "..",
+    "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"
+  ]
+}
+`;
+
 async function loadBenchmarkManifest(): Promise<GameTopologyManifest> {
   return materializeManifest(benchmarkRoot) as Promise<GameTopologyManifest>;
 }
@@ -79,6 +126,32 @@ async function ensureSymlink(targetPath: string, linkPath: string) {
   );
 }
 
+async function ensurePackageSymlink(targetPath: string, linkPath: string) {
+  try {
+    const stats = await lstat(linkPath);
+    if (stats.isSymbolicLink()) {
+      const existingTarget = await readlink(linkPath);
+      const resolvedExistingTarget = path.resolve(
+        path.dirname(linkPath),
+        existingTarget,
+      );
+      if (resolvedExistingTarget === targetPath) {
+        return;
+      }
+    }
+    await rm(linkPath, { recursive: true, force: true });
+  } catch {
+    // Fall through and create the symlink.
+  }
+
+  await mkdir(path.dirname(linkPath), { recursive: true });
+  await symlink(
+    targetPath,
+    linkPath,
+    process.platform === "win32" ? "junction" : "dir",
+  );
+}
+
 function collectComponentHomeTypes(
   manifest: GameTopologyManifest,
 ): Set<string> {
@@ -258,12 +331,15 @@ test("authoritative ui framework tsconfig uses the scaffold format", async () =>
     await loadBenchmarkManifest(),
   );
 
+  expect(authoritativeFiles["app/tsconfig.framework.json"]).toBe(
+    EXPECTED_APP_FRAMEWORK_TSCONFIG,
+  );
   expect(authoritativeFiles["ui/tsconfig.framework.json"]).toBe(
     EXPECTED_UI_FRAMEWORK_TSCONFIG,
   );
 });
 
-test("generated ui-contract.ts exposes a typed useHexBoardView wrapper", async () => {
+test("generated ui-contract.ts exposes typed hex board view primitives", async () => {
   const manifest = await loadBenchmarkManifest();
   const authoritativeFiles = generateAuthoritativeFiles(manifest);
 
@@ -274,20 +350,31 @@ test("generated ui-contract.ts exposes a typed useHexBoardView wrapper", async (
     );
   }
 
-  // Imports static topology and exports the workspace-typed helper.
+  // Imports static topology and exports the workspace-typed component.
   expect(uiContract).toContain("staticBoards");
-  expect(uiContract).toContain("createHexBoardView");
-  expect(uiContract).toContain("export function useHexBoardView");
-
-  // Constrains the boardId argument to the manifest's hex-board ids and
-  // narrows TSpaceView.id to that board's space-id type.
+  expect(uiContract).toContain(
+    "type BoardHexViewProps as BoardHexViewPropsGeneric",
+  );
+  expect(uiContract).toContain(
+    "type BoardHexGridProps as BoardHexGridPropsGeneric",
+  );
+  expect(uiContract).toContain("export type HexBoardViewProps");
+  expect(uiContract).toContain("export type HexBoardGridProps");
+  expect(uiContract).toContain("type WorkspaceBoard");
+  expect(uiContract).toContain('export const Board: WorkspaceUI["Board"]');
+  expect(uiContract).toContain("baseUI.Board.HexView");
+  expect(uiContract).toContain("baseUI.Board.HexGrid");
+  expect(uiContract).not.toContain("export function useHexBoardView");
+
+  // Constrains the board prop to the manifest's hex-board ids and narrows
+  // TSpaceView.id to that board's space-id type.
   expect(uiContract).toContain("export type HexBoardId");
   expect(uiContract).toContain("keyof typeof hexStaticBoards");
   expect(uiContract).toContain("Id extends HexBoardId");
   expect(uiContract).toContain("BoardSpaceIdOf");
 });
 
-test("generated ui-contract.ts exposes typed interaction form wrappers", async () => {
+test("generated ui-contract.ts exposes Interaction.Field without standalone field wrappers", async () => {
   const manifest = await loadBenchmarkManifest();
   const authoritativeFiles = generateAuthoritativeFiles(manifest);
 
@@ -298,13 +385,19 @@ test("generated ui-contract.ts exposes typed interaction form wrappers", async (
     );
   }
 
-  expect(uiContract).toContain("InteractionForm as InteractionFormGeneric");
-  expect(uiContract).toContain("export type InteractionFieldRenderers");
-  expect(uiContract).toContain(
+  expect(uiContract).not.toContain("InteractionForm as InteractionFormGeneric");
+  expect(uiContract).not.toContain("export type InteractionFieldRenderers");
+  expect(uiContract).not.toContain("export type InteractionFieldProps");
+  expect(uiContract).not.toContain(
     "export type InteractionFormProps<Key extends InteractionKey>",
   );
-  expect(uiContract).toContain("export function InteractionForm");
-  expect(uiContract).toContain("export function InteractionField");
+  expect(uiContract).not.toContain("export function InteractionForm");
+  expect(uiContract).not.toContain("export function InteractionField");
+  expect(uiContract).toContain("readonly Interaction: Omit<");
+  expect(uiContract).toContain(
+    'DreamboardUI<typeof uiContract>["Interaction"]',
+  );
+  expect(uiContract).toContain("export const Interaction = UI.Interaction;");
 });
 
 test("generated ui-contract.ts exposes typed Radix-style primitives without GameShell wrappers", async () => {
@@ -318,11 +411,20 @@ test("generated ui-contract.ts exposes typed Radix-style primitives without Game
     );
   }
 
-  expect(uiContract).toContain("export const UI = createDreamboardUI");
+  expect(uiContract).toContain("const baseUI = createDreamboardUI(uiContract)");
+  expect(uiContract).toContain("export const UI: WorkspaceUI = {");
+  expect(uiContract).toContain("type TypedGame");
+  expect(uiContract).toContain("export const Game");
   expect(uiContract).toContain("export const Interaction = UI.Interaction");
   expect(uiContract).toContain("export const Prompt = UI.Prompt");
+  expect(uiContract).toContain("type UIPlayerRegistry");
+  expect(uiContract).toContain("players: {} as UIPlayerRegistry");
+  expect(uiContract).toContain("export const PlayerRoster");
+  expect(uiContract).toContain('export const Dice: WorkspaceUI["Dice"]');
   expect(uiContract).toContain("export const Zone = UI.Zone");
-  expect(uiContract).toContain("export const Board = UI.Board");
+  expect(uiContract).toContain("createResourceCounter");
+  expect(uiContract).toContain("export const ResourceCounter");
+  expect(uiContract).toContain('export const Board: WorkspaceUI["Board"]');
   expect(uiContract).not.toContain("WorkspaceGameShell");
   expect(uiContract).not.toContain("GameShell as GameShellGeneric");
   expect(uiContract).not.toContain("defineMarketSurface");
@@ -330,18 +432,7 @@ test("generated ui-contract.ts exposes typed Radix-style primitives without Game
 });
 
 test("board-contract-lab manifest authoring typechecks", async () => {
-  await ensureSymlink(
-    WORKSPACE_NODE_MODULES,
-    path.join(benchmarkRoot, "node_modules"),
-  );
-  await ensureSymlink(
-    SDK_TYPES_PACKAGE_ROOT,
-    path.join(benchmarkRoot, "node_modules", "@dreamboard", "sdk-types"),
-  );
-  await ensureSymlink(
-    UI_SDK_NODE_MODULES,
-    path.join(benchmarkRoot, "ui", "node_modules"),
-  );
+  await prepareExampleTypecheckDependencies(benchmarkRoot);
 
   const result = runNode20ExampleScript(benchmarkRoot, "typecheck:manifest");
 
@@ -354,9 +445,35 @@ test("generated app contracts typecheck under Node 20 without a larger heap", as
   const examples = [thingsInRingsRoot, benchmarkRoot];
 
   for (const exampleRoot of examples) {
+    await prepareExampleTypecheckDependencies(exampleRoot);
     const result = runNode20ExampleScript(exampleRoot, "typecheck:app");
     if (result.exitCode !== 0) {
       throwTypecheckError(`${exampleRoot} app`, result);
     }
   }
 }, 120_000);
+
+async function prepareExampleTypecheckDependencies(exampleRoot: string) {
+  const nodeModulesPath = path.join(exampleRoot, "node_modules");
+  await ensureSymlink(WORKSPACE_NODE_MODULES, nodeModulesPath);
+  await ensureSymlink(
+    SDK_TYPES_PACKAGE_ROOT,
+    path.join(exampleRoot, "node_modules", "@dreamboard", "sdk-types"),
+  );
+  await ensureSymlink(
+    UI_SDK_NODE_MODULES,
+    path.join(exampleRoot, "ui", "node_modules"),
+  );
+
+  const nodeModulesStats = await lstat(nodeModulesPath);
+  if (!nodeModulesStats.isSymbolicLink()) {
+    await ensurePackageSymlink(
+      path.join(UI_SDK_NODE_MODULES, "@types", "react"),
+      path.join(nodeModulesPath, "@types", "react"),
+    );
+    await ensurePackageSymlink(
+      path.join(UI_SDK_NODE_MODULES, "@types", "react-dom"),
+      path.join(nodeModulesPath, "@types", "react-dom"),
+    );
+  }
+}

package/src/manifest-contract.test.ts

@@ -724,7 +724,7 @@ test("generateManifestContractSource emits typed topology fields and helper lite
   expect(source).not.toContain("cardName: z.string().optional()");
   expect(source).not.toContain("description: z.string().optional()");
   expect(source).toContain(
-    "const cardPropertiesSchemaByCardSetId: Record<string, z.ZodTypeAny> = {",
+    "const cardPropertiesSchemaByCardSetId: Record<string, z.ZodType<unknown>> = {",
   );
   expect(source).toContain(
     "function createCardStateSchema<CardIdValue extends CardId>(",

package/src/manifest-contract.ts

@@ -3383,7 +3383,7 @@ function renderCardPropertiesSchemaByCardSetId(
       `  ${quote(cardSet.id)}: ${toPascalCase(cardSet.id)}CardPropertiesSchema,`,
     ];
   });
-  return `const cardPropertiesSchemaByCardSetId: Record<string, z.ZodTypeAny> = {\n${entries.join("\n")}\n};`;
+  return `const cardPropertiesSchemaByCardSetId: Record<string, z.ZodType<unknown>> = {\n${entries.join("\n")}\n};`;
 }
 
 function renderObjectSchemaSection(
@@ -3666,7 +3666,7 @@ function renderCardStateSchemaById(analysis: ManifestAnalysis): string {
   return `z.object(
   Object.fromEntries(
     literals.cardIds.map((cardId) => [cardId, createCardStateSchema(cardId)]),
-  ) as Record<CardId, z.ZodTypeAny>,
+  ) as Record<CardId, z.ZodType<unknown>>,
 )`;
 }
 
@@ -3773,8 +3773,17 @@ function renderGenericBoardStateSchema(
     },
     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, …)\` 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(),
@@ -3835,8 +3844,9 @@ function renderHexBoardStateSchema(
     },
     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(),
@@ -3907,8 +3917,9 @@ function renderSquareBoardStateSchema(
     },
     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(),
@@ -5718,7 +5729,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),
 });
@@ -5748,7 +5763,8 @@ const squareVertexStateSchema = z.object({
 });
 const runtimeHexBoardStateSchema = runtimeGenericBoardStateSchema.extend({
   layout: z.literal("hex"),
-  spaces: z.record(ids.spaceId, hexSpaceStateSchema),
+  // T220: loose-keyed by string — see comment above.
+  spaces: z.record(z.string(), hexSpaceStateSchema),
   relations: z.array(boardRelationStateSchema),
   containers: z.object({}),
   orientation: z.enum(["pointy-top", "flat-top"]),
@@ -5757,7 +5773,8 @@ const runtimeHexBoardStateSchema = runtimeGenericBoardStateSchema.extend({
 });
 const runtimeSquareBoardStateSchema = runtimeGenericBoardStateSchema.extend({
   layout: z.literal("square"),
-  spaces: z.record(ids.spaceId, squareSpaceStateSchema),
+  // T220: loose-keyed by string — see comment above.
+  spaces: z.record(z.string(), squareSpaceStateSchema),
   relations: z.array(boardRelationStateSchema),
   containers: z.record(ids.boardContainerId, boardContainerStateSchema),
   edges: z.array(hexEdgeStateSchema),
@@ -5973,11 +5990,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,
@@ -6178,6 +6195,34 @@ function renderManifestRuntimeSource(legacySource: string): string {
       `} from "@dreamboard/app-sdk/reducer";\n\nconst unknownRecordSchema`,
       `} from "@dreamboard/app-sdk/reducer";\nimport { literals } from "./manifest-literals";\nimport type { PlayerId as PublicPlayerId, TableState as PublicTableState } from "./manifest-types";\n\nconst 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<\n  RuntimeTableRecord,`,
       `export const manifestContract: ReducerManifestContract<\n  PublicTableState,`,
@@ -6188,7 +6233,7 @@ function renderManifestRuntimeSource(legacySource: string): string {
     )
     .replace(
       `const playerIdSchema = markManifestScopedSchema(\n  z\n    .string()\n    .min(1)\n    .transform((value) => asPlayerId(value)),\n);`,
-      `const playerIdSchema = markManifestScopedSchema(\n  z\n    .string()\n    .min(1)\n    .transform((value) => asPlayerId(value)),\n) as unknown as z.ZodType<PublicPlayerId>;`,
+      `const playerIdSchema = assumeManifestSchema<PublicPlayerId>(\n  markManifestScopedSchema(\n    z\n      .string()\n      .min(1)\n      .transform((value) => asPlayerId(value)),\n  ),\n);`,
     );
 }