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

package/dist/chunk-H6VDGFL5.js

@@ -1,2903 +0,0 @@
-import {
-  zod_exports
-} from "./chunk-UGH54WZ2.js";
-
-// src/reducer/model/manifest.ts
-import { z } from "zod";
-function toNonEmptyStringTuple(values) {
-  const [first, ...rest] = Array.from(values);
-  if (typeof first === "undefined") {
-    throw new Error("Expected a non-empty literal tuple");
-  }
-  return [first, ...rest];
-}
-var manifestScopedSchemas = /* @__PURE__ */ new WeakMap();
-function markManifestScopedSchema(schema, family) {
-  manifestScopedSchemas.set(schema, family);
-  return schema;
-}
-function isManifestScopedSchema(schema) {
-  return typeof schema === "object" && schema !== null && manifestScopedSchemas.has(schema);
-}
-function manifestSchemaFamily(schema) {
-  if (typeof schema !== "object" || schema === null) {
-    return void 0;
-  }
-  return manifestScopedSchemas.get(schema);
-}
-function createManifestStringLiteralSchema(values, family) {
-  const schema = values.length === 0 ? z.string() : z.enum(toNonEmptyStringTuple(values));
-  return markManifestScopedSchema(schema, family);
-}
-function assumeManifestSchema(schema) {
-  return schema;
-}
-function cloneManifestDefault(value) {
-  if (typeof globalThis.structuredClone === "function") {
-    return globalThis.structuredClone(value);
-  }
-  return JSON.parse(JSON.stringify(value));
-}
-function resolveManifestPlayerIds(manifestPlayerIds, playerIds) {
-  if (!playerIds || playerIds.length === 0) {
-    return manifestPlayerIds;
-  }
-  const knownPlayerIds = new Set(manifestPlayerIds);
-  return playerIds.filter(
-    (playerId) => knownPlayerIds.has(playerId)
-  );
-}
-function createManifestRuntimeSchema({
-  phaseNameSchema,
-  playerIdSchema,
-  setupProfileIdSchema
-}) {
-  return z.object({
-    prompts: z.array(
-      z.object({
-        id: z.string(),
-        promptId: z.string(),
-        to: playerIdSchema,
-        title: z.string().optional(),
-        payload: z.unknown().optional(),
-        options: z.array(z.object({ id: z.string(), label: z.string() })).optional(),
-        resume: z.object({ id: z.string(), data: z.unknown() })
-      })
-    ).default([]),
-    rng: z.object({
-      seed: z.number().nullable().optional(),
-      cursor: z.number().int().default(0),
-      trace: z.array(z.string()).default([]),
-      draws: z.array(zod_exports.RngDrawSchema).default([])
-    }).default({
-      seed: null,
-      cursor: 0,
-      trace: [],
-      draws: []
-    }),
-    setup: z.object({
-      profileId: setupProfileIdSchema,
-      optionValues: z.record(z.string(), z.string().nullable()).default({})
-    }).nullable().default(null),
-    simultaneous: z.object({
-      current: z.object({
-        phaseName: phaseNameSchema,
-        actors: z.array(playerIdSchema),
-        submissions: z.record(
-          z.string(),
-          z.object({
-            interactionId: z.string(),
-            params: z.unknown()
-          })
-        )
-      }).nullable()
-    }).default({ current: null }),
-    lastTransition: z.object({
-      from: phaseNameSchema,
-      to: phaseNameSchema
-    }).nullable().default(null),
-    nextInstanceId: z.number().int().default(1)
-  });
-}
-function createManifestGameStateSchema({
-  tableSchema,
-  playerIdSchema,
-  setupProfileIdSchema,
-  phaseNameSchema,
-  publicSchema,
-  privateSchema,
-  hiddenSchema,
-  phasesSchema
-}) {
-  return z.object({
-    table: tableSchema,
-    public: publicSchema,
-    private: z.record(z.string(), privateSchema),
-    hidden: hiddenSchema,
-    flow: z.object({
-      currentPhase: phaseNameSchema,
-      turn: z.number().int(),
-      round: z.number().int(),
-      activePlayers: z.array(playerIdSchema)
-    }),
-    phase: phasesSchema,
-    runtime: createManifestRuntimeSchema({
-      phaseNameSchema,
-      playerIdSchema,
-      setupProfileIdSchema
-    })
-  });
-}
-
-// src/reducer/model/error-codes.ts
-var FrameworkErrorCodes = {
-  NOT_YOUR_TURN: "NOT_YOUR_TURN",
-  WRONG_PHASE: "WRONG_PHASE",
-  WRONG_STEP: "WRONG_STEP",
-  NO_LEGAL_INPUT: "NO_LEGAL_INPUT",
-  INVALID_PARAMS: "INVALID_PARAMS",
-  UNKNOWN_INTERACTION: "UNKNOWN_INTERACTION",
-  INTERNAL_ERROR: "INTERNAL_ERROR"
-};
-
-// src/reducer/per-player.ts
-import { z as z2 } from "zod";
-function asPlayerId(raw) {
-  return raw;
-}
-function isPlayerId(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function perPlayer(ids, init) {
-  const seen = /* @__PURE__ */ new Set();
-  const entries = [];
-  for (const [index, id] of ids.entries()) {
-    if (seen.has(id)) {
-      throw new Error(`perPlayer: duplicate player id '${id}'`);
-    }
-    seen.add(id);
-    entries.push([id, init(id, index)]);
-  }
-  return { __perPlayer: true, entries };
-}
-function perPlayerKeys(value) {
-  return value.entries.map((entry) => entry[0]);
-}
-function perPlayerValues(value) {
-  return value.entries.map((entry) => entry[1]);
-}
-function perPlayerEntries(value) {
-  return value.entries;
-}
-function perPlayerSize(value) {
-  return value.entries.length;
-}
-function perPlayerHas(value, id) {
-  for (const [candidate] of value.entries) {
-    if (candidate === id) {
-      return true;
-    }
-  }
-  return false;
-}
-function perPlayerGet(value, id) {
-  for (const [candidate, v] of value.entries) {
-    if (candidate === id) {
-      return v;
-    }
-  }
-  return void 0;
-}
-function perPlayerRequire(value, id) {
-  const found = perPlayerGet(value, id);
-  if (found === void 0 && !perPlayerHas(value, id)) {
-    throw new Error(`perPlayerRequire: missing entry for player id '${id}'`);
-  }
-  return found;
-}
-function perPlayerSet(value, id, next) {
-  const entries = value.entries.slice();
-  const index = entries.findIndex((entry) => entry[0] === id);
-  if (index >= 0) {
-    entries[index] = [id, next];
-  } else {
-    entries.push([id, next]);
-  }
-  return { __perPlayer: true, entries };
-}
-function perPlayerMap(value, f) {
-  return {
-    __perPlayer: true,
-    entries: value.entries.map(
-      ([id, v], index) => [id, f(v, id, index)]
-    )
-  };
-}
-function isPerPlayer(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  const candidate = value;
-  if (candidate.__perPlayer !== true) {
-    return false;
-  }
-  if (!Array.isArray(candidate.entries)) {
-    return false;
-  }
-  return candidate.entries.every(
-    (entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string"
-  );
-}
-function perPlayerSchema(valueSchema, options = {}) {
-  const keySchema = options.playerIdSchema ?? z2.string().min(1);
-  const base = z2.object({
-    __perPlayer: z2.literal(true),
-    entries: z2.array(z2.tuple([keySchema, valueSchema]))
-  }).transform(
-    (value) => ({
-      __perPlayer: true,
-      entries: value.entries
-    })
-  );
-  if (!options.players) {
-    return base;
-  }
-  const expected = options.players;
-  return base.superRefine((value, ctx) => {
-    const seen = /* @__PURE__ */ new Set();
-    for (const [id] of value.entries) {
-      if (seen.has(id)) {
-        ctx.addIssue({
-          code: "custom",
-          message: `Duplicate player id '${id}'`
-        });
-      }
-      seen.add(id);
-    }
-    for (const expectedId of expected) {
-      if (!seen.has(expectedId)) {
-        ctx.addIssue({
-          code: "custom",
-          message: `Missing entry for player id '${expectedId}'`
-        });
-      }
-    }
-    for (const id of seen) {
-      if (!expected.some((expectedId) => expectedId === id)) {
-        ctx.addIssue({
-          code: "custom",
-          message: `Unexpected player id '${id}' (allowed: ${expected.join(", ")})`
-        });
-      }
-    }
-  });
-}
-function sharedBoardRef(baseId) {
-  return { baseId };
-}
-function perPlayerBoardRef(baseId, seat) {
-  return { baseId, seat };
-}
-function boardRef(baseId, seat) {
-  if (seat === void 0) {
-    return { baseId };
-  }
-  return { baseId, seat };
-}
-function boardRefKey(ref) {
-  return ref.seat === void 0 ? ref.baseId : `${ref.baseId}:${ref.seat}`;
-}
-function parseBoardRefKey(key) {
-  if (!key.length) {
-    return null;
-  }
-  const colon = key.indexOf(":");
-  if (colon < 0) {
-    return { baseId: key };
-  }
-  const baseId = key.slice(0, colon);
-  const seat = key.slice(colon + 1);
-  if (!baseId.length || !seat.length) {
-    return null;
-  }
-  return { baseId, seat };
-}
-function boardRefSchema(options = {}) {
-  const baseSchema = options.baseIdSchema ?? z2.string().min(1);
-  const playerSchema = options.playerIdSchema ?? z2.string().min(1);
-  const shared = z2.strictObject({ baseId: baseSchema });
-  const perPlayer2 = z2.strictObject({ baseId: baseSchema, seat: playerSchema });
-  return z2.union([perPlayer2, shared]);
-}
-function isSharedBoardRef(ref) {
-  return ref.seat === void 0;
-}
-function isPerPlayerBoardRef(ref) {
-  return ref.seat !== void 0;
-}
-
-// src/reducer/table/internal.ts
-function ppRead(value, playerId) {
-  if (value === void 0) return void 0;
-  return perPlayerGet(value, playerId);
-}
-function ppWrite(value, playerId, next) {
-  const base = value ?? { __perPlayer: true, entries: [] };
-  return perPlayerSet(base, playerId, next);
-}
-function ensureArray(value) {
-  return Array.isArray(value) ? [...value] : [];
-}
-function locationPosition(location) {
-  return "position" in location && typeof location.position === "number" ? location.position : Number.MAX_SAFE_INTEGER;
-}
-function orderedComponentIdsForLocation(table, predicate) {
-  return Object.entries(table.componentLocations).filter(([, location]) => predicate(location)).sort(
-    (left, right) => locationPosition(left[1]) - locationPosition(right[1])
-  ).map(([componentId]) => componentId);
-}
-function hasOwnKey(record, key) {
-  return Object.prototype.hasOwnProperty.call(record, key);
-}
-function isSharedZoneId(table, zoneId) {
-  return hasOwnKey(table.decks, zoneId) || hasOwnKey(table.zones.shared, zoneId);
-}
-function isPlayerZoneId(table, zoneId) {
-  return hasOwnKey(table.hands, zoneId) || hasOwnKey(table.zones.perPlayer, zoneId) || hasOwnKey(table.handVisibility, zoneId);
-}
-function zoneScopeForId(table, zoneId) {
-  if (isPlayerZoneId(table, zoneId)) {
-    return "perPlayer";
-  }
-  if (isSharedZoneId(table, zoneId)) {
-    return "shared";
-  }
-  return null;
-}
-function assertZoneScope(table, zoneId, expectedScope, operation, argumentName) {
-  const actualScope = zoneScopeForId(table, zoneId);
-  if (actualScope === expectedScope) {
-    return;
-  }
-  if (actualScope === null) {
-    throw new Error(
-      `Unknown zone '${zoneId}' passed as ${argumentName} to ${operation}.`
-    );
-  }
-  throw new Error(
-    `Zone '${zoneId}' has scope '${actualScope}', but ${operation} requires ${argumentName} to be a ${expectedScope === "shared" ? "shared" : "perPlayer"} zone.`
-  );
-}
-function syncSharedZoneWithDeck(table, zoneId, nextCards) {
-  table.decks[zoneId] = [...nextCards];
-  table.zones.shared[zoneId] = [
-    ...nextCards
-  ];
-}
-function syncPlayerZoneWithHand(table, zoneId, playerId, nextCards) {
-  table.hands[zoneId] = ppWrite(table.hands[zoneId], playerId, [
-    ...nextCards
-  ]);
-  table.zones.perPlayer[zoneId] = ppWrite(
-    table.zones.perPlayer[zoneId],
-    playerId,
-    [...nextCards]
-  );
-}
-
-// src/reducer/table/board-queries.ts
-function getBoard(table, boardId) {
-  return table.boards.byId[boardId];
-}
-function getHexBoard(table, boardId) {
-  return getBoard(table, boardId);
-}
-function getTiledBoard(table, boardId) {
-  return getBoard(table, boardId);
-}
-function getSquareBoard(table, boardId) {
-  return getBoard(table, boardId);
-}
-function getSpace(table, boardId, spaceId) {
-  return getBoard(table, boardId).spaces[spaceId];
-}
-function getHexSpace(table, boardId, spaceId) {
-  return getHexBoard(table, boardId).spaces[spaceId];
-}
-function getSquareSpace(table, boardId, spaceId) {
-  return getSquareBoard(table, boardId).spaces[spaceId];
-}
-function getContainer(table, boardId, containerId) {
-  return getBoard(table, boardId).containers[containerId];
-}
-function getEdge(table, boardId, edgeId) {
-  const edge = getTiledBoard(table, boardId).edges.find(
-    (candidate) => candidate.id === edgeId
-  );
-  if (!edge) {
-    throw new Error(`Unknown edge '${edgeId}' on board '${boardId}'.`);
-  }
-  return edge;
-}
-function getVertex(table, boardId, vertexId) {
-  const vertex = getTiledBoard(table, boardId).vertices.find(
-    (candidate) => candidate.id === vertexId
-  );
-  if (!vertex) {
-    throw new Error(`Unknown vertex '${vertexId}' on board '${boardId}'.`);
-  }
-  return vertex;
-}
-function getHexSpaceAt(table, boardId, q, r) {
-  return Object.values(getHexBoard(table, boardId).spaces).find(
-    (space) => space.q === q && space.r === r
-  );
-}
-function getSquareSpaceAt(table, boardId, row, col) {
-  return Object.values(getSquareBoard(table, boardId).spaces).find(
-    (space) => space.row === row && space.col === col
-  );
-}
-function getSpaceEdges(table, boardId, spaceId) {
-  return getTiledBoard(table, boardId).edges.filter((edge) => edge.spaceIds.includes(spaceId)).map((edge) => edge.id);
-}
-function getSpaceVertices(table, boardId, spaceId) {
-  return getTiledBoard(table, boardId).vertices.filter((vertex) => vertex.spaceIds.includes(spaceId)).map((vertex) => vertex.id);
-}
-function getIncidentEdges(table, boardId, vertexId) {
-  const tiledBoard = getTiledBoard(table, boardId);
-  const vertex = tiledBoard.vertices.find(
-    (candidate) => candidate.id === vertexId
-  );
-  if (!vertex) {
-    throw new Error(`Unknown vertex '${vertexId}' on board '${boardId}'.`);
-  }
-  const vertexSpaceIds = new Set(vertex.spaceIds);
-  return tiledBoard.edges.filter(
-    (edge) => edge.spaceIds.every((spaceId) => vertexSpaceIds.has(spaceId))
-  ).map((edge) => edge.id);
-}
-function getIncidentVertices(table, boardId, edgeId) {
-  const tiledBoard = getTiledBoard(table, boardId);
-  const edge = tiledBoard.edges.find((candidate) => candidate.id === edgeId);
-  if (!edge) {
-    throw new Error(`Unknown edge '${edgeId}' on board '${boardId}'.`);
-  }
-  const edgeSpaceIds = new Set(edge.spaceIds);
-  return tiledBoard.vertices.filter(
-    (vertex) => Array.from(edgeSpaceIds).every(
-      (spaceId) => vertex.spaceIds.includes(spaceId)
-    )
-  ).map((vertex) => vertex.id);
-}
-function getRelatedSpaces(table, boardId, spaceId, relationTypeId) {
-  const board = getBoard(table, boardId);
-  const related = /* @__PURE__ */ new Set();
-  for (const relation of board.relations) {
-    if (relation.typeId !== relationTypeId) {
-      continue;
-    }
-    if (relation.fromSpaceId === spaceId) {
-      related.add(relation.toSpaceId);
-      continue;
-    }
-    if (!relation.directed && relation.toSpaceId === spaceId) {
-      related.add(relation.fromSpaceId);
-    }
-  }
-  return [...related];
-}
-function getAdjacentSpaces(table, boardId, spaceId) {
-  return getRelatedSpaces(
-    table,
-    boardId,
-    spaceId,
-    "adjacent"
-  );
-}
-function getSpaceDistance(table, boardId, fromSpaceId, toSpaceId) {
-  if (fromSpaceId === toSpaceId) {
-    return 0;
-  }
-  const visited = /* @__PURE__ */ new Set([fromSpaceId]);
-  let frontier = [fromSpaceId];
-  let distance = 0;
-  while (frontier.length > 0) {
-    distance += 1;
-    const nextFrontier = [];
-    for (const currentSpaceId of frontier) {
-      for (const neighborId of getAdjacentSpaces(
-        table,
-        boardId,
-        currentSpaceId
-      )) {
-        if (neighborId === toSpaceId) {
-          return distance;
-        }
-        if (!visited.has(neighborId)) {
-          visited.add(neighborId);
-          nextFrontier.push(neighborId);
-        }
-      }
-    }
-    frontier = nextFrontier;
-  }
-  return Number.POSITIVE_INFINITY;
-}
-function getSquareNeighbors(table, boardId, spaceId, options = {}) {
-  const board = getSquareBoard(table, boardId);
-  const space = getSquareSpace(table, boardId, spaceId);
-  const offsets = options.mode === "diagonal" ? [
-    [-1, -1],
-    [-1, 1],
-    [1, -1],
-    [1, 1]
-  ] : options.mode === "all" ? [
-    [-1, 0],
-    [0, 1],
-    [1, 0],
-    [0, -1],
-    [-1, -1],
-    [-1, 1],
-    [1, -1],
-    [1, 1]
-  ] : [
-    [-1, 0],
-    [0, 1],
-    [1, 0],
-    [0, -1]
-  ];
-  return offsets.map(
-    ([rowOffset, colOffset]) => Object.values(board.spaces).find(
-      (candidate) => candidate.row === space.row + rowOffset && candidate.col === space.col + colOffset
-    )
-  ).filter((candidate) => candidate !== void 0).map((candidate) => candidate.id);
-}
-function getSquareDistance(table, boardId, fromSpaceId, toSpaceId, options = {}) {
-  const from = getSquareSpace(table, boardId, fromSpaceId);
-  const to = getSquareSpace(table, boardId, toSpaceId);
-  const rowDistance = Math.abs(from.row - to.row);
-  const colDistance = Math.abs(from.col - to.col);
-  return options.metric === "chebyshev" ? Math.max(rowDistance, colDistance) : rowDistance + colDistance;
-}
-function getBoardsByTypeId(table, typeId) {
-  return Object.entries(table.boards.byId).filter(([, board]) => board.typeId === typeId).map(([boardId]) => boardId);
-}
-function getSpacesByTypeId(table, boardId, typeId) {
-  return Object.entries(getBoard(table, boardId).spaces).filter(([, space]) => space.typeId === typeId).map(([spaceId]) => spaceId);
-}
-function getEdgesByTypeId(table, boardId, typeId) {
-  return getTiledBoard(table, boardId).edges.filter((edge) => edge.typeId === typeId).map((edge) => edge.id);
-}
-function getVerticesByTypeId(table, boardId, typeId) {
-  return getTiledBoard(table, boardId).vertices.filter((vertex) => vertex.typeId === typeId).map((vertex) => vertex.id);
-}
-function getComponentsOnSpace(table, boardId, spaceId) {
-  const zoneId = getSpace(table, boardId, spaceId).zoneId;
-  return orderedComponentIdsForLocation(
-    table,
-    (location) => location.type === "OnSpace" && location.boardId === boardId && location.spaceId === spaceId || location.type === "InZone" && typeof zoneId === "string" && zoneId.length > 0 && location.zoneId === zoneId
-  );
-}
-function getComponentsInContainer(table, boardId, containerId) {
-  const zoneId = getContainer(table, boardId, containerId).zoneId;
-  return orderedComponentIdsForLocation(
-    table,
-    (location) => location.type === "InContainer" && location.boardId === boardId && location.containerId === containerId || location.type === "InZone" && typeof zoneId === "string" && zoneId.length > 0 && location.zoneId === zoneId
-  );
-}
-function getComponentsOnEdge(table, boardId, edgeId) {
-  return orderedComponentIdsForLocation(
-    table,
-    (location) => location.type === "OnEdge" && location.boardId === boardId && location.edgeId === edgeId
-  );
-}
-function getComponentsOnVertex(table, boardId, vertexId) {
-  return orderedComponentIdsForLocation(
-    table,
-    (location) => location.type === "OnVertex" && location.boardId === boardId && location.vertexId === vertexId
-  );
-}
-
-// src/reducer/table/card-validation.ts
-function allowedCardSetIdsForZone(table, zoneId) {
-  return table.zones.cardSetIdsByZoneId?.[zoneId] ?? [];
-}
-function assertCardAllowedInZone(table, zoneId, componentId) {
-  const card = table.cards[componentId];
-  if (!card) {
-    return;
-  }
-  const allowedCardSetIds = allowedCardSetIdsForZone(table, zoneId);
-  if (allowedCardSetIds.length > 0 && !allowedCardSetIds.includes(card.cardSetId)) {
-    throw new Error(
-      `Card '${componentId}' from card set '${card.cardSetId}' cannot enter zone '${zoneId}'.`
-    );
-  }
-}
-function assertCardAllowedInContainer(table, boardId, containerId, componentId) {
-  const card = table.cards[componentId];
-  if (!card) {
-    return;
-  }
-  const allowedCardSetIds = getContainer(table, boardId, containerId).allowedCardSetIds ?? [];
-  if (allowedCardSetIds.length > 0 && !allowedCardSetIds.includes(card.cardSetId)) {
-    throw new Error(
-      `Card '${componentId}' from card set '${card.cardSetId}' cannot enter container '${containerId}' on board '${boardId}'.`
-    );
-  }
-}
-
-// src/reducer/table/phase-state.ts
-function setActivePlayers(state, activePlayers) {
-  return {
-    ...state,
-    flow: {
-      ...state.flow,
-      activePlayers
-    }
-  };
-}
-function setPhaseState(state, phaseState) {
-  return {
-    ...state,
-    phase: phaseState
-  };
-}
-
-// src/reducer/table/clone.ts
-var cloneRuntimeTableCallCount = 0;
-function cloneRuntimeBoardState(board) {
-  if (board.layout !== "generic") {
-    return {
-      ...board,
-      fields: { ...board.fields },
-      spaces: Object.fromEntries(
-        Object.entries(board.spaces).map(([spaceId, space]) => [
-          spaceId,
-          {
-            ...space,
-            fields: { ...space.fields }
-          }
-        ])
-      ),
-      relations: board.relations.map((relation) => ({
-        ...relation,
-        fields: { ...relation.fields }
-      })),
-      containers: Object.fromEntries(
-        Object.entries(board.containers).map(([containerId, container]) => [
-          containerId,
-          {
-            ...container,
-            fields: { ...container.fields }
-          }
-        ])
-      ),
-      edges: board.edges.map((edge) => ({
-        ...edge,
-        spaceIds: [...edge.spaceIds],
-        fields: { ...edge.fields }
-      })),
-      vertices: board.vertices.map((vertex) => ({
-        ...vertex,
-        spaceIds: [...vertex.spaceIds],
-        fields: { ...vertex.fields }
-      }))
-    };
-  }
-  return {
-    ...board,
-    fields: { ...board.fields },
-    spaces: Object.fromEntries(
-      Object.entries(board.spaces).map(([spaceId, space]) => [
-        spaceId,
-        {
-          ...space,
-          fields: { ...space.fields }
-        }
-      ])
-    ),
-    relations: board.relations.map((relation) => ({
-      ...relation,
-      fields: { ...relation.fields }
-    })),
-    containers: Object.fromEntries(
-      Object.entries(board.containers).map(([containerId, container]) => [
-        containerId,
-        {
-          ...container,
-          fields: { ...container.fields }
-        }
-      ])
-    )
-  };
-}
-function cloneRuntimeTable(table) {
-  cloneRuntimeTableCallCount += 1;
-  return {
-    ...table,
-    zones: {
-      shared: Object.fromEntries(
-        Object.entries(table.zones.shared).map(([zoneId, componentIds]) => [
-          zoneId,
-          [...componentIds]
-        ])
-      ),
-      perPlayer: Object.fromEntries(
-        Object.entries(table.zones.perPlayer).map(([zoneId, players]) => [
-          zoneId,
-          perPlayerMap(players, (componentIds) => [
-            ...componentIds
-          ])
-        ])
-      ),
-      visibility: { ...table.zones.visibility },
-      cardSetIdsByZoneId: table.zones.cardSetIdsByZoneId ? Object.fromEntries(
-        Object.entries(table.zones.cardSetIdsByZoneId).map(
-          ([zoneId, cardSetIds]) => [zoneId, [...cardSetIds]]
-        )
-      ) : table.zones.cardSetIdsByZoneId
-    },
-    decks: Object.fromEntries(
-      Object.entries(table.decks).map(([deckId, cards]) => [
-        deckId,
-        [...cards]
-      ])
-    ),
-    hands: Object.fromEntries(
-      Object.entries(table.hands).map(([handId, players]) => [
-        handId,
-        perPlayerMap(players, (cards) => [...cards])
-      ])
-    ),
-    handVisibility: { ...table.handVisibility },
-    pieces: Object.fromEntries(
-      Object.entries(table.pieces).map(([pieceId, piece]) => [
-        pieceId,
-        { ...piece }
-      ])
-    ),
-    componentLocations: { ...table.componentLocations },
-    ownerOfCard: { ...table.ownerOfCard },
-    visibility: { ...table.visibility },
-    resources: perPlayerMap(
-      table.resources,
-      (resources) => ({ ...resources })
-    ),
-    boards: {
-      ...table.boards,
-      byId: Object.fromEntries(
-        Object.entries(table.boards.byId).map(([boardId, board]) => [
-          boardId,
-          cloneRuntimeBoardState(board)
-        ])
-      ),
-      hex: Object.fromEntries(
-        Object.entries(table.boards.hex ?? {}).map(([boardId, board]) => [
-          boardId,
-          cloneRuntimeBoardState(board)
-        ])
-      ),
-      square: Object.fromEntries(
-        Object.entries(table.boards.square ?? {}).map(([boardId, board]) => [
-          boardId,
-          cloneRuntimeBoardState(board)
-        ])
-      )
-    },
-    dice: Object.fromEntries(
-      Object.entries(table.dice).map(([dieId, die]) => [dieId, { ...die }])
-    )
-  };
-}
-
-// src/reducer/table/component-locations.ts
-function getComponentLocation(table, componentId) {
-  return table.componentLocations[componentId];
-}
-function getComponentDeckLocation(table, componentId) {
-  const location = getComponentLocation(table, componentId);
-  if (location?.type !== "InDeck") {
-    return null;
-  }
-  return {
-    componentId,
-    deckId: location.deckId,
-    cards: table.decks[location.deckId],
-    location
-  };
-}
-function getComponentHandLocation(table, componentId) {
-  const location = getComponentLocation(table, componentId);
-  if (location?.type !== "InHand") {
-    return null;
-  }
-  return {
-    componentId,
-    handId: location.handId,
-    playerId: location.playerId,
-    cards: ppRead(
-      table.hands[location.handId],
-      location.playerId
-    ),
-    location
-  };
-}
-function getComponentZoneLocation(table, componentId) {
-  const location = getComponentLocation(table, componentId);
-  if (location?.type !== "InZone") {
-    return null;
-  }
-  return {
-    componentId,
-    zoneId: location.zoneId,
-    location
-  };
-}
-function getComponentSpaceLocation(table, componentId) {
-  const location = getComponentLocation(table, componentId);
-  if (location?.type !== "OnSpace") {
-    return null;
-  }
-  const boardId = location.boardId;
-  const spaceId = location.spaceId;
-  return {
-    componentId,
-    boardId,
-    board: getBoard(table, boardId),
-    spaceId,
-    space: getSpace(table, boardId, spaceId),
-    location
-  };
-}
-function getComponentContainerLocation(table, componentId) {
-  const location = getComponentLocation(table, componentId);
-  if (location?.type !== "InContainer") {
-    return null;
-  }
-  const boardId = location.boardId;
-  const containerId = location.containerId;
-  return {
-    componentId,
-    boardId,
-    board: getBoard(table, boardId),
-    containerId,
-    container: getContainer(table, boardId, containerId),
-    location
-  };
-}
-function getComponentEdgeLocation(table, componentId) {
-  const location = getComponentLocation(table, componentId);
-  if (location?.type !== "OnEdge") {
-    return null;
-  }
-  const boardId = location.boardId;
-  const edgeId = location.edgeId;
-  return {
-    componentId,
-    boardId,
-    board: getTiledBoard(table, boardId),
-    edgeId,
-    edge: getEdge(table, boardId, edgeId),
-    location
-  };
-}
-function getComponentVertexLocation(table, componentId) {
-  const location = getComponentLocation(table, componentId);
-  if (location?.type !== "OnVertex") {
-    return null;
-  }
-  const boardId = location.boardId;
-  const vertexId = location.vertexId;
-  return {
-    componentId,
-    boardId,
-    board: getTiledBoard(table, boardId),
-    vertexId,
-    vertex: getVertex(table, boardId, vertexId),
-    location
-  };
-}
-function getComponentSlotLocation(table, componentId) {
-  const location = getComponentLocation(table, componentId);
-  if (location?.type !== "InSlot") {
-    return null;
-  }
-  return {
-    componentId,
-    host: location.host,
-    slotId: location.slotId,
-    location
-  };
-}
-
-// src/reducer/table/zone-queries.ts
-function matchesSlotHost(location, host, slotId) {
-  return location.type === "InSlot" && location.host.kind === host.kind && location.host.id === host.id && (slotId === void 0 || location.slotId === slotId);
-}
-function componentPlayerId(table, componentId) {
-  const piece = table.pieces[componentId];
-  if (piece) {
-    return piece.ownerId ?? null;
-  }
-  const die = table.dice[componentId];
-  if (die) {
-    return die.ownerId ?? null;
-  }
-  const owner = table.ownerOfCard[componentId];
-  if (owner !== void 0) {
-    return owner ?? null;
-  }
-  return null;
-}
-function componentData(table, componentId) {
-  const piece = table.pieces[componentId];
-  if (piece) {
-    return piece.properties;
-  }
-  const die = table.dice[componentId];
-  if (die) {
-    return die.properties;
-  }
-  const card = table.cards[componentId];
-  if (card) {
-    return card.properties;
-  }
-  return void 0;
-}
-function getSharedZoneCards(table, zoneId) {
-  assertZoneScope(
-    table,
-    zoneId,
-    "shared",
-    "getSharedZoneCards",
-    "zoneId"
-  );
-  return [
-    ...ensureArray(table.zones.shared[zoneId] ?? table.decks[zoneId])
-  ];
-}
-function getPlayerZoneCards(table, playerId, zoneId) {
-  assertZoneScope(
-    table,
-    zoneId,
-    "perPlayer",
-    "getPlayerZoneCards",
-    "zoneId"
-  );
-  const cards = ppRead(table.zones.perPlayer[zoneId], playerId) ?? ppRead(table.hands[zoneId], playerId);
-  return [
-    ...ensureArray(cards)
-  ];
-}
-function collectZoneIds(...sources) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const source of sources) {
-    if (!source) continue;
-    for (const key of Object.keys(source)) {
-      seen.add(key);
-    }
-  }
-  return [...seen];
-}
-function getAllSharedZoneCards(table) {
-  const zoneIds = collectZoneIds(
-    table.zones.shared,
-    table.decks
-  );
-  const result = {};
-  for (const zoneId of zoneIds) {
-    result[zoneId] = getSharedZoneCards(
-      table,
-      zoneId
-    );
-  }
-  return result;
-}
-function getAllPlayerZoneCards(table, zoneId) {
-  const result = {};
-  for (const playerId of table.playerOrder) {
-    result[playerId] = getPlayerZoneCards(
-      table,
-      playerId,
-      zoneId
-    );
-  }
-  return result;
-}
-function getCard(table, cardId) {
-  const card = table.cards[cardId];
-  return {
-    id: card.id,
-    cardType: card.cardType,
-    name: card.name,
-    text: card.text,
-    properties: card.properties
-  };
-}
-function getCardsById(table, cardIds) {
-  return Object.fromEntries(
-    cardIds.map((cardId) => [
-      cardId,
-      table.cards[cardId] ? getCard(table, cardId) : void 0
-    ])
-  );
-}
-function getSharedZoneCardCollection(table, zoneId) {
-  const cardIds = getSharedZoneCards(table, zoneId);
-  return {
-    cardIds,
-    cardsById: getCardsById(table, cardIds)
-  };
-}
-function getPlayerZoneCardCollection(table, playerId, zoneId) {
-  const cardIds = getPlayerZoneCards(table, playerId, zoneId);
-  return {
-    cardIds,
-    cardsById: getCardsById(table, cardIds)
-  };
-}
-function getSlotOccupants(table, host, slotId) {
-  return orderedComponentIdsForLocation(
-    table,
-    (location) => matchesSlotHost(location, host, slotId)
-  ).map((componentId) => ({
-    pieceId: componentId,
-    playerId: componentPlayerId(
-      table,
-      componentId
-    ),
-    slotId,
-    data: componentData(table, componentId)
-  }));
-}
-function getSlotOccupantsByHost(table, host) {
-  const occupantsBySlot = {};
-  orderedComponentIdsForLocation(
-    table,
-    (location) => matchesSlotHost(location, host)
-  ).forEach((componentId) => {
-    const location = table.componentLocations[componentId];
-    if (!location || !matchesSlotHost(location, host)) {
-      return;
-    }
-    const slotOccupant = {
-      pieceId: componentId,
-      playerId: componentPlayerId(
-        table,
-        componentId
-      ),
-      slotId: location.slotId,
-      data: componentData(table, componentId)
-    };
-    (occupantsBySlot[location.slotId] ??= []).push(slotOccupant);
-  });
-  return occupantsBySlot;
-}
-function getCardOwner(table, cardId) {
-  return table.ownerOfCard[cardId];
-}
-function getCardVisibility(table, cardId) {
-  return table.visibility[cardId];
-}
-
-// src/reducer/table/numeric.ts
-function assertNonNegativeSafeInteger(value, label) {
-  if (!Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`${label} must be a non-negative safe integer.`);
-  }
-}
-
-// src/reducer/table/resource-ops.ts
-function getPlayerOrder(table) {
-  return table.playerOrder;
-}
-function getPlayerResources(table, playerId) {
-  return perPlayerGet(
-    table.resources,
-    playerId
-  );
-}
-function getPlayerResourceAmount(table, playerId, resourceId) {
-  const playerResources = perPlayerGet(
-    table.resources,
-    playerId
-  );
-  if (!playerResources) return 0;
-  const value = playerResources[resourceId];
-  if (value === void 0) return 0;
-  if (typeof value !== "number") {
-    throw new Error(
-      `Resource '${resourceId}' balance must be a non-negative safe integer.`
-    );
-  }
-  assertNonNegativeSafeInteger(value, `Resource '${resourceId}' balance`);
-  return value;
-}
-function getPlayerResourceTotal(table, playerId) {
-  const playerResources = perPlayerGet(
-    table.resources,
-    playerId
-  );
-  if (!playerResources) return 0;
-  let total = 0;
-  for (const key of Object.keys(playerResources)) {
-    const value = playerResources[key];
-    if (value === void 0) continue;
-    if (typeof value !== "number") {
-      throw new Error(
-        `Resource '${key}' balance must be a non-negative safe integer.`
-      );
-    }
-    assertNonNegativeSafeInteger(value, `Resource '${key}' balance`);
-    const nextTotal = total + value;
-    assertNonNegativeSafeInteger(nextTotal, "Resource total");
-    total = nextTotal;
-  }
-  return total;
-}
-function getNextPlayerInOrder(table, playerId) {
-  const order = table.playerOrder;
-  if (order.length === 0) return null;
-  const idx = order.indexOf(playerId);
-  if (idx < 0) return null;
-  return order[(idx + 1) % order.length] ?? null;
-}
-function resourceEntries(amounts) {
-  const entries = [];
-  for (const resourceId of Object.keys(amounts)) {
-    const amount = amounts[resourceId];
-    if (amount === void 0 || amount === 0) continue;
-    if (typeof amount !== "number") {
-      throw new Error(
-        `Resource '${resourceId}' amount must be a non-negative safe integer.`
-      );
-    }
-    assertNonNegativeSafeInteger(amount, `Resource '${resourceId}' amount`);
-    entries.push([resourceId, amount]);
-  }
-  return entries;
-}
-function canAffordResources(table, playerId, amounts) {
-  for (const [resourceId, required] of resourceEntries(amounts)) {
-    if (getPlayerResourceAmount(table, playerId, resourceId) < required) {
-      return false;
-    }
-  }
-  return true;
-}
-function getMissingResources(table, playerId, amounts) {
-  const missing = {};
-  for (const [resourceId, required] of resourceEntries(amounts)) {
-    const have = getPlayerResourceAmount(table, playerId, resourceId);
-    if (have < required) missing[resourceId] = required - have;
-  }
-  return missing;
-}
-function writePlayerResources(table, playerId, nextForPlayer) {
-  table.resources = perPlayerSet(
-    table.resources,
-    playerId,
-    nextForPlayer
-  );
-}
-function addPlayerResources(table, playerId, amounts) {
-  const nextTable = { ...table };
-  addPlayerResourcesInPlace(nextTable, playerId, amounts);
-  return nextTable;
-}
-function addPlayerResourcesInPlace(table, playerId, amounts) {
-  const prev = perPlayerGet(
-    table.resources,
-    playerId
-  ) ?? {};
-  const next = { ...prev };
-  for (const [resourceId, amount] of resourceEntries(amounts)) {
-    const nextAmount = getPlayerResourceAmount(table, playerId, resourceId) + amount;
-    assertNonNegativeSafeInteger(
-      nextAmount,
-      `Resource '${resourceId}' balance`
-    );
-    next[resourceId] = nextAmount;
-  }
-  writePlayerResources(table, playerId, next);
-}
-function spendPlayerResources(table, playerId, amounts) {
-  const nextTable = { ...table };
-  spendPlayerResourcesInPlace(nextTable, playerId, amounts);
-  return nextTable;
-}
-function spendPlayerResourcesInPlace(table, playerId, amounts) {
-  const entries = resourceEntries(amounts);
-  if (!canAffordResources(table, playerId, amounts)) {
-    const missing = getMissingResources(table, playerId, amounts);
-    throw new Error(
-      `spendPlayerResources: player '${playerId}' cannot afford ${JSON.stringify(
-        missing
-      )}. Check canAfford in your validate step first.`
-    );
-  }
-  const prev = perPlayerGet(
-    table.resources,
-    playerId
-  ) ?? {};
-  const next = { ...prev };
-  for (const [resourceId, amount] of entries) {
-    const nextAmount = getPlayerResourceAmount(table, playerId, resourceId) - amount;
-    assertNonNegativeSafeInteger(
-      nextAmount,
-      `Resource '${resourceId}' balance`
-    );
-    next[resourceId] = nextAmount;
-  }
-  writePlayerResources(table, playerId, next);
-}
-function transferPlayerResources(table, fromPlayerId, toPlayerId, amounts) {
-  const nextTable = { ...table };
-  transferPlayerResourcesInPlace(nextTable, fromPlayerId, toPlayerId, amounts);
-  return nextTable;
-}
-function transferPlayerResourcesInPlace(table, fromPlayerId, toPlayerId, amounts) {
-  const entries = resourceEntries(amounts);
-  if (!canAffordResources(table, fromPlayerId, amounts)) {
-    const missing = getMissingResources(table, fromPlayerId, amounts);
-    throw new Error(
-      `spendPlayerResources: player '${fromPlayerId}' cannot afford ${JSON.stringify(
-        missing
-      )}. Check canAfford in your validate step first.`
-    );
-  }
-  if (fromPlayerId === toPlayerId) return;
-  const fromPrev = perPlayerGet(
-    table.resources,
-    fromPlayerId
-  ) ?? {};
-  const toPrev = perPlayerGet(
-    table.resources,
-    toPlayerId
-  ) ?? {};
-  const fromNext = { ...fromPrev };
-  const toNext = { ...toPrev };
-  for (const [resourceId, amount] of entries) {
-    const sourceBalance = getPlayerResourceAmount(table, fromPlayerId, resourceId) - amount;
-    const destinationBalance = getPlayerResourceAmount(table, toPlayerId, resourceId) + amount;
-    assertNonNegativeSafeInteger(
-      sourceBalance,
-      `Resource '${resourceId}' balance`
-    );
-    assertNonNegativeSafeInteger(
-      destinationBalance,
-      `Resource '${resourceId}' balance`
-    );
-    fromNext[resourceId] = sourceBalance;
-    toNext[resourceId] = destinationBalance;
-  }
-  writePlayerResources(table, fromPlayerId, fromNext);
-  writePlayerResources(table, toPlayerId, toNext);
-}
-function setPlayerResource(table, playerId, resourceId, amount) {
-  const nextTable = { ...table };
-  setPlayerResourceInPlace(nextTable, playerId, resourceId, amount);
-  return nextTable;
-}
-function setPlayerResourceInPlace(table, playerId, resourceId, amount) {
-  assertNonNegativeSafeInteger(amount, `Resource '${resourceId}' amount`);
-  const prev = perPlayerGet(
-    table.resources,
-    playerId
-  ) ?? {};
-  writePlayerResources(table, playerId, {
-    ...prev,
-    [resourceId]: amount
-  });
-}
-
-// src/reducer/table/component-mutations.ts
-function reindexSpaceOccupants(table, boardId, spaceId) {
-  getComponentsOnSpace(table, boardId, spaceId).forEach(
-    (componentId, index) => {
-      const location = table.componentLocations[componentId];
-      if (location?.type === "OnSpace") {
-        table.componentLocations[componentId] = {
-          ...location,
-          position: index
-        };
-      }
-    }
-  );
-}
-function reindexContainerOccupants(table, boardId, containerId) {
-  getComponentsInContainer(table, boardId, containerId).forEach(
-    (componentId, index) => {
-      const location = table.componentLocations[componentId];
-      if (location?.type === "InContainer") {
-        table.componentLocations[componentId] = {
-          ...location,
-          position: index
-        };
-      }
-    }
-  );
-}
-function reindexEdgeOccupants(table, boardId, edgeId) {
-  orderedComponentIdsForLocation(
-    table,
-    (location) => location.type === "OnEdge" && location.boardId === boardId && location.edgeId === edgeId
-  ).forEach((componentId, index) => {
-    const location = table.componentLocations[componentId];
-    if (location?.type === "OnEdge") {
-      table.componentLocations[componentId] = {
-        ...location,
-        position: index
-      };
-    }
-  });
-}
-function reindexVertexOccupants(table, boardId, vertexId) {
-  orderedComponentIdsForLocation(
-    table,
-    (location) => location.type === "OnVertex" && location.boardId === boardId && location.vertexId === vertexId
-  ).forEach((componentId, index) => {
-    const location = table.componentLocations[componentId];
-    if (location?.type === "OnVertex") {
-      table.componentLocations[componentId] = {
-        ...location,
-        position: index
-      };
-    }
-  });
-}
-function reindexSlotOccupants(table, host, slotId) {
-  orderedComponentIdsForLocation(
-    table,
-    (location) => location.type === "InSlot" && location.host.kind === host.kind && location.host.id === host.id && location.slotId === slotId
-  ).forEach((componentId, index) => {
-    const location = table.componentLocations[componentId];
-    if (location?.type === "InSlot") {
-      table.componentLocations[componentId] = {
-        ...location,
-        position: index
-      };
-    }
-  });
-}
-function removeComponentFromCurrentLocation(table, componentId) {
-  const currentLocation = table.componentLocations[componentId];
-  if (!currentLocation) {
-    return;
-  }
-  if (currentLocation.type === "InDeck") {
-    const nextCards = ensureArray(table.decks[currentLocation.deckId]).filter(
-      (candidate) => candidate !== componentId
-    );
-    syncSharedZoneWithDeck(
-      table,
-      currentLocation.deckId,
-      nextCards
-    );
-    nextCards.forEach((cardId, index) => {
-      const location = table.componentLocations[cardId];
-      if (location?.type === "InDeck") {
-        table.componentLocations[cardId] = {
-          ...location,
-          position: index
-        };
-      }
-    });
-    return;
-  }
-  if (currentLocation.type === "InHand") {
-    const nextCards = ensureArray(
-      ppRead(table.hands[currentLocation.handId], currentLocation.playerId)
-    ).filter((candidate) => candidate !== componentId);
-    syncPlayerZoneWithHand(
-      table,
-      currentLocation.handId,
-      currentLocation.playerId,
-      nextCards
-    );
-    nextCards.forEach((cardId, index) => {
-      const location = table.componentLocations[cardId];
-      if (location?.type === "InHand") {
-        table.componentLocations[cardId] = {
-          ...location,
-          position: index
-        };
-      }
-    });
-    return;
-  }
-  if (currentLocation.type === "OnSpace") {
-    delete table.componentLocations[componentId];
-    reindexSpaceOccupants(
-      table,
-      currentLocation.boardId,
-      currentLocation.spaceId
-    );
-    return;
-  }
-  if (currentLocation.type === "InZone") {
-    if (currentLocation.zoneId in table.zones.shared) {
-      const nextComponents = ensureArray(
-        table.zones.shared[currentLocation.zoneId]
-      ).filter((candidate) => candidate !== componentId);
-      syncSharedZoneWithDeck(
-        table,
-        currentLocation.zoneId,
-        nextComponents
-      );
-      nextComponents.forEach((currentComponentId, index) => {
-        const location = table.componentLocations[currentComponentId];
-        if (location?.type === "InZone") {
-          table.componentLocations[currentComponentId] = {
-            ...location,
-            position: index
-          };
-        }
-      });
-    }
-    delete table.componentLocations[componentId];
-    return;
-  }
-  if (currentLocation.type === "InContainer") {
-    delete table.componentLocations[componentId];
-    reindexContainerOccupants(
-      table,
-      currentLocation.boardId,
-      currentLocation.containerId
-    );
-    return;
-  }
-  if (currentLocation.type === "OnEdge") {
-    delete table.componentLocations[componentId];
-    reindexEdgeOccupants(
-      table,
-      currentLocation.boardId,
-      currentLocation.edgeId
-    );
-    return;
-  }
-  if (currentLocation.type === "OnVertex") {
-    delete table.componentLocations[componentId];
-    reindexVertexOccupants(
-      table,
-      currentLocation.boardId,
-      currentLocation.vertexId
-    );
-    return;
-  }
-  if (currentLocation.type === "InSlot") {
-    delete table.componentLocations[componentId];
-    reindexSlotOccupants(table, currentLocation.host, currentLocation.slotId);
-    return;
-  }
-  delete table.componentLocations[componentId];
-}
-function moveComponentToSpace(table, componentId, boardId, spaceId) {
-  const nextTable = cloneRuntimeTable(table);
-  moveComponentToSpaceInPlace(nextTable, componentId, boardId, spaceId);
-  return nextTable;
-}
-function moveComponentToSpaceInPlace(table, componentId, boardId, spaceId) {
-  const position = getComponentsOnSpace(table, boardId, spaceId).length;
-  removeComponentFromCurrentLocation(table, componentId);
-  table.componentLocations[componentId] = {
-    type: "OnSpace",
-    boardId,
-    spaceId,
-    position
-  };
-}
-function moveComponentToContainer(table, componentId, boardId, containerId) {
-  const nextTable = cloneRuntimeTable(table);
-  moveComponentToContainerInPlace(nextTable, componentId, boardId, containerId);
-  return nextTable;
-}
-function moveComponentToContainerInPlace(table, componentId, boardId, containerId) {
-  assertCardAllowedInContainer(table, boardId, containerId, componentId);
-  const position = getComponentsInContainer(table, boardId, containerId).length;
-  removeComponentFromCurrentLocation(table, componentId);
-  table.componentLocations[componentId] = {
-    type: "InContainer",
-    boardId,
-    containerId,
-    position
-  };
-}
-function moveComponentToDetached(table, componentId) {
-  const nextTable = cloneRuntimeTable(table);
-  moveComponentToDetachedInPlace(nextTable, componentId);
-  return nextTable;
-}
-function moveComponentToDetachedInPlace(table, componentId) {
-  removeComponentFromCurrentLocation(table, componentId);
-  table.componentLocations[componentId] = { type: "Detached" };
-}
-function moveComponentToEdge(table, componentId, boardId, edgeId) {
-  const nextTable = cloneRuntimeTable(table);
-  moveComponentToEdgeInPlace(nextTable, componentId, boardId, edgeId);
-  return nextTable;
-}
-function moveComponentToEdgeInPlace(table, componentId, boardId, edgeId) {
-  getEdge(table, boardId, edgeId);
-  const position = getComponentsOnEdge(table, boardId, edgeId).length;
-  removeComponentFromCurrentLocation(table, componentId);
-  table.componentLocations[componentId] = {
-    type: "OnEdge",
-    boardId,
-    edgeId,
-    position
-  };
-}
-function moveComponentToVertex(table, componentId, boardId, vertexId) {
-  const nextTable = cloneRuntimeTable(table);
-  moveComponentToVertexInPlace(nextTable, componentId, boardId, vertexId);
-  return nextTable;
-}
-function moveComponentToVertexInPlace(table, componentId, boardId, vertexId) {
-  getVertex(table, boardId, vertexId);
-  const position = getComponentsOnVertex(table, boardId, vertexId).length;
-  removeComponentFromCurrentLocation(table, componentId);
-  table.componentLocations[componentId] = {
-    type: "OnVertex",
-    boardId,
-    vertexId,
-    position
-  };
-}
-
-// src/reducer/table/card-mutations.ts
-function sharedZoneCards(table, zoneId) {
-  return [...ensureArray(table.zones.shared[zoneId] ?? table.decks[zoneId])];
-}
-function playerZoneCards(table, zoneId, playerId) {
-  return [
-    ...ensureArray(
-      ppRead(table.zones.perPlayer[zoneId] ?? table.hands[zoneId], playerId)
-    )
-  ];
-}
-function assertCardInSharedZone(table, zoneId, cardId) {
-  if (!sharedZoneCards(table, zoneId).includes(cardId)) {
-    throw new Error(`Card '${cardId}' is not in shared zone '${zoneId}'.`);
-  }
-  const location = table.componentLocations[cardId];
-  if (location?.type !== "InDeck" || location.deckId !== zoneId) {
-    throw new Error(
-      `Card '${cardId}' has a location that disagrees with shared zone '${zoneId}'.`
-    );
-  }
-}
-function assertCardInPlayerZone(table, zoneId, playerId, cardId) {
-  if (!playerZoneCards(table, zoneId, playerId).includes(cardId)) {
-    throw new Error(
-      `Card '${cardId}' is not in zone '${zoneId}' for player '${playerId}'.`
-    );
-  }
-  const location = table.componentLocations[cardId];
-  if (location?.type !== "InHand" || location.handId !== zoneId || location.playerId !== playerId) {
-    throw new Error(
-      `Card '${cardId}' has a location that disagrees with zone '${zoneId}' for player '${playerId}'.`
-    );
-  }
-}
-function assertCardDetached(table, cardId) {
-  const location = table.componentLocations[cardId];
-  if (location?.type !== "Detached") {
-    throw new Error(`Card '${cardId}' must be detached before placement.`);
-  }
-}
-function assertCardAbsentFromSharedZone(table, zoneId, cardId) {
-  if (sharedZoneCards(table, zoneId).includes(cardId)) {
-    throw new Error(`Card '${cardId}' is already in shared zone '${zoneId}'.`);
-  }
-}
-function assertCardAbsentFromPlayerZone(table, zoneId, playerId, cardId) {
-  if (playerZoneCards(table, zoneId, playerId).includes(cardId)) {
-    throw new Error(
-      `Card '${cardId}' is already in zone '${zoneId}' for player '${playerId}'.`
-    );
-  }
-}
-function reindexSharedZoneCards(table, zoneId, cardIds, playedByForCard) {
-  for (const [index, currentCardId] of cardIds.entries()) {
-    const existing = table.componentLocations[currentCardId];
-    table.componentLocations[currentCardId] = {
-      type: "InDeck",
-      deckId: zoneId,
-      playedBy: playedByForCard?.[currentCardId] ?? (existing?.type === "InDeck" ? existing.playedBy : null),
-      position: index
-    };
-  }
-}
-function reindexPlayerZoneCards(table, zoneId, playerId, cardIds) {
-  for (const [index, currentCardId] of cardIds.entries()) {
-    table.componentLocations[currentCardId] = {
-      type: "InHand",
-      handId: zoneId,
-      playerId,
-      position: index
-    };
-  }
-}
-function insertCard(cardIds, cardId, position = "bottom") {
-  return position === "top" ? [cardId, ...cardIds] : [...cardIds, cardId];
-}
-function removeCard(cardIds, cardId) {
-  return cardIds.filter((candidate) => candidate !== cardId);
-}
-function appendCardToSharedZoneCollectionInPlace(table, deckId, cardId, playedBy, position = "bottom") {
-  const nextCards = insertCard(
-    sharedZoneCards(table, deckId),
-    cardId,
-    position
-  );
-  syncSharedZoneWithDeck(
-    table,
-    deckId,
-    nextCards
-  );
-  reindexSharedZoneCards(table, deckId, nextCards, {
-    [cardId]: playedBy
-  });
-}
-function removeCardFromSharedZoneCollectionInPlace(table, deckId, cardId) {
-  const remaining = removeCard(
-    sharedZoneCards(table, deckId),
-    cardId
-  );
-  syncSharedZoneWithDeck(
-    table,
-    deckId,
-    remaining
-  );
-  reindexSharedZoneCards(table, deckId, remaining);
-}
-function setPlayerZoneCardsInPlace(table, zoneId, playerId, cardIds) {
-  syncPlayerZoneWithHand(table, zoneId, playerId, cardIds);
-  reindexPlayerZoneCards(table, zoneId, playerId, cardIds);
-}
-function shufflePlayerZoneCards(table, zoneId, playerId, nextCards) {
-  if (nextCards === void 0) {
-    const fromZone = ppRead(
-      table.zones.perPlayer[zoneId] ?? table.hands[zoneId],
-      playerId
-    );
-    return [...ensureArray(fromZone)];
-  }
-  table.hands[zoneId] = ppWrite(table.hands[zoneId], playerId, [
-    ...nextCards
-  ]);
-  table.zones.perPlayer[zoneId] = ppWrite(
-    table.zones.perPlayer[zoneId],
-    playerId,
-    [...nextCards]
-  );
-  return [...nextCards];
-}
-function appendToDeck(table, deckId, cardId, playedBy = null, position = "bottom") {
-  const nextTable = cloneRuntimeTable(table);
-  appendToDeckInPlace(nextTable, deckId, cardId, playedBy, position);
-  return nextTable;
-}
-function appendToDeckInPlace(table, deckId, cardId, playedBy = null, position = "bottom") {
-  assertZoneScope(
-    table,
-    deckId,
-    "shared",
-    "addCardToSharedZone",
-    "zoneId"
-  );
-  assertCardDetached(table, cardId);
-  assertCardAbsentFromSharedZone(table, deckId, cardId);
-  assertCardAllowedInZone(table, deckId, cardId);
-  appendCardToSharedZoneCollectionInPlace(
-    table,
-    deckId,
-    cardId,
-    playedBy,
-    position
-  );
-  table.ownerOfCard[cardId] = playedBy;
-  table.visibility[cardId] = {
-    faceUp: true
-  };
-}
-function removeFromDeck(table, deckId, cardId) {
-  const nextTable = cloneRuntimeTable(table);
-  removeFromDeckInPlace(nextTable, deckId, cardId);
-  return nextTable;
-}
-function removeFromDeckInPlace(table, deckId, cardId) {
-  assertZoneScope(
-    table,
-    deckId,
-    "shared",
-    "removeCardFromSharedZone",
-    "zoneId"
-  );
-  assertCardInSharedZone(table, deckId, cardId);
-  removeCardFromSharedZoneCollectionInPlace(table, deckId, cardId);
-  table.componentLocations[cardId] = { type: "Detached" };
-}
-function computeVisibilityForPlayerZone(table, zoneId, playerId) {
-  const mode = table.handVisibility[zoneId];
-  if (mode === "all" || mode === "public") {
-    return { faceUp: true };
-  }
-  return { faceUp: false, visibleTo: [playerId] };
-}
-function moveFromHandToDeck(options) {
-  const nextTable = cloneRuntimeTable(options.table);
-  moveFromHandToDeckInPlace({
-    ...options,
-    table: nextTable
-  });
-  return nextTable;
-}
-function moveFromHandToDeckInPlace(options) {
-  assertZoneScope(
-    options.table,
-    options.handId,
-    "perPlayer",
-    "moveCardFromPlayerZoneToSharedZone",
-    "fromZoneId"
-  );
-  assertZoneScope(
-    options.table,
-    options.deckId,
-    "shared",
-    "moveCardFromPlayerZoneToSharedZone",
-    "toZoneId"
-  );
-  assertCardInPlayerZone(
-    options.table,
-    options.handId,
-    options.playerId,
-    options.cardId
-  );
-  assertCardAbsentFromSharedZone(
-    options.table,
-    options.deckId,
-    options.cardId
-  );
-  assertCardAllowedInZone(
-    options.table,
-    options.deckId,
-    options.cardId
-  );
-  const currentHand = playerZoneCards(
-    options.table,
-    options.handId,
-    options.playerId
-  );
-  const nextHand = removeCard(currentHand, options.cardId);
-  setPlayerZoneCardsInPlace(
-    options.table,
-    options.handId,
-    options.playerId,
-    nextHand
-  );
-  appendCardToSharedZoneCollectionInPlace(
-    options.table,
-    options.deckId,
-    options.cardId,
-    options.playedBy ?? options.playerId,
-    options.position ?? "bottom"
-  );
-  options.table.ownerOfCard[options.cardId] = options.playedBy ?? options.playerId;
-  options.table.visibility[options.cardId] = {
-    faceUp: true
-  };
-}
-function moveCardFromPlayerZoneToSharedZone(options) {
-  return moveFromHandToDeck({
-    table: options.table,
-    playerId: options.playerId,
-    handId: options.fromZoneId,
-    cardId: options.cardId,
-    deckId: options.toZoneId,
-    playedBy: options.playedBy,
-    position: options.position
-  });
-}
-function moveCardFromPlayerZoneToSharedZoneInPlace(options) {
-  moveFromHandToDeckInPlace({
-    table: options.table,
-    playerId: options.playerId,
-    handId: options.fromZoneId,
-    cardId: options.cardId,
-    deckId: options.toZoneId,
-    playedBy: options.playedBy,
-    position: options.position
-  });
-}
-function dealCardsBetweenPlayerZones(options) {
-  const nextTable = cloneRuntimeTable(options.table);
-  dealCardsBetweenPlayerZonesInPlace({
-    ...options,
-    table: nextTable
-  });
-  return nextTable;
-}
-function dealCardsBetweenPlayerZonesInPlace(options) {
-  assertNonNegativeSafeInteger(options.count, "Deal count");
-  if (options.count === 0) return;
-  assertZoneScope(
-    options.table,
-    options.fromZoneId,
-    "perPlayer",
-    "dealCardsBetweenPlayerZones",
-    "fromZoneId"
-  );
-  assertZoneScope(
-    options.table,
-    options.toZoneId,
-    "perPlayer",
-    "dealCardsBetweenPlayerZones",
-    "toZoneId"
-  );
-  if (options.fromZoneId === options.toZoneId) {
-    throw new Error("Deal source and destination must differ.");
-  }
-  const sourceCards = playerZoneCards(
-    options.table,
-    options.fromZoneId,
-    options.playerId
-  );
-  const selectedCards = sourceCards.slice(0, options.count);
-  const destinationCards = playerZoneCards(
-    options.table,
-    options.toZoneId,
-    options.playerId
-  );
-  for (const cardId of selectedCards) {
-    assertCardInPlayerZone(
-      options.table,
-      options.fromZoneId,
-      options.playerId,
-      cardId
-    );
-    assertCardAbsentFromPlayerZone(
-      options.table,
-      options.toZoneId,
-      options.playerId,
-      cardId
-    );
-    assertCardAllowedInZone(options.table, options.toZoneId, cardId);
-  }
-  const remainingSource = sourceCards.slice(selectedCards.length);
-  const nextDestination = [...destinationCards, ...selectedCards];
-  setPlayerZoneCardsInPlace(
-    options.table,
-    options.fromZoneId,
-    options.playerId,
-    remainingSource
-  );
-  setPlayerZoneCardsInPlace(
-    options.table,
-    options.toZoneId,
-    options.playerId,
-    nextDestination
-  );
-  for (const cardId of selectedCards) {
-    options.table.visibility[cardId] = computeVisibilityForPlayerZone(
-      options.table,
-      options.toZoneId,
-      options.playerId
-    );
-  }
-}
-function moveCardFromSharedZoneToPlayerZone(options) {
-  const nextTable = cloneRuntimeTable(options.table);
-  moveCardFromSharedZoneToPlayerZoneInPlace({
-    ...options,
-    table: nextTable
-  });
-  return nextTable;
-}
-function moveCardFromSharedZoneToPlayerZoneInPlace(options) {
-  assertZoneScope(
-    options.table,
-    options.fromZoneId,
-    "shared",
-    "moveCardFromSharedZoneToPlayerZone",
-    "fromZoneId"
-  );
-  assertZoneScope(
-    options.table,
-    options.toZoneId,
-    "perPlayer",
-    "moveCardFromSharedZoneToPlayerZone",
-    "toZoneId"
-  );
-  assertCardInSharedZone(
-    options.table,
-    options.fromZoneId,
-    options.cardId
-  );
-  assertCardAbsentFromPlayerZone(
-    options.table,
-    options.toZoneId,
-    options.playerId,
-    options.cardId
-  );
-  assertCardAllowedInZone(
-    options.table,
-    options.toZoneId,
-    options.cardId
-  );
-  const destinationCards = playerZoneCards(
-    options.table,
-    options.toZoneId,
-    options.playerId
-  );
-  const nextDestination = insertCard(
-    destinationCards,
-    options.cardId,
-    options.position ?? "bottom"
-  );
-  removeCardFromSharedZoneCollectionInPlace(
-    options.table,
-    options.fromZoneId,
-    options.cardId
-  );
-  setPlayerZoneCardsInPlace(
-    options.table,
-    options.toZoneId,
-    options.playerId,
-    nextDestination
-  );
-  options.table.ownerOfCard[options.cardId] = options.playerId;
-  options.table.visibility[options.cardId] = computeVisibilityForPlayerZone(
-    options.table,
-    options.toZoneId,
-    options.playerId
-  );
-}
-function moveCardBetweenPlayerZones(options) {
-  const nextTable = cloneRuntimeTable(options.table);
-  moveCardBetweenPlayerZonesInPlace({
-    ...options,
-    table: nextTable
-  });
-  return nextTable;
-}
-function moveCardBetweenPlayerZonesInPlace(options) {
-  assertZoneScope(
-    options.table,
-    options.fromZoneId,
-    "perPlayer",
-    "moveCardBetweenPlayerZones",
-    "fromZoneId"
-  );
-  assertZoneScope(
-    options.table,
-    options.toZoneId,
-    "perPlayer",
-    "moveCardBetweenPlayerZones",
-    "toZoneId"
-  );
-  assertCardInPlayerZone(
-    options.table,
-    options.fromZoneId,
-    options.playerId,
-    options.cardId
-  );
-  assertCardAbsentFromPlayerZone(
-    options.table,
-    options.toZoneId,
-    options.playerId,
-    options.cardId
-  );
-  assertCardAllowedInZone(
-    options.table,
-    options.toZoneId,
-    options.cardId
-  );
-  const sourceCards = playerZoneCards(
-    options.table,
-    options.fromZoneId,
-    options.playerId
-  );
-  const destinationCards = playerZoneCards(
-    options.table,
-    options.toZoneId,
-    options.playerId
-  );
-  const remainingSource = removeCard(sourceCards, options.cardId);
-  const nextDestination = insertCard(
-    destinationCards,
-    options.cardId,
-    options.position ?? "bottom"
-  );
-  setPlayerZoneCardsInPlace(
-    options.table,
-    options.fromZoneId,
-    options.playerId,
-    remainingSource
-  );
-  setPlayerZoneCardsInPlace(
-    options.table,
-    options.toZoneId,
-    options.playerId,
-    nextDestination
-  );
-  options.table.visibility[options.cardId] = computeVisibilityForPlayerZone(
-    options.table,
-    options.toZoneId,
-    options.playerId
-  );
-}
-function moveCardBetweenSharedZones(options) {
-  const nextTable = cloneRuntimeTable(options.table);
-  moveCardBetweenSharedZonesInPlace({
-    ...options,
-    table: nextTable
-  });
-  return nextTable;
-}
-function moveCardBetweenSharedZonesInPlace(options) {
-  assertZoneScope(
-    options.table,
-    options.fromZoneId,
-    "shared",
-    "moveCardBetweenSharedZones",
-    "fromZoneId"
-  );
-  assertZoneScope(
-    options.table,
-    options.toZoneId,
-    "shared",
-    "moveCardBetweenSharedZones",
-    "toZoneId"
-  );
-  assertCardInSharedZone(
-    options.table,
-    options.fromZoneId,
-    options.cardId
-  );
-  assertCardAbsentFromSharedZone(
-    options.table,
-    options.toZoneId,
-    options.cardId
-  );
-  assertCardAllowedInZone(
-    options.table,
-    options.toZoneId,
-    options.cardId
-  );
-  removeCardFromSharedZoneCollectionInPlace(
-    options.table,
-    options.fromZoneId,
-    options.cardId
-  );
-  appendCardToSharedZoneCollectionInPlace(
-    options.table,
-    options.toZoneId,
-    options.cardId,
-    options.playedBy ?? null,
-    options.position ?? "bottom"
-  );
-  options.table.ownerOfCard[options.cardId] = options.playedBy ?? null;
-  options.table.visibility[options.cardId] = {
-    faceUp: true
-  };
-}
-function removeCardFromSharedZone(table, deckId, cardId) {
-  return removeFromDeck(table, deckId, cardId);
-}
-function removeCardFromSharedZoneInPlace(table, deckId, cardId) {
-  removeFromDeckInPlace(table, deckId, cardId);
-}
-function addCardToSharedZone(table, deckId, cardId, playedBy = null, position = "bottom") {
-  return appendToDeck(table, deckId, cardId, playedBy, position);
-}
-function addCardToSharedZoneInPlace(table, deckId, cardId, playedBy = null, position = "bottom") {
-  appendToDeckInPlace(table, deckId, cardId, playedBy, position);
-}
-function dealCardsFromDeckToHand(table, fromZoneId, playerId, toZoneId, count) {
-  const nextTable = cloneRuntimeTable(table);
-  dealCardsFromDeckToHandInPlace(
-    nextTable,
-    fromZoneId,
-    playerId,
-    toZoneId,
-    count
-  );
-  return nextTable;
-}
-function dealCardsFromDeckToHandInPlace(table, fromZoneId, playerId, toZoneId, count) {
-  assertNonNegativeSafeInteger(count, "Deal count");
-  if (count === 0) return;
-  assertZoneScope(
-    table,
-    fromZoneId,
-    "shared",
-    "dealCardsFromDeckToHand",
-    "fromZoneId"
-  );
-  assertZoneScope(
-    table,
-    toZoneId,
-    "perPlayer",
-    "dealCardsFromDeckToHand",
-    "toZoneId"
-  );
-  const sourceCards = sharedZoneCards(table, fromZoneId);
-  const selectedCards = sourceCards.slice(0, count);
-  const destinationCards = playerZoneCards(
-    table,
-    toZoneId,
-    playerId
-  );
-  for (const cardId of selectedCards) {
-    assertCardInSharedZone(table, fromZoneId, cardId);
-    assertCardAbsentFromPlayerZone(
-      table,
-      toZoneId,
-      playerId,
-      cardId
-    );
-    assertCardAllowedInZone(table, toZoneId, cardId);
-  }
-  const remainingSource = sourceCards.slice(selectedCards.length);
-  const nextHand = [...destinationCards, ...selectedCards];
-  syncSharedZoneWithDeck(
-    table,
-    fromZoneId,
-    remainingSource
-  );
-  reindexSharedZoneCards(table, fromZoneId, remainingSource);
-  setPlayerZoneCardsInPlace(table, toZoneId, playerId, nextHand);
-  for (const cardId of selectedCards) {
-    table.ownerOfCard[cardId] = playerId;
-    table.visibility[cardId] = computeVisibilityForPlayerZone(
-      table,
-      toZoneId,
-      playerId
-    );
-  }
-}
-
-// src/reducer/rng.ts
-function nextRandomInt(bound, rng, operation = {
-  kind: "integer",
-  parameters: { minInclusive: 0, maxInclusive: bound - 1 }
-}) {
-  if (!Number.isSafeInteger(bound) || bound <= 0) {
-    throw new Error("Random bound must be a positive safe integer.");
-  }
-  const seed = rng.seed ?? 1;
-  const raw = hashSeedCursor(seed, rng.cursor);
-  const value = raw % bound;
-  const draw = {
-    index: rng.draws.length,
-    cursorBefore: rng.cursor,
-    cursorAfter: rng.cursor + 1,
-    operation: {
-      kind: operation.kind,
-      parameters: { ...operation.parameters }
-    }
-  };
-  return [
-    value,
-    {
-      ...rng,
-      cursor: rng.cursor + 1,
-      trace: [
-        ...rng.trace,
-        `cursor=${rng.cursor};bound=${bound};value=${value}`
-      ],
-      draws: [...rng.draws, draw]
-    },
-    draw
-  ];
-}
-function hashSeedCursor(seed, cursor) {
-  const seedLo = seed | 0;
-  const seedHi = Math.floor(seed / 4294967296) | 0;
-  let x = Math.imul(seedLo, 2654435761);
-  x = x + Math.imul(seedHi, 2246822519) | 0;
-  x = x + Math.imul(cursor | 0, 3266489917) | 0;
-  x = Math.imul(x ^ x >>> 16, 2246822507);
-  x = Math.imul(x ^ x >>> 13, 3266489909);
-  x = x ^ x >>> 16;
-  return x >>> 0;
-}
-
-// src/reducer/setup-bootstrap.ts
-function isCardComponent(table, componentId) {
-  return componentId in table.cards;
-}
-function resolveRuntimeBoardId(table, boardId, playerId) {
-  if (playerId) {
-    const perPlayerBoardId = `${boardId}:${playerId}`;
-    if (table.boards.byId[perPlayerBoardId]) {
-      return perPlayerBoardId;
-    }
-  }
-  if (table.boards.byId[boardId]) {
-    return boardId;
-  }
-  throw new Error(`Unknown board '${boardId}'.`);
-}
-function resolveContainerRef(table, ref) {
-  if (ref.type === "sharedZone") {
-    return {
-      kind: "sharedZone",
-      zoneId: ref.zoneId
-    };
-  }
-  if (ref.type === "playerZone") {
-    return {
-      kind: "playerZone",
-      zoneId: ref.zoneId,
-      playerId: ref.playerId
-    };
-  }
-  if (ref.type === "sharedBoardContainer") {
-    const board2 = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId)];
-    const container = board2?.containers[ref.containerId];
-    if (!container) {
-      throw new Error(
-        `Unknown board container '${ref.containerId}' on board '${ref.boardId}'.`
-      );
-    }
-    return {
-      kind: "container",
-      boardId: board2.id,
-      containerId: ref.containerId,
-      zoneId: container.zoneId
-    };
-  }
-  if (ref.type === "playerBoardContainer") {
-    const board2 = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId, ref.playerId)];
-    const container = board2?.containers[ref.containerId];
-    if (!container) {
-      throw new Error(
-        `Unknown board container '${ref.containerId}' on board '${ref.boardId}' for '${ref.playerId}'.`
-      );
-    }
-    return {
-      kind: "container",
-      boardId: board2.id,
-      containerId: ref.containerId,
-      zoneId: container.zoneId
-    };
-  }
-  if (ref.type === "sharedBoardSpace") {
-    const board2 = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId)];
-    if (!board2) {
-      throw new Error(`Unknown board '${ref.boardId}'.`);
-    }
-    const space2 = board2?.spaces[ref.spaceId];
-    if (!space2) {
-      throw new Error(
-        `Unknown board space '${ref.spaceId}' on board '${ref.boardId}'.`
-      );
-    }
-    return {
-      kind: "space",
-      boardId: board2.id,
-      spaceId: ref.spaceId
-    };
-  }
-  const board = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId, ref.playerId)];
-  if (!board) {
-    throw new Error(
-      `Unknown board '${ref.boardId}' for player '${ref.playerId}'.`
-    );
-  }
-  const space = board?.spaces[ref.spaceId];
-  if (!space) {
-    throw new Error(
-      `Unknown board space '${ref.spaceId}' on board '${ref.boardId}' for '${ref.playerId}'.`
-    );
-  }
-  return {
-    kind: "space",
-    boardId: board.id,
-    spaceId: ref.spaceId
-  };
-}
-function readContainerComponents(table, ref) {
-  if (ref.kind === "sharedZone") {
-    return [
-      ...ensureArray(table.zones.shared[ref.zoneId] ?? table.decks[ref.zoneId])
-    ];
-  }
-  if (ref.kind === "playerZone") {
-    const zoneValue = table.zones.perPlayer[ref.zoneId];
-    const handValue = table.hands[ref.zoneId];
-    const seat = ref.playerId;
-    return [
-      ...ensureArray(
-        (zoneValue !== void 0 ? perPlayerGet(zoneValue, seat) : void 0) ?? (handValue !== void 0 ? perPlayerGet(handValue, seat) : void 0)
-      )
-    ];
-  }
-  if (ref.kind === "space") {
-    return getComponentsOnSpace(table, ref.boardId, ref.spaceId);
-  }
-  return getComponentsInContainer(table, ref.boardId, ref.containerId);
-}
-function sharedZoneLocationFor(table, componentId, zoneId, position) {
-  if (isCardComponent(table, componentId)) {
-    return {
-      type: "InDeck",
-      deckId: zoneId,
-      playedBy: null,
-      position
-    };
-  }
-  return {
-    type: "InZone",
-    zoneId,
-    playedBy: null,
-    position
-  };
-}
-function updateCardVisibilityForZone(table, componentId, ref) {
-  if (!isCardComponent(table, componentId)) {
-    return;
-  }
-  if (ref.kind === "playerZone") {
-    const visibility = table.zones.visibility[ref.zoneId];
-    table.ownerOfCard[componentId] = ref.playerId;
-    table.visibility[componentId] = visibility === "all" || visibility === "public" ? { faceUp: true } : { faceUp: false, visibleTo: [ref.playerId] };
-    return;
-  }
-  if (ref.kind === "sharedZone") {
-    const visibility = table.zones.visibility[ref.zoneId];
-    if (visibility === "hidden" || visibility === "ownerOnly") {
-      table.visibility[componentId] = { faceUp: false };
-      return;
-    }
-    table.visibility[componentId] = { faceUp: true };
-  }
-}
-function writeContainerComponents(table, ref, componentIds) {
-  if (ref.kind === "sharedZone") {
-    componentIds.forEach((componentId) => {
-      assertCardAllowedInZone(table, ref.zoneId, componentId);
-    });
-    table.decks[ref.zoneId] = [...componentIds];
-    table.zones.shared[ref.zoneId] = [...componentIds];
-    componentIds.forEach((componentId, index) => {
-      table.componentLocations[componentId] = sharedZoneLocationFor(
-        table,
-        componentId,
-        ref.zoneId,
-        index
-      );
-      updateCardVisibilityForZone(table, componentId, ref);
-    });
-    return;
-  }
-  if (ref.kind === "playerZone") {
-    componentIds.forEach((componentId) => {
-      assertCardAllowedInZone(table, ref.zoneId, componentId);
-    });
-    const seat = ref.playerId;
-    const prevHand = table.hands[ref.zoneId] ?? {
-      __perPlayer: true,
-      entries: []
-    };
-    table.hands[ref.zoneId] = perPlayerSet(prevHand, seat, [...componentIds]);
-    const prevZone = table.zones.perPlayer[ref.zoneId] ?? {
-      __perPlayer: true,
-      entries: []
-    };
-    table.zones.perPlayer[ref.zoneId] = perPlayerSet(prevZone, seat, [
-      ...componentIds
-    ]);
-    componentIds.forEach((componentId, index) => {
-      table.componentLocations[componentId] = {
-        type: "InHand",
-        handId: ref.zoneId,
-        playerId: ref.playerId,
-        position: index
-      };
-      updateCardVisibilityForZone(table, componentId, ref);
-    });
-    return;
-  }
-  if (ref.kind === "space") {
-    componentIds.forEach((componentId, index) => {
-      table.componentLocations[componentId] = {
-        type: "OnSpace",
-        boardId: ref.boardId,
-        spaceId: ref.spaceId,
-        position: index
-      };
-    });
-    return;
-  }
-  componentIds.forEach((componentId) => {
-    assertCardAllowedInContainer(
-      table,
-      ref.boardId,
-      ref.containerId,
-      componentId
-    );
-  });
-  componentIds.forEach((componentId, index) => {
-    table.componentLocations[componentId] = {
-      type: "InContainer",
-      boardId: ref.boardId,
-      containerId: ref.containerId,
-      position: index
-    };
-  });
-}
-function selectMovedComponents(current, step) {
-  if (step.componentIds && typeof step.count === "number") {
-    throw new Error(
-      "Setup bootstrap move step cannot specify both count and componentIds."
-    );
-  }
-  if (step.componentIds) {
-    const missing = step.componentIds.filter(
-      (componentId) => !current.includes(componentId)
-    );
-    if (missing.length > 0) {
-      throw new Error(
-        `Setup bootstrap move step references missing components: ${missing.join(", ")}`
-      );
-    }
-    return [...step.componentIds];
-  }
-  if (typeof step.count === "number") {
-    return current.slice(0, step.count);
-  }
-  return [...current];
-}
-function resolveDealTargetRef(table, ref, playerId) {
-  if (ref.type === "playerZone") {
-    return {
-      kind: "playerZone",
-      zoneId: ref.zoneId,
-      playerId
-    };
-  }
-  const board = table.boards.byId[resolveRuntimeBoardId(table, ref.boardId, playerId)];
-  const container = board?.containers[ref.containerId];
-  if (!container) {
-    throw new Error(
-      `Unknown board container '${ref.containerId}' on board '${ref.boardId}' for '${playerId}'.`
-    );
-  }
-  return {
-    kind: "container",
-    boardId: board.id,
-    containerId: ref.containerId,
-    zoneId: container.zoneId
-  };
-}
-function applySetupBootstrap(state, steps) {
-  if (steps.length === 0) {
-    return state;
-  }
-  const nextTable = cloneRuntimeTable(state.table);
-  let nextRng = state.runtime.rng;
-  for (const step of steps) {
-    if (step.type === "shuffle") {
-      const container = resolveContainerRef(nextTable, step.container);
-      const shuffled = readContainerComponents(nextTable, container);
-      for (let lastIndex = shuffled.length - 1; lastIndex > 0; lastIndex -= 1) {
-        const [swapIndex, updatedRng] = nextRandomInt(lastIndex + 1, nextRng);
-        nextRng = updatedRng;
-        const current = shuffled[lastIndex];
-        const swap = shuffled[swapIndex];
-        if (current === void 0 || swap === void 0) {
-          throw new Error(
-            `setup shuffle: invalid index (lastIndex=${lastIndex}, swapIndex=${swapIndex}, length=${shuffled.length})`
-          );
-        }
-        shuffled[lastIndex] = swap;
-        shuffled[swapIndex] = current;
-      }
-      writeContainerComponents(nextTable, container, shuffled);
-      continue;
-    }
-    if (step.type === "move") {
-      const from2 = resolveContainerRef(nextTable, step.from);
-      const to = resolveContainerRef(nextTable, step.to);
-      const currentFrom = readContainerComponents(nextTable, from2);
-      const moved = selectMovedComponents(currentFrom, step);
-      const remaining = currentFrom.filter(
-        (componentId) => !moved.includes(componentId)
-      );
-      const currentTo = readContainerComponents(nextTable, to);
-      writeContainerComponents(nextTable, from2, remaining);
-      writeContainerComponents(nextTable, to, [...currentTo, ...moved]);
-      continue;
-    }
-    const from = resolveContainerRef(nextTable, step.from);
-    if (from.kind === "playerZone") {
-      throw new Error(
-        "Setup bootstrap deal steps require a shared source container."
-      );
-    }
-    const playerIds = step.playerIds ? [...step.playerIds] : [...nextTable.playerOrder];
-    let sourceComponents = readContainerComponents(nextTable, from);
-    for (const playerId of playerIds) {
-      if (sourceComponents.length === 0) {
-        break;
-      }
-      const dealt = sourceComponents.slice(0, step.count);
-      if (dealt.length === 0) {
-        break;
-      }
-      sourceComponents = sourceComponents.slice(dealt.length);
-      const target = resolveDealTargetRef(nextTable, step.to, playerId);
-      const currentTo = readContainerComponents(nextTable, target);
-      writeContainerComponents(nextTable, target, [...currentTo, ...dealt]);
-    }
-    writeContainerComponents(nextTable, from, sourceComponents);
-  }
-  return {
-    ...state,
-    table: nextTable,
-    runtime: {
-      ...state.runtime,
-      rng: nextRng
-    }
-  };
-}
-
-// 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/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 z3 } from "zod";
-function cardInput(options) {
-  const target = options.target;
-  const dependsOn = options.dependsOn?.map((dependency) => dependency.key);
-  return {
-    kind: "card",
-    schema: z3.string(),
-    eligibleTargets: ((state, playerId, q, values) => target.eligible({
-      state,
-      playerId,
-      q,
-      values
-    })),
-    validateTarget: ((state, playerId, q, targetId, values) => target.validate(
-      {
-        state,
-        playerId,
-        q,
-        values
-      },
-      targetId
-    )),
-    ...dependsOn ? { dependsOn } : {},
-    domain: (state, playerId, q, _derived, values) => ({
-      type: "cardTarget",
-      projection: "resolved",
-      targetKind: target.targetKind,
-      zoneIds: target.zoneIds,
-      eligibleTargets: target.eligible({
-        state,
-        playerId,
-        q,
-        values
-      }).map(String)
-    }),
-    meta: {
-      zoneId: target.zoneId,
-      zoneIds: target.zoneIds,
-      targetKind: target.targetKind
-    }
-  };
-}
-
-// src/reducer/definition-index.ts
-function phaseEntriesOf(definition) {
-  return Object.entries(definition.phases);
-}
-function interactionEntriesOf(phase) {
-  return Object.entries(
-    phase.interactions ?? {}
-  );
-}
-function simultaneousSubmitEntriesOf(phase) {
-  const submit = phase.submit;
-  if (!submit) return [];
-  return [
-    ["submit", submit]
-  ];
-}
-function cardActionEntriesOf(phase) {
-  return Object.entries(
-    phase.cardActions ?? {}
-  );
-}
-function stageEntriesOf(phase) {
-  return Object.entries(
-    phase.stages ?? {}
-  );
-}
-function zoneEntriesOf(phase) {
-  return Array.from(
-    phase.zones ?? []
-  );
-}
-function effectEntriesOf(phase) {
-  return Object.entries(
-    phase.effects ?? {}
-  );
-}
-function collectReducerDefinitionIndex(definition) {
-  const phaseEntries = phaseEntriesOf(definition);
-  const phasesByName = /* @__PURE__ */ new Map();
-  for (const [phaseName, phase] of phaseEntries) {
-    const interactionEntries = [
-      ...interactionEntriesOf(phase),
-      ...simultaneousSubmitEntriesOf(phase)
-    ];
-    const cardActionEntries = cardActionEntriesOf(phase).map(([cardActionId, cardAction]) => [
-      cardActionId,
-      {
-        ...cardAction,
-        __steps: cardAction.__steps,
-        inputs: {
-          cardId: cardInput({
-            target: cardTarget.zones([cardAction.playFrom]).where({
-              id: "card-type",
-              errorCode: "WRONG_CARD_TYPE",
-              message: `Card must be ${cardAction.cardType}.`,
-              test: ({ q, targetId }) => q.card.get(targetId).cardType === cardAction.cardType
-            }).build()
-          }),
-          ...cardAction.inputs ?? {}
-        }
-      }
-    ]);
-    const effects = effectEntriesOf(
-      phase
-    ).map(([effectKey, effectValue]) => [
-      effectKey,
-      {
-        id: effectValue.id ?? effectKey,
-        type: effectValue.type ?? "rollDie",
-        continuation: effectValue.__continuation
-      }
-    ]);
-    phasesByName.set(phaseName, {
-      phaseName,
-      phase,
-      interactions: [...interactionEntries, ...cardActionEntries],
-      stages: stageEntriesOf(phase),
-      zones: zoneEntriesOf(phase),
-      cardActions: cardActionEntriesOf(phase),
-      effects
-    });
-  }
-  return {
-    phaseEntries,
-    phasesByName
-  };
-}
-
-export {
-  markManifestScopedSchema,
-  isManifestScopedSchema,
-  manifestSchemaFamily,
-  createManifestStringLiteralSchema,
-  assumeManifestSchema,
-  cloneManifestDefault,
-  resolveManifestPlayerIds,
-  createManifestRuntimeSchema,
-  createManifestGameStateSchema,
-  FrameworkErrorCodes,
-  asPlayerId,
-  isPlayerId,
-  perPlayer,
-  perPlayerKeys,
-  perPlayerValues,
-  perPlayerEntries,
-  perPlayerSize,
-  perPlayerHas,
-  perPlayerGet,
-  perPlayerRequire,
-  perPlayerSet,
-  perPlayerMap,
-  isPerPlayer,
-  perPlayerSchema,
-  sharedBoardRef,
-  perPlayerBoardRef,
-  boardRef,
-  boardRefKey,
-  parseBoardRefKey,
-  boardRefSchema,
-  isSharedBoardRef,
-  isPerPlayerBoardRef,
-  createTargetRule,
-  createTargetRuleBuilder,
-  cardTarget,
-  cardInput,
-  ensureArray,
-  cloneRuntimeTable,
-  getBoard,
-  getHexBoard,
-  getTiledBoard,
-  getSquareBoard,
-  getSpace,
-  getHexSpace,
-  getSquareSpace,
-  getContainer,
-  getEdge,
-  getVertex,
-  getHexSpaceAt,
-  getSquareSpaceAt,
-  getSpaceEdges,
-  getSpaceVertices,
-  getIncidentEdges,
-  getIncidentVertices,
-  getRelatedSpaces,
-  getAdjacentSpaces,
-  getSpaceDistance,
-  getSquareNeighbors,
-  getSquareDistance,
-  getBoardsByTypeId,
-  getSpacesByTypeId,
-  getEdgesByTypeId,
-  getVerticesByTypeId,
-  getComponentsOnSpace,
-  getComponentsInContainer,
-  getComponentsOnEdge,
-  getComponentsOnVertex,
-  assertCardAllowedInContainer,
-  getComponentLocation,
-  getComponentDeckLocation,
-  getComponentHandLocation,
-  getComponentZoneLocation,
-  getComponentSpaceLocation,
-  getComponentContainerLocation,
-  getComponentEdgeLocation,
-  getComponentVertexLocation,
-  getComponentSlotLocation,
-  getSharedZoneCards,
-  getPlayerZoneCards,
-  getAllSharedZoneCards,
-  getAllPlayerZoneCards,
-  getCard,
-  getCardsById,
-  getSharedZoneCardCollection,
-  getPlayerZoneCardCollection,
-  getSlotOccupants,
-  getSlotOccupantsByHost,
-  getCardOwner,
-  getCardVisibility,
-  getPlayerOrder,
-  getPlayerResources,
-  getPlayerResourceAmount,
-  getPlayerResourceTotal,
-  getNextPlayerInOrder,
-  canAffordResources,
-  getMissingResources,
-  addPlayerResources,
-  addPlayerResourcesInPlace,
-  spendPlayerResources,
-  spendPlayerResourcesInPlace,
-  transferPlayerResources,
-  transferPlayerResourcesInPlace,
-  setPlayerResource,
-  setPlayerResourceInPlace,
-  moveComponentToSpace,
-  moveComponentToSpaceInPlace,
-  moveComponentToContainer,
-  moveComponentToContainerInPlace,
-  moveComponentToDetached,
-  moveComponentToDetachedInPlace,
-  moveComponentToEdge,
-  moveComponentToEdgeInPlace,
-  moveComponentToVertex,
-  moveComponentToVertexInPlace,
-  shufflePlayerZoneCards,
-  moveCardFromPlayerZoneToSharedZone,
-  moveCardFromPlayerZoneToSharedZoneInPlace,
-  dealCardsBetweenPlayerZones,
-  dealCardsBetweenPlayerZonesInPlace,
-  moveCardFromSharedZoneToPlayerZone,
-  moveCardFromSharedZoneToPlayerZoneInPlace,
-  moveCardBetweenPlayerZones,
-  moveCardBetweenPlayerZonesInPlace,
-  moveCardBetweenSharedZones,
-  moveCardBetweenSharedZonesInPlace,
-  removeCardFromSharedZone,
-  removeCardFromSharedZoneInPlace,
-  addCardToSharedZone,
-  addCardToSharedZoneInPlace,
-  dealCardsFromDeckToHand,
-  dealCardsFromDeckToHandInPlace,
-  setActivePlayers,
-  setPhaseState,
-  nextRandomInt,
-  collectReducerDefinitionIndex,
-  applySetupBootstrap
-};
-//# sourceMappingURL=chunk-H6VDGFL5.js.map