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

package/dist/{chunk-MYKS6MTR.js → chunk-ZZGN2ATS.js}

@@ -1,13 +1,26 @@
 import {
+  asPlayerId,
+  assumeManifestSchema,
   cardInput,
   cardTarget,
+  createManifestGameStateSchema,
+  createManifestRuntimeSchema,
   createManifestStringLiteralSchema,
   createTargetRule,
   createTargetRuleBuilder,
   isManifestScopedSchema,
   isPerPlayer,
-  markManifestScopedSchema
-} from "./chunk-EHPEMPRZ.js";
+  markManifestScopedSchema,
+  perPlayer,
+  perPlayerSchema
+} from "./chunk-H6VDGFL5.js";
+import {
+  buildTypedRecord
+} from "./chunk-5YV2WHJ4.js";
+import {
+  analyzeManifest,
+  materializeManifestTable
+} from "./chunk-Z7QCREWI.js";
 
 // src/reducer/schema-helpers.ts
 import { z } from "zod";
@@ -786,6 +799,585 @@ function coin() {
 }
 var rngInput = { d6, coin };
 
+// src/reducer/manifest/compiler.ts
+import { z as z7 } from "zod";
+
+// src/reducer/manifest/schema.ts
+import { z as z6 } from "zod";
+function createTableSchema(analysis, ids) {
+  const unknownRecordSchema = z6.record(z6.string(), z6.unknown());
+  const objectSchema = (schema) => schema && Object.keys(schema.properties).length ? z6.object(
+    Object.fromEntries(
+      Object.entries(schema.properties).map(([key, value]) => [
+        key,
+        propertySchema(value)
+      ])
+    )
+  ) : unknownRecordSchema;
+  function propertySchema(schema) {
+    if (!schema) return z6.unknown();
+    let result;
+    switch (schema.type) {
+      case "string":
+        result = z6.string();
+        break;
+      case "integer":
+        result = z6.number().int();
+        break;
+      case "number":
+        result = z6.number();
+        break;
+      case "boolean":
+        result = z6.boolean();
+        break;
+      case "enum":
+        result = schema.enums?.length ? z6.enum(schema.enums) : z6.string();
+        break;
+      case "array":
+        result = z6.array(propertySchema(schema.items));
+        break;
+      case "record":
+        result = z6.record(z6.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) => z6.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 z6.object({
+        componentType: z6.string().optional(),
+        id: z6.literal(id),
+        cardSetId: z6.literal(setId),
+        cardType: z6.literal(type),
+        name: z6.string().optional(),
+        text: z6.string().optional(),
+        properties
+      });
+    }
+  );
+  const pieceStateByIdSchema = shape(
+    analysis.pieceIds,
+    (id) => id,
+    (id) => {
+      const type = analysis.pieceTypeIdByPieceId.get(id);
+      return z6.object({
+        componentType: z6.string().optional(),
+        id: z6.literal(id),
+        pieceTypeId: z6.literal(type),
+        pieceName: z6.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 z6.object({
+        componentType: z6.string().optional(),
+        id: z6.literal(id),
+        dieTypeId: z6.literal(type),
+        dieName: z6.string().nullish(),
+        ownerId: ids.playerId.nullish(),
+        sides: z6.literal(
+          analysis.manifest.dieTypes?.find((die) => die.id === type)?.sides ?? 6
+        ),
+        value: z6.number().int().nullish(),
+        properties: objectSchema(analysis.dieTypeSchemasById.get(type))
+      });
+    }
+  );
+  const sharedZoneSchema = shape(
+    analysis.sharedZones,
+    (zone) => zone.id,
+    () => z6.array(ids.cardId)
+  );
+  const playerZoneSchema = shape(
+    analysis.playerZones,
+    (zone) => zone.id,
+    () => perPlayerSchema(z6.array(ids.cardId))
+  );
+  const zoneIdSchema = ids.zoneId;
+  const playerZoneIdSchema = ids.playerZoneId;
+  const slotVariants = analysis.strictSlotHosts.flatMap(
+    (host) => host.slotIds.map(
+      (slotId) => z6.object({
+        type: z6.literal("InSlot"),
+        host: z6.object({ kind: z6.literal(host.kind), id: z6.literal(host.id) }),
+        slotId: z6.literal(slotId),
+        position: z6.number().int().nullish()
+      })
+    )
+  );
+  const slotLocationSchema = slotVariants.length ? z6.union(
+    slotVariants
+  ) : z6.never();
+  const boardSpaceTypeIdSchema = ids.spaceTypeId.nullable().optional();
+  const boardSpaceStateSchema = z6.object({
+    id: ids.spaceId,
+    name: z6.string().nullable().optional(),
+    typeId: boardSpaceTypeIdSchema,
+    fields: unknownRecordSchema,
+    zoneId: z6.string().nullable().optional()
+  });
+  const hexSpaceStateSchema = boardSpaceStateSchema.extend({
+    q: z6.number().int(),
+    r: z6.number().int()
+  });
+  const squareSpaceStateSchema = boardSpaceStateSchema.extend({
+    row: z6.number().int(),
+    col: z6.number().int()
+  });
+  const boardRelationStateSchema = z6.object({
+    id: z6.string().nullable().optional(),
+    typeId: ids.relationTypeId,
+    fromSpaceId: ids.spaceId,
+    toSpaceId: ids.spaceId,
+    directed: z6.boolean(),
+    fields: unknownRecordSchema
+  });
+  const boardContainerStateSchema = z6.object({
+    id: ids.boardContainerId,
+    name: z6.string(),
+    host: z6.discriminatedUnion("type", [
+      z6.object({ type: z6.literal("board") }),
+      z6.object({ type: z6.literal("space"), spaceId: ids.spaceId })
+    ]),
+    allowedCardSetIds: z6.array(ids.cardSetId).optional(),
+    zoneId: z6.string(),
+    fields: unknownRecordSchema
+  });
+  const runtimeGenericBoardStateSchema = z6.object({
+    id: ids.boardId,
+    baseId: ids.boardBaseId,
+    layout: z6.literal("generic"),
+    typeId: ids.boardTypeId.nullable().optional(),
+    scope: z6.enum(["shared", "perPlayer"]),
+    playerId: ids.playerId.nullable().optional(),
+    templateId: z6.string().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: z6.record(z6.string(), boardSpaceStateSchema),
+    relations: z6.array(boardRelationStateSchema),
+    containers: z6.record(z6.string(), boardContainerStateSchema)
+  });
+  const hexEdgeStateSchema = z6.object({
+    id: ids.edgeId,
+    spaceIds: z6.array(ids.spaceId).min(1).max(2),
+    typeId: ids.edgeTypeId.nullable().optional(),
+    label: z6.string().nullable().optional(),
+    ownerId: ids.playerId.nullable().optional(),
+    fields: unknownRecordSchema
+  });
+  const hexVertexStateSchema = z6.object({
+    id: ids.vertexId,
+    spaceIds: z6.array(ids.spaceId).min(1).max(3),
+    typeId: ids.vertexTypeId.nullable().optional(),
+    label: z6.string().nullable().optional(),
+    ownerId: ids.playerId.nullable().optional(),
+    fields: unknownRecordSchema
+  });
+  const squareVertexStateSchema = z6.object({
+    id: ids.vertexId,
+    spaceIds: z6.array(ids.spaceId).min(1).max(4),
+    typeId: ids.vertexTypeId.nullable().optional(),
+    label: z6.string().nullable().optional(),
+    ownerId: ids.playerId.nullable().optional(),
+    fields: unknownRecordSchema
+  });
+  const runtimeHexBoardStateSchema = runtimeGenericBoardStateSchema.extend({
+    layout: z6.literal("hex"),
+    // T220: loose-keyed by string — see comment above.
+    spaces: z6.record(z6.string(), hexSpaceStateSchema),
+    relations: z6.array(boardRelationStateSchema),
+    containers: z6.object({}),
+    orientation: z6.enum(["pointy-top", "flat-top"]),
+    edges: z6.array(hexEdgeStateSchema),
+    vertices: z6.array(hexVertexStateSchema)
+  });
+  const runtimeSquareBoardStateSchema = runtimeGenericBoardStateSchema.extend({
+    layout: z6.literal("square"),
+    // T220: loose-keyed by string — see comment above.
+    spaces: z6.record(z6.string(), squareSpaceStateSchema),
+    relations: z6.array(boardRelationStateSchema),
+    containers: z6.record(z6.string(), boardContainerStateSchema),
+    edges: z6.array(hexEdgeStateSchema),
+    vertices: z6.array(squareVertexStateSchema)
+  });
+  const boards = analysis.analyzedBoards.flatMap(
+    (board) => board.runtimeBoardIds.map((id) => {
+      const base = {
+        id: board.board.scope === "perPlayer" ? z6.templateLiteral([board.board.id, ":", z6.string().min(1)]) : z6.literal(id),
+        baseId: z6.literal(board.board.id),
+        scope: z6.literal(board.board.scope),
+        fields: objectSchema(board.boardFieldsSchema)
+      };
+      const spaces = boardSpaceStateSchema.extend({
+        fields: objectSchema(board.spaceFieldsSchema)
+      });
+      const relations = z6.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: z6.literal(item.id),
+          fields: objectSchema(board.containerFieldsSchema)
+        })
+      ) : z6.object({});
+      if (board.layout === "generic")
+        return {
+          id,
+          scope: board.board.scope,
+          layout: board.layout,
+          schema: runtimeGenericBoardStateSchema.extend({
+            ...base,
+            spaces: z6.record(z6.string(), spaces),
+            relations,
+            containers
+          })
+        };
+      const edges = z6.array(
+        hexEdgeStateSchema.extend({
+          fields: objectSchema(board.edgeFieldsSchema)
+        })
+      );
+      const vertices = z6.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: z6.record(
+            z6.string(),
+            spaces.extend({ q: z6.number().int(), r: z6.number().int() })
+          ),
+          edges,
+          vertices
+        }) : runtimeSquareBoardStateSchema.extend({
+          ...base,
+          spaces: z6.record(
+            z6.string(),
+            spaces.extend({
+              row: z6.number().int(),
+              col: z6.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 ? z6.union(scoped) : z6.never());
+  };
+  const boardStateByIdSchema = boardCollection(boards);
+  const hexBoardStateByIdSchema = boardCollection(
+    boards.filter((board) => board.layout === "hex")
+  );
+  const squareBoardStateByIdSchema = boardCollection(
+    boards.filter((board) => board.layout === "square")
+  );
+  return z6.object({
+    playerOrder: z6.array(ids.playerId),
+    zones: z6.object({
+      shared: sharedZoneSchema,
+      perPlayer: playerZoneSchema,
+      visibility: z6.record(
+        zoneIdSchema,
+        z6.enum(["all", "ownerOnly", "public", "hidden"])
+      ),
+      cardSetIdsByZoneId: z6.record(zoneIdSchema, z6.array(ids.cardSetId)).optional()
+    }),
+    decks: sharedZoneSchema,
+    hands: playerZoneSchema,
+    handVisibility: z6.record(
+      playerZoneIdSchema,
+      z6.enum(["all", "ownerOnly", "public", "hidden"])
+    ),
+    cards: cardStateByIdSchema,
+    pieces: pieceStateByIdSchema,
+    componentLocations: z6.record(
+      z6.string(),
+      z6.union([
+        z6.object({ type: z6.literal("Detached") }),
+        z6.object({
+          type: z6.literal("InDeck"),
+          deckId: ids.deckId,
+          playedBy: ids.playerId.nullable(),
+          position: z6.number().int().nullable().optional()
+        }),
+        z6.object({
+          type: z6.literal("InHand"),
+          handId: ids.handId,
+          playerId: ids.playerId,
+          position: z6.number().int().nullable().optional()
+        }),
+        z6.object({
+          type: z6.literal("InZone"),
+          zoneId: z6.string(),
+          playedBy: ids.playerId.nullable().optional(),
+          position: z6.number().int().nullable().optional()
+        }),
+        z6.object({
+          type: z6.literal("OnSpace"),
+          boardId: ids.boardId,
+          spaceId: ids.spaceId,
+          position: z6.number().int().nullable().optional()
+        }),
+        z6.object({
+          type: z6.literal("InContainer"),
+          boardId: ids.boardId,
+          containerId: ids.boardContainerId,
+          position: z6.number().int().nullable().optional()
+        }),
+        z6.object({
+          type: z6.literal("OnEdge"),
+          boardId: ids.boardId,
+          edgeId: ids.edgeId,
+          position: z6.number().int().nullable().optional()
+        }),
+        z6.object({
+          type: z6.literal("OnVertex"),
+          boardId: ids.boardId,
+          vertexId: ids.vertexId,
+          position: z6.number().int().nullable().optional()
+        }),
+        slotLocationSchema
+      ])
+    ),
+    ownerOfCard: z6.record(ids.cardId, ids.playerId.nullable()),
+    visibility: z6.record(
+      ids.cardId,
+      z6.object({
+        faceUp: z6.boolean(),
+        visibleTo: z6.array(ids.playerId).nullable().optional()
+      })
+    ),
+    resources: perPlayerSchema(z6.record(ids.resourceId, z6.number().int())),
+    boards: z6.object({
+      byId: boardStateByIdSchema,
+      hex: hexBoardStateByIdSchema,
+      square: squareBoardStateByIdSchema,
+      network: z6.record(z6.string(), unknownRecordSchema).default({}),
+      track: z6.record(z6.string(), unknownRecordSchema).default({})
+    }),
+    dice: dieStateByIdSchema
+  });
+}
+
+// src/reducer/manifest/compiler.ts
+function compileManifest(manifest) {
+  const source = 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,
+    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),
+    setupChoiceIdsByOptionId: Object.fromEntries(
+      analysis.setupChoiceIdsByOptionId
+    ),
+    cardSetIdsBySharedZoneId: Object.fromEntries(analysis.sharedZoneCardSetIds),
+    cardSetIdsByPlayerZoneId: Object.fromEntries(analysis.playerZoneCardSetIds)
+  };
+  const families = [
+    "phaseName",
+    "boardLayout",
+    "setupOptionId",
+    "setupProfileId",
+    "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(z7.string(), family) : values.length ? createManifestStringLiteralSchema(values, family) : markManifestScopedSchema(z7.never(), family)
+        ];
+      })
+    ),
+    playerId: markManifestScopedSchema(
+      z7.string().min(1).transform(asPlayerId),
+      "playerId"
+    )
+  };
+  const boardIdSchemas = analysis.analyzedBoards.map(
+    (board) => board.board.scope === "perPlayer" ? z7.templateLiteral([board.board.id, ":", z7.string().min(1)]) : z7.literal(board.board.id)
+  );
+  ids.boardId = markManifestScopedSchema(
+    boardIdSchemas.length ? z7.union(boardIdSchemas) : z7.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,
+      perPlayer(resolvePlayers(players), () => [])
+    ])
+  );
+  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) => perPlayer(
+      resolvePlayers(players),
+      () => Object.fromEntries(analysis.resourceIds.map((id) => [id, 0]))
+    )
+  };
+  const runtimeSchema = createManifestRuntimeSchema({
+    phaseNameSchema: z7.string(),
+    playerIdSchema: ids.playerId,
+    setupProfileIdSchema: ids.setupProfileId
+  });
+  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, "playerId"].map((family) => [
+        `${family}s`,
+        (initial2) => buildTypedRecord(
+          literals[`${family}s`],
+          initial2
+        )
+      ])
+    ),
+    tableSchema,
+    runtimeSchema,
+    schemas: { table: tableSchema, runtime: runtimeSchema },
+    staticBoards: initial.boards,
+    setupOptionsById: analysis.setupOptionsById,
+    setupChoiceIdsByOptionId: literals.setupChoiceIdsByOptionId,
+    setupProfilesById: analysis.setupProfilesById,
+    createInitialTable,
+    normalSetup: {
+      minPlayers: source.players.minPlayers,
+      maxPlayers: source.players.maxPlayers,
+      createInitialTable
+    },
+    createGameStateSchema: (config) => createManifestGameStateSchema({
+      ...config,
+      tableSchema,
+      playerIdSchema: ids.playerId,
+      setupProfileIdSchema: ids.setupProfileId
+    })
+  };
+}
+
 // src/reducer/authoring/validation.ts
 var MANIFEST_SCOPED_ID_NAMES = [
   "playerId",
@@ -1061,14 +1653,14 @@ function defineCardAction() {
 }
 
 // src/reducer/authoring/phase.ts
-import { z as z6 } from "zod";
+import { z as z8 } from "zod";
 function stepStateSchema(schema, steps) {
-  const stepSchema = z6.enum(steps);
+  const stepSchema = z8.enum(steps);
   const maybeObject = schema;
   if (typeof maybeObject.extend === "function") {
     return maybeObject.extend({ step: stepSchema });
   }
-  return z6.intersection(schema, z6.object({ step: stepSchema }));
+  return z8.intersection(schema, z8.object({ step: stepSchema }));
 }
 function unwrapStepInteractions(interactions) {
   if (!interactions) return void 0;
@@ -1332,7 +1924,8 @@ function defineGameDefinition(definition) {
   return definition;
 }
 function createGame(model) {
-  return createContractAuthoring(defineGameContract(model));
+  const manifest = "literals" in model.manifest ? model.manifest : compileManifest(model.manifest);
+  return createContractAuthoring(defineGameContract({ ...model, manifest }));
 }
 
 export {
@@ -1341,7 +1934,8 @@ export {
   normalizeCommandParams,
   defineInputs,
   many,
+  compileManifest,
   defineGameDefinition,
   createGame
 };
-//# sourceMappingURL=chunk-MYKS6MTR.js.map
+//# sourceMappingURL=chunk-ZZGN2ATS.js.map