@dreamboard-games/sdk 0.5.0-alpha.2 → 0.5.0-alpha.4

package/dist/reducer.js

@@ -1,172 +1,4255 @@
-import {
-  StaleContractArtifactError,
-  contractFingerprint,
-  createDerivedResolver,
-  createReducerBundle,
-  createReducerOps,
-  createStateQueries,
-  createTableQueries,
-  defineDerived,
-  isStaleContractArtifactError,
-  noopDiagnosticsSink
-} from "./chunk-S2JEDVWH.js";
-import {
-  compileManifest,
-  createGame,
-  defineInputs,
-  many,
-  normalizeCommandParams,
-  sparseCounts,
-  sparseMap
-} from "./chunk-ZZGN2ATS.js";
 import {
   FrameworkErrorCodes,
+  REDUCER_CONTRACT_VERSION,
   asPlayerId,
   assertCardAllowedInContainer,
+  assertReducerBundleContract,
+  assumeManifestSchema,
   boardRef,
   boardRefKey,
   boardRefSchema,
-  isPerPlayer,
+  createManifestGameStateSchema,
+  createManifestRuntimeSchema,
+  createManifestStringLiteralSchema,
+  createReducerBundle,
+  createStateQueries,
+  createTableQueries,
+  isManifestScopedSchema,
   isPerPlayerBoardRef,
   isPlayerId,
   isSharedBoardRef,
+  markManifestScopedSchema,
+  noopDiagnosticsSink,
   parseBoardRefKey,
-  perPlayer,
   perPlayerBoardRef,
-  perPlayerEntries,
-  perPlayerGet,
-  perPlayerHas,
-  perPlayerKeys,
-  perPlayerMap,
-  perPlayerRequire,
-  perPlayerSchema,
-  perPlayerSet,
-  perPlayerSize,
-  perPlayerValues,
-  setActivePlayers,
-  sharedBoardRef
-} from "./chunk-H6VDGFL5.js";
-import "./chunk-5YV2WHJ4.js";
-import "./chunk-PF7L4BMG.js";
-import "./chunk-Z7QCREWI.js";
-import "./chunk-UGH54WZ2.js";
-import "./chunk-PZ5AY32C.js";
-
-// src/reducer/authoring/effect.ts
-import { z } from "zod";
-function createContinuationCallable(definition) {
-  const continuation = ((data) => {
-    return {
-      id: continuation.id,
-      data
-    };
+  sharedBoardRef,
+  validatedReducerDefinition
+} from "./chunk-C77SYIVT.js";
+import {
+  createHexBoardGeometry,
+  fromCoordinates,
+  hexagon,
+  rectangle,
+  resolveHexSpaces,
+  ring,
+  runtime_schema_exports,
+  spiral
+} from "./chunk-XU6WJW6K.js";
+import {
+  isPlayerBoardSpaceTarget,
+  samePlayerBoardSpaceTarget
+} from "./chunk-3JXUL4VN.js";
+
+// src/reducer/manifest/compiler.ts
+import { z as z2 } from "zod";
+
+// src/reducer/manifest/generated-helpers.ts
+function buildTypedRecord(ids, initial) {
+  const createValue = typeof initial === "function" ? initial : () => initial;
+  return Object.fromEntries(ids.map((id) => [id, createValue(id)]));
+}
+
+// src/reducer/manifest/manifest-validation.ts
+function isHexBoardSpec(board) {
+  return board.layout === "hex";
+}
+function collectDuplicateIdIssues(options) {
+  const issues = [];
+  const pathsById = /* @__PURE__ */ new Map();
+  for (const entry of options.entries) {
+    const id = entry.id?.trim();
+    if (!id) {
+      continue;
+    }
+    const paths = pathsById.get(id) ?? [];
+    paths.push(entry.path);
+    pathsById.set(id, paths);
+  }
+  for (const [id, paths] of pathsById.entries()) {
+    if (paths.length > 1) {
+      issues.push(`${paths.join(", ")}: Duplicate ${options.label} '${id}'.`);
+    }
+  }
+  return issues;
+}
+var PROTOTYPE_SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "prototype",
+  "constructor"
+]);
+function validateRecordKey(value, path) {
+  if (!value || !PROTOTYPE_SENSITIVE_KEYS.has(value)) {
+    return [];
+  }
+  return [
+    `${path}: '${value}' is reserved and cannot be used as a generated record key.`
+  ];
+}
+function collectKeyIssues(entries) {
+  return entries.flatMap(({ value, path }) => validateRecordKey(value, path));
+}
+function renderCardInstanceIds(card) {
+  return card.count > 1 ? Array.from(
+    { length: card.count },
+    (_, index) => `${card.id}-${index + 1}`
+  ) : [card.id];
+}
+function collectPropertySchemaKeyIssues(schema, path) {
+  if (!schema) {
+    return [];
+  }
+  const issues = [];
+  if (schema.type === "object") {
+    for (const [key, property] of Object.entries(schema.properties ?? {})) {
+      issues.push(
+        ...validateRecordKey(key, `${path}.properties.${key}`),
+        ...collectPropertySchemaKeyIssues(
+          property,
+          `${path}.properties.${key}`
+        )
+      );
+    }
+  }
+  if (schema.type === "array") {
+    issues.push(
+      ...collectPropertySchemaKeyIssues(schema.items, `${path}.items`)
+    );
+  }
+  if (schema.type === "record") {
+    issues.push(
+      ...collectPropertySchemaKeyIssues(schema.values, `${path}.values`)
+    );
+  }
+  return issues;
+}
+function collectObjectSchemaKeyIssues(schema, path) {
+  const issues = [];
+  for (const [key, property] of Object.entries(schema?.properties ?? {})) {
+    issues.push(
+      ...validateRecordKey(key, `${path}.properties.${key}`),
+      ...collectPropertySchemaKeyIssues(property, `${path}.properties.${key}`)
+    );
+  }
+  return issues;
+}
+function collectCardSchemaKeyIssues(cardSet, path) {
+  const schema = cardSet.cardSchema;
+  if ("variants" in schema) {
+    return [
+      ...Object.entries(schema.shared ?? {}).flatMap(([key, property]) => [
+        ...validateRecordKey(key, `${path}.cardSchema.shared.${key}`),
+        ...collectPropertySchemaKeyIssues(
+          property,
+          `${path}.cardSchema.shared.${key}`
+        )
+      ]),
+      ...Object.entries(schema.variants).flatMap(
+        ([variantKey, variantSchema]) => [
+          ...validateRecordKey(
+            variantKey,
+            `${path}.cardSchema.variants.${variantKey}`
+          ),
+          ...collectObjectSchemaKeyIssues(
+            variantSchema,
+            `${path}.cardSchema.variants.${variantKey}`
+          )
+        ]
+      )
+    ];
+  }
+  return collectObjectSchemaKeyIssues(schema, `${path}.cardSchema`);
+}
+function expandSeedIds(seeds) {
+  return seeds.flatMap((seed) => {
+    const count = seed.count ?? 1;
+    const baseId = seed.id ?? seed.typeId;
+    return count > 1 ? Array.from({ length: count }, (_, index) => `${baseId}-${index + 1}`) : [baseId];
   });
-  continuation.id = definition.id;
-  continuation.source = "effect";
-  continuation.dataSchema = definition.data;
-  continuation.responseSchema = definition.response;
-  continuation.reduce = definition.reduce;
-  if (definition.effectKind !== void 0) {
-    continuation.effectKind = definition.effectKind;
-  }
-  return continuation;
-}
-function defineEffect() {
-  function effect(definition) {
-    if (definition.type === "rollDie" || definition.type === "shuffleSharedZone" || definition.type === "shufflePlayerZone") {
-      const effectKind = definition.type;
-      if (!definition.reduce) {
-        return {
-          type: definition.type,
-          id: definition.id,
-          contextSchema: definition.context
-        };
+}
+function validateTypeSlotDuplicates(options) {
+  const issues = [];
+  for (const [index, pieceType] of options.pieceTypes.entries()) {
+    issues.push(
+      ...collectDuplicateIdIssues({
+        entries: (pieceType.slots ?? []).map((slot, slotIndex) => ({
+          id: slot.id,
+          path: `manifest.pieceTypes[${index}].slots[${slotIndex}].id`
+        })),
+        label: "piece slot id"
+      })
+    );
+  }
+  for (const [index, dieType] of options.dieTypes.entries()) {
+    issues.push(
+      ...collectDuplicateIdIssues({
+        entries: (dieType.slots ?? []).map((slot, slotIndex) => ({
+          id: slot.id,
+          path: `manifest.dieTypes[${index}].slots[${slotIndex}].id`
+        })),
+        label: "die slot id"
+      })
+    );
+  }
+  return issues;
+}
+function validateSlotHostsAndHomes(manifest) {
+  const issues = [];
+  const pieceTypesById = new Map(
+    (manifest.pieceTypes ?? []).map(
+      (pieceType) => [pieceType.id, pieceType]
+    )
+  );
+  const dieTypesById = new Map(
+    (manifest.dieTypes ?? []).map((dieType) => [dieType.id, dieType])
+  );
+  const slotIdsByHostKey = /* @__PURE__ */ new Map();
+  for (const [index, seed] of (manifest.pieceSeeds ?? []).entries()) {
+    const pieceType = pieceTypesById.get(seed.typeId);
+    const slotIds = (pieceType?.slots ?? []).map((slot) => slot.id);
+    if (slotIds.length === 0) {
+      continue;
+    }
+    if (typeof seed.id !== "string" || seed.id.length === 0) {
+      issues.push(
+        `manifest.pieceSeeds[${index}].id: Piece seed for slot-bearing type '${seed.typeId}' must declare an explicit id.`
+      );
+      continue;
+    }
+    if ((seed.count ?? 1) !== 1) {
+      issues.push(
+        `manifest.pieceSeeds[${index}].count: Piece seed '${seed.id}' for slot-bearing type '${seed.typeId}' must omit count or set it to 1.`
+      );
+      continue;
+    }
+    slotIdsByHostKey.set(`piece:${seed.id}`, new Set(slotIds));
+  }
+  for (const [index, seed] of (manifest.dieSeeds ?? []).entries()) {
+    const dieType = dieTypesById.get(seed.typeId);
+    const slotIds = (dieType?.slots ?? []).map((slot) => slot.id);
+    if (slotIds.length === 0) {
+      continue;
+    }
+    if (typeof seed.id !== "string" || seed.id.length === 0) {
+      issues.push(
+        `manifest.dieSeeds[${index}].id: Die seed for slot-bearing type '${seed.typeId}' must declare an explicit id.`
+      );
+      continue;
+    }
+    if ((seed.count ?? 1) !== 1) {
+      issues.push(
+        `manifest.dieSeeds[${index}].count: Die seed '${seed.id}' for slot-bearing type '${seed.typeId}' must omit count or set it to 1.`
+      );
+      continue;
+    }
+    slotIdsByHostKey.set(`die:${seed.id}`, new Set(slotIds));
+  }
+  const validateHome = (home, path) => {
+    if (home?.type !== "slot") {
+      return;
+    }
+    const hostKey = `${home.host.kind}:${home.host.id}`;
+    const slotIds = slotIdsByHostKey.get(hostKey);
+    if (!slotIds) {
+      issues.push(
+        `${path}.host: Unknown strict slot host '${home.host.kind}:${home.host.id}'. Hosts must be singleton piece/die seeds whose type declares slots.`
+      );
+      return;
+    }
+    if (!slotIds.has(home.slotId)) {
+      issues.push(
+        `${path}.slotId: Unknown slot '${home.slotId}' for host '${home.host.kind}:${home.host.id}'.`
+      );
+    }
+  };
+  for (const [cardSetIndex, cardSet] of manifest.cardSets.entries()) {
+    validateHome(
+      cardSet.defaultHome,
+      `manifest.cardSets[${cardSetIndex}].defaultHome`
+    );
+    for (const [cardIndex, card] of cardSet.cards.entries()) {
+      validateHome(
+        card.home,
+        `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].home`
+      );
+    }
+  }
+  for (const [index, seed] of (manifest.pieceSeeds ?? []).entries()) {
+    validateHome(seed.home, `manifest.pieceSeeds[${index}].home`);
+  }
+  for (const [index, seed] of (manifest.dieSeeds ?? []).entries()) {
+    validateHome(seed.home, `manifest.dieSeeds[${index}].home`);
+  }
+  return issues;
+}
+function validatePlayerScopedSeedHomes(manifest) {
+  const issues = [];
+  const boardScopeById = new Map(
+    (manifest.boards ?? []).map((board) => [board.id, board.scope])
+  );
+  const zoneScopeById = new Map(
+    (manifest.zones ?? []).map((zone) => [zone.id, zone.scope])
+  );
+  const validateSeedHome = (seed, path, label) => {
+    const authoredId = seed.id ?? seed.typeId;
+    if (seed.ownerId) {
+      return;
+    }
+    if (homeTargetsBoard(seed.home) && boardScopeById.get(seed.home.boardId) === "perPlayer") {
+      issues.push(
+        `${path}.boardId: ${label} '${authoredId}' requires ownerId because board '${seed.home.boardId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
+      );
+      return;
+    }
+    if (seed.home?.type === "zone" && zoneScopeById.get(seed.home.zoneId) === "perPlayer") {
+      issues.push(
+        `${path}.zoneId: ${label} '${authoredId}' requires ownerId because zone '${seed.home.zoneId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
+      );
+    }
+  };
+  for (const [index, seed] of (manifest.pieceSeeds ?? []).entries()) {
+    validateSeedHome(seed, `manifest.pieceSeeds[${index}].home`, "Piece seed");
+  }
+  for (const [index, seed] of (manifest.dieSeeds ?? []).entries()) {
+    validateSeedHome(seed, `manifest.dieSeeds[${index}].home`, "Die seed");
+  }
+  return issues;
+}
+function validateCardHomes(manifest) {
+  const issues = [];
+  const boardScopeById = new Map(
+    (manifest.boards ?? []).map((board) => [board.id, board.scope])
+  );
+  const zoneScopeById = new Map(
+    (manifest.zones ?? []).map((zone) => [zone.id, zone.scope])
+  );
+  for (const [cardSetIndex, cardSet] of manifest.cardSets.entries()) {
+    if (!cardSet.defaultHome) {
+      issues.push(
+        `manifest.cardSets[${cardSetIndex}].defaultHome: Card sets must declare defaultHome.`
+      );
+      continue;
+    }
+    const validateCardHome = (home, path, label) => {
+      if (home?.type === "zone" && zoneScopeById.get(home.zoneId) === "perPlayer") {
+        issues.push(
+          `${path}.zoneId: ${label} cannot target per-player zone '${home.zoneId}' because card inventory has no ownerId. Place it during reducer setup instead.`
+        );
+      }
+      if (homeTargetsBoard(home) && boardScopeById.get(home.boardId) === "perPlayer") {
+        issues.push(
+          `${path}.boardId: ${label} cannot target per-player board '${home.boardId}' because card inventory has no ownerId. Place it during reducer setup instead.`
+        );
       }
-      const contextSchema = definition.context ?? z.object({});
-      const continuation = createContinuationCallable({
-        id: definition.id,
-        data: contextSchema,
-        response: z.unknown(),
-        effectKind,
-        reduce: definition.reduce
+    };
+    validateCardHome(
+      cardSet.defaultHome,
+      `manifest.cardSets[${cardSetIndex}].defaultHome`,
+      `Card set '${cardSet.id}' defaultHome`
+    );
+    for (const [cardIndex, card] of cardSet.cards.entries()) {
+      const path = `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].home`;
+      validateCardHome(card.home, path, `Card '${card.id}'`);
+    }
+  }
+  return issues;
+}
+var CARD_IMAGE_PATH = /^assets\/(?:[\w-][\w.-]*\/)*[\w-][\w.-]*\.(?:avif|gif|jpe?g|png|svg|webp)$/i;
+function validateCardImages(manifest) {
+  return manifest.cardSets.flatMap(
+    (cardSet, cardSetIndex) => cardSet.cards.flatMap(
+      (card, cardIndex) => ["frontImage", "backImage"].flatMap((key) => {
+        const image = card[key];
+        return image === void 0 || CARD_IMAGE_PATH.test(image) ? [] : [
+          `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].${key}: '${image}' must be an image path under assets/, such as assets/cards/front.webp.`
+        ];
+      })
+    )
+  );
+}
+function homeTargetsBoard(home) {
+  return home?.type === "space" || home?.type === "container" || home?.type === "edge" || home?.type === "vertex";
+}
+function validateBoardDuplicates(boards) {
+  const issues = [];
+  for (const [index, board] of boards.entries()) {
+    if (isHexBoardSpec(board)) {
+      issues.push(
+        ...collectDuplicateIdIssues({
+          entries: Object.values(board.spaces ?? {}).map(
+            (space, spaceIndex) => ({
+              id: space.id,
+              path: `manifest.boards[${index}].spaces[${spaceIndex}].id`
+            })
+          ),
+          label: "space id"
+        })
+      );
+      continue;
+    }
+    issues.push(
+      ...collectDuplicateIdIssues({
+        entries: (board.spaces ?? []).map((space, spaceIndex) => ({
+          id: space.id,
+          path: `manifest.boards[${index}].spaces[${spaceIndex}].id`
+        })),
+        label: "space id"
+      })
+    );
+    issues.push(
+      ...collectDuplicateIdIssues({
+        entries: (board.containers ?? []).map((container, containerIndex) => ({
+          id: container.id,
+          path: `manifest.boards[${index}].containers[${containerIndex}].id`
+        })),
+        label: "container id"
+      })
+    );
+    issues.push(
+      ...collectDuplicateIdIssues({
+        entries: (board.relations ?? []).map((relation, relationIndex) => ({
+          id: relation.id,
+          path: `manifest.boards[${index}].relations[${relationIndex}].id`
+        })),
+        label: "relation id"
+      })
+    );
+  }
+  return issues;
+}
+function validateHexBoardVertexRefs(manifest) {
+  const issues = [];
+  for (const board of manifest.boards ?? []) {
+    if (board.layout !== "hex") continue;
+    try {
+      const geometry = createHexBoardGeometry({
+        ...board,
+        spaces: resolveHexSpaces(board)
       });
-      return {
-        type: definition.type,
-        id: definition.id,
-        contextSchema,
-        __continuation: continuation
-      };
+      const vertices = (board.vertices ?? []).map(
+        (vertex) => "spaces" in vertex.ref ? geometry.vertex(...vertex.ref.spaces) : geometry.vertexAt(vertex.ref.space, vertex.ref.corner)
+      );
+      const edges = (board.edges ?? []).map(
+        (edge) => "spaces" in edge.ref ? geometry.edge(...edge.ref.spaces) : geometry.edgeAt(edge.ref.space, edge.ref.side)
+      );
+      if (new Set(vertices).size !== vertices.length)
+        throw new Error("Duplicate hex vertex refs.");
+      if (new Set(edges).size !== edges.length)
+        throw new Error("Duplicate hex edge refs.");
+    } catch (error) {
+      issues.push(
+        `Hex board '${board.id}': ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return issues;
+}
+function collectAmbiguousBoardTypeWarnings(manifest) {
+  const warnings = [];
+  const boardsBySpaceType = /* @__PURE__ */ new Map();
+  const boardsByEdgeType = /* @__PURE__ */ new Map();
+  const boardsByVertexType = /* @__PURE__ */ new Map();
+  const addBoardUsage = (target, typeId, boardId) => {
+    if (!typeId) {
+      return;
+    }
+    const boardIds = target.get(typeId) ?? /* @__PURE__ */ new Set();
+    boardIds.add(boardId);
+    target.set(typeId, boardIds);
+  };
+  for (const board of manifest.boards ?? []) {
+    for (const space of [
+      ...board.layout === "hex" ? Object.values(board.spaces ?? {}) : board.spaces ?? []
+    ]) {
+      addBoardUsage(boardsBySpaceType, space.typeId, board.id);
+    }
+    if (board.layout === "hex" || board.layout === "square") {
+      for (const edge of [...board.edges ?? []]) {
+        addBoardUsage(boardsByEdgeType, edge.typeId, board.id);
+      }
+      for (const vertex of [...board.vertices ?? []]) {
+        addBoardUsage(boardsByVertexType, vertex.typeId, board.id);
+      }
+    }
+  }
+  const pushWarnings = (kind, boardsByType, helperName) => {
+    for (const [typeId, boardIds] of boardsByType.entries()) {
+      if (boardIds.size < 2) {
+        continue;
+      }
+      warnings.push(
+        `Ambiguous ${kind}.typeId '${typeId}' is authored on multiple boards (${Array.from(boardIds).sort().join(", ")}). Prefer ${helperName} for board-scoped lookups.`
+      );
+    }
+  };
+  pushWarnings(
+    "space",
+    boardsBySpaceType,
+    "boardHelpers.spaceIdsByBoardId / boardHelpers.spaceTypeIdByBoardId"
+  );
+  pushWarnings(
+    "edge",
+    boardsByEdgeType,
+    "boardHelpers.edgeIdsByBoardIdAndTypeId"
+  );
+  pushWarnings(
+    "vertex",
+    boardsByVertexType,
+    "boardHelpers.vertexIdsByBoardIdAndTypeId"
+  );
+  return warnings;
+}
+function collectBoardRecordKeyIssues(manifest) {
+  const issues = [];
+  const maxPlayers = manifest.players.maxPlayers;
+  const playerIds = Array.from(
+    { length: maxPlayers },
+    (_, index) => `player-${index + 1}`
+  );
+  for (const [boardIndex, board] of (manifest.boards ?? []).entries()) {
+    const boardPath = `manifest.boards[${boardIndex}]`;
+    const runtimeBoardIds = board.scope === "perPlayer" ? playerIds.map((playerId) => `${board.id}:${playerId}`) : [board.id];
+    issues.push(
+      ...collectKeyIssues([
+        { value: board.id, path: `${boardPath}.id` },
+        { value: board.typeId, path: `${boardPath}.typeId` },
+        ...runtimeBoardIds.map((runtimeBoardId) => ({
+          value: runtimeBoardId,
+          path: `${boardPath}.runtimeBoardId`
+        }))
+      ]),
+      ...collectObjectSchemaKeyIssues(
+        board.boardFieldsSchema,
+        `${boardPath}.boardFieldsSchema`
+      ),
+      ...collectObjectSchemaKeyIssues(
+        board.spaceFieldsSchema,
+        `${boardPath}.spaceFieldsSchema`
+      )
+    );
+    if (board.layout !== "hex") {
+      issues.push(
+        ...collectObjectSchemaKeyIssues(
+          board.relationFieldsSchema,
+          `${boardPath}.relationFieldsSchema`
+        ),
+        ...collectObjectSchemaKeyIssues(
+          board.containerFieldsSchema,
+          `${boardPath}.containerFieldsSchema`
+        ),
+        ...collectKeyIssues([
+          ...(board.containers ?? []).flatMap((container, containerIndex) => [
+            {
+              value: container.id,
+              path: `${boardPath}.containers[${containerIndex}].id`
+            },
+            {
+              value: container.host.type === "space" ? container.host.spaceId : void 0,
+              path: `${boardPath}.containers[${containerIndex}].host.spaceId`
+            }
+          ]),
+          ...(board.relations ?? []).flatMap((relation, relationIndex) => [
+            {
+              value: relation.id,
+              path: `${boardPath}.relations[${relationIndex}].id`
+            },
+            {
+              value: relation.typeId,
+              path: `${boardPath}.relations[${relationIndex}].typeId`
+            },
+            {
+              value: relation.fromSpaceId,
+              path: `${boardPath}.relations[${relationIndex}].fromSpaceId`
+            },
+            {
+              value: relation.toSpaceId,
+              path: `${boardPath}.relations[${relationIndex}].toSpaceId`
+            }
+          ])
+        ])
+      );
+    }
+    if (board.layout !== "generic") {
+      issues.push(
+        ...collectObjectSchemaKeyIssues(
+          board.edgeFieldsSchema,
+          `${boardPath}.edgeFieldsSchema`
+        ),
+        ...collectObjectSchemaKeyIssues(
+          board.vertexFieldsSchema,
+          `${boardPath}.vertexFieldsSchema`
+        ),
+        ...collectKeyIssues([
+          ...(board.edges ?? []).map((edge, edgeIndex) => ({
+            value: edge.typeId,
+            path: `${boardPath}.edges[${edgeIndex}].typeId`
+          })),
+          ...(board.vertices ?? []).map((vertex, vertexIndex) => ({
+            value: vertex.typeId,
+            path: `${boardPath}.vertices[${vertexIndex}].typeId`
+          }))
+        ])
+      );
+    }
+    issues.push(
+      ...collectKeyIssues(
+        (board.layout === "hex" ? Object.values(board.spaces ?? {}) : board.spaces ?? []).flatMap((space, spaceIndex) => [
+          {
+            value: space.id,
+            path: `${boardPath}.spaces[${spaceIndex}].id`
+          },
+          {
+            value: space.typeId,
+            path: `${boardPath}.spaces[${spaceIndex}].typeId`
+          }
+        ])
+      )
+    );
+  }
+  return issues;
+}
+function collectManifestRecordKeyIssues(manifest) {
+  const cardSets = manifest.cardSets;
+  const cards = cardSets.flatMap(
+    (cardSet, cardSetIndex) => cardSet.cards.flatMap(
+      (card, cardIndex) => renderCardInstanceIds(card).map((cardId) => ({
+        card,
+        cardId,
+        cardIndex,
+        cardSetIndex
+      }))
+    )
+  );
+  return [
+    ...collectKeyIssues([
+      ...cardSets.map((cardSet, index) => ({
+        value: cardSet.id,
+        path: `manifest.cardSets[${index}].id`
+      })),
+      ...cards.flatMap(({ card, cardId, cardIndex, cardSetIndex }) => [
+        {
+          value: card.id,
+          path: `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].id`
+        },
+        {
+          value: card.cardType,
+          path: `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].cardType`
+        },
+        {
+          value: cardId,
+          path: `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].runtimeId`
+        }
+      ]),
+      ...(manifest.zones ?? []).map((zone, index) => ({
+        value: zone.id,
+        path: `manifest.zones[${index}].id`
+      })),
+      ...(manifest.resources ?? []).map((resource, index) => ({
+        value: resource.id,
+        path: `manifest.resources[${index}].id`
+      })),
+      ...(manifest.pieceTypes ?? []).flatMap((pieceType, typeIndex) => [
+        {
+          value: pieceType.id,
+          path: `manifest.pieceTypes[${typeIndex}].id`
+        },
+        ...(pieceType.slots ?? []).map((slot, slotIndex) => ({
+          value: slot.id,
+          path: `manifest.pieceTypes[${typeIndex}].slots[${slotIndex}].id`
+        }))
+      ]),
+      ...(manifest.dieTypes ?? []).flatMap((dieType, typeIndex) => [
+        {
+          value: dieType.id,
+          path: `manifest.dieTypes[${typeIndex}].id`
+        },
+        ...(dieType.slots ?? []).map((slot, slotIndex) => ({
+          value: slot.id,
+          path: `manifest.dieTypes[${typeIndex}].slots[${slotIndex}].id`
+        }))
+      ]),
+      ...expandSeedIds(manifest.pieceSeeds ?? []).map((pieceId, index) => ({
+        value: pieceId,
+        path: `manifest.pieceSeeds[*][${index}]`
+      })),
+      ...expandSeedIds(manifest.dieSeeds ?? []).map((dieId, index) => ({
+        value: dieId,
+        path: `manifest.dieSeeds[*][${index}]`
+      }))
+    ]),
+    ...cardSets.flatMap(
+      (cardSet, cardSetIndex) => collectCardSchemaKeyIssues(cardSet, `manifest.cardSets[${cardSetIndex}]`)
+    ),
+    ...(manifest.pieceTypes ?? []).flatMap(
+      (pieceType, typeIndex) => collectObjectSchemaKeyIssues(
+        pieceType.fieldsSchema,
+        `manifest.pieceTypes[${typeIndex}].fieldsSchema`
+      )
+    ),
+    ...(manifest.dieTypes ?? []).flatMap(
+      (dieType, typeIndex) => collectObjectSchemaKeyIssues(
+        dieType.fieldsSchema,
+        `manifest.dieTypes[${typeIndex}].fieldsSchema`
+      )
+    ),
+    ...collectBoardRecordKeyIssues(manifest)
+  ];
+}
+function validateCounts(manifest) {
+  const errors = [];
+  const check = (count, path) => {
+    if (!Number.isSafeInteger(count) || count < 1) {
+      errors.push(`${path}: Expected a positive safe integer.`);
     }
+  };
+  manifest.cardSets.forEach((set, setIndex) => {
+    set.cards.forEach(
+      (card, index) => check(card.count, `manifest.cardSets[${setIndex}].cards[${index}].count`)
+    );
+  });
+  for (const family of ["pieceSeeds", "dieSeeds"]) {
+    manifest[family]?.forEach((seed, index) => {
+      if (seed.count !== void 0)
+        check(seed.count, `manifest.${family}[${index}].count`);
+    });
+  }
+  check(manifest.players.minPlayers, "manifest.players.minPlayers");
+  check(manifest.players.maxPlayers, "manifest.players.maxPlayers");
+  if (manifest.players.minPlayers > manifest.players.maxPlayers) {
+    errors.push("manifest.players: minPlayers must not exceed maxPlayers.");
+  }
+  return errors;
+}
+function assertValidManifest(manifest) {
+  const validation = validateManifestAuthoring(manifest);
+  if (validation.errors.length) {
     throw new Error(
-      `defineEffect: unknown effect definition. Expected type 'rollDie' | 'shuffleSharedZone' | 'shufflePlayerZone'. Addressed prompts are authored as prompt-kind interactions via defineInteraction({ kind: "prompt" }).`
+      `Invalid topology manifest:
+${validation.errors.join("\n")}`
     );
   }
-  return effect;
+}
+function validateManifestAuthoring(manifest) {
+  const errors = validateCounts(manifest);
+  if (errors.length) return { errors, warnings: [] };
+  errors.push(...collectManifestRecordKeyIssues(manifest));
+  errors.push(
+    ...collectDuplicateIdIssues({
+      entries: manifest.cardSets.map((cardSet, index) => ({
+        id: cardSet.id,
+        path: `manifest.cardSets[${index}].id`
+      })),
+      label: "card set id"
+    })
+  );
+  errors.push(
+    ...collectDuplicateIdIssues({
+      entries: manifest.cardSets.flatMap(
+        (cardSet, cardSetIndex) => cardSet.cards.flatMap(
+          (card, cardIndex) => renderCardInstanceIds(card).map((cardId) => ({
+            id: cardId,
+            path: `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].id`
+          }))
+        )
+      ),
+      label: "card runtime id"
+    })
+  );
+  errors.push(
+    ...collectDuplicateIdIssues({
+      entries: (manifest.zones ?? []).map((zone, index) => ({
+        id: zone.id,
+        path: `manifest.zones[${index}].id`
+      })),
+      label: "zone id"
+    })
+  );
+  errors.push(
+    ...collectDuplicateIdIssues({
+      entries: (manifest.boards ?? []).map((board, index) => ({
+        id: board.id,
+        path: `manifest.boards[${index}].id`
+      })),
+      label: "board id"
+    })
+  );
+  errors.push(...validateBoardDuplicates(manifest.boards ?? []));
+  errors.push(
+    ...validateTypeSlotDuplicates({
+      pieceTypes: manifest.pieceTypes ?? [],
+      dieTypes: manifest.dieTypes ?? []
+    })
+  );
+  errors.push(
+    ...collectDuplicateIdIssues({
+      entries: (manifest.pieceTypes ?? []).map((pieceType, index) => ({
+        id: pieceType.id,
+        path: `manifest.pieceTypes[${index}].id`
+      })),
+      label: "piece type id"
+    })
+  );
+  errors.push(
+    ...collectDuplicateIdIssues({
+      entries: expandSeedIds(manifest.pieceSeeds ?? []).map(
+        (pieceId, index) => ({
+          id: pieceId,
+          path: `manifest.pieceSeeds[*][${index}]`
+        })
+      ),
+      label: "piece runtime id"
+    })
+  );
+  errors.push(
+    ...collectDuplicateIdIssues({
+      entries: (manifest.dieTypes ?? []).map((dieType, index) => ({
+        id: dieType.id,
+        path: `manifest.dieTypes[${index}].id`
+      })),
+      label: "die type id"
+    })
+  );
+  errors.push(
+    ...collectDuplicateIdIssues({
+      entries: expandSeedIds(manifest.dieSeeds ?? []).map((dieId, index) => ({
+        id: dieId,
+        path: `manifest.dieSeeds[*][${index}]`
+      })),
+      label: "die runtime id"
+    })
+  );
+  errors.push(
+    ...collectDuplicateIdIssues({
+      entries: (manifest.resources ?? []).map((resource, index) => ({
+        id: resource.id,
+        path: `manifest.resources[${index}].id`
+      })),
+      label: "resource id"
+    })
+  );
+  errors.push(...validateSlotHostsAndHomes(manifest));
+  errors.push(...validatePlayerScopedSeedHomes(manifest));
+  errors.push(...validateCardHomes(manifest));
+  for (const [cardSetIndex, cardSet] of manifest.cardSets.entries()) {
+    for (const [cardIndex, card] of cardSet.cards.entries()) {
+      const path = `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}]`;
+      if (typeof card.id !== "string" || card.id.length === 0) {
+        errors.push(`${path}.id: Card definition id is required.`);
+      }
+      if (typeof card.cardType !== "string" || card.cardType.length === 0) {
+        errors.push(`${path}.cardType: Card category is required.`);
+      } else if ("variants" in cardSet.cardSchema && !Object.hasOwn(cardSet.cardSchema.variants, card.cardType)) {
+        errors.push(
+          `${path}.cardType: Unknown card category '${card.cardType}' for card set '${cardSet.id}'.`
+        );
+      }
+    }
+  }
+  errors.push(...validateCardImages(manifest));
+  errors.push(...validateHexBoardVertexRefs(manifest));
+  return {
+    errors,
+    warnings: collectAmbiguousBoardTypeWarnings(manifest)
+  };
 }
 
-// src/reducer/game-event.ts
-var gameEvent = {
-  systemAction(event) {
+// src/reducer/manifest/materialize.ts
+function isCardPropertySchemaVariants(schema) {
+  return Boolean(schema && "variants" in schema);
+}
+function mergeSharedCardProperties(schema, cardType) {
+  const variant = schema.variants[cardType];
+  return {
+    properties: {
+      ...schema.shared ?? {},
+      ...variant.properties
+    }
+  };
+}
+function hasPropertySchemaDefault(property) {
+  return Boolean(property && "default" in property);
+}
+function dedupeSorted(values) {
+  return Array.from(new Set(values)).sort();
+}
+function sortedObject(entries) {
+  return Object.fromEntries(
+    Array.from(entries).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function createRecord() {
+  return /* @__PURE__ */ Object.create(null);
+}
+function renderCardInstanceIds2(card) {
+  if (card.count > 1) {
+    return Array.from(
+      { length: card.count },
+      (_, index) => `${card.id}-${index + 1}`
+    );
+  }
+  return [card.id];
+}
+function expandSeedIds2(seeds) {
+  const expanded = [];
+  for (const seed of seeds) {
+    const count = seed.count ?? 1;
+    const baseId = seed.id ?? seed.typeId;
+    if (count <= 1) {
+      expanded.push(baseId);
+      continue;
+    }
+    for (let index = 1; index <= count; index += 1) {
+      expanded.push(`${baseId}-${index}`);
+    }
+  }
+  return expanded;
+}
+function isHexBoardSpec2(board) {
+  return board.layout === "hex";
+}
+function isSquareBoardSpec(board) {
+  return board.layout === "square";
+}
+var SQUARE_SIDES = ["north", "east", "south", "west"];
+var SQUARE_CORNERS = ["nw", "ne", "se", "sw"];
+function squareEdgeIdFromGeometryKey(key) {
+  return `square-edge:${key}`;
+}
+function squareVertexIdFromGeometryKey(key) {
+  return `square-vertex:${key}`;
+}
+function squareCornerGeometryKey(space, corner) {
+  switch (corner) {
+    case "nw":
+      return `${space.col},${space.row}`;
+    case "ne":
+      return `${space.col + 1},${space.row}`;
+    case "se":
+      return `${space.col + 1},${space.row + 1}`;
+    case "sw":
+      return `${space.col},${space.row + 1}`;
+  }
+}
+function squareEdgeGeometryKey(space, side) {
+  const endpoints = side === "north" ? [`${space.col},${space.row}`, `${space.col + 1},${space.row}`] : side === "east" ? [`${space.col + 1},${space.row}`, `${space.col + 1},${space.row + 1}`] : side === "south" ? [
+    `${space.col},${space.row + 1}`,
+    `${space.col + 1},${space.row + 1}`
+  ] : [`${space.col},${space.row}`, `${space.col},${space.row + 1}`];
+  return endpoints.sort((left, right) => left.localeCompare(right)).join("::");
+}
+function geometryKeyFromSquareEdgeRef(ref, spacesById) {
+  const resolvedSpaces = [...ref.spaces].sort((a, b) => a.localeCompare(b)).map((spaceId) => {
+    const space = spacesById.get(spaceId);
+    if (!space) {
+      throw new Error(
+        `Square edge ref references unknown space '${spaceId}'.`
+      );
+    }
+    return space;
+  });
+  const keyCounts = /* @__PURE__ */ new Map();
+  for (const space of resolvedSpaces) {
+    for (const side of SQUARE_SIDES) {
+      const key = squareEdgeGeometryKey(space, side);
+      keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
+    }
+  }
+  const candidates = [...keyCounts.entries()].filter(([, count]) => count === resolvedSpaces.length).map(([key]) => key).sort((left, right) => left.localeCompare(right));
+  if (candidates.length !== 1) {
+    throw new Error(
+      `Square edge ref spaces '${ref.spaces.join(", ")}' do not resolve to exactly one shared edge.`
+    );
+  }
+  const [only] = candidates;
+  if (only === void 0) {
+    throw new Error(
+      "unreachable: candidates.length === 1 but first is undefined"
+    );
+  }
+  return only;
+}
+function geometryKeyFromSquareVertexRef(ref, spacesById) {
+  const resolvedSpaces = [...ref.spaces].sort((a, b) => a.localeCompare(b)).map((spaceId) => {
+    const space = spacesById.get(spaceId);
+    if (!space) {
+      throw new Error(
+        `Square vertex ref references unknown space '${spaceId}'.`
+      );
+    }
+    return space;
+  });
+  const keyCounts = /* @__PURE__ */ new Map();
+  for (const space of resolvedSpaces) {
+    for (const corner of SQUARE_CORNERS) {
+      const key = squareCornerGeometryKey(space, corner);
+      keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
+    }
+  }
+  const candidates = [...keyCounts.entries()].filter(([, count]) => count === resolvedSpaces.length).map(([key]) => key).sort((left, right) => left.localeCompare(right));
+  if (candidates.length !== 1) {
+    throw new Error(
+      `Square vertex ref spaces '${ref.spaces.join(", ")}' do not resolve to exactly one shared vertex.`
+    );
+  }
+  const [only] = candidates;
+  if (only === void 0) {
+    throw new Error(
+      "unreachable: candidates.length === 1 but first is undefined"
+    );
+  }
+  return only;
+}
+function resolveAuthoredHexEdges(board, geometry) {
+  return (board.edges ?? []).map((edge) => ({
+    ...edge,
+    id: "spaces" in edge.ref ? geometry.edge(...edge.ref.spaces) : geometry.edgeAt(edge.ref.space, edge.ref.side)
+  }));
+}
+function resolveAuthoredHexVertices(board, geometry) {
+  return (board.vertices ?? []).map((vertex) => ({
+    ...vertex,
+    id: "spaces" in vertex.ref ? geometry.vertex(...vertex.ref.spaces) : geometry.vertexAt(vertex.ref.space, vertex.ref.corner)
+  }));
+}
+function resolveSquareSpaces(board) {
+  return [...board.spaces ?? []].sort(
+    (left, right) => left.id.localeCompare(right.id)
+  );
+}
+function deriveSquareEdges(spaces) {
+  const edgeMap = /* @__PURE__ */ new Map();
+  for (const space of spaces) {
+    for (const side of SQUARE_SIDES) {
+      const geometryKey = squareEdgeGeometryKey(space, side);
+      const existing = edgeMap.get(geometryKey);
+      const nextSpaceIds = dedupeSorted([
+        ...existing?.spaceIds ?? [],
+        space.id
+      ]);
+      edgeMap.set(geometryKey, {
+        id: squareEdgeIdFromGeometryKey(geometryKey),
+        geometryKey,
+        spaceIds: nextSpaceIds,
+        typeId: existing?.typeId ?? null,
+        label: existing?.label ?? null,
+        fields: existing?.fields ?? null
+      });
+    }
+  }
+  return [...edgeMap.values()].sort(
+    (left, right) => left.id.localeCompare(right.id)
+  );
+}
+function deriveSquareVertices(spaces) {
+  const vertexMap = /* @__PURE__ */ new Map();
+  for (const space of spaces) {
+    for (const corner of SQUARE_CORNERS) {
+      const geometryKey = squareCornerGeometryKey(space, corner);
+      const existing = vertexMap.get(geometryKey);
+      const nextSpaceIds = dedupeSorted([
+        ...existing?.spaceIds ?? [],
+        space.id
+      ]);
+      vertexMap.set(geometryKey, {
+        id: squareVertexIdFromGeometryKey(geometryKey),
+        geometryKey,
+        spaceIds: nextSpaceIds,
+        typeId: existing?.typeId ?? null,
+        label: existing?.label ?? null,
+        fields: existing?.fields ?? null
+      });
+    }
+  }
+  return [...vertexMap.values()].sort(
+    (left, right) => left.id.localeCompare(right.id)
+  );
+}
+function indexSquareEdgeMetadata(specs, spacesById, ownerLabel) {
+  const metadataByKey = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    const geometryKey = geometryKeyFromSquareEdgeRef(spec.ref, spacesById);
+    if (metadataByKey.has(geometryKey)) {
+      throw new Error(`${ownerLabel} contains duplicate square edge refs.`);
+    }
+    metadataByKey.set(geometryKey, {
+      geometryKey,
+      typeId: spec.typeId ?? null,
+      label: spec.label ?? null,
+      fields: spec.fields ?? null
+    });
+  }
+  return metadataByKey;
+}
+function indexSquareVertexMetadata(specs, spacesById, ownerLabel) {
+  const metadataByKey = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    const geometryKey = geometryKeyFromSquareVertexRef(spec.ref, spacesById);
+    if (metadataByKey.has(geometryKey)) {
+      throw new Error(`${ownerLabel} contains duplicate square vertex refs.`);
+    }
+    metadataByKey.set(geometryKey, {
+      geometryKey,
+      typeId: spec.typeId ?? null,
+      label: spec.label ?? null,
+      fields: spec.fields ?? null
+    });
+  }
+  return metadataByKey;
+}
+function resolveSquareEdges(board, spaces) {
+  const spacesById = new Map(spaces.map((space) => [space.id, space]));
+  const derived = deriveSquareEdges(spaces);
+  const edgesByGeometryKey = new Map(
+    derived.map((edge) => [edge.geometryKey, edge])
+  );
+  const metadataByKey = indexSquareEdgeMetadata(
+    board.edges ?? [],
+    spacesById,
+    `Square board '${board.id}'`
+  );
+  for (const [geometryKey, metadata] of metadataByKey.entries()) {
+    const edge = edgesByGeometryKey.get(geometryKey);
+    if (!edge) {
+      throw new Error(
+        `Square edge ref on board '${board.id}' does not resolve to a derived edge.`
+      );
+    }
+    edgesByGeometryKey.set(geometryKey, {
+      ...edge,
+      typeId: metadata.typeId ?? null,
+      label: metadata.label ?? null,
+      fields: metadata.fields ?? null
+    });
+  }
+  return [...edgesByGeometryKey.values()].sort(
+    (left, right) => left.id.localeCompare(right.id)
+  );
+}
+function resolveSquareVertices(board, spaces) {
+  const spacesById = new Map(spaces.map((space) => [space.id, space]));
+  const derived = deriveSquareVertices(spaces);
+  const verticesByGeometryKey = new Map(
+    derived.map((vertex) => [vertex.geometryKey, vertex])
+  );
+  const metadataByKey = indexSquareVertexMetadata(
+    board.vertices ?? [],
+    spacesById,
+    `Square board '${board.id}'`
+  );
+  for (const [geometryKey, metadata] of metadataByKey.entries()) {
+    const vertex = verticesByGeometryKey.get(geometryKey);
+    if (!vertex) {
+      throw new Error(
+        `Square vertex ref on board '${board.id}' does not resolve to a derived vertex.`
+      );
+    }
+    verticesByGeometryKey.set(geometryKey, {
+      ...vertex,
+      typeId: metadata.typeId ?? null,
+      label: metadata.label ?? null,
+      fields: metadata.fields ?? null
+    });
+  }
+  return [...verticesByGeometryKey.values()].sort(
+    (left, right) => left.id.localeCompare(right.id)
+  );
+}
+function analyzeBoards(manifest, playerIds) {
+  return (manifest.boards ?? []).map((board) => {
+    const runtimeBoardIds = board.scope === "perPlayer" ? playerIds.map((playerId) => `${board.id}:${playerId}`) : [board.id];
+    if (isHexBoardSpec2(board)) {
+      const spaces = resolveHexSpaces(board);
+      const geometry = createHexBoardGeometry({ ...board, spaces });
+      const authoredEdges = resolveAuthoredHexEdges(board, geometry);
+      const authoredVertices = resolveAuthoredHexVertices(board, geometry);
+      return {
+        layout: "hex",
+        board,
+        boardTypeId: board.typeId,
+        runtimeBoardIds,
+        boardFieldsSchema: board.boardFieldsSchema,
+        spaceFieldsSchema: board.spaceFieldsSchema,
+        edgeFieldsSchema: board.edgeFieldsSchema,
+        vertexFieldsSchema: board.vertexFieldsSchema,
+        spaces,
+        authoredEdges,
+        authoredVertices,
+        edges: geometry.edges.map((edge) => ({
+          ...edge,
+          ...authoredEdges.find((authored) => authored.id === edge.id)
+        })),
+        vertices: geometry.vertices.map((vertex) => ({
+          ...vertex,
+          ...authoredVertices.find((authored) => authored.id === vertex.id)
+        }))
+      };
+    }
+    if (isSquareBoardSpec(board)) {
+      const squareBoard = board;
+      const spaces = resolveSquareSpaces(squareBoard);
+      return {
+        layout: "square",
+        board: squareBoard,
+        boardTypeId: squareBoard.typeId,
+        runtimeBoardIds,
+        boardFieldsSchema: squareBoard.boardFieldsSchema,
+        spaceFieldsSchema: squareBoard.spaceFieldsSchema,
+        relationFieldsSchema: squareBoard.relationFieldsSchema,
+        containerFieldsSchema: squareBoard.containerFieldsSchema,
+        edgeFieldsSchema: squareBoard.edgeFieldsSchema,
+        vertexFieldsSchema: squareBoard.vertexFieldsSchema,
+        spaces,
+        relations: [...squareBoard.relations ?? []],
+        containers: [...squareBoard.containers ?? []].sort(
+          (left, right) => left.id.localeCompare(right.id)
+        ),
+        edges: resolveSquareEdges(squareBoard, spaces),
+        vertices: resolveSquareVertices(squareBoard, spaces)
+      };
+    }
+    const genericBoard = board;
     return {
-      kind: "systemAction",
-      ...event
+      layout: "generic",
+      board: genericBoard,
+      boardTypeId: genericBoard.typeId,
+      runtimeBoardIds,
+      boardFieldsSchema: genericBoard.boardFieldsSchema,
+      spaceFieldsSchema: genericBoard.spaceFieldsSchema,
+      relationFieldsSchema: genericBoard.relationFieldsSchema,
+      containerFieldsSchema: genericBoard.containerFieldsSchema,
+      spaces: [...genericBoard.spaces ?? []].sort(
+        (left, right) => left.id.localeCompare(right.id)
+      ),
+      relations: [...genericBoard.relations ?? []],
+      containers: [...genericBoard.containers ?? []].sort(
+        (left, right) => left.id.localeCompare(right.id)
+      )
     };
+  });
+}
+function isSingletonExplicitSeed(seed) {
+  return typeof seed.id === "string" && seed.id.length > 0 && (seed.count ?? 1) === 1;
+}
+function analyzeManifest(manifest, runtimePlayerIds) {
+  assertValidManifest(manifest);
+  const playerIds = runtimePlayerIds ? [...runtimePlayerIds] : Array.from(
+    { length: manifest.players.maxPlayers },
+    (_, index) => `player-${index + 1}`
+  );
+  const sharedZones = (manifest.zones ?? []).filter(
+    (zone) => zone.scope === "shared"
+  );
+  const playerZones = (manifest.zones ?? []).filter(
+    (zone) => zone.scope === "perPlayer"
+  );
+  const zoneIds = dedupeSorted((manifest.zones ?? []).map((zone) => zone.id));
+  const cardSets = manifest.cardSets;
+  const cardSetIds = dedupeSorted(cardSets.map((cardSet) => cardSet.id));
+  const cardTypes = dedupeSorted(
+    cardSets.flatMap((cardSet) => cardSet.cards.map((card) => card.cardType))
+  );
+  const cardIds = dedupeSorted(
+    cardSets.flatMap((cardSet) => cardSet.cards.flatMap(renderCardInstanceIds2))
+  );
+  const cardSetIdByCardId = /* @__PURE__ */ new Map();
+  const cardTypeByCardId = /* @__PURE__ */ new Map();
+  for (const cardSet of cardSets) {
+    for (const card of cardSet.cards) {
+      for (const cardId of renderCardInstanceIds2(card)) {
+        cardSetIdByCardId.set(cardId, cardSet.id);
+        cardTypeByCardId.set(cardId, card.cardType);
+      }
+    }
   }
-};
-
-// src/reducer/compose.ts
-function pipe(state, ...ops) {
-  let result = state;
-  for (const op of ops) {
-    result = op(result);
+  const sharedZoneCardSetIds = /* @__PURE__ */ new Map();
+  for (const zone of sharedZones) {
+    sharedZoneCardSetIds.set(
+      zone.id,
+      dedupeSorted(zone.allowedCardSetIds ?? [])
+    );
+  }
+  const playerZoneCardSetIds = /* @__PURE__ */ new Map();
+  for (const zone of playerZones) {
+    playerZoneCardSetIds.set(
+      zone.id,
+      dedupeSorted(zone.allowedCardSetIds ?? [])
+    );
+  }
+  const zoneCardSetIdsById = /* @__PURE__ */ new Map();
+  for (const [zoneId, cardSetIds2] of sharedZoneCardSetIds.entries()) {
+    zoneCardSetIdsById.set(zoneId, cardSetIds2);
+  }
+  for (const [zoneId, cardSetIds2] of playerZoneCardSetIds.entries()) {
+    zoneCardSetIdsById.set(zoneId, cardSetIds2);
+  }
+  const sharedZoneIdsByCardSetId = new Map(
+    cardSetIds.map((cardSetId) => [cardSetId, []])
+  );
+  for (const [zoneId, allowedCardSetIds] of sharedZoneCardSetIds.entries()) {
+    for (const cardSetId of allowedCardSetIds) {
+      const zoneIds2 = sharedZoneIdsByCardSetId.get(cardSetId) ?? [];
+      zoneIds2.push(zoneId);
+      sharedZoneIdsByCardSetId.set(cardSetId, zoneIds2);
+    }
+  }
+  for (const [cardSetId, zoneIds2] of sharedZoneIdsByCardSetId.entries()) {
+    sharedZoneIdsByCardSetId.set(cardSetId, dedupeSorted(zoneIds2));
+  }
+  const sharedZoneIdSet = new Set(sharedZones.map((zone) => zone.id));
+  const homeSharedZoneIdsByCardType = new Map(
+    cardTypes.map((cardType) => [cardType, []])
+  );
+  for (const cardSet of cardSets) {
+    for (const card of cardSet.cards) {
+      if (card.home?.type !== "zone" || !sharedZoneIdSet.has(card.home.zoneId)) {
+        continue;
+      }
+      const cardType = card.cardType;
+      const zoneIds2 = homeSharedZoneIdsByCardType.get(cardType) ?? [];
+      zoneIds2.push(card.home.zoneId);
+      homeSharedZoneIdsByCardType.set(cardType, zoneIds2);
+    }
+  }
+  const homeSharedZoneIdByCardType = /* @__PURE__ */ new Map();
+  for (const [cardType, zoneIds2] of homeSharedZoneIdsByCardType.entries()) {
+    const uniqueZoneIds = dedupeSorted(zoneIds2);
+    homeSharedZoneIdsByCardType.set(cardType, uniqueZoneIds);
+    const [homeZoneId] = uniqueZoneIds;
+    if (uniqueZoneIds.length === 1 && homeZoneId !== void 0) {
+      homeSharedZoneIdByCardType.set(cardType, homeZoneId);
+    }
+  }
+  const zoneVisibilityById = new Map(
+    (manifest.zones ?? []).map((zone) => [
+      zone.id,
+      zone.visibility ?? "public"
+    ])
+  );
+  const resourceIds = dedupeSorted(
+    (manifest.resources ?? []).map((resource) => resource.id)
+  );
+  const resourcePresentationById = sortedObject(
+    (manifest.resources ?? []).map((resource) => [
+      resource.id,
+      {
+        label: resource.name,
+        ...resource.icon ? { icon: resource.icon } : {}
+      }
+    ])
+  );
+  const pieceTypeIds = dedupeSorted(
+    (manifest.pieceTypes ?? []).map((pieceType) => pieceType.id)
+  );
+  const pieceTypeSchemasById = new Map(
+    (manifest.pieceTypes ?? []).map((pieceType) => [
+      pieceType.id,
+      pieceType.fieldsSchema
+    ])
+  );
+  const pieceTypeSlotIdsById = new Map(
+    (manifest.pieceTypes ?? []).map((pieceType) => [
+      pieceType.id,
+      dedupeSorted((pieceType.slots ?? []).map((slot) => slot.id))
+    ])
+  );
+  const pieceTypeIdByPieceId = /* @__PURE__ */ new Map();
+  for (const seed of manifest.pieceSeeds ?? []) {
+    for (const pieceId of expandSeedIds2([seed])) {
+      pieceTypeIdByPieceId.set(pieceId, seed.typeId);
+    }
   }
-  return result;
+  const pieceIds = dedupeSorted(pieceTypeIdByPieceId.keys());
+  const dieTypeIds = dedupeSorted(
+    (manifest.dieTypes ?? []).map((dieType) => dieType.id)
+  );
+  const dieTypeSchemasById = new Map(
+    (manifest.dieTypes ?? []).map((dieType) => [
+      dieType.id,
+      dieType.fieldsSchema
+    ])
+  );
+  const dieTypeSlotIdsById = new Map(
+    (manifest.dieTypes ?? []).map((dieType) => [
+      dieType.id,
+      dedupeSorted((dieType.slots ?? []).map((slot) => slot.id))
+    ])
+  );
+  const dieTypeIdByDieId = /* @__PURE__ */ new Map();
+  for (const seed of manifest.dieSeeds ?? []) {
+    for (const dieId of expandSeedIds2([seed])) {
+      dieTypeIdByDieId.set(dieId, seed.typeId);
+    }
+  }
+  const dieIds = dedupeSorted(dieTypeIdByDieId.keys());
+  const strictSlotHosts = [
+    ...(manifest.pieceSeeds ?? []).flatMap((seed) => {
+      if (!isSingletonExplicitSeed(seed)) {
+        return [];
+      }
+      const slotIds = pieceTypeSlotIdsById.get(seed.typeId) ?? [];
+      return slotIds.length > 0 ? [
+        {
+          kind: "piece",
+          id: seed.id,
+          slotIds
+        }
+      ] : [];
+    }),
+    ...(manifest.dieSeeds ?? []).flatMap((seed) => {
+      if (!isSingletonExplicitSeed(seed)) {
+        return [];
+      }
+      const slotIds = dieTypeSlotIdsById.get(seed.typeId) ?? [];
+      return slotIds.length > 0 ? [
+        {
+          kind: "die",
+          id: seed.id,
+          slotIds
+        }
+      ] : [];
+    })
+  ].sort(
+    (left, right) => left.kind.localeCompare(right.kind) || left.id.localeCompare(right.id)
+  );
+  const analyzedBoards = analyzeBoards(manifest, playerIds);
+  const boardBaseIds = dedupeSorted(
+    analyzedBoards.map(({ board }) => board.id)
+  );
+  const boardIds = dedupeSorted(
+    analyzedBoards.flatMap((entry) => entry.runtimeBoardIds)
+  );
+  const boardTypeIds = dedupeSorted(
+    analyzedBoards.map((board) => board.boardTypeId).filter((typeId) => typeof typeId === "string")
+  );
+  const boardLayoutById = /* @__PURE__ */ new Map();
+  const boardIdsByLayout = /* @__PURE__ */ new Map();
+  const boardBaseIdsByLayout = /* @__PURE__ */ new Map();
+  const boardIdsByBaseId = /* @__PURE__ */ new Map();
+  const boardIdsByTypeId = /* @__PURE__ */ new Map();
+  const spaceIdsByBoardId = /* @__PURE__ */ new Map();
+  const spaceTypeIdByBoardId = /* @__PURE__ */ new Map();
+  const spaceIdsByTypeId = /* @__PURE__ */ new Map();
+  const containerIdsByBoardId = /* @__PURE__ */ new Map();
+  const containerHostByBoardId = /* @__PURE__ */ new Map();
+  const relationTypeIdsByBoardId = /* @__PURE__ */ new Map();
+  const edgeIdsByTypeId = /* @__PURE__ */ new Map();
+  const edgeIdsByBoardIdAndTypeId = /* @__PURE__ */ new Map();
+  const vertexIdsByTypeId = /* @__PURE__ */ new Map();
+  const vertexIdsByBoardIdAndTypeId = /* @__PURE__ */ new Map();
+  for (const analyzedBoard of analyzedBoards) {
+    boardIdsByBaseId.set(analyzedBoard.board.id, analyzedBoard.runtimeBoardIds);
+    boardIdsByLayout.set(
+      analyzedBoard.board.layout,
+      dedupeSorted([
+        ...boardIdsByLayout.get(analyzedBoard.board.layout) ?? [],
+        ...analyzedBoard.runtimeBoardIds
+      ])
+    );
+    boardBaseIdsByLayout.set(
+      analyzedBoard.board.layout,
+      dedupeSorted([
+        ...boardBaseIdsByLayout.get(analyzedBoard.board.layout) ?? [],
+        analyzedBoard.board.id
+      ])
+    );
+    const runtimeSpaceIds = analyzedBoard.spaces.map((space) => space.id);
+    const runtimeSpaceTypeIds = sortedObject(
+      analyzedBoard.spaces.map(
+        (space) => [space.id, space.typeId ?? null]
+      )
+    );
+    const runtimeContainerIds = analyzedBoard.layout === "hex" ? [] : analyzedBoard.containers.map((container) => container.id);
+    const runtimeContainerHosts = analyzedBoard.layout === "hex" ? {} : sortedObject(
+      analyzedBoard.containers.map((container) => [
+        container.id,
+        container.host.type === "space" ? { type: "space", spaceId: container.host.spaceId } : { type: "board" }
+      ])
+    );
+    const runtimeRelationTypeIds = analyzedBoard.layout === "hex" ? ["adjacent"] : analyzedBoard.layout === "square" ? dedupeSorted([
+      "adjacent",
+      ...analyzedBoard.relations.map((relation) => relation.typeId)
+    ]) : dedupeSorted(
+      analyzedBoard.relations.map((relation) => relation.typeId)
+    );
+    for (const runtimeBoardId of analyzedBoard.runtimeBoardIds) {
+      boardLayoutById.set(runtimeBoardId, analyzedBoard.board.layout);
+      spaceIdsByBoardId.set(runtimeBoardId, runtimeSpaceIds);
+      spaceTypeIdByBoardId.set(runtimeBoardId, runtimeSpaceTypeIds);
+      containerIdsByBoardId.set(runtimeBoardId, runtimeContainerIds);
+      containerHostByBoardId.set(runtimeBoardId, runtimeContainerHosts);
+      relationTypeIdsByBoardId.set(runtimeBoardId, runtimeRelationTypeIds);
+    }
+    if (analyzedBoard.boardTypeId) {
+      boardIdsByTypeId.set(
+        analyzedBoard.boardTypeId,
+        dedupeSorted([
+          ...boardIdsByTypeId.get(analyzedBoard.boardTypeId) ?? [],
+          ...analyzedBoard.runtimeBoardIds
+        ])
+      );
+    }
+    for (const space of analyzedBoard.spaces) {
+      if (!space.typeId) {
+        continue;
+      }
+      spaceIdsByTypeId.set(
+        space.typeId,
+        dedupeSorted([...spaceIdsByTypeId.get(space.typeId) ?? [], space.id])
+      );
+    }
+    if (analyzedBoard.layout !== "generic") {
+      const edgeIdsForBoardByType = {};
+      for (const edge of analyzedBoard.edges) {
+        if (!edge.typeId) {
+          continue;
+        }
+        edgeIdsByTypeId.set(
+          edge.typeId,
+          dedupeSorted([...edgeIdsByTypeId.get(edge.typeId) ?? [], edge.id])
+        );
+        edgeIdsForBoardByType[edge.typeId] = dedupeSorted([
+          ...edgeIdsForBoardByType[edge.typeId] ?? [],
+          edge.id
+        ]);
+      }
+      const vertexIdsForBoardByType = {};
+      for (const vertex of analyzedBoard.vertices) {
+        if (!vertex.typeId) {
+          continue;
+        }
+        vertexIdsByTypeId.set(
+          vertex.typeId,
+          dedupeSorted([
+            ...vertexIdsByTypeId.get(vertex.typeId) ?? [],
+            vertex.id
+          ])
+        );
+        vertexIdsForBoardByType[vertex.typeId] = dedupeSorted([
+          ...vertexIdsForBoardByType[vertex.typeId] ?? [],
+          vertex.id
+        ]);
+      }
+      for (const runtimeBoardId of analyzedBoard.runtimeBoardIds) {
+        edgeIdsByBoardIdAndTypeId.set(runtimeBoardId, edgeIdsForBoardByType);
+        vertexIdsByBoardIdAndTypeId.set(
+          runtimeBoardId,
+          vertexIdsForBoardByType
+        );
+      }
+    }
+  }
+  const relationTypeIds = dedupeSorted(
+    Array.from(relationTypeIdsByBoardId.values()).flat()
+  );
+  const edgeIds = dedupeSorted(
+    analyzedBoards.flatMap(
+      (board) => board.layout === "generic" ? [] : board.edges.map((edge) => edge.id)
+    )
+  );
+  const edgeTypeIds = dedupeSorted(edgeIdsByTypeId.keys());
+  const vertexIds = dedupeSorted(
+    analyzedBoards.flatMap(
+      (board) => board.layout === "generic" ? [] : board.vertices.map((vertex) => vertex.id)
+    )
+  );
+  const vertexTypeIds = dedupeSorted(vertexIdsByTypeId.keys());
+  const boardContainerIds = dedupeSorted(
+    analyzedBoards.flatMap(
+      (board) => board.layout === "hex" ? [] : board.containers.map((container) => container.id)
+    )
+  );
+  const spaceIds = dedupeSorted(
+    analyzedBoards.flatMap((board) => board.spaces.map((space) => space.id))
+  );
+  const spaceTypeIds = dedupeSorted(
+    analyzedBoards.flatMap(
+      (board) => board.spaces.map((space) => space.typeId).filter((typeId) => typeof typeId === "string")
+    )
+  );
+  return {
+    manifest,
+    playerIds,
+    sharedZones,
+    playerZones,
+    zoneIds,
+    cardSets,
+    cardSetIds,
+    cardTypes,
+    cardIds,
+    cardSetIdByCardId,
+    cardTypeByCardId,
+    sharedZoneCardSetIds,
+    sharedZoneIdsByCardSetId,
+    homeSharedZoneIdsByCardType,
+    homeSharedZoneIdByCardType,
+    playerZoneCardSetIds,
+    zoneCardSetIdsById,
+    zoneVisibilityById,
+    resourceIds,
+    resourcePresentationById,
+    pieceTypeIds,
+    pieceIds,
+    pieceTypeIdByPieceId,
+    dieTypeIds,
+    dieIds,
+    dieTypeIdByDieId,
+    strictSlotHosts,
+    boardBaseIds,
+    boardIds,
+    boardContainerIds,
+    boardTypeIds,
+    boardLayoutById,
+    boardIdsByLayout,
+    boardBaseIdsByLayout,
+    boardIdsByBaseId,
+    boardIdsByTypeId,
+    spaceIdsByBoardId,
+    spaceTypeIdByBoardId,
+    spaceIdsByTypeId,
+    containerIdsByBoardId,
+    containerHostByBoardId,
+    relationTypeIds,
+    relationTypeIdsByBoardId,
+    edgeIds,
+    edgeTypeIds,
+    edgeIdsByTypeId,
+    edgeIdsByBoardIdAndTypeId,
+    vertexIds,
+    vertexTypeIds,
+    vertexIdsByTypeId,
+    vertexIdsByBoardIdAndTypeId,
+    spaceIds,
+    spaceTypeIds,
+    analyzedBoards,
+    pieceTypeSchemasById,
+    dieTypeSchemasById
+  };
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function boardSpaceRefKey(spaceIds) {
+  return [...spaceIds].sort((left, right) => left.localeCompare(right)).join("$$");
+}
+function materializePropertySchemaDefault(property, analysis, runtimeBoardId) {
+  if (hasPropertySchemaDefault(property)) {
+    return cloneJson(property.default);
+  }
+  if (property.optional) {
+    return void 0;
+  }
+  if (property.nullable) {
+    return null;
+  }
+  switch (property.type) {
+    case "string":
+      return "";
+    case "integer":
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "enum":
+      return property.enums?.[0] ?? "";
+    case "array":
+      return [];
+    case "object":
+      return materializeObjectSchemaDefaults(
+        property.properties ? { properties: property.properties } : void 0,
+        analysis,
+        runtimeBoardId
+      );
+    case "record":
+      return {};
+    case "zoneId":
+      return analysis.zoneIds[0] ?? "";
+    case "cardId":
+      return analysis.cardIds[0] ?? "";
+    case "playerId":
+      return analysis.playerIds[0] ?? "";
+    case "boardId":
+      return runtimeBoardId ?? analysis.boardIds[0] ?? "";
+    case "edgeId":
+      return analysis.edgeIds[0] ?? "";
+    case "vertexId":
+      return analysis.vertexIds[0] ?? "";
+    case "spaceId":
+      return (runtimeBoardId ? analysis.spaceIdsByBoardId.get(runtimeBoardId)?.[0] : void 0) ?? analysis.spaceIds[0] ?? "";
+    case "pieceId":
+      return analysis.pieceIds[0] ?? "";
+    case "dieId":
+      return analysis.dieIds[0] ?? "";
+    case "resourceId":
+      return analysis.resourceIds[0] ?? "";
+  }
+}
+function materializeObjectSchemaDefaults(schema, analysis, runtimeBoardId) {
+  if (!schema?.properties) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(schema.properties).flatMap(([key, property]) => {
+      const value = materializePropertySchemaDefault(
+        property,
+        analysis,
+        runtimeBoardId
+      );
+      return value === void 0 ? [] : [[key, value]];
+    })
+  );
+}
+function materializeCardPropertiesDefaults(schema, cardType, analysis) {
+  const objectSchema = isCardPropertySchemaVariants(schema) ? mergeSharedCardProperties(schema, cardType) : schema;
+  return materializeObjectSchemaDefaults(objectSchema, analysis);
+}
+function materializeManifestTable(options) {
+  const analysis = analyzeManifest(options.manifest, options.playerIds);
+  const manifest = analysis.manifest;
+  const playerIds = [...options.playerIds];
+  const cards = createRecord();
+  const pieces = createRecord();
+  const dice = createRecord();
+  const componentLocations = createRecord();
+  const locationOrder = /* @__PURE__ */ new Map();
+  const boardAnalysisByBaseId = new Map(
+    analysis.analyzedBoards.map((board) => [board.board.id, board])
+  );
+  const edgeIdByBoardBaseIdAndSpaces = /* @__PURE__ */ new Map();
+  const vertexIdByBoardBaseIdAndSpaces = /* @__PURE__ */ new Map();
+  for (const analyzedBoard of analysis.analyzedBoards) {
+    if (analyzedBoard.layout === "generic") {
+      continue;
+    }
+    edgeIdByBoardBaseIdAndSpaces.set(
+      analyzedBoard.board.id,
+      new Map(
+        analyzedBoard.edges.map((edge) => [
+          boardSpaceRefKey(edge.spaceIds),
+          edge.id
+        ])
+      )
+    );
+    vertexIdByBoardBaseIdAndSpaces.set(
+      analyzedBoard.board.id,
+      new Map(
+        analyzedBoard.vertices.map((vertex) => [
+          boardSpaceRefKey(vertex.spaceIds),
+          vertex.id
+        ])
+      )
+    );
+  }
+  const nextLocationPosition = (location) => {
+    const key = JSON.stringify(location);
+    const position = locationOrder.get(key) ?? 0;
+    locationOrder.set(key, position + 1);
+    return position;
+  };
+  const zoneScopeById = new Map([
+    ...analysis.sharedZones.map((zone) => [zone.id, "shared"]),
+    ...analysis.playerZones.map((zone) => [zone.id, "perPlayer"])
+  ]);
+  const resolveRuntimeBoardId = (boardBaseId, ownerId, context) => {
+    const analyzedBoard = boardAnalysisByBaseId.get(boardBaseId);
+    if (!analyzedBoard) {
+      throw new Error(
+        `${context ?? "Component home"}.boardId: Unknown board '${boardBaseId}'.`
+      );
+    }
+    if (analyzedBoard?.board.scope === "perPlayer") {
+      if (!ownerId) {
+        throw new Error(
+          `${context ?? `Home on board '${boardBaseId}'`} requires ownerId because board '${boardBaseId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
+        );
+      }
+      return `${boardBaseId}:${ownerId}`;
+    }
+    return boardBaseId;
+  };
+  const resolveBoardEdgeId = (boardBaseId, spaceIds) => {
+    const edgeId = edgeIdByBoardBaseIdAndSpaces.get(boardBaseId)?.get(boardSpaceRefKey(spaceIds));
+    if (!edgeId) {
+      throw new Error(
+        `Unknown edge on board '${boardBaseId}' for spaces [${spaceIds.join(", ")}].`
+      );
+    }
+    return edgeId;
+  };
+  const resolveBoardVertexId = (boardBaseId, spaceIds) => {
+    const vertexId = vertexIdByBoardBaseIdAndSpaces.get(boardBaseId)?.get(boardSpaceRefKey(spaceIds));
+    if (!vertexId) {
+      throw new Error(
+        `Unknown vertex on board '${boardBaseId}' for spaces [${spaceIds.join(", ")}].`
+      );
+    }
+    return vertexId;
+  };
+  const materializeComponentLocation = (home, context) => {
+    if (home.type === "detached") {
+      return { type: "Detached" };
+    }
+    if (home.type === "slot") {
+      return {
+        type: "InSlot",
+        host: home.host,
+        slotId: home.slotId,
+        position: nextLocationPosition({
+          type: "InSlot",
+          host: home.host,
+          slotId: home.slotId
+        })
+      };
+    }
+    if (home.type === "zone") {
+      const zoneScope = zoneScopeById.get(home.zoneId);
+      if (!zoneScope) {
+        throw new Error(
+          `${context.path}.zoneId: ${context.label} targets unknown zone '${home.zoneId}'.`
+        );
+      }
+      if (zoneScope === "perPlayer") {
+        throw new Error(
+          `${context.path}.zoneId: ${context.label} cannot target per-player zone '${home.zoneId}' because card inventory has no ownerId. Place it during reducer setup instead.`
+        );
+      }
+      return {
+        type: "InDeck",
+        deckId: home.zoneId,
+        playedBy: null,
+        position: nextLocationPosition({
+          type: "InDeck",
+          deckId: home.zoneId,
+          playedBy: null
+        })
+      };
+    }
+    if (home.type === "space") {
+      const boardId = resolveRuntimeBoardId(
+        home.boardId,
+        null,
+        `${context.path}.boardId: ${context.label}`
+      );
+      if (!analysis.spaceIdsByBoardId.get(home.boardId)?.includes(home.spaceId)) {
+        throw new Error(
+          `${context.path}.spaceId: ${context.label} targets unknown space '${home.spaceId}' on board '${home.boardId}'.`
+        );
+      }
+      return {
+        type: "OnSpace",
+        boardId,
+        spaceId: home.spaceId,
+        position: nextLocationPosition({
+          type: "OnSpace",
+          boardId,
+          spaceId: home.spaceId
+        })
+      };
+    }
+    if (home.type === "container") {
+      const boardId = resolveRuntimeBoardId(
+        home.boardId,
+        null,
+        `${context.path}.boardId: ${context.label}`
+      );
+      if (!analysis.containerIdsByBoardId.get(home.boardId)?.includes(home.containerId)) {
+        throw new Error(
+          `${context.path}.containerId: ${context.label} targets unknown container '${home.containerId}' on board '${home.boardId}'.`
+        );
+      }
+      return {
+        type: "InContainer",
+        boardId,
+        containerId: home.containerId,
+        position: nextLocationPosition({
+          type: "InContainer",
+          boardId,
+          containerId: home.containerId
+        })
+      };
+    }
+    if (home.type === "edge") {
+      const boardId = resolveRuntimeBoardId(
+        home.boardId,
+        null,
+        `${context.path}.boardId: ${context.label}`
+      );
+      const edgeId = resolveBoardEdgeId(home.boardId, home.ref.spaces);
+      return {
+        type: "OnEdge",
+        boardId,
+        edgeId,
+        position: nextLocationPosition({
+          type: "OnEdge",
+          boardId,
+          edgeId
+        })
+      };
+    }
+    if (home.type === "vertex") {
+      const boardId = resolveRuntimeBoardId(
+        home.boardId,
+        null,
+        `${context.path}.boardId: ${context.label}`
+      );
+      const vertexId = resolveBoardVertexId(home.boardId, home.ref.spaces);
+      return {
+        type: "OnVertex",
+        boardId,
+        vertexId,
+        position: nextLocationPosition({
+          type: "OnVertex",
+          boardId,
+          vertexId
+        })
+      };
+    }
+    const exhaustive = home;
+    throw new Error(
+      `Unsupported component home: ${JSON.stringify(exhaustive)}`
+    );
+  };
+  for (const [cardSetIndex, cardSet] of manifest.cardSets.entries()) {
+    for (const [cardIndex, card] of cardSet.cards.entries()) {
+      const cardInstanceIds = renderCardInstanceIds2(card);
+      for (const [instanceIndex, cardId] of cardInstanceIds.entries()) {
+        cards[cardId] = {
+          id: cardId,
+          cardSetId: cardSet.id,
+          cardType: card.cardType,
+          name: card.name,
+          text: card.text,
+          frontImage: card.frontImage,
+          backImage: card.backImage,
+          properties: {
+            ...materializeCardPropertiesDefaults(
+              cardSet.cardSchema,
+              card.cardType,
+              analysis
+            ),
+            ...card.properties ?? {}
+          }
+        };
+        const resolvedHome = card.home ?? cardSet.defaultHome;
+        const path = card.home === void 0 ? `manifest.cardSets[${cardSetIndex}].defaultHome` : `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].home`;
+        componentLocations[cardId] = materializeComponentLocation(
+          resolvedHome,
+          {
+            path,
+            label: `Card '${card.id}' instance ${instanceIndex + 1}`
+          }
+        );
+      }
+    }
+  }
+  if (Object.keys(cards).length !== analysis.cardIds.length) {
+    throw new Error(
+      "Materialized card record cardinality drifted from analysis."
+    );
+  }
+  if (Object.keys(componentLocations).length !== analysis.cardIds.length) {
+    throw new Error(
+      "Materialized card locations drifted from analysis before seed placement."
+    );
+  }
+  const pieceTypesById = new Map(
+    (manifest.pieceTypes ?? []).map((pieceType) => [pieceType.id, pieceType])
+  );
+  const dieTypesById = new Map(
+    (manifest.dieTypes ?? []).map((dieType) => [dieType.id, dieType])
+  );
+  const assignSeedLocation = (componentId, ownerId, home, context) => {
+    if (!home) {
+      componentLocations[componentId] = { type: "Detached" };
+      return;
+    }
+    if (home.type === "slot") {
+      componentLocations[componentId] = {
+        type: "InSlot",
+        host: home.host,
+        slotId: home.slotId,
+        position: nextLocationPosition({
+          type: "InSlot",
+          host: home.host,
+          slotId: home.slotId
+        })
+      };
+      return;
+    }
+    if (home.type === "zone") {
+      if (zoneScopeById.get(home.zoneId) === "perPlayer") {
+        if (!ownerId) {
+          throw new Error(
+            `${context.path}.zoneId: ${context.label} requires ownerId because zone '${home.zoneId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
+          );
+        }
+        componentLocations[componentId] = {
+          type: "InHand",
+          handId: home.zoneId,
+          playerId: ownerId,
+          position: nextLocationPosition({
+            type: "InHand",
+            handId: home.zoneId,
+            playerId: ownerId
+          })
+        };
+        return;
+      }
+      componentLocations[componentId] = {
+        type: "InZone",
+        zoneId: home.zoneId,
+        playedBy: null,
+        position: nextLocationPosition({
+          type: "InZone",
+          zoneId: home.zoneId
+        })
+      };
+      return;
+    }
+    if (home.type === "space") {
+      const boardId = resolveRuntimeBoardId(
+        home.boardId,
+        ownerId,
+        `${context.path}.boardId: ${context.label}`
+      );
+      componentLocations[componentId] = {
+        type: "OnSpace",
+        boardId,
+        spaceId: home.spaceId,
+        position: nextLocationPosition({
+          type: "OnSpace",
+          boardId,
+          spaceId: home.spaceId
+        })
+      };
+      return;
+    }
+    if (home.type === "container") {
+      const boardId = resolveRuntimeBoardId(
+        home.boardId,
+        ownerId,
+        `${context.path}.boardId: ${context.label}`
+      );
+      componentLocations[componentId] = {
+        type: "InContainer",
+        boardId,
+        containerId: home.containerId,
+        position: nextLocationPosition({
+          type: "InContainer",
+          boardId,
+          containerId: home.containerId
+        })
+      };
+      return;
+    }
+    if (home.type === "edge") {
+      const boardId = resolveRuntimeBoardId(
+        home.boardId,
+        ownerId,
+        `${context.path}.boardId: ${context.label}`
+      );
+      const edgeId = resolveBoardEdgeId(home.boardId, home.ref.spaces);
+      componentLocations[componentId] = {
+        type: "OnEdge",
+        boardId,
+        edgeId,
+        position: nextLocationPosition({
+          type: "OnEdge",
+          boardId,
+          edgeId
+        })
+      };
+      return;
+    }
+    if (home.type === "vertex") {
+      const boardId = resolveRuntimeBoardId(
+        home.boardId,
+        ownerId,
+        `${context.path}.boardId: ${context.label}`
+      );
+      const vertexId = resolveBoardVertexId(home.boardId, home.ref.spaces);
+      componentLocations[componentId] = {
+        type: "OnVertex",
+        boardId,
+        vertexId,
+        position: nextLocationPosition({
+          type: "OnVertex",
+          boardId,
+          vertexId
+        })
+      };
+      return;
+    }
+    componentLocations[componentId] = { type: "Detached" };
+  };
+  for (const [seedIndex, seed] of (manifest.pieceSeeds ?? []).entries()) {
+    const pieceType = pieceTypesById.get(seed.typeId);
+    for (const componentId of expandSeedIds2([seed])) {
+      pieces[componentId] = {
+        componentType: "piece",
+        id: componentId,
+        pieceTypeId: seed.typeId,
+        pieceName: pieceType?.name ?? seed.typeId,
+        ownerId: seed.ownerId ?? null,
+        properties: {
+          ...materializeObjectSchemaDefaults(
+            analysis.pieceTypeSchemasById.get(seed.typeId),
+            analysis
+          ),
+          ...seed.fields ?? {}
+        }
+      };
+      assignSeedLocation(componentId, seed.ownerId, seed.home, {
+        path: `manifest.pieceSeeds[${seedIndex}].home`,
+        label: `Piece seed '${seed.id ?? seed.typeId}'`
+      });
+    }
+  }
+  for (const [seedIndex, seed] of (manifest.dieSeeds ?? []).entries()) {
+    const dieType = dieTypesById.get(seed.typeId);
+    for (const componentId of expandSeedIds2([seed])) {
+      dice[componentId] = {
+        componentType: "die",
+        id: componentId,
+        dieTypeId: seed.typeId,
+        dieName: dieType?.name ?? seed.typeId,
+        ownerId: seed.ownerId ?? null,
+        sides: dieType?.sides ?? 6,
+        value: null,
+        properties: {
+          ...materializeObjectSchemaDefaults(
+            analysis.dieTypeSchemasById.get(seed.typeId),
+            analysis
+          ),
+          ...seed.fields ?? {}
+        }
+      };
+      assignSeedLocation(componentId, seed.ownerId, seed.home, {
+        path: `manifest.dieSeeds[${seedIndex}].home`,
+        label: `Die seed '${seed.id ?? seed.typeId}'`
+      });
+    }
+  }
+  const boardStatesById = createRecord();
+  const hexBoardStatesById = createRecord();
+  const squareBoardStatesById = createRecord();
+  for (const analyzedBoard of analysis.analyzedBoards) {
+    const sharedBoardState = {
+      baseId: analyzedBoard.board.id,
+      layout: analyzedBoard.layout,
+      typeId: analyzedBoard.boardTypeId ?? null,
+      scope: analyzedBoard.board.scope,
+      fields: {
+        ...materializeObjectSchemaDefaults(
+          analyzedBoard.boardFieldsSchema,
+          analysis
+        ),
+        ...analyzedBoard.board.fields ?? {}
+      }
+    };
+    const buildSpaces = () => Object.fromEntries(
+      analyzedBoard.spaces.map((space) => {
+        const spaceId = space.id;
+        const baseSpaceState = {
+          id: spaceId,
+          name: "name" in space ? space.name ?? null : null,
+          typeId: space?.typeId ?? null,
+          fields: {
+            ...materializeObjectSchemaDefaults(
+              analyzedBoard.spaceFieldsSchema,
+              analysis
+            ),
+            ...space.fields ?? {}
+          },
+          zoneId: "zoneId" in space ? space.zoneId ?? null : null
+        };
+        if (analyzedBoard.layout === "hex") {
+          const hexSpace = space;
+          return [
+            spaceId,
+            {
+              ...baseSpaceState,
+              q: hexSpace.q,
+              r: hexSpace.r
+            }
+          ];
+        }
+        if (analyzedBoard.layout === "square") {
+          const squareSpace = space;
+          return [
+            spaceId,
+            {
+              ...baseSpaceState,
+              row: squareSpace.row,
+              col: squareSpace.col
+            }
+          ];
+        }
+        return [spaceId, baseSpaceState];
+      })
+    );
+    const relations = analyzedBoard.layout === "hex" ? [] : analyzedBoard.relations.map((relation) => ({
+      id: relation.id ?? null,
+      typeId: relation.typeId,
+      fromSpaceId: relation.fromSpaceId,
+      toSpaceId: relation.toSpaceId,
+      directed: relation.directed ?? false,
+      fields: {
+        ...materializeObjectSchemaDefaults(
+          analyzedBoard.relationFieldsSchema,
+          analysis
+        ),
+        ...relation.fields ?? {}
+      }
+    }));
+    const buildContainers = (runtimeBoardId) => analyzedBoard.layout === "hex" ? {} : Object.fromEntries(
+      analyzedBoard.containers.map((container) => {
+        const containerId = container.id;
+        return [
+          containerId,
+          {
+            id: containerId,
+            name: container.name ?? containerId,
+            host: container.host.type === "space" ? { type: "space", spaceId: container.host.spaceId } : { type: "board" },
+            allowedCardSetIds: container.allowedCardSetIds,
+            zoneId: `board:${runtimeBoardId}:container:${containerId}`,
+            fields: {
+              ...materializeObjectSchemaDefaults(
+                analyzedBoard.containerFieldsSchema,
+                analysis,
+                runtimeBoardId
+              ),
+              ...container.fields ?? {}
+            }
+          }
+        ];
+      })
+    );
+    const edges = analyzedBoard.layout === "generic" ? [] : analyzedBoard.edges.map((edge) => ({
+      id: edge.id,
+      spaceIds: [...edge.spaceIds],
+      typeId: edge.typeId ?? null,
+      label: edge.label ?? null,
+      ownerId: null,
+      fields: {
+        ...materializeObjectSchemaDefaults(
+          analyzedBoard.edgeFieldsSchema,
+          analysis
+        ),
+        ...edge.fields ?? {}
+      }
+    }));
+    const vertices = analyzedBoard.layout === "generic" ? [] : analyzedBoard.vertices.map((vertex) => ({
+      id: vertex.id,
+      spaceIds: [...vertex.spaceIds],
+      typeId: vertex.typeId ?? null,
+      label: vertex.label ?? null,
+      ownerId: null,
+      fields: {
+        ...materializeObjectSchemaDefaults(
+          analyzedBoard.vertexFieldsSchema,
+          analysis
+        ),
+        ...vertex.fields ?? {}
+      }
+    }));
+    for (const runtimeBoardId of analyzedBoard.runtimeBoardIds) {
+      const playerId = analyzedBoard.board.scope === "perPlayer" ? runtimeBoardId.slice(analyzedBoard.board.id.length + 1) : null;
+      const boardState = {
+        id: runtimeBoardId,
+        ...sharedBoardState,
+        playerId,
+        spaces: cloneJson(buildSpaces()),
+        relations: cloneJson(relations),
+        containers: cloneJson(buildContainers(runtimeBoardId)),
+        ...analyzedBoard.layout === "hex" ? {
+          orientation: analyzedBoard.board.orientation ?? "pointy",
+          edges: cloneJson(edges),
+          vertices: cloneJson(vertices)
+        } : analyzedBoard.layout === "square" ? {
+          edges: cloneJson(edges),
+          vertices: cloneJson(vertices)
+        } : {}
+      };
+      boardStatesById[runtimeBoardId] = boardState;
+      if (analyzedBoard.layout === "hex") {
+        hexBoardStatesById[runtimeBoardId] = boardState;
+      }
+      if (analyzedBoard.layout === "square") {
+        squareBoardStatesById[runtimeBoardId] = boardState;
+      }
+    }
+  }
+  const sharedZones = Object.fromEntries(
+    analysis.sharedZones.map((zone) => [zone.id, []])
+  );
+  const perPlayerZones = Object.fromEntries(
+    analysis.playerZones.map((zone) => [
+      zone.id,
+      Object.fromEntries(
+        playerIds.map((playerId) => [playerId, []])
+      )
+    ])
+  );
+  const zoneVisibility = Object.fromEntries(
+    (manifest.zones ?? []).map((zone) => [
+      zone.id,
+      zone.visibility ?? "public"
+    ])
+  );
+  const zoneCardSetIdsByZoneId = Object.fromEntries(
+    Array.from(analysis.zoneCardSetIdsById.entries()).sort(
+      ([left], [right]) => left.localeCompare(right)
+    )
+  );
+  const handVisibility = Object.fromEntries(
+    analysis.playerZones.map((zone) => [
+      zone.id,
+      zone.visibility ?? "ownerOnly"
+    ])
+  );
+  const componentSortPosition = (position) => typeof position === "number" ? position : Number.MAX_SAFE_INTEGER;
+  const pushSharedComponent = (zoneId, componentId) => {
+    const zone = sharedZones[zoneId];
+    if (!zone) {
+      return;
+    }
+    zone.push(componentId);
+    zone.sort(
+      (left, right) => componentSortPosition(componentLocations[left]?.position) - componentSortPosition(componentLocations[right]?.position)
+    );
+  };
+  const pushPlayerComponent = (zoneId, playerId, componentId) => {
+    const zone = perPlayerZones[zoneId]?.[playerId];
+    if (!zone) {
+      return;
+    }
+    zone.push(componentId);
+    zone.sort(
+      (left, right) => componentSortPosition(componentLocations[left]?.position) - componentSortPosition(componentLocations[right]?.position)
+    );
+  };
+  for (const [componentId, location] of Object.entries(componentLocations)) {
+    switch (location.type) {
+      case "InDeck":
+        pushSharedComponent(location.deckId, componentId);
+        break;
+      case "InHand":
+        pushPlayerComponent(
+          location.handId,
+          location.playerId,
+          componentId
+        );
+        break;
+      case "InZone":
+        pushSharedComponent(location.zoneId, componentId);
+        break;
+      default:
+        break;
+    }
+  }
+  const ownerOfCard = Object.fromEntries(
+    Object.keys(cards).map((cardId) => [cardId, null])
+  );
+  const visibility = Object.fromEntries(
+    Object.keys(cards).map((cardId) => [cardId, { faceUp: true }])
+  );
+  const resourcesByPlayer = Object.fromEntries(
+    playerIds.map((playerId) => [
+      playerId,
+      Object.fromEntries(
+        analysis.resourceIds.map((resourceId) => [resourceId, 0])
+      )
+    ])
+  );
+  return cloneJson({
+    playerOrder: playerIds,
+    zones: {
+      shared: sharedZones,
+      perPlayer: perPlayerZones,
+      visibility: zoneVisibility,
+      cardSetIdsByZoneId: zoneCardSetIdsByZoneId
+    },
+    decks: cloneJson(sharedZones),
+    hands: cloneJson(perPlayerZones),
+    handVisibility,
+    cards,
+    pieces,
+    componentLocations,
+    ownerOfCard,
+    visibility,
+    resources: resourcesByPlayer,
+    boards: {
+      byId: boardStatesById,
+      hex: hexBoardStatesById,
+      square: squareBoardStatesById,
+      network: {},
+      track: {}
+    },
+    dice
+  });
+}
+
+// src/reducer/manifest/schema.ts
+import { z } from "zod";
+function createTableSchema(analysis, ids) {
+  const unknownRecordSchema = z.record(z.string(), z.unknown());
+  const objectSchema = (schema) => schema && Object.keys(schema.properties).length ? z.object(
+    Object.fromEntries(
+      Object.entries(schema.properties).map(([key, value]) => [
+        key,
+        propertySchema(value)
+      ])
+    )
+  ) : unknownRecordSchema;
+  function propertySchema(schema) {
+    if (!schema) return z.unknown();
+    let result;
+    switch (schema.type) {
+      case "string":
+        result = z.string();
+        break;
+      case "integer":
+        result = z.number().int();
+        break;
+      case "number":
+        result = z.number();
+        break;
+      case "boolean":
+        result = z.boolean();
+        break;
+      case "enum":
+        result = schema.enums?.length ? z.enum(schema.enums) : z.string();
+        break;
+      case "array":
+        result = z.array(propertySchema(schema.items));
+        break;
+      case "record":
+        result = z.record(z.string(), propertySchema(schema.values));
+        break;
+      case "object":
+        result = objectSchema({ properties: schema.properties ?? {} });
+        break;
+      default:
+        result = ids[schema.type];
+    }
+    if (schema.nullable) result = result.nullable();
+    if (schema.optional) result = result.optional();
+    if (Object.prototype.hasOwnProperty.call(schema, "default"))
+      result = result.default(schema.default);
+    return result;
+  }
+  const shape = (items, getKey, getSchema) => z.object(
+    Object.fromEntries(items.map((item) => [getKey(item), getSchema(item)]))
+  );
+  const cardStateByIdSchema = shape(
+    analysis.cardIds,
+    (id) => id,
+    (id) => {
+      const setId = analysis.cardSetIdByCardId.get(id);
+      const type = analysis.cardTypeByCardId.get(id);
+      const schema = analysis.cardSets.find(
+        (set) => set.id === setId
+      ).cardSchema;
+      const properties = schema && "variants" in schema ? objectSchema({
+        properties: {
+          ...schema.shared,
+          ...schema.variants[type].properties
+        }
+      }) : objectSchema(schema);
+      return z.object({
+        componentType: z.string().optional(),
+        id: z.literal(id),
+        cardSetId: z.literal(setId),
+        cardType: z.literal(type),
+        name: z.string().optional(),
+        text: z.string().optional(),
+        frontImage: z.string().optional(),
+        backImage: z.string().optional(),
+        properties
+      });
+    }
+  );
+  const pieceStateByIdSchema = shape(
+    analysis.pieceIds,
+    (id) => id,
+    (id) => {
+      const type = analysis.pieceTypeIdByPieceId.get(id);
+      return z.object({
+        componentType: z.string().optional(),
+        id: z.literal(id),
+        pieceTypeId: z.literal(type),
+        pieceName: z.string().nullish(),
+        ownerId: ids.playerId.nullish(),
+        properties: objectSchema(analysis.pieceTypeSchemasById.get(type))
+      });
+    }
+  );
+  const dieStateByIdSchema = shape(
+    analysis.dieIds,
+    (id) => id,
+    (id) => {
+      const type = analysis.dieTypeIdByDieId.get(id);
+      return z.object({
+        componentType: z.string().optional(),
+        id: z.literal(id),
+        dieTypeId: z.literal(type),
+        dieName: z.string().nullish(),
+        ownerId: ids.playerId.nullish(),
+        sides: z.literal(
+          analysis.manifest.dieTypes?.find((die) => die.id === type)?.sides ?? 6
+        ),
+        value: z.number().int().nullish(),
+        properties: objectSchema(analysis.dieTypeSchemasById.get(type))
+      });
+    }
+  );
+  const sharedZoneSchema = shape(
+    analysis.sharedZones,
+    (zone) => zone.id,
+    () => z.array(ids.cardId)
+  );
+  const playerZoneSchema = shape(
+    analysis.playerZones,
+    (zone) => zone.id,
+    () => z.record(ids.playerId, z.array(ids.cardId))
+  );
+  const zoneIdSchema = ids.zoneId;
+  const playerZoneIdSchema = ids.playerZoneId;
+  const slotVariants = analysis.strictSlotHosts.flatMap(
+    (host) => host.slotIds.map(
+      (slotId) => z.object({
+        type: z.literal("InSlot"),
+        host: z.object({ kind: z.literal(host.kind), id: z.literal(host.id) }),
+        slotId: z.literal(slotId),
+        position: z.number().int().nullish()
+      })
+    )
+  );
+  const slotLocationSchema = slotVariants.length ? z.union(
+    slotVariants
+  ) : z.never();
+  const boardSpaceTypeIdSchema = ids.spaceTypeId.nullable().optional();
+  const boardSpaceStateSchema = z.object({
+    id: ids.spaceId,
+    name: z.string().nullable().optional(),
+    typeId: boardSpaceTypeIdSchema,
+    fields: unknownRecordSchema,
+    zoneId: z.string().nullable().optional()
+  });
+  const hexSpaceStateSchema = boardSpaceStateSchema.extend({
+    q: z.number().int(),
+    r: z.number().int()
+  });
+  const squareSpaceStateSchema = boardSpaceStateSchema.extend({
+    row: z.number().int(),
+    col: z.number().int()
+  });
+  const boardRelationStateSchema = z.object({
+    id: z.string().nullable().optional(),
+    typeId: ids.relationTypeId,
+    fromSpaceId: ids.spaceId,
+    toSpaceId: ids.spaceId,
+    directed: z.boolean(),
+    fields: unknownRecordSchema
+  });
+  const boardContainerStateSchema = z.object({
+    id: ids.boardContainerId,
+    name: z.string(),
+    host: z.discriminatedUnion("type", [
+      z.object({ type: z.literal("board") }),
+      z.object({ type: z.literal("space"), spaceId: ids.spaceId })
+    ]),
+    allowedCardSetIds: z.array(ids.cardSetId).optional(),
+    zoneId: z.string(),
+    fields: unknownRecordSchema
+  });
+  const runtimeGenericBoardStateSchema = z.object({
+    id: ids.boardId,
+    baseId: ids.boardBaseId,
+    layout: z.literal("generic"),
+    typeId: ids.boardTypeId.nullable().optional(),
+    scope: z.enum(["shared", "perPlayer"]),
+    playerId: ids.playerId.nullable().optional(),
+    fields: unknownRecordSchema,
+    // 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(z.string(), boardContainerStateSchema)
+  });
+  const hexEdgeStateSchema = z.object({
+    id: ids.edgeId,
+    spaceIds: z.array(ids.spaceId).min(1).max(2),
+    typeId: ids.edgeTypeId.nullable().optional(),
+    label: z.string().nullable().optional(),
+    ownerId: ids.playerId.nullable().optional(),
+    fields: unknownRecordSchema
+  });
+  const hexVertexStateSchema = z.object({
+    id: ids.vertexId,
+    spaceIds: z.array(ids.spaceId).min(1).max(3),
+    typeId: ids.vertexTypeId.nullable().optional(),
+    label: z.string().nullable().optional(),
+    ownerId: ids.playerId.nullable().optional(),
+    fields: unknownRecordSchema
+  });
+  const squareVertexStateSchema = z.object({
+    id: ids.vertexId,
+    spaceIds: z.array(ids.spaceId).min(1).max(4),
+    typeId: ids.vertexTypeId.nullable().optional(),
+    label: z.string().nullable().optional(),
+    ownerId: ids.playerId.nullable().optional(),
+    fields: unknownRecordSchema
+  });
+  const runtimeHexBoardStateSchema = runtimeGenericBoardStateSchema.extend({
+    layout: z.literal("hex"),
+    // 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", "flat"]),
+    edges: z.array(hexEdgeStateSchema),
+    vertices: z.array(hexVertexStateSchema)
+  });
+  const runtimeSquareBoardStateSchema = runtimeGenericBoardStateSchema.extend({
+    layout: z.literal("square"),
+    // T220: loose-keyed by string — see comment above.
+    spaces: z.record(z.string(), squareSpaceStateSchema),
+    relations: z.array(boardRelationStateSchema),
+    containers: z.record(z.string(), boardContainerStateSchema),
+    edges: z.array(hexEdgeStateSchema),
+    vertices: z.array(squareVertexStateSchema)
+  });
+  const boards = analysis.analyzedBoards.flatMap(
+    (board) => board.runtimeBoardIds.map((id) => {
+      const base = {
+        id: board.board.scope === "perPlayer" ? z.templateLiteral([board.board.id, ":", z.string().min(1)]) : z.literal(id),
+        baseId: z.literal(board.board.id),
+        scope: z.literal(board.board.scope),
+        fields: objectSchema(board.boardFieldsSchema)
+      };
+      const spaces = boardSpaceStateSchema.extend({
+        fields: objectSchema(board.spaceFieldsSchema)
+      });
+      const relations = z.array(
+        boardRelationStateSchema.extend({
+          fields: objectSchema(
+            "relationFieldsSchema" in board ? board.relationFieldsSchema : void 0
+          )
+        })
+      );
+      const containers = "containers" in board ? shape(
+        board.containers,
+        (item) => item.id,
+        (item) => boardContainerStateSchema.extend({
+          id: z.literal(item.id),
+          fields: objectSchema(board.containerFieldsSchema)
+        })
+      ) : z.object({});
+      if (board.layout === "generic")
+        return {
+          id,
+          scope: board.board.scope,
+          layout: board.layout,
+          schema: runtimeGenericBoardStateSchema.extend({
+            ...base,
+            spaces: z.record(z.string(), spaces),
+            relations,
+            containers
+          })
+        };
+      const edges = z.array(
+        hexEdgeStateSchema.extend({
+          fields: objectSchema(board.edgeFieldsSchema)
+        })
+      );
+      const vertices = z.array(
+        (board.layout === "hex" ? hexVertexStateSchema : squareVertexStateSchema).extend({ fields: objectSchema(board.vertexFieldsSchema) })
+      );
+      return {
+        id,
+        scope: board.board.scope,
+        layout: board.layout,
+        schema: board.layout === "hex" ? runtimeHexBoardStateSchema.extend({
+          ...base,
+          spaces: z.record(
+            z.string(),
+            spaces.extend({ q: z.number().int(), r: z.number().int() })
+          ),
+          edges,
+          vertices
+        }) : runtimeSquareBoardStateSchema.extend({
+          ...base,
+          spaces: z.record(
+            z.string(),
+            spaces.extend({
+              row: z.number().int(),
+              col: z.number().int()
+            })
+          ),
+          relations,
+          containers,
+          edges,
+          vertices
+        })
+      };
+    })
+  );
+  const boardCollection = (entries) => {
+    const shared = entries.filter((board) => board.scope === "shared");
+    const scoped = entries.filter((board) => board.scope === "perPlayer").map((board) => board.schema);
+    return shape(
+      shared,
+      (board) => board.id,
+      (board) => board.schema
+    ).catchall(scoped.length ? z.union(scoped) : z.never());
+  };
+  const boardStateByIdSchema = boardCollection(boards);
+  const hexBoardStateByIdSchema = boardCollection(
+    boards.filter((board) => board.layout === "hex")
+  );
+  const squareBoardStateByIdSchema = boardCollection(
+    boards.filter((board) => board.layout === "square")
+  );
+  return z.object({
+    playerOrder: z.array(ids.playerId),
+    zones: z.object({
+      shared: sharedZoneSchema,
+      perPlayer: playerZoneSchema,
+      visibility: z.record(
+        zoneIdSchema,
+        z.enum(["all", "ownerOnly", "public", "hidden"])
+      ),
+      cardSetIdsByZoneId: z.record(zoneIdSchema, z.array(ids.cardSetId)).optional()
+    }),
+    decks: sharedZoneSchema,
+    hands: playerZoneSchema,
+    handVisibility: z.record(
+      playerZoneIdSchema,
+      z.enum(["all", "ownerOnly", "public", "hidden"])
+    ),
+    cards: cardStateByIdSchema,
+    pieces: pieceStateByIdSchema,
+    componentLocations: z.record(
+      z.string(),
+      z.union([
+        z.object({ type: z.literal("Detached") }),
+        z.object({
+          type: z.literal("InDeck"),
+          deckId: ids.deckId,
+          playedBy: ids.playerId.nullable(),
+          position: z.number().int().nullable().optional()
+        }),
+        z.object({
+          type: z.literal("InHand"),
+          handId: ids.handId,
+          playerId: ids.playerId,
+          position: z.number().int().nullable().optional()
+        }),
+        z.object({
+          type: z.literal("InZone"),
+          zoneId: z.string(),
+          playedBy: ids.playerId.nullable().optional(),
+          position: z.number().int().nullable().optional()
+        }),
+        z.object({
+          type: z.literal("OnSpace"),
+          boardId: ids.boardId,
+          spaceId: ids.spaceId,
+          position: z.number().int().nullable().optional()
+        }),
+        z.object({
+          type: z.literal("InContainer"),
+          boardId: ids.boardId,
+          containerId: ids.boardContainerId,
+          position: z.number().int().nullable().optional()
+        }),
+        z.object({
+          type: z.literal("OnEdge"),
+          boardId: ids.boardId,
+          edgeId: ids.edgeId,
+          position: z.number().int().nullable().optional()
+        }),
+        z.object({
+          type: z.literal("OnVertex"),
+          boardId: ids.boardId,
+          vertexId: ids.vertexId,
+          position: z.number().int().nullable().optional()
+        }),
+        slotLocationSchema
+      ])
+    ),
+    ownerOfCard: z.record(ids.cardId, ids.playerId.nullable()),
+    visibility: z.record(
+      ids.cardId,
+      z.object({
+        faceUp: z.boolean(),
+        visibleTo: z.array(ids.playerId).nullable().optional()
+      })
+    ),
+    resources: z.record(
+      ids.playerId,
+      z.record(ids.resourceId, z.number().int())
+    ),
+    boards: z.object({
+      byId: boardStateByIdSchema,
+      hex: hexBoardStateByIdSchema,
+      square: squareBoardStateByIdSchema,
+      network: z.record(z.string(), unknownRecordSchema).default({}),
+      track: z.record(z.string(), unknownRecordSchema).default({})
+    }),
+    dice: dieStateByIdSchema
+  }).superRefine((table, context) => {
+    const players = new Set(table.playerOrder);
+    if (players.size !== table.playerOrder.length) {
+      context.addIssue({
+        code: "custom",
+        path: ["playerOrder"],
+        message: "Duplicate player id"
+      });
+    }
+    const checkPlayers = (record, path) => {
+      for (const playerId of table.playerOrder) {
+        if (!Object.hasOwn(record, playerId))
+          context.addIssue({
+            code: "custom",
+            path: [...path, playerId],
+            message: "Missing active player"
+          });
+      }
+      for (const playerId of Object.keys(record)) {
+        if (!players.has(playerId))
+          context.addIssue({
+            code: "custom",
+            path: [...path, playerId],
+            message: "Unknown active player"
+          });
+      }
+    };
+    checkPlayers(table.resources, ["resources"]);
+    for (const [id, players2] of Object.entries(
+      table.hands
+    ))
+      checkPlayers(players2, ["hands", id]);
+    for (const [id, players2] of Object.entries(
+      table.zones.perPlayer
+    ))
+      checkPlayers(players2, ["zones", "perPlayer", id]);
+  });
+}
+
+// src/reducer/manifest/compiler.ts
+function compileManifest(manifest) {
+  const source = structuredClone(manifest);
+  const analysis = analyzeManifest(source);
+  const initial = materializeManifestTable({
+    manifest: source,
+    playerIds: analysis.playerIds,
+    shuffleItems: (values) => [...values]
+  });
+  const sharedZoneIds = analysis.sharedZones.map((zone) => zone.id).sort();
+  const playerZoneIds = analysis.playerZones.map((zone) => zone.id).sort();
+  const literals = {
+    ...Object.fromEntries(
+      Object.entries(analysis).filter(([key]) => key.endsWith("Ids") || key === "cardTypes").map(([key, value]) => [key, value])
+    ),
+    playerIds: analysis.playerIds.map(asPlayerId),
+    phaseNames: [],
+    boardLayouts: ["generic", "hex", "square"],
+    deckIds: sharedZoneIds,
+    handIds: playerZoneIds,
+    sharedZoneIds,
+    playerZoneIds,
+    resourcePresentationById: analysis.resourcePresentationById,
+    ownerResourceIds: (source.resources ?? []).filter((resource) => resource.visibility === "owner").map((resource) => resource.id).sort(),
+    handVisibilityById: Object.fromEntries(
+      playerZoneIds.map((id) => [
+        id,
+        analysis.zoneVisibilityById.get(id) ?? "ownerOnly"
+      ])
+    ),
+    zoneVisibilityById: Object.fromEntries(analysis.zoneVisibilityById),
+    cardSetIdByCardId: Object.fromEntries(analysis.cardSetIdByCardId),
+    cardTypeByCardId: Object.fromEntries(analysis.cardTypeByCardId),
+    cardSetIdsBySharedZoneId: Object.fromEntries(analysis.sharedZoneCardSetIds),
+    cardSetIdsByPlayerZoneId: Object.fromEntries(analysis.playerZoneCardSetIds)
+  };
+  const families = [
+    "phaseName",
+    "boardLayout",
+    "cardSetId",
+    "cardType",
+    "cardId",
+    "deckId",
+    "handId",
+    "sharedZoneId",
+    "playerZoneId",
+    "zoneId",
+    "resourceId",
+    "pieceTypeId",
+    "pieceId",
+    "dieTypeId",
+    "dieId",
+    "boardTypeId",
+    "boardBaseId",
+    "boardId",
+    "boardContainerId",
+    "relationTypeId",
+    "edgeId",
+    "edgeTypeId",
+    "vertexId",
+    "vertexTypeId",
+    "spaceId",
+    "spaceTypeId"
+  ];
+  const ids = {
+    ...Object.fromEntries(
+      families.map((family) => {
+        const values = literals[`${family}s`];
+        return [
+          family,
+          family === "phaseName" ? markManifestScopedSchema(z2.string(), family) : values.length ? createManifestStringLiteralSchema(values, family) : markManifestScopedSchema(z2.never(), family)
+        ];
+      })
+    ),
+    playerId: markManifestScopedSchema(
+      z2.string().min(1).transform(asPlayerId),
+      "playerId"
+    )
+  };
+  const boardIdSchemas = analysis.analyzedBoards.map(
+    (board) => board.board.scope === "perPlayer" ? z2.templateLiteral([board.board.id, ":", z2.string().min(1)]) : z2.literal(board.board.id)
+  );
+  ids.boardId = markManifestScopedSchema(
+    boardIdSchemas.length ? z2.union(boardIdSchemas) : z2.never(),
+    "boardId"
+  );
+  const tableSchema = assumeManifestSchema(
+    createTableSchema(analysis, ids)
+  );
+  const resolvePlayers = (players = analysis.playerIds) => players.map(asPlayerId);
+  const emptyDecks = () => Object.fromEntries(sharedZoneIds.map((id) => [id, []]));
+  const hands = (players) => Object.fromEntries(
+    playerZoneIds.map((id) => [
+      id,
+      Object.fromEntries(resolvePlayers(players).map((id2) => [id2, []]))
+    ])
+  );
+  const defaults = {
+    zones: (players) => ({
+      shared: emptyDecks(),
+      perPlayer: hands(players),
+      visibility: structuredClone(literals.zoneVisibilityById),
+      cardSetIdsByZoneId: Object.fromEntries(analysis.zoneCardSetIdsById)
+    }),
+    decks: emptyDecks,
+    hands,
+    handVisibility: () => structuredClone(literals.handVisibilityById),
+    ownerOfCard: () => Object.fromEntries(analysis.cardIds.map((id) => [id, null])),
+    visibility: () => Object.fromEntries(analysis.cardIds.map((id) => [id, { faceUp: true }])),
+    resources: (players) => Object.fromEntries(
+      resolvePlayers(players).map((id) => [
+        id,
+        Object.fromEntries(analysis.resourceIds.map((id2) => [id2, 0]))
+      ])
+    )
+  };
+  const runtimeSchema = createManifestRuntimeSchema({
+    phaseNameSchema: z2.string(),
+    playerIdSchema: ids.playerId
+  });
+  const createInitialTable = (options = {}) => tableSchema.parse(
+    materializeManifestTable({
+      manifest: source,
+      playerIds: options.playerIds ?? analysis.playerIds,
+      shuffleItems: options.shuffleItems ?? ((values) => [...values])
+    })
+  );
+  return {
+    literals,
+    ids,
+    defaults,
+    records: Object.fromEntries(
+      families.map((family) => [
+        `${family}s`,
+        (initial2) => buildTypedRecord(
+          literals[`${family}s`],
+          initial2
+        )
+      ])
+    ),
+    tableSchema,
+    runtimeSchema,
+    schemas: { table: tableSchema, runtime: runtimeSchema },
+    staticBoards: initial.boards,
+    createInitialTable,
+    normalSetup: {
+      minPlayers: source.players.minPlayers,
+      maxPlayers: source.players.maxPlayers,
+      createInitialTable
+    },
+    createGameStateSchema: (config) => createManifestGameStateSchema({
+      ...config,
+      tableSchema,
+      playerIdSchema: ids.playerId
+    })
+  };
+}
+
+// src/reducer/schema-helpers.ts
+import { z as z3 } from "zod";
+var sparseSchemas = /* @__PURE__ */ new WeakMap();
+function sparseMap(keySchema, valueSchema) {
+  const schema = z3.partialRecord(keySchema, valueSchema);
+  sparseSchemas.set(schema, {
+    keySchema,
+    valueSchema
+  });
+  return schema;
+}
+function sparseCounts(keySchema) {
+  return sparseMap(keySchema, z3.number().int().min(0));
+}
+function getZodDef(schema) {
+  const anySchema = schema;
+  const fromInternal = anySchema?._zod?.def;
+  if (fromInternal && typeof fromInternal === "object") {
+    return fromInternal;
+  }
+  const fromLegacy = anySchema?.def;
+  if (fromLegacy && typeof fromLegacy === "object") {
+    return fromLegacy;
+  }
+  return {};
+}
+function unwrapWrappers(schema) {
+  let current = schema;
+  while (true) {
+    const def = getZodDef(current);
+    const innerType = def.innerType;
+    if ((def.type === "nullable" || def.type === "optional" || def.type === "default" || def.type === "readonly" || def.type === "catch") && innerType) {
+      current = innerType;
+      continue;
+    }
+    return current;
+  }
+}
+function isPlainZodString(schema) {
+  return getZodDef(schema).type === "string";
+}
+function isZodArray(schema) {
+  return getZodDef(schema).type === "array";
+}
+function isEnumKeyedRecordSchema(schema) {
+  const def = getZodDef(schema);
+  const keyType = def.keyType;
+  return def.type === "record" && typeof keyType === "object" && keyType !== null && getZodDef(keyType).type === "enum";
+}
+function isSparseMapSchema(schema) {
+  const inner = unwrapWrappers(schema);
+  return typeof inner === "object" && inner !== null && sparseSchemas.has(inner);
+}
+function getSparseSchemaMetadata(schema) {
+  const inner = unwrapWrappers(schema);
+  if (typeof inner !== "object" || inner === null) {
+    return void 0;
+  }
+  return sparseSchemas.get(inner);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getObjectShape(schema) {
+  const def = getZodDef(schema);
+  if (def.type !== "object") {
+    return null;
+  }
+  const shape = def.shape;
+  if (typeof shape === "function") {
+    const resolved = shape();
+    return resolved && typeof resolved === "object" ? resolved : null;
+  }
+  return shape && typeof shape === "object" ? shape : null;
+}
+function normalizeSchemaInput(schema, input) {
+  const inner = unwrapWrappers(schema);
+  const sparse = getSparseSchemaMetadata(inner);
+  if (sparse && isPlainObject(input)) {
+    const filtered = Object.fromEntries(
+      Object.entries(input).filter(
+        ([key, value]) => typeof value !== "undefined" && sparse.keySchema.safeParse(key).success
+      ).map(([key, value]) => [
+        key,
+        normalizeSchemaInput(sparse.valueSchema, value)
+      ])
+    );
+    return filtered;
+  }
+  const shape = getObjectShape(inner);
+  if (shape && isPlainObject(input)) {
+    return Object.fromEntries(
+      Object.entries(input).map(([key, value]) => {
+        const fieldSchema = shape[key];
+        return [
+          key,
+          typeof fieldSchema === "undefined" ? value : normalizeSchemaInput(fieldSchema, value)
+        ];
+      })
+    );
+  }
+  const def = getZodDef(inner);
+  if (def.type === "array" && Array.isArray(input) && def.element) {
+    return input.map((value) => normalizeSchemaInput(def.element, value));
+  }
+  return input;
+}
+function normalizeCommandParams(schema, input) {
+  return schema.parse(normalizeSchemaInput(schema, input));
+}
+
+// src/reducer/authoring/validation.ts
+var MANIFEST_SCOPED_ID_NAMES = [
+  "playerId",
+  "cardId",
+  "deckId",
+  "handId",
+  "zoneId",
+  "sharedZoneId",
+  "playerZoneId",
+  "boardId",
+  "boardContainerId",
+  "boardTypeId",
+  "boardBaseId",
+  "edgeId",
+  "edgeTypeId",
+  "vertexId",
+  "vertexTypeId",
+  "spaceId",
+  "spaceTypeId",
+  "relationTypeId",
+  "resourceId",
+  "pieceId",
+  "pieceTypeId",
+  "dieId",
+  "dieTypeId",
+  "cardSetId",
+  "cardType"
+];
+function matchManifestScopedIdName(key) {
+  for (const name of MANIFEST_SCOPED_ID_NAMES) {
+    const capitalized = `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
+    if (key === name || key.endsWith(capitalized)) {
+      return { name, kind: "singular" };
+    }
+    const plural = `${name}s`;
+    const capitalizedPlural = `${capitalized}s`;
+    if (key === plural || key.endsWith(capitalizedPlural)) {
+      return { name, kind: "plural" };
+    }
+  }
+  return null;
+}
+function validateInteractionParamsSchema(schema, context, path) {
+  const inner = unwrapWrappers(schema);
+  if (isEnumKeyedRecordSchema(inner) && !isSparseMapSchema(inner)) {
+    throw new Error(
+      `${context}: ${path} uses an enum-keyed z.record(...), which parses as a total map at runtime. Use sparseMap(...) or sparseCounts(...) from @dreamboard-games/sdk/reducer instead so interaction params stay sparse and match runtime validation.`
+    );
+  }
+  const shape = getObjectShape(inner);
+  if (shape) {
+    for (const [key, fieldSchema] of Object.entries(shape)) {
+      validateInteractionParamsSchema(fieldSchema, context, `${path}.${key}`);
+    }
+    return;
+  }
+  const def = getZodDef(inner);
+  if (def.type === "array" && def.element) {
+    validateInteractionParamsSchema(def.element, context, `${path}[]`);
+    return;
+  }
+  if (def.type === "record" && def.valueType) {
+    validateInteractionParamsSchema(def.valueType, context, `${path}.*`);
+  }
+}
+function validateInteractionInputsSchema(inputs, context) {
+  if (!inputs) return;
+  for (const [key, collector] of Object.entries(inputs)) {
+    validateInteractionParamsSchema(collector.schema, context, `inputs.${key}`);
+  }
+}
+function validateManyCommitPolicy(input) {
+  if (input.commit?.mode !== "autoWhenReady") return;
+  if (Object.values(input.inputs ?? {}).some(
+    (collector) => collector.selection?.mode === "many"
+  )) {
+    throw new Error(
+      `${input.context}: interactions with many(...) inputs must use commit: { mode: "manual" }.`
+    );
+  }
+}
+function validateInteractionLikeDefinition(input, context) {
+  if (input.steps) {
+    if (input.inputs !== void 0)
+      throw new Error("An interaction declares inputs or steps, never both.");
+    if (input.steps.entries.length === 0)
+      throw new Error("An interaction requires at least one step.");
+    const keys = input.steps.entries.map((entry) => entry.key);
+    if (new Set(keys).size !== keys.length)
+      throw new Error("Interaction step keys must be unique.");
+  }
+  validateInteractionInputsSchema(input.inputs, context);
+  validateManyCommitPolicy({
+    inputs: input.inputs,
+    commit: input.commit,
+    context
+  });
+  if (input.paramsSchema) {
+    validateInteractionParamsSchema(
+      input.paramsSchema,
+      context,
+      "paramsSchema"
+    );
+  }
+}
+function validateStateSchemaIdBranding(schema, scope) {
+  const def = getZodDef(schema);
+  if (def.type !== "object") {
+    return;
+  }
+  const shape = def.shape;
+  if (!shape) {
+    return;
+  }
+  for (const [key, fieldSchema] of Object.entries(shape)) {
+    const match = matchManifestScopedIdName(key);
+    if (!match) {
+      continue;
+    }
+    const inner = unwrapWrappers(fieldSchema);
+    if (match.kind === "singular") {
+      if (isPlainZodString(inner) && !isManifestScopedSchema(inner)) {
+        throw new Error(
+          `defineGameContract: state.${scope}.${key} uses a raw z.string() but its name identifies it as a manifest-scoped '${match.name}'. Use gameContract.schemas.${match.name} (or manifest.ids.${match.name}) so the branded literal union flows through state types.`
+        );
+      }
+      continue;
+    }
+    if (match.kind === "plural" && isZodArray(inner)) {
+      const element = unwrapWrappers(getZodDef(inner).element);
+      if (isPlainZodString(element) && !isManifestScopedSchema(element)) {
+        throw new Error(
+          `defineGameContract: state.${scope}.${key} uses z.array(z.string()) but its name identifies it as manifest-scoped '${match.name}' values. Use z.array(gameContract.schemas.${match.name}) (or manifest.ids.${match.name}) so the branded literal union flows through state types.`
+        );
+      }
+    }
+  }
+}
+function validateDefineGamePhaseNames(definition) {
+  const contractPhaseNames = definition.contract.phaseNames;
+  if (!Array.isArray(contractPhaseNames)) {
+    return;
+  }
+  const declared = new Set(contractPhaseNames);
+  const actual = new Set(Object.keys(definition.phases));
+  const missing = [...declared].filter((name) => !actual.has(name));
+  const extra = [...actual].filter((name) => !declared.has(name));
+  if (missing.length > 0 || extra.length > 0) {
+    const parts = [];
+    if (missing.length > 0) {
+      parts.push(`missing: [${missing.join(", ")}]`);
+    }
+    if (extra.length > 0) {
+      parts.push(`extra: [${extra.join(", ")}]`);
+    }
+    throw new Error(
+      `defineGame: phases record does not match contract.phaseNames (${parts.join(
+        "; "
+      )}). Update contract.phaseNames or the phases record so they agree.`
+    );
+  }
+  if (definition.initialPhase !== void 0 && !declared.has(definition.initialPhase)) {
+    throw new Error(
+      `defineGame: initialPhase '${definition.initialPhase}' is not declared in contract.phaseNames.`
+    );
+  }
+}
+function validateDefineGamePhases(definition) {
+  for (const [phaseName, phase] of Object.entries(definition.phases)) {
+    const phaseRecord = typeof phase === "object" && phase !== null ? phase : null;
+    for (const interaction of Object.values(phaseRecord?.interactions ?? {})) {
+      validateInteractionLikeDefinition(
+        interaction,
+        "defineInteraction"
+      );
+    }
+    if (!phaseRecord || phaseRecord.kind !== "simultaneousPlayer") {
+      continue;
+    }
+    if (!phaseRecord.submit) {
+      throw new Error(
+        `defineGame: phases.${phaseName} is kind 'simultaneousPlayer' but does not declare submit.`
+      );
+    }
+    if (typeof phaseRecord.resolve !== "function") {
+      throw new Error(
+        `defineGame: phases.${phaseName} is kind 'simultaneousPlayer' but does not declare resolve.`
+      );
+    }
+    if (phaseRecord.interactions?.submit) {
+      throw new Error(
+        `defineGame: phases.${phaseName}.interactions.submit conflicts with the reserved simultaneous submit interaction id.`
+      );
+    }
+    validateInteractionLikeDefinition(
+      phaseRecord.submit,
+      `defineGame: phases.${phaseName}.submit`
+    );
+  }
+}
+
+// src/reducer/authoring/steps.ts
+var InteractionSteps = class _InteractionSteps {
+  constructor(entries = []) {
+    this.entries = entries;
+  }
+  entries;
+  input(key, collector) {
+    if (this.entries.some((entry) => entry.key === key)) {
+      throw new Error(`Duplicate interaction step '${key}'.`);
+    }
+    const factory = typeof collector === "function" ? collector : () => collector;
+    const resolve = (args) => {
+      const resolved = factory(args);
+      if (resolved.kind === "rng")
+        throw new Error("Interaction steps cannot contain RNG collectors.");
+      validateInteractionInputsSchema({ [key]: resolved }, "defineInteraction");
+      return resolved;
+    };
+    if (typeof collector !== "function" && collector.kind === "rng") {
+      throw new Error("Interaction steps cannot contain RNG collectors.");
+    }
+    if (typeof collector !== "function")
+      validateInteractionInputsSchema(
+        { [key]: collector },
+        "defineInteraction"
+      );
+    return new _InteractionSteps([...this.entries, { key, resolve }]);
+  }
+};
+
+// src/reducer/inputs/formInput.ts
+import { z as z4 } from "zod";
+function isResourceMapChoiceSource(choices) {
+  return choices === "resourceMap" || typeof choices === "object" && choices !== null && !Array.isArray(choices) && "source" in choices && choices.source === "resourceMap";
+}
+function resolveDomainNumber(value, context, fallback) {
+  if (typeof value === "function") return value(context);
+  return value ?? fallback;
+}
+function resolveDomainChoices(choices, context) {
+  if (isResourceMapChoiceSource(choices)) {
+    return resolveResourceMapChoices(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) {
+  if (choices.length === 0) return z4.never();
+  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 z4.null();
+  }
+  const stringSchema = z4.enum(
+    stringValues
+  );
+  if (hasNull) {
+    return z4.union([stringSchema, z4.null()]);
+  }
+  return stringSchema;
+}
+function resolveResourceMapChoices(choices, context) {
+  const firstPlayerId = context.state.table.playerOrder[0];
+  const firstResourceMap = firstPlayerId === void 0 ? void 0 : context.state.table.resources[firstPlayerId];
+  if (typeof firstResourceMap !== "object" || firstResourceMap === null || Array.isArray(firstResourceMap)) {
+    return [];
+  }
+  const decorate = choices === "resourceMap" ? void 0 : choices.decorate;
+  return Object.keys(firstResourceMap).sort().map((resourceId) => {
+    const label = resourceId;
+    const presentation = decorate?.({ ...context, resourceId, label });
+    return {
+      value: resourceId,
+      label,
+      badge: presentation?.badge,
+      description: presentation?.description,
+      disabled: presentation?.disabled,
+      disabledReason: presentation?.disabledReason
+    };
+  });
+}
+function createFormInput(schema, options) {
+  return {
+    kind: "form",
+    schema,
+    ...options && "defaultValue" in options ? { defaultValue: options.defaultValue } : {}
+  };
+}
+function baseFormInput(schema, options) {
+  return createFormInput(schema, options);
+}
+function resourceMapInput(options) {
+  return {
+    kind: "form",
+    schema: z4.record(z4.string(), z4.number().int().nonnegative()),
+    ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
+    domain: (state, playerId, q) => {
+      const context = {
+        state,
+        playerId,
+        q
+      };
+      return {
+        type: "resourceMap",
+        resources: options.resources.map((resource) => ({
+          resourceId: resource.resourceId,
+          label: resource.label,
+          icon: resource.icon,
+          min: resolveDomainNumber(resource.min, context, 0),
+          max: resolveDomainNumber(resource.max, context, 0)
+        }))
+      };
+    }
+  };
+}
+function numberInput(options) {
+  return {
+    kind: "form",
+    schema: z4.number(),
+    ..."defaultValue" in options ? { defaultValue: options.defaultValue } : {},
+    domain: (state, playerId, q) => {
+      const context = {
+        state,
+        playerId,
+        q
+      };
+      return {
+        type: "boundedNumber",
+        min: resolveDomainNumber(options.min, context, 0),
+        max: resolveDomainNumber(options.max, context, 0),
+        step: options.step === void 0 ? void 0 : resolveDomainNumber(options.step, context, 1)
+      };
+    }
+  };
+}
+function choiceInput(options) {
+  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) : z4.string().nullable();
+  const dynamicDefault = typeof options.defaultValue === "function" ? options.defaultValue : void 0;
+  return {
+    kind: "form",
+    schema,
+    ...hasStaticDefault ? { defaultValue: staticDefault } : {},
+    domain: (state, playerId, q) => {
+      const context = {
+        state,
+        playerId,
+        q
+      };
+      const choices = resolveDomainChoices(options.choices, context);
+      if (hasStaticDefault) {
+        assertChoiceDefaultInChoices(
+          "formInput.choice",
+          choices,
+          staticDefault
+        );
+      }
+      return {
+        type: "choice",
+        choices
+      };
+    },
+    ...dynamicDefault ? {
+      resolveDefaultValue: (state, playerId, q, 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,
+          choices
+        });
+        if (resolved === void 0) return void 0;
+        assertChoiceDefaultInChoices("formInput.choice", choices, resolved);
+        return resolved;
+      }
+    } : {}
+  };
+}
+function choiceListInput(options) {
+  if (Array.isArray(options.choices) && options.choices.length === 0) {
+    throw new Error("formInput.choiceList requires at least one choice.");
+  }
+  const staticDefaultValue = Array.isArray(options.defaultValue) ? options.defaultValue : void 0;
+  const dynamicDefaultValue = options.defaultValue === "all" || typeof options.defaultValue === "function" ? options.defaultValue : void 0;
+  return {
+    kind: "form",
+    schema: z4.array(z4.string()),
+    ...staticDefaultValue !== void 0 ? { defaultValue: staticDefaultValue } : {},
+    domain: (state, playerId, q) => {
+      const context = {
+        state,
+        playerId,
+        q
+      };
+      const choices = resolveDomainChoices(options.choices, context).map(
+        (choice) => ({
+          ...choice,
+          value: choice.value
+        })
+      );
+      return {
+        type: "choiceList",
+        choices,
+        min: resolveDomainNumber(options.min, context, 0),
+        max: resolveDomainNumber(options.max, context, choices.length)
+      };
+    },
+    ...dynamicDefaultValue ? {
+      resolveDefaultValue: (state, playerId, q, domain) => {
+        const choices = domain.type === "choiceList" ? 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
+        })) : [];
+        if (dynamicDefaultValue === "all") {
+          return choices.map((choice) => choice.value);
+        }
+        return dynamicDefaultValue({
+          state,
+          playerId,
+          q,
+          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) => ({
+    source: "resourceMap",
+    ...options
+  }),
+  number: numberInput,
+  choice: choiceInput,
+  choiceList: choiceListInput,
+  forState: formInputForState
+});
+
+// src/reducer/inputs/boardInput.ts
+import { z as z5 } from "zod";
+function makeBoardCollector(kind) {
+  return function collector(options) {
+    const target = options.target;
+    return {
+      kind,
+      schema: z5.string(),
+      eligibleTargets: ((state, playerId, q) => target.eligible({
+        state,
+        playerId,
+        q
+      })),
+      validateTarget: ((state, playerId, q, targetId) => target.validate(
+        {
+          state,
+          playerId,
+          q
+        },
+        targetId
+      )),
+      domain: (state, playerId, q) => ({
+        type: "boardTarget",
+        projection: "resolved",
+        targetKind: target.targetKind,
+        boardId: target.boardId,
+        valueKind: "board-id",
+        eligibleTargets: target.eligible({
+          state,
+          playerId,
+          q
+        })
+      }),
+      meta: {
+        targetKind: target.targetKind,
+        boardId: target.boardId,
+        valueKind: "board-id"
+      }
+    };
+  };
+}
+var vertexInput = makeBoardCollector("board-vertex");
+var edgeInput = makeBoardCollector("board-edge");
+var tileInput = makeBoardCollector("board-tile");
+var spaceInput = makeBoardCollector("board-space");
+function playerSpaceInput(options) {
+  const target = options.target;
+  const playerIdSchema = markManifestScopedSchema(
+    z5.string(),
+    "playerId"
+  );
+  return {
+    kind: "board-space",
+    schema: z5.strictObject({
+      boardId: z5.literal(target.boardId),
+      playerId: playerIdSchema,
+      spaceId: z5.string()
+    }),
+    eligibleTargets: ((state, playerId, q) => target.eligible({
+      state,
+      playerId,
+      q
+    })),
+    validateTarget: ((state, playerId, q, targetValue) => target.validate(
+      {
+        state,
+        playerId,
+        q
+      },
+      targetValue
+    )),
+    domain: (state, playerId, q) => ({
+      type: "boardTarget",
+      projection: "resolved",
+      targetKind: "space",
+      boardId: target.boardId,
+      valueKind: "player-board-space",
+      eligibleTargets: target.eligible({
+        state,
+        playerId,
+        q
+      })
+    }),
+    meta: {
+      targetKind: target.targetKind,
+      boardId: target.boardId,
+      valueKind: "player-board-space"
+    }
+  };
+}
+var boardInput = {
+  vertex: vertexInput,
+  edge: edgeInput,
+  tile: tileInput,
+  space: spaceInput,
+  playerSpace: playerSpaceInput
+};
+
+// src/reducer/inputs/targetRule.ts
+var DEFAULT_MISSING_CANDIDATE_ISSUE = {
+  errorCode: "TARGET_NOT_ELIGIBLE",
+  message: "Target is not eligible."
+};
+function createTargetRule(candidates, predicates, options = {}) {
+  const missingCandidateIssue = options.missingCandidateIssue ?? DEFAULT_MISSING_CANDIDATE_ISSUE;
+  const equals = options.equals ?? Object.is;
+  const validate = (ctx, target) => {
+    if (!candidates(ctx).some((candidate) => equals(candidate, target))) {
+      return missingCandidateIssue;
+    }
+    for (const predicate of predicates) {
+      if (!predicate.test({ ...ctx, targetId: target, target })) {
+        return {
+          errorCode: predicate.errorCode,
+          message: predicate.message
+        };
+      }
+    }
+    return null;
+  };
+  const rule = {
+    eligible: (ctx) => candidates(ctx).filter((targetId) => validate(ctx, targetId) == null),
+    validate,
+    isEligible: (ctx, target) => validate(ctx, target) == null,
+    bind: (ctx) => ({
+      eligible: () => rule.eligible(ctx),
+      validate: (id) => rule.validate(ctx, id),
+      isEligible: (id) => rule.isEligible(ctx, id)
+    })
+  };
+  return rule;
+}
+function createTargetRuleBuilder(buildRule, predicates = []) {
+  return {
+    where: (predicate) => createTargetRuleBuilder(buildRule, [...predicates, predicate]),
+    build: () => buildRule(predicates)
+  };
+}
+
+// src/reducer/inputs/boardTarget.ts
+function candidateIdsForKind(q, boardId, targetKind) {
+  const board = q.board(boardId).state;
+  if (targetKind === "edge")
+    return idsFromCollection(board.layout === "generic" ? [] : board.edges);
+  if (targetKind === "vertex")
+    return idsFromCollection(
+      board.layout === "generic" ? [] : board.vertices
+    );
+  return idsFromCollection(board.spaces);
+}
+function idsFromCollection(collection) {
+  if (!collection) return [];
+  const values = Array.isArray(collection) ? collection : Object.values(collection);
+  return values.flatMap((value) => {
+    if (typeof value === "string") return [value];
+    if (typeof value === "object" && value !== null && "id" in value && typeof value.id === "string") {
+      return [value.id];
+    }
+    return [];
+  });
+}
+function createBoardTargetBuilder(targetKind, boardId) {
+  return createTargetRuleBuilder(
+    (predicates) => ({
+      ...createTargetRule(
+        ({ q }) => candidateIdsForKind(q, boardId, targetKind),
+        predicates,
+        {
+          missingCandidateIssue: {
+            errorCode: "BOARD_TARGET_NOT_ELIGIBLE",
+            message: "Board target is not eligible."
+          }
+        }
+      ),
+      boardId,
+      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) && samePlayerBoardSpaceTarget(left, right)
+      }
+    ),
+    boardId,
+    targetKind: "space",
+    valueKind: "player-board-space"
+  }));
+}
+function makeBoardTargetFactory(targetKind) {
+  return function target(boardId) {
+    return createBoardTargetBuilder(targetKind, boardId);
+  };
+}
+var boardTarget = {
+  edge: makeBoardTargetFactory("edge"),
+  vertex: makeBoardTargetFactory("vertex"),
+  space: makeBoardTargetFactory("space"),
+  tile: makeBoardTargetFactory("tile"),
+  playerSpace(boardId) {
+    return createPlayerSpaceTargetBuilder(boardId);
+  }
+};
+
+// src/reducer/inputs/cardTarget.ts
+function cardIdsForZone(state, playerId, q, zoneId) {
+  const table = state.table;
+  if (zoneId in (table.hands ?? {}) || zoneId in (table.zones?.perPlayer ?? {})) {
+    return q.zone.playerCards(
+      playerId,
+      zoneId
+    );
+  }
+  if (zoneId in (table.decks ?? {}) || zoneId in (table.zones?.shared ?? {})) {
+    return q.zone.sharedCards(zoneId);
+  }
+  return [];
+}
+function createCardTargetBuilder(zoneIds) {
+  return createTargetRuleBuilder(
+    (predicates) => ({
+      ...createTargetRule(
+        ({ state, playerId, q }) => zoneIds.flatMap(
+          (zoneId) => cardIdsForZone(state, playerId, q, zoneId)
+        ),
+        predicates,
+        {
+          missingCandidateIssue: {
+            errorCode: "CARD_TARGET_NOT_ELIGIBLE",
+            message: "Card target is not eligible."
+          }
+        }
+      ),
+      zoneIds,
+      zoneId: zoneIds[0],
+      targetKind: "card"
+    })
+  );
+}
+var cardTarget = {
+  zones(zoneIds) {
+    return createCardTargetBuilder(zoneIds);
+  }
+};
+
+// src/reducer/inputs/cardInput.ts
+import { z as z6 } from "zod";
+function cardInput(options) {
+  const target = options.target;
+  return {
+    kind: "card",
+    schema: z6.string(),
+    eligibleTargets: ((state, playerId, q) => target.eligible({
+      state,
+      playerId,
+      q
+    })),
+    validateTarget: ((state, playerId, q, targetId) => target.validate(
+      {
+        state,
+        playerId,
+        q
+      },
+      targetId
+    )),
+    domain: (state, playerId, q) => ({
+      type: "cardTarget",
+      projection: "resolved",
+      targetKind: target.targetKind,
+      zoneIds: target.zoneIds,
+      eligibleTargets: target.eligible({
+        state,
+        playerId,
+        q
+      }).map(String)
+    }),
+    meta: {
+      zoneId: target.zoneId,
+      zoneIds: target.zoneIds,
+      targetKind: target.targetKind
+    }
+  };
+}
+
+// src/reducer/inputs/rngInput.ts
+import { z as z7 } from "zod";
+function d6(count = 1) {
+  return {
+    kind: "rng",
+    schema: z7.object({
+      values: z7.array(z7.number().int().min(1).max(6)).length(count)
+    }),
+    meta: { rng: "d6", count }
+  };
+}
+function coin() {
+  return {
+    kind: "rng",
+    schema: z7.object({
+      value: z7.enum(["heads", "tails"])
+    }),
+    meta: { rng: "coin" }
+  };
+}
+var rngInput = { d6, coin };
+
+// src/reducer/inputs/many.ts
+import { z as z8 } from "zod";
+function normalizeManyOptions(options) {
+  if ("count" in options) {
+    assertNonNegativeInteger(options.count, "many(...).count");
+    return {
+      mode: "many",
+      min: options.count,
+      max: options.count,
+      distinct: options.distinct
+    };
+  }
+  const min = options.min ?? 0;
+  assertNonNegativeInteger(min, "many(...).min");
+  if (options.max !== void 0) {
+    assertNonNegativeInteger(options.max, "many(...).max");
+    if (options.max < min) {
+      throw new Error("many(...).max must be greater than or equal to min.");
+    }
+  }
+  return {
+    mode: "many",
+    min,
+    max: options.max,
+    distinct: options.distinct
+  };
+}
+function assertNonNegativeInteger(value, label) {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer.`);
+  }
+}
+function many(collector, options) {
+  if (collector.kind === "rng") {
+    throw new Error("many(...) cannot wrap rngInput collectors.");
+  }
+  const selection = normalizeManyOptions(options);
+  const rest = { ...collector };
+  delete rest.schema;
+  delete rest.selection;
+  delete rest.defaultValue;
+  return {
+    ...rest,
+    schema: z8.array(
+      collector.schema
+    ),
+    selection
+  };
+}
+
+// src/reducer/authoring/interaction.ts
+function defineInteraction() {
+  return (definition) => {
+    validateInteractionLikeDefinition(
+      definition,
+      "defineInteraction"
+    );
+    return definition;
+  };
+}
+function defineInteractionRule() {
+  return (definition) => definition;
+}
+
+// src/reducer/authoring/phase.ts
+function definePhase() {
+  return (definition) => {
+    return definition;
+  };
+}
+
+// src/reducer/authoring/views.ts
+function defineView() {
+  return (view) => view;
+}
+
+// src/reducer/authoring/contract-authoring.ts
+var PHANTOM_TYPES_MESSAGE = "`.types` is a compile-time carrier: use it only in `typeof` positions.";
+function phantomTypes() {
+  return new Proxy(Object.freeze({}), {
+    get() {
+      throw new TypeError(PHANTOM_TYPES_MESSAGE);
+    }
+  });
+}
+function toPredicateList(where) {
+  if (!where) return [];
+  return Array.isArray(where) ? where : [where];
+}
+function applyWhere(builder, where) {
+  return toPredicateList(where).reduce(
+    (current, predicate) => current.where(predicate),
+    builder
+  );
+}
+function createFusedCardInput() {
+  return ((options) => {
+    const target = applyWhere(
+      cardTarget.zones(options.from),
+      options.where
+    ).build();
+    return cardInput({
+      target
+    });
+  });
+}
+function createFusedBoardInputs() {
+  const fuse = (kind) => (options) => {
+    const target = applyWhere(
+      boardTarget[kind](options.boardId),
+      options.where
+    ).build();
+    return boardInput[kind]({
+      target
+    });
+  };
+  const playerSpace = (options) => boardInput.playerSpace({
+    target: applyWhere(
+      boardTarget.playerSpace(options.boardId),
+      options.where
+    ).build()
+  });
+  return {
+    vertex: fuse("vertex"),
+    edge: fuse("edge"),
+    space: fuse("space"),
+    tile: fuse("tile"),
+    playerSpace
+  };
+}
+function createBoundInputBuilders() {
+  return {
+    board: createFusedBoardInputs(),
+    card: createFusedCardInput(),
+    form: formInput.forState(),
+    rng: rngInput
+  };
+}
+function createPhaseAuthoring(_contract, schema) {
+  return {
+    steps: () => new InteractionSteps(),
+    interaction: defineInteraction(),
+    rule: (rule) => defineInteractionRule()(
+      rule
+    ),
+    define: (definition) => definePhase()({
+      ...definition,
+      state: schema
+    }),
+    inputs: createBoundInputBuilders(),
+    types: phantomTypes()
+  };
+}
+function createContractAuthoring(contract) {
+  const phaseCache = /* @__PURE__ */ new Map();
+  const assemble = (definition) => {
+    const game = { ...definition, contract };
+    validateDefineGamePhaseNames(game);
+    validateDefineGamePhases(game);
+    return { ...game, [validatedReducerDefinition]: true };
+  };
+  return {
+    contract,
+    view: defineView(),
+    types: phantomTypes(),
+    assemble,
+    phase: (name) => {
+      const cached = phaseCache.get(name);
+      if (cached) return cached;
+      const schema = contract.phases[name];
+      const bound = createPhaseAuthoring(contract, schema);
+      phaseCache.set(name, bound);
+      return bound;
+    }
+  };
+}
+
+// src/reducer/authoring/contract.ts
+import { z as z9 } from "zod";
+function validateErrorMap(errors) {
+  if (!errors) return;
+  const codePattern = /^[A-Z][A-Z0-9_]*$/;
+  for (const [code, message] of Object.entries(errors)) {
+    if (!codePattern.test(code)) {
+      throw new Error(
+        `defineGameContract: error code '${code}' must use UPPER_SNAKE_CASE.`
+      );
+    }
+    if (typeof message !== "string" || message.length === 0) {
+      throw new Error(
+        `defineGameContract: error code '${code}' must declare a non-empty default message.`
+      );
+    }
+  }
+}
+function validateOptionsSchema(schema) {
+  z9.toJSONSchema(schema, {
+    override: ({ zodSchema }) => {
+      const definition = zodSchema._zod.def;
+      if (definition.type === "pipe" || "coerce" in definition && definition.coerce || definition.checks?.some((check) => check._zod.def.check === "overwrite")) {
+        throw new Error(
+          "Game options schemas must not transform or coerce persisted values."
+        );
+      }
+    }
+  });
+}
+function defineGameContract(definition) {
+  validateStateSchemaIdBranding(definition.state.public, "public");
+  validateStateSchemaIdBranding(definition.state.private, "private");
+  validateStateSchemaIdBranding(definition.state.hidden, "hidden");
+  validateErrorMap(definition.errors);
+  const optionsSchema = definition.options ?? z9.strictObject({});
+  validateOptionsSchema(optionsSchema);
+  const phaseNames = Object.keys(definition.phases);
+  if (phaseNames.length === 0) {
+    throw new Error(
+      "defineGameContract: phases must be a non-empty record of phase schemas."
+    );
+  }
+  for (const name of phaseNames) {
+    if (typeof name !== "string" || name.length === 0) {
+      throw new Error(
+        "defineGameContract: phase names must be non-empty strings."
+      );
+    }
+  }
+  const phaseNameSchema = createManifestStringLiteralSchema(phaseNames);
+  const narrowedManifest = {
+    ...definition.manifest,
+    literals: {
+      ...definition.manifest.literals,
+      phaseNames
+    },
+    ids: {
+      ...definition.manifest.ids,
+      phaseName: phaseNameSchema
+    }
+  };
+  const contract = {
+    manifest: narrowedManifest,
+    state: definition.state,
+    phases: definition.phases,
+    errors: definition.errors,
+    options: optionsSchema,
+    phaseNames,
+    schemas: narrowedManifest.ids
+  };
+  return contract;
+}
+
+// src/reducer/authoring/game.ts
+function createGame(model) {
+  const manifest = "literals" in model.manifest ? model.manifest : compileManifest(model.manifest);
+  return createContractAuthoring(defineGameContract({ ...model, manifest }));
+}
+
+// src/reducer/game-event.ts
+var gameEvent = {
+  systemAction(event) {
+    return {
+      kind: "systemAction",
+      ...event
+    };
+  }
+};
+
+// src/reducer/memoize.ts
+function memoize(fn) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  return (a) => {
+    if (cache.has(a)) return cache.get(a);
+    const value = fn(a);
+    cache.set(a, value);
+    return value;
+  };
+}
+
+// src/reducer/manifest/authoring.ts
+function defineTopologyManifest(manifest) {
+  const validated = structuredClone(manifest);
+  assertValidManifest(
+    validated
+  );
+  return validated;
 }
 export {
   FrameworkErrorCodes,
-  StaleContractArtifactError,
+  REDUCER_CONTRACT_VERSION,
+  runtime_schema_exports as ReducerWireZod,
   asPlayerId,
   assertCardAllowedInContainer,
+  assertReducerBundleContract,
   boardRef,
   boardRefKey,
   boardRefSchema,
   compileManifest,
-  contractFingerprint,
-  createDerivedResolver,
   createGame,
   createReducerBundle,
-  createReducerOps,
   createStateQueries,
   createTableQueries,
-  defineDerived,
-  defineEffect,
-  defineInputs,
+  defineTopologyManifest,
+  fromCoordinates,
   gameEvent,
-  isPerPlayer,
+  hexagon,
   isPerPlayerBoardRef,
   isPlayerId,
   isSharedBoardRef,
-  isStaleContractArtifactError,
   many,
+  materializeManifestTable,
+  memoize,
   noopDiagnosticsSink,
   normalizeCommandParams,
   parseBoardRefKey,
-  perPlayer,
   perPlayerBoardRef,
-  perPlayerEntries,
-  perPlayerGet,
-  perPlayerHas,
-  perPlayerKeys,
-  perPlayerMap,
-  perPlayerRequire,
-  perPlayerSchema,
-  perPlayerSet,
-  perPlayerSize,
-  perPlayerValues,
-  pipe,
-  setActivePlayers,
+  rectangle,
+  ring,
   sharedBoardRef,
   sparseCounts,
-  sparseMap
+  sparseMap,
+  spiral
 };
 //# sourceMappingURL=reducer.js.map