@dreamboard-games/sdk 0.3.0-alpha.1 → 0.4.0-alpha.0

package/dist/chunk-U5KBV2BA.js

@@ -0,0 +1,2654 @@
+// 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 WeakSet();
+function markManifestScopedSchema(schema) {
+  manifestScopedSchemas.add(schema);
+  return schema;
+}
+function isManifestScopedSchema(schema) {
+  return typeof schema === "object" && schema !== null && manifestScopedSchemas.has(schema);
+}
+function createManifestStringLiteralSchema(values) {
+  const schema = values.length === 0 ? z.string() : z.enum(toNonEmptyStringTuple(values));
+  return markManifestScopedSchema(schema);
+}
+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([])
+    }).default({
+      seed: null,
+      cursor: 0,
+      trace: []
+    }),
+    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",
+  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/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/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/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];
+  return typeof value === "number" ? value : 0;
+}
+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 (typeof value === "number") total += value;
+  }
+  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 forEachResourceEntry(amounts, visit) {
+  for (const resourceId of Object.keys(amounts)) {
+    const amount = amounts[resourceId];
+    if (typeof amount !== "number" || amount === 0) continue;
+    visit(resourceId, amount);
+  }
+}
+function canAffordResources(table, playerId, amounts) {
+  for (const resourceId of Object.keys(amounts)) {
+    const required = amounts[resourceId];
+    if (typeof required !== "number" || required <= 0) continue;
+    if (getPlayerResourceAmount(table, playerId, resourceId) < required) {
+      return false;
+    }
+  }
+  return true;
+}
+function getMissingResources(table, playerId, amounts) {
+  const missing = {};
+  for (const resourceId of Object.keys(amounts)) {
+    const required = amounts[resourceId];
+    if (typeof required !== "number" || required <= 0) continue;
+    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 };
+  forEachResourceEntry(amounts, (resourceId, amount) => {
+    if (amount < 0) {
+      throw new Error(
+        `addPlayerResources: negative amount for resource '${resourceId}'. Use spendPlayerResources or transferPlayerResources instead.`
+      );
+    }
+    next[resourceId] = (next[resourceId] ?? 0) + amount;
+  });
+  writePlayerResources(table, playerId, next);
+}
+function spendPlayerResources(table, playerId, amounts) {
+  const nextTable = { ...table };
+  spendPlayerResourcesInPlace(nextTable, playerId, amounts);
+  return nextTable;
+}
+function spendPlayerResourcesInPlace(table, playerId, 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 };
+  forEachResourceEntry(amounts, (resourceId, amount) => {
+    if (amount < 0) {
+      throw new Error(
+        `spendPlayerResources: negative amount for resource '${resourceId}'. Pass positive amounts \u2014 the op deducts them from the player.`
+      );
+    }
+    next[resourceId] = Math.max(0, (next[resourceId] ?? 0) - amount);
+  });
+  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) {
+  spendPlayerResourcesInPlace(table, fromPlayerId, amounts);
+  addPlayerResourcesInPlace(table, toPlayerId, amounts);
+}
+function setPlayerResource(table, playerId, resourceId, amount) {
+  const nextTable = { ...table };
+  setPlayerResourceInPlace(nextTable, playerId, resourceId, amount);
+  return nextTable;
+}
+function setPlayerResourceInPlace(table, playerId, resourceId, amount) {
+  if (!Number.isFinite(amount) || amount < 0) {
+    throw new Error(
+      `setPlayerResource: amount must be a non-negative finite number, got ${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 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"
+  );
+  const deckCards = [...ensureArray(table.decks[deckId])];
+  assertCardAllowedInZone(table, deckId, cardId);
+  if (position === "top") {
+    deckCards.unshift(cardId);
+  } else {
+    deckCards.push(cardId);
+  }
+  syncSharedZoneWithDeck(table, deckId, deckCards);
+  for (const [index, currentCardId] of deckCards.entries()) {
+    if (currentCardId === cardId) {
+      table.componentLocations[currentCardId] = {
+        type: "InDeck",
+        deckId,
+        playedBy,
+        position: index
+      };
+      continue;
+    }
+    const existing = table.componentLocations[currentCardId];
+    table.componentLocations[currentCardId] = {
+      type: "InDeck",
+      deckId,
+      playedBy: existing?.type === "InDeck" ? existing.playedBy : null,
+      position: index
+    };
+  }
+  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"
+  );
+  const remaining = ensureArray(table.decks[deckId]).filter(
+    (candidate) => candidate !== cardId
+  );
+  syncSharedZoneWithDeck(table, deckId, remaining);
+  for (const [index, currentCardId] of remaining.entries()) {
+    const currentLocation = table.componentLocations[currentCardId];
+    if (currentLocation?.type === "InDeck") {
+      table.componentLocations[currentCardId] = {
+        ...currentLocation,
+        position: index
+      };
+    }
+  }
+}
+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"
+  );
+  const currentHand = ensureArray(
+    ppRead(options.table.hands[options.handId], options.playerId)
+  ).filter((candidate) => candidate !== options.cardId);
+  syncPlayerZoneWithHand(
+    options.table,
+    options.handId,
+    options.playerId,
+    currentHand
+  );
+  for (const [index, currentCardId] of currentHand.entries()) {
+    options.table.componentLocations[currentCardId] = {
+      type: "InHand",
+      handId: options.handId,
+      playerId: options.playerId,
+      position: index
+    };
+  }
+  options.table.ownerOfCard[options.cardId] = options.playedBy ?? options.playerId;
+  options.table.visibility[options.cardId] = {
+    faceUp: true
+  };
+  appendToDeckInPlace(
+    options.table,
+    options.deckId,
+    options.cardId,
+    options.playedBy ?? options.playerId,
+    options.position ?? "bottom"
+  );
+}
+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) {
+  let nextTable = options.table;
+  for (let i = 0; i < options.count; i += 1) {
+    const sourceCards = ensureArray(
+      ppRead(
+        nextTable.zones.perPlayer[options.fromZoneId] ?? nextTable.hands[options.fromZoneId],
+        options.playerId
+      )
+    );
+    const topCardId = sourceCards[0];
+    if (topCardId === void 0) {
+      break;
+    }
+    moveCardBetweenPlayerZonesInPlace({
+      table: nextTable,
+      playerId: options.playerId,
+      fromZoneId: options.fromZoneId,
+      toZoneId: options.toZoneId,
+      cardId: topCardId
+    });
+  }
+}
+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"
+  );
+  const sourceCards = ensureArray(
+    options.table.zones.shared[options.fromZoneId] ?? options.table.decks[options.fromZoneId]
+  );
+  if (!sourceCards.includes(options.cardId)) {
+    throw new Error(
+      `Card '${String(options.cardId)}' is not in shared zone '${String(
+        options.fromZoneId
+      )}'.`
+    );
+  }
+  assertCardAllowedInZone(
+    options.table,
+    options.toZoneId,
+    options.cardId
+  );
+  const remainingSource = sourceCards.filter(
+    (candidate) => candidate !== options.cardId
+  );
+  syncSharedZoneWithDeck(options.table, options.fromZoneId, remainingSource);
+  for (const [index, currentCardId] of remainingSource.entries()) {
+    const existing = options.table.componentLocations[currentCardId];
+    if (existing?.type === "InDeck") {
+      options.table.componentLocations[currentCardId] = {
+        ...existing,
+        position: index
+      };
+    }
+  }
+  const destinationCards = ensureArray(
+    ppRead(
+      options.table.zones.perPlayer[options.toZoneId] ?? options.table.hands[options.toZoneId],
+      options.playerId
+    )
+  );
+  const nextDestination = options.position === "top" ? [options.cardId, ...destinationCards] : [...destinationCards, options.cardId];
+  syncPlayerZoneWithHand(
+    options.table,
+    options.toZoneId,
+    options.playerId,
+    nextDestination
+  );
+  for (const [index, currentCardId] of nextDestination.entries()) {
+    options.table.componentLocations[currentCardId] = {
+      type: "InHand",
+      handId: options.toZoneId,
+      playerId: options.playerId,
+      position: index
+    };
+  }
+  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"
+  );
+  const sourceCards = ensureArray(
+    ppRead(
+      options.table.zones.perPlayer[options.fromZoneId] ?? options.table.hands[options.fromZoneId],
+      options.playerId
+    )
+  );
+  if (!sourceCards.includes(options.cardId)) {
+    throw new Error(
+      `Card '${String(options.cardId)}' is not in zone '${String(
+        options.fromZoneId
+      )}' for player '${String(options.playerId)}'.`
+    );
+  }
+  assertCardAllowedInZone(
+    options.table,
+    options.toZoneId,
+    options.cardId
+  );
+  const remainingSource = sourceCards.filter(
+    (candidate) => candidate !== options.cardId
+  );
+  syncPlayerZoneWithHand(
+    options.table,
+    options.fromZoneId,
+    options.playerId,
+    remainingSource
+  );
+  for (const [index, currentCardId] of remainingSource.entries()) {
+    const existing = options.table.componentLocations[currentCardId];
+    if (existing?.type === "InHand") {
+      options.table.componentLocations[currentCardId] = {
+        ...existing,
+        position: index
+      };
+    }
+  }
+  const destinationCards = ensureArray(
+    ppRead(
+      options.table.zones.perPlayer[options.toZoneId] ?? options.table.hands[options.toZoneId],
+      options.playerId
+    )
+  );
+  const nextDestination = options.position === "top" ? [options.cardId, ...destinationCards] : [...destinationCards, options.cardId];
+  syncPlayerZoneWithHand(
+    options.table,
+    options.toZoneId,
+    options.playerId,
+    nextDestination
+  );
+  for (const [index, currentCardId] of nextDestination.entries()) {
+    options.table.componentLocations[currentCardId] = {
+      type: "InHand",
+      handId: options.toZoneId,
+      playerId: options.playerId,
+      position: index
+    };
+  }
+  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) {
+  removeFromDeckInPlace(options.table, options.fromZoneId, options.cardId);
+  appendToDeckInPlace(
+    options.table,
+    options.toZoneId,
+    options.cardId,
+    options.playedBy ?? null,
+    options.position ?? "bottom"
+  );
+}
+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) {
+  const publicHands = new Set(
+    Object.entries(table.handVisibility).filter(([, mode]) => mode === "all" || mode === "public").map(([handId]) => handId)
+  );
+  for (let index = 0; index < count; index += 1) {
+    const nextCard = ensureArray(table.decks[fromZoneId])[0];
+    if (!nextCard) {
+      break;
+    }
+    table.decks[fromZoneId] = ensureArray(table.decks[fromZoneId]).slice(
+      1
+    );
+    table.zones.shared[fromZoneId] = [
+      ...ensureArray(table.decks[fromZoneId])
+    ];
+    const prevHand = ppRead(table.hands[toZoneId], playerId);
+    const nextHand = [...ensureArray(prevHand), nextCard];
+    assertCardAllowedInZone(table, toZoneId, nextCard);
+    table.hands[toZoneId] = ppWrite(
+      table.hands[toZoneId],
+      playerId,
+      nextHand
+    );
+    table.zones.perPlayer[toZoneId] = ppWrite(
+      table.zones.perPlayer[toZoneId],
+      playerId,
+      [...nextHand]
+    );
+    table.componentLocations[nextCard] = {
+      type: "InHand",
+      handId: toZoneId,
+      playerId,
+      position: nextHand.length - 1
+    };
+    table.ownerOfCard[nextCard] = playerId;
+    table.visibility[nextCard] = publicHands.has(toZoneId) ? {
+      faceUp: true
+    } : {
+      faceUp: false,
+      visibleTo: [playerId]
+    };
+  }
+}
+
+// src/reducer/rng.ts
+function nextRandomInt(bound, rng) {
+  if (bound <= 0) {
+    throw new Error("Random bound must be positive.");
+  }
+  const seed = rng.seed ?? 1;
+  const raw = hashSeedCursor(seed, rng.cursor);
+  const value = raw % bound;
+  return [
+    value,
+    {
+      ...rng,
+      cursor: rng.cursor + 1,
+      trace: [
+        ...rng.trace,
+        `cursor=${rng.cursor};bound=${bound};value=${value}`
+      ]
+    }
+  ];
+}
+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/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,
+  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-U5KBV2BA.js.map