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

package/dist/reducer.js

@@ -1,7 +1,8 @@
 import {
   REDUCER_CONTRACT_VERSION,
-  ReducerSessionStateSchema
-} from "./chunk-MKXPVOUT.js";
+  builders_exports,
+  zod_exports
+} from "./chunk-Y2AFYBMB.js";
 import "./chunk-PZ5AY32C.js";
 
 // src/reducer/model/manifest.ts
@@ -1748,7 +1749,7 @@ function createRuntimeInstructionEngine({
   };
 }
 
-// src/reducer/table-ops.ts
+// src/reducer/table/internal.ts
 function ppRead(value, playerId) {
   if (value === void 0) return void 0;
   return perPlayerGet(value, playerId);
@@ -1768,9 +1769,6 @@ function orderedComponentIdsForLocation(table, predicate) {
     (left, right) => locationPosition(left[1]) - locationPosition(right[1])
   ).map(([componentId]) => componentId);
 }
-function allowedCardSetIdsForZone(table, zoneId) {
-  return table.zones.cardSetIdsByZoneId?.[zoneId] ?? [];
-}
 function hasOwnKey(record, key) {
   return Object.prototype.hasOwnProperty.call(record, key);
 }
@@ -1803,51 +1801,24 @@ function assertZoneScope(table, zoneId, expectedScope, operation, argumentName)
     `Zone '${zoneId}' has scope '${actualScope}', but ${operation} requires ${argumentName} to be a ${expectedScope === "shared" ? "shared" : "perPlayer"} zone.`
   );
 }
-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 syncSharedZoneWithDeck(table, zoneId, nextCards) {
+  table.decks[zoneId] = [...nextCards];
+  table.zones.shared[zoneId] = [
+    ...nextCards
+  ];
 }
-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 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/clone.ts
 function cloneRuntimeBoardState(board) {
   if (board.layout !== "generic") {
     return {
@@ -1991,623 +1962,251 @@ function cloneRuntimeTable(table) {
     )
   };
 }
-function syncSharedZoneWithDeck(table, zoneId, nextCards) {
-  table.decks[zoneId] = [...nextCards];
-  table.zones.shared[zoneId] = [
-    ...nextCards
-  ];
+
+// src/reducer/table/board-queries.ts
+function getBoard(table, boardId) {
+  return table.boards.byId[boardId];
 }
-function shufflePlayerZoneCards(table, zoneId, playerId, nextCards) {
-  if (nextCards === void 0) {
-    const fromZone = ppRead(
-      table.zones.perPlayer[zoneId] ?? table.hands[zoneId],
-      playerId
-    );
-    return [...ensureArray(fromZone)];
+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}'.`);
   }
-  table.hands[zoneId] = ppWrite(table.hands[zoneId], playerId, [
-    ...nextCards
-  ]);
-  table.zones.perPlayer[zoneId] = ppWrite(
-    table.zones.perPlayer[zoneId],
-    playerId,
-    [...nextCards]
+  return edge;
+}
+function getVertex(table, boardId, vertexId) {
+  const vertex = getTiledBoard(table, boardId).vertices.find(
+    (candidate) => candidate.id === vertexId
   );
-  return [...nextCards];
+  if (!vertex) {
+    throw new Error(`Unknown vertex '${vertexId}' on board '${boardId}'.`);
+  }
+  return vertex;
 }
-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]
+function getHexSpaceAt(table, boardId, q, r) {
+  return Object.values(getHexBoard(table, boardId).spaces).find(
+    (space) => space.q === q && space.r === r
   );
 }
-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 getSquareSpaceAt(table, boardId, row, col) {
+  return Object.values(getSquareBoard(table, boardId).spaces).find(
+    (space) => space.row === row && space.col === col
   );
 }
-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 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 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 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 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 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 reindexSlotOccupants(table, host, slotId) {
-  orderedComponentIdsForLocation(
+function getAdjacentSpaces(table, boardId, spaceId) {
+  return getRelatedSpaces(
     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
-      };
-    }
-  });
+    boardId,
+    spaceId,
+    "adjacent"
+  );
 }
-function removeComponentFromCurrentLocation(table, componentId) {
-  const currentLocation = table.componentLocations[componentId];
-  if (!currentLocation) {
-    return;
+function getSpaceDistance(table, boardId, fromSpaceId, toSpaceId) {
+  if (fromSpaceId === toSpaceId) {
+    return 0;
   }
-  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 appendToDeck(table, deckId, cardId, playedBy = null, position = "bottom") {
-  const nextTable = cloneRuntimeTable(table);
-  assertZoneScope(
-    nextTable,
-    deckId,
-    "shared",
-    "addCardToSharedZone",
-    "zoneId"
-  );
-  const deckCards = [
-    ...ensureArray(nextTable.decks[deckId])
-  ];
-  assertCardAllowedInZone(nextTable, deckId, cardId);
-  if (position === "top") {
-    deckCards.unshift(cardId);
-  } else {
-    deckCards.push(cardId);
-  }
-  syncSharedZoneWithDeck(nextTable, deckId, deckCards);
-  for (const [index, currentCardId] of deckCards.entries()) {
-    if (currentCardId === cardId) {
-      nextTable.componentLocations[currentCardId] = {
-        type: "InDeck",
-        deckId,
-        playedBy,
-        position: index
-      };
-      continue;
-    }
-    const existing = nextTable.componentLocations[currentCardId];
-    nextTable.componentLocations[currentCardId] = {
-      type: "InDeck",
-      deckId,
-      playedBy: existing?.type === "InDeck" ? existing.playedBy : null,
-      position: index
-    };
-  }
-  nextTable.ownerOfCard[cardId] = playedBy;
-  nextTable.visibility[cardId] = {
-    faceUp: true
-  };
-  return nextTable;
-}
-function removeFromDeck(table, deckId, cardId) {
-  const nextTable = cloneRuntimeTable(table);
-  assertZoneScope(
-    nextTable,
-    deckId,
-    "shared",
-    "removeCardFromSharedZone",
-    "zoneId"
-  );
-  const remaining = ensureArray(nextTable.decks[deckId]).filter(
-    (candidate) => candidate !== cardId
-  );
-  syncSharedZoneWithDeck(nextTable, deckId, remaining);
-  for (const [index, currentCardId] of remaining.entries()) {
-    const currentLocation = nextTable.componentLocations[currentCardId];
-    if (currentLocation?.type === "InDeck") {
-      nextTable.componentLocations[currentCardId] = {
-        ...currentLocation,
-        position: index
-      };
-    }
-  }
-  return nextTable;
-}
-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);
-  assertZoneScope(
-    nextTable,
-    options.handId,
-    "perPlayer",
-    "moveCardFromPlayerZoneToSharedZone",
-    "fromZoneId"
-  );
-  assertZoneScope(
-    nextTable,
-    options.deckId,
-    "shared",
-    "moveCardFromPlayerZoneToSharedZone",
-    "toZoneId"
-  );
-  const currentHand = ensureArray(
-    ppRead(nextTable.hands[options.handId], options.playerId)
-  ).filter((candidate) => candidate !== options.cardId);
-  syncPlayerZoneWithHand(
-    nextTable,
-    options.handId,
-    options.playerId,
-    currentHand
-  );
-  for (const [index, currentCardId] of currentHand.entries()) {
-    nextTable.componentLocations[currentCardId] = {
-      type: "InHand",
-      handId: options.handId,
-      playerId: options.playerId,
-      position: index
-    };
-  }
-  nextTable.ownerOfCard[options.cardId] = options.playedBy ?? options.playerId;
-  nextTable.visibility[options.cardId] = {
-    faceUp: true
-  };
-  return appendToDeck(
-    nextTable,
-    options.deckId,
-    options.cardId,
-    options.playedBy ?? options.playerId,
-    options.position ?? "bottom"
-  );
-}
-function setActivePlayers(state, activePlayers) {
-  return {
-    ...state,
-    flow: {
-      ...state.flow,
-      activePlayers
-    }
-  };
-}
-function setPhaseState(state, phaseState) {
-  return {
-    ...state,
-    phase: phaseState
-  };
-}
-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);
+  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 [...seen];
+  return Number.POSITIVE_INFINITY;
 }
-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 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 getAllPlayerZoneCards(table, zoneId) {
-  const result = {};
-  for (const playerId of table.playerOrder) {
-    result[playerId] = getPlayerZoneCards(
-      table,
-      playerId,
-      zoneId
-    );
-  }
-  return result;
+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 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 getBoardsByTypeId(table, typeId) {
+  return Object.entries(table.boards.byId).filter(([, board]) => board.typeId === typeId).map(([boardId]) => boardId);
 }
-function getCardsById(table, cardIds) {
-  return Object.fromEntries(
-    cardIds.map((cardId) => [
-      cardId,
-      table.cards[cardId] ? getCard(table, cardId) : void 0
-    ])
-  );
+function getSpacesByTypeId(table, boardId, typeId) {
+  return Object.entries(getBoard(table, boardId).spaces).filter(([, space]) => space.typeId === typeId).map(([spaceId]) => spaceId);
 }
-function getSharedZoneCardCollection(table, zoneId) {
-  const cardIds = getSharedZoneCards(table, zoneId);
-  return {
-    cardIds,
-    cardsById: getCardsById(table, cardIds)
-  };
+function getEdgesByTypeId(table, boardId, typeId) {
+  return getTiledBoard(table, boardId).edges.filter((edge) => edge.typeId === typeId).map((edge) => edge.id);
 }
-function getPlayerZoneCardCollection(table, playerId, zoneId) {
-  const cardIds = getPlayerZoneCards(table, playerId, zoneId);
-  return {
-    cardIds,
-    cardsById: getCardsById(table, cardIds)
-  };
+function getVerticesByTypeId(table, boardId, typeId) {
+  return getTiledBoard(table, boardId).vertices.filter((vertex) => vertex.typeId === typeId).map((vertex) => vertex.id);
 }
-function getSlotOccupants(table, host, slotId) {
+function getComponentsOnSpace(table, boardId, spaceId) {
+  const zoneId = getSpace(table, boardId, spaceId).zoneId;
   return orderedComponentIdsForLocation(
     table,
-    (location) => matchesSlotHost(location, host, slotId)
-  ).map((componentId) => ({
-    pieceId: componentId,
-    playerId: componentPlayerId(
-      table,
-      componentId
-    ),
-    slotId,
-    data: componentData(table, componentId)
-  }));
+    (location) => location.type === "OnSpace" && location.boardId === boardId && location.spaceId === spaceId || location.type === "InZone" && typeof zoneId === "string" && zoneId.length > 0 && location.zoneId === zoneId
+  );
 }
-function getSlotOccupantsByHost(table, host) {
-  const occupantsBySlot = {};
-  orderedComponentIdsForLocation(
+function getComponentsInContainer(table, boardId, containerId) {
+  const zoneId = getContainer(table, boardId, containerId).zoneId;
+  return 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];
-}
-function getPlayerOrder(table) {
-  return table.playerOrder;
-}
-function getPlayerResources(table, playerId) {
-  return perPlayerGet(
-    table.resources,
-    playerId
+    (location) => location.type === "InContainer" && location.boardId === boardId && location.containerId === containerId || location.type === "InZone" && typeof zoneId === "string" && zoneId.length > 0 && location.zoneId === zoneId
   );
 }
-function getPlayerResourceAmount(table, playerId, resourceId) {
-  const playerResources = perPlayerGet(
-    table.resources,
-    playerId
+function getComponentsOnEdge(table, boardId, edgeId) {
+  return orderedComponentIdsForLocation(
+    table,
+    (location) => location.type === "OnEdge" && location.boardId === boardId && location.edgeId === edgeId
   );
-  if (!playerResources) return 0;
-  const value = playerResources[resourceId];
-  return typeof value === "number" ? value : 0;
 }
-function getPlayerResourceTotal(table, playerId) {
-  const playerResources = perPlayerGet(
-    table.resources,
-    playerId
+function getComponentsOnVertex(table, boardId, vertexId) {
+  return orderedComponentIdsForLocation(
+    table,
+    (location) => location.type === "OnVertex" && location.boardId === boardId && location.vertexId === vertexId
   );
-  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 withPlayerResources(table, playerId, nextForPlayer) {
-  return {
-    ...table,
-    resources: perPlayerSet(
-      table.resources,
-      playerId,
-      nextForPlayer
-    )
-  };
 }
-function addPlayerResources(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;
-  });
-  return withPlayerResources(table, playerId, next);
+
+// src/reducer/table/card-validation.ts
+function allowedCardSetIdsForZone(table, zoneId) {
+  return table.zones.cardSetIdsByZoneId?.[zoneId] ?? [];
 }
-function spendPlayerResources(table, playerId, amounts) {
-  if (!canAffordResources(table, playerId, amounts)) {
-    const missing = getMissingResources(table, playerId, amounts);
+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(
-      `spendPlayerResources: player '${playerId}' cannot afford ${JSON.stringify(
-        missing
-      )}. Check canAfford in your validate step first.`
+      `Card '${componentId}' from card set '${card.cardSetId}' cannot enter zone '${zoneId}'.`
     );
   }
-  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);
-  });
-  return withPlayerResources(table, playerId, next);
-}
-function transferPlayerResources(table, fromPlayerId, toPlayerId, amounts) {
-  const afterSpend = spendPlayerResources(table, fromPlayerId, amounts);
-  return addPlayerResources(afterSpend, toPlayerId, amounts);
 }
-function setPlayerResource(table, playerId, resourceId, amount) {
-  if (!Number.isFinite(amount) || amount < 0) {
+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(
-      `setPlayerResource: amount must be a non-negative finite number, got ${amount}.`
+      `Card '${componentId}' from card set '${card.cardSetId}' cannot enter container '${containerId}' on board '${boardId}'.`
     );
   }
-  const prev = perPlayerGet(
-    table.resources,
-    playerId
-  ) ?? {};
-  return withPlayerResources(table, playerId, {
-    ...prev,
-    [resourceId]: amount
-  });
 }
+
+// src/reducer/table/component-locations.ts
 function getComponentLocation(table, componentId) {
   return table.componentLocations[componentId];
 }
@@ -2726,229 +2325,493 @@ function getComponentSlotLocation(table, componentId) {
     location
   };
 }
-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);
+
+// 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 getSpace(table, boardId, spaceId) {
-  return getBoard(table, boardId).spaces[spaceId];
+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 getHexSpace(table, boardId, spaceId) {
-  return getHexBoard(table, boardId).spaces[spaceId];
+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 getSquareSpace(table, boardId, spaceId) {
-  return getSquareBoard(table, boardId).spaces[spaceId];
+function getSharedZoneCards(table, zoneId) {
+  assertZoneScope(
+    table,
+    zoneId,
+    "shared",
+    "getSharedZoneCards",
+    "zoneId"
+  );
+  return [
+    ...ensureArray(table.zones.shared[zoneId] ?? table.decks[zoneId])
+  ];
 }
-function getContainer(table, boardId, containerId) {
-  return getBoard(table, boardId).containers[containerId];
+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 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}'.`
-    );
+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 getEdge(table, boardId, edgeId) {
-  const edge = getTiledBoard(table, boardId).edges.find(
-    (candidate) => candidate.id === edgeId
+function getAllSharedZoneCards(table) {
+  const zoneIds = collectZoneIds(
+    table.zones.shared,
+    table.decks
   );
-  if (!edge) {
-    throw new Error(`Unknown edge '${edgeId}' on board '${boardId}'.`);
+  const result = {};
+  for (const zoneId of zoneIds) {
+    result[zoneId] = getSharedZoneCards(
+      table,
+      zoneId
+    );
   }
-  return edge;
+  return result;
 }
-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}'.`);
+function getAllPlayerZoneCards(table, zoneId) {
+  const result = {};
+  for (const playerId of table.playerOrder) {
+    result[playerId] = getPlayerZoneCards(
+      table,
+      playerId,
+      zoneId
+    );
   }
-  return vertex;
+  return result;
 }
-function getHexSpaceAt(table, boardId, q, r) {
-  return Object.values(getHexBoard(table, boardId).spaces).find(
-    (space) => space.q === q && space.r === r
+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 getSquareSpaceAt(table, boardId, row, col) {
-  return Object.values(getSquareBoard(table, boardId).spaces).find(
-    (space) => space.row === row && space.col === col
+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 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 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 getIncidentEdges(table, boardId, vertexId) {
-  const tiledBoard = getTiledBoard(table, boardId);
-  const vertex = tiledBoard.vertices.find(
-    (candidate) => candidate.id === vertexId
+function getPlayerResourceTotal(table, playerId) {
+  const playerResources = perPlayerGet(
+    table.resources,
+    playerId
   );
-  if (!vertex) {
-    throw new Error(`Unknown vertex '${vertexId}' on board '${boardId}'.`);
+  if (!playerResources) return 0;
+  let total = 0;
+  for (const key of Object.keys(playerResources)) {
+    const value = playerResources[key];
+    if (typeof value === "number") total += value;
   }
-  const vertexSpaceIds = new Set(vertex.spaceIds);
-  return tiledBoard.edges.filter(
-    (edge) => edge.spaceIds.every((spaceId) => vertexSpaceIds.has(spaceId))
-  ).map((edge) => edge.id);
+  return total;
 }
-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}'.`);
+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);
   }
-  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);
+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 [...related];
-}
-function getAdjacentSpaces(table, boardId, spaceId) {
-  return getRelatedSpaces(
-    table,
-    boardId,
-    spaceId,
-    "adjacent"
-  );
+  return true;
 }
-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;
+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 Number.POSITIVE_INFINITY;
+  return missing;
 }
-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
+function withPlayerResources(table, playerId, nextForPlayer) {
+  return {
+    ...table,
+    resources: perPlayerSet(
+      table.resources,
+      playerId,
+      nextForPlayer
     )
-  ).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 addPlayerResources(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;
+  });
+  return withPlayerResources(table, playerId, next);
 }
-function getSpacesByTypeId(table, boardId, typeId) {
-  return Object.entries(getBoard(table, boardId).spaces).filter(([, space]) => space.typeId === typeId).map(([spaceId]) => spaceId);
+function spendPlayerResources(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);
+  });
+  return withPlayerResources(table, playerId, next);
 }
-function getEdgesByTypeId(table, boardId, typeId) {
-  return getTiledBoard(table, boardId).edges.filter((edge) => edge.typeId === typeId).map((edge) => edge.id);
+function transferPlayerResources(table, fromPlayerId, toPlayerId, amounts) {
+  const afterSpend = spendPlayerResources(table, fromPlayerId, amounts);
+  return addPlayerResources(afterSpend, toPlayerId, amounts);
 }
-function getVerticesByTypeId(table, boardId, typeId) {
-  return getTiledBoard(table, boardId).vertices.filter((vertex) => vertex.typeId === typeId).map((vertex) => vertex.id);
+function setPlayerResource(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
+  ) ?? {};
+  return withPlayerResources(table, playerId, {
+    ...prev,
+    [resourceId]: amount
+  });
 }
-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
+
+// 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 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 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 getComponentsOnEdge(table, boardId, edgeId) {
-  return orderedComponentIdsForLocation(
+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 getComponentsOnVertex(table, boardId, vertexId) {
-  return orderedComponentIdsForLocation(
+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);
@@ -2979,37 +2842,176 @@ function moveComponentToContainer(table, componentId, boardId, containerId) {
   };
   return nextTable;
 }
-function moveComponentToDetached(table, componentId) {
+function moveComponentToDetached(table, componentId) {
+  const nextTable = cloneRuntimeTable(table);
+  removeComponentFromCurrentLocation(nextTable, componentId);
+  nextTable.componentLocations[componentId] = { type: "Detached" };
+  return nextTable;
+}
+function moveComponentToEdge(table, componentId, boardId, edgeId) {
+  const nextTable = cloneRuntimeTable(table);
+  getEdge(nextTable, boardId, edgeId);
+  const position = getComponentsOnEdge(nextTable, boardId, edgeId).length;
+  removeComponentFromCurrentLocation(nextTable, componentId);
+  nextTable.componentLocations[componentId] = {
+    type: "OnEdge",
+    boardId,
+    edgeId,
+    position
+  };
+  return nextTable;
+}
+function moveComponentToVertex(table, componentId, boardId, vertexId) {
+  const nextTable = cloneRuntimeTable(table);
+  getVertex(nextTable, boardId, vertexId);
+  const position = getComponentsOnVertex(nextTable, boardId, vertexId).length;
+  removeComponentFromCurrentLocation(nextTable, componentId);
+  nextTable.componentLocations[componentId] = {
+    type: "OnVertex",
+    boardId,
+    vertexId,
+    position
+  };
+  return nextTable;
+}
+
+// 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);
+  assertZoneScope(
+    nextTable,
+    deckId,
+    "shared",
+    "addCardToSharedZone",
+    "zoneId"
+  );
+  const deckCards = [
+    ...ensureArray(nextTable.decks[deckId])
+  ];
+  assertCardAllowedInZone(nextTable, deckId, cardId);
+  if (position === "top") {
+    deckCards.unshift(cardId);
+  } else {
+    deckCards.push(cardId);
+  }
+  syncSharedZoneWithDeck(nextTable, deckId, deckCards);
+  for (const [index, currentCardId] of deckCards.entries()) {
+    if (currentCardId === cardId) {
+      nextTable.componentLocations[currentCardId] = {
+        type: "InDeck",
+        deckId,
+        playedBy,
+        position: index
+      };
+      continue;
+    }
+    const existing = nextTable.componentLocations[currentCardId];
+    nextTable.componentLocations[currentCardId] = {
+      type: "InDeck",
+      deckId,
+      playedBy: existing?.type === "InDeck" ? existing.playedBy : null,
+      position: index
+    };
+  }
+  nextTable.ownerOfCard[cardId] = playedBy;
+  nextTable.visibility[cardId] = {
+    faceUp: true
+  };
+  return nextTable;
+}
+function removeFromDeck(table, deckId, cardId) {
   const nextTable = cloneRuntimeTable(table);
-  removeComponentFromCurrentLocation(nextTable, componentId);
-  nextTable.componentLocations[componentId] = { type: "Detached" };
+  assertZoneScope(
+    nextTable,
+    deckId,
+    "shared",
+    "removeCardFromSharedZone",
+    "zoneId"
+  );
+  const remaining = ensureArray(nextTable.decks[deckId]).filter(
+    (candidate) => candidate !== cardId
+  );
+  syncSharedZoneWithDeck(nextTable, deckId, remaining);
+  for (const [index, currentCardId] of remaining.entries()) {
+    const currentLocation = nextTable.componentLocations[currentCardId];
+    if (currentLocation?.type === "InDeck") {
+      nextTable.componentLocations[currentCardId] = {
+        ...currentLocation,
+        position: index
+      };
+    }
+  }
   return nextTable;
 }
-function moveComponentToEdge(table, componentId, boardId, edgeId) {
-  const nextTable = cloneRuntimeTable(table);
-  getEdge(nextTable, boardId, edgeId);
-  const position = getComponentsOnEdge(nextTable, boardId, edgeId).length;
-  removeComponentFromCurrentLocation(nextTable, componentId);
-  nextTable.componentLocations[componentId] = {
-    type: "OnEdge",
-    boardId,
-    edgeId,
-    position
-  };
-  return nextTable;
+function computeVisibilityForPlayerZone(table, zoneId, playerId) {
+  const mode = table.handVisibility[zoneId];
+  if (mode === "all" || mode === "public") {
+    return { faceUp: true };
+  }
+  return { faceUp: false, visibleTo: [playerId] };
 }
-function moveComponentToVertex(table, componentId, boardId, vertexId) {
-  const nextTable = cloneRuntimeTable(table);
-  getVertex(nextTable, boardId, vertexId);
-  const position = getComponentsOnVertex(nextTable, boardId, vertexId).length;
-  removeComponentFromCurrentLocation(nextTable, componentId);
-  nextTable.componentLocations[componentId] = {
-    type: "OnVertex",
-    boardId,
-    vertexId,
-    position
+function moveFromHandToDeck(options) {
+  const nextTable = cloneRuntimeTable(options.table);
+  assertZoneScope(
+    nextTable,
+    options.handId,
+    "perPlayer",
+    "moveCardFromPlayerZoneToSharedZone",
+    "fromZoneId"
+  );
+  assertZoneScope(
+    nextTable,
+    options.deckId,
+    "shared",
+    "moveCardFromPlayerZoneToSharedZone",
+    "toZoneId"
+  );
+  const currentHand = ensureArray(
+    ppRead(nextTable.hands[options.handId], options.playerId)
+  ).filter((candidate) => candidate !== options.cardId);
+  syncPlayerZoneWithHand(
+    nextTable,
+    options.handId,
+    options.playerId,
+    currentHand
+  );
+  for (const [index, currentCardId] of currentHand.entries()) {
+    nextTable.componentLocations[currentCardId] = {
+      type: "InHand",
+      handId: options.handId,
+      playerId: options.playerId,
+      position: index
+    };
+  }
+  nextTable.ownerOfCard[options.cardId] = options.playedBy ?? options.playerId;
+  nextTable.visibility[options.cardId] = {
+    faceUp: true
   };
-  return nextTable;
+  return appendToDeck(
+    nextTable,
+    options.deckId,
+    options.cardId,
+    options.playedBy ?? options.playerId,
+    options.position ?? "bottom"
+  );
 }
 function moveCardFromPlayerZoneToSharedZone(options) {
   return moveFromHandToDeck({
@@ -3264,6 +3266,23 @@ function dealCardsFromDeckToHand(table, fromZoneId, playerId, toZoneId, count) {
   return nextTable;
 }
 
+// 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/rng.ts
 function nextRandomInt(bound, rng) {
   if (bound <= 0) {
@@ -4904,33 +4923,7 @@ function createTrustedInstructionRunner(scope, interactions, lifecycle) {
   };
 }
 
-// src/reducer/parse-utils.ts
-function formatIssue(label, issue) {
-  const path = issue.path.map(
-    (segment) => typeof segment === "symbol" ? segment.toString() : String(segment)
-  ).join(".");
-  return `${path || label}: ${issue.message}`;
-}
-function safeParseOrThrow(schema, value, label) {
-  const parsed = schema.safeParse(value);
-  if (!parsed.success) {
-    const message = parsed.error.issues.map((issue) => formatIssue(label, issue)).join("; ");
-    throw new Error(message || `Invalid ${label}`);
-  }
-  return parsed.data;
-}
-
-// src/reducer/bundle/trusted/interaction-types.ts
-function makeValidationError(errorCode, message) {
-  return {
-    valid: false,
-    errorCode,
-    message
-  };
-}
-
-// src/reducer/bundle/trusted/interaction-collectors.ts
-var MAX_EAGER_DEPENDENT_DOMAIN_CASES = 64;
+// src/reducer/bundle/trusted/collector-introspection.ts
 function collectTargetDomainMetadata(collector) {
   switch (collector.kind) {
     case "card": {
@@ -4956,128 +4949,44 @@ function collectTargetDomainMetadata(collector) {
       return {};
   }
 }
-function withSelection(domain, collector) {
-  if (!collector.selection) return domain;
-  return { ...domain, selection: collector.selection };
-}
-function lazyTargetDomainFromCollectorMetadata(key, collector, dependencies) {
-  const metadata = collectTargetDomainMetadata(collector);
-  if (collector.kind === "card") {
-    return withSelection(
-      {
-        type: "cardTarget",
-        projection: "lazy",
-        targetKind: "card",
-        zoneIds: metadata.zoneIds ?? (metadata.zoneId === void 0 ? [] : [metadata.zoneId]),
-        dependencies: {
-          mode: "lazy",
-          dependsOn: dependencies,
-          resolver: { inputKey: key }
-        }
-      },
-      collector
-    );
-  }
-  if (collector.kind === "board-edge" || collector.kind === "board-space" || collector.kind === "board-tile" || collector.kind === "board-vertex") {
-    return withSelection(
-      {
-        type: "boardTarget",
-        projection: "lazy",
-        targetKind: metadata.targetKind ?? collector.kind.replace("board-", ""),
-        boardId: metadata.boardId ?? "",
-        ...metadata.valueKind ? { valueKind: metadata.valueKind } : {},
-        dependencies: {
-          mode: "lazy",
-          dependsOn: dependencies,
-          resolver: { inputKey: key }
-        }
-      },
-      collector
-    );
-  }
-  return null;
+function interactionInputsOf(interaction) {
+  return interaction.inputs;
 }
-function finiteValuesForDependency(key, domain) {
-  if (!domain) {
-    throw new Error(
-      `Interaction input '${key}' is declared as a dependency before it has a projected domain.`
-    );
-  }
-  if (domain.type === "cardTarget" || domain.type === "boardTarget") {
-    if (domain.projection !== "resolved") {
-      throw new Error(
-        `Interaction input '${key}' cannot be used as a dependency because its target domain is not finite.`
-      );
+function collectFirstCardZoneId(interaction) {
+  const collectors = interactionInputsOf(interaction);
+  for (const collector of Object.values(collectors)) {
+    if (collector.kind === "card") {
+      if (collector.meta.zoneId.length > 0) {
+        return collector.meta.zoneId;
+      }
     }
-    return [...domain.eligibleTargets];
-  }
-  if (domain.type === "choice") {
-    return domain.choices.flatMap(
-      (choice) => choice.value === null ? [] : [choice.value]
-    );
   }
-  throw new Error(
-    `Interaction input '${key}' cannot be used as a dependency. V1 supports finite target and choice dependencies only.`
-  );
-}
-function cartesianDependencyTuples(dependencies, domainsByKey) {
-  return dependencies.reduce(
-    (tuples, key) => {
-      const values = finiteValuesForDependency(key, domainsByKey[key]);
-      return tuples.flatMap(
-        (tuple) => values.map((value) => ({ ...tuple, [key]: value }))
-      );
-    },
-    [{}]
-  );
-}
-function withoutDependentProjection(domain) {
-  const { dependencies: _dependencies, ...rest } = domain;
-  return rest;
+  return void 0;
 }
-function toLazyTargetDomain(key, domain, dependencies) {
-  if (domain.type === "cardTarget") {
-    return {
-      type: "cardTarget",
-      projection: "lazy",
-      targetKind: "card",
-      zoneIds: domain.zoneIds,
-      ...domain.selection ? { selection: domain.selection } : {},
-      dependencies: {
-        mode: "lazy",
-        dependsOn: dependencies,
-        resolver: { inputKey: key }
-      }
-    };
-  }
-  if (domain.type === "boardTarget") {
-    return {
-      type: "boardTarget",
-      projection: "lazy",
-      targetKind: domain.targetKind,
-      boardId: domain.boardId,
-      ...domain.valueKind ? { valueKind: domain.valueKind } : {},
-      ...domain.selection ? { selection: domain.selection } : {},
-      dependencies: {
-        mode: "lazy",
-        dependsOn: dependencies,
-        resolver: { inputKey: key }
+function collectCardZoneIds(interaction) {
+  const collectors = interactionInputsOf(interaction);
+  const zoneIds = /* @__PURE__ */ new Set();
+  for (const collector of Object.values(collectors)) {
+    if (collector.kind === "card") {
+      for (const zoneId of collector.meta.zoneIds ?? [collector.meta.zoneId]) {
+        if (zoneId.length > 0) zoneIds.add(zoneId);
       }
-    };
+    }
   }
-  return null;
-}
-function dependencyCaseCount(dependencies, domainsByKey) {
-  return dependencies.map((key) => finiteValuesForDependency(key, domainsByKey[key]).length).reduce((total, count) => total * count, 1);
+  return [...zoneIds];
 }
-function unsupportedDefaultInputError(key, collector) {
-  return new Error(
-    `Interaction input '${key}' uses a '${collector.kind}' collector without a default-renderable domain or target metadata. Use formInput.choice(...), formInput.choiceList(...), formInput.number(...), formInput.resourceMap(...), cardInput(...), or boardInput(...). For custom payloads, use a custom interaction surface with paramsSchema instead of the default InteractionForm.`
-  );
+function findCardInputKey(interaction) {
+  return Object.entries(interactionInputsOf(interaction)).find(
+    ([, collector]) => collector.kind === "card"
+  )?.[0];
 }
-function interactionInputsOf(interaction) {
-  return interaction.inputs;
+function findCardInputKeyForZone(interaction, zoneId) {
+  return Object.entries(interactionInputsOf(interaction)).find(
+    ([, collector]) => collector.kind === "card" && (collector.meta.zoneIds ?? [collector.meta.zoneId]).map(String).includes(zoneId)
+  )?.[0];
 }
+
+// src/reducer/bundle/trusted/collector-eligibility.ts
 function collectEligibleTargets(interaction, domainState, playerId, options = {}) {
   const collectors = interactionInputsOf(interaction);
   const result = {};
@@ -5108,233 +5017,33 @@ function collectEligibleTargets(interaction, domainState, playerId, options = {}
   }
   return result;
 }
-function collectInputDomains(interaction, domainState, playerId, eligibleTargets, options = {}) {
-  const collectors = interactionInputsOf(interaction);
-  let queriesLazy = options.queries ?? null;
-  const queries = () => queriesLazy ??= createStateQueries(
-    domainState
-  );
-  let derivedLazy = options.derived ?? null;
-  const derived = () => derivedLazy ??= createDerivedResolver(domainState, { q: queries() });
-  const result = {};
-  for (const [key, collector] of Object.entries(collectors)) {
-    if (collector.kind === "rng") {
-      continue;
-    }
-    if (collector.kind === "prompt") {
-      const optionFactory = collector.meta?.options;
-      if (!optionFactory) continue;
-      result[key] = {
-        type: "choice",
-        choices: optionFactory(domainState, playerId, queries()).map(
-          (option) => ({
-            value: String(option.id),
-            label: option.label ?? String(option.id),
-            ...(() => {
-              const issue = collector.validateTarget?.(
-                domainState,
-                playerId,
-                queries(),
-                String(option.id)
-              );
-              return issue ? {
-                disabled: true,
-                disabledReason: issue.message ?? issue.errorCode
-              } : {};
-            })()
-          })
-        )
-      };
-      continue;
-    }
-    if (collector.domain) {
-      const domainProjector = collector.domain;
-      const dependencies = collector.dependsOn ?? [];
-      if (options.includeEligibleTargets === false && !Object.prototype.hasOwnProperty.call(eligibleTargets, key)) {
-        const lazyDomain2 = lazyTargetDomainFromCollectorMetadata(
-          key,
-          collector,
-          dependencies
-        );
-        if (lazyDomain2) {
-          result[key] = lazyDomain2;
-          continue;
-        }
-      }
-      const baseDomain = withSelection(
-        domainProjector(
-          domainState,
-          playerId,
-          queries(),
-          derived(),
-          {}
-        ),
-        collector
-      );
-      if (dependencies.length === 0) {
-        result[key] = baseDomain;
-        continue;
-      }
-      const caseCount = dependencyCaseCount(dependencies, result);
-      const lazyDomain = caseCount > MAX_EAGER_DEPENDENT_DOMAIN_CASES ? toLazyTargetDomain(key, baseDomain, dependencies) : null;
-      if (lazyDomain) {
-        result[key] = lazyDomain;
-        continue;
-      }
-      const dependentCases = cartesianDependencyTuples(
-        dependencies,
-        result
-      ).map((values) => ({
-        when: values,
-        domain: withoutDependentProjection(
-          withSelection(
-            domainProjector(
-              domainState,
-              playerId,
-              queries(),
-              derived(),
-              values
-            ),
-            collector
-          )
-        )
-      }));
-      result[key] = {
-        ...baseDomain,
-        dependencies: {
-          mode: "eager",
-          dependentCases
-        }
-      };
-      continue;
-    }
-    throw unsupportedDefaultInputError(key, collector);
-  }
-  return result;
-}
-function collectInteractionInputs(interaction, domainState, playerId, options = {}) {
-  const collectors = interactionInputsOf(interaction);
-  const dependencyKeys = new Set(
-    Object.values(collectors).flatMap((collector) => [
-      ...collector.dependsOn ?? []
-    ])
-  );
-  const collectedEligibleTargets = options.includeEligibleTargets === false && dependencyKeys.size === 0 ? {} : collectEligibleTargets(interaction, domainState, playerId, options);
-  const eligibleTargets = options.includeEligibleTargets === false ? Object.fromEntries(
-    Object.entries(collectedEligibleTargets).filter(
-      ([key]) => dependencyKeys.has(key)
-    )
-  ) : collectedEligibleTargets;
-  const domainsByKey = collectInputDomains(
-    interaction,
-    domainState,
-    playerId,
-    eligibleTargets,
-    options
-  );
-  let queriesLazy = options.queries ?? null;
-  const queries = () => queriesLazy ??= createStateQueries(
-    domainState
-  );
-  let derivedLazy = options.derived ?? null;
-  const derived = () => derivedLazy ??= createDerivedResolver(domainState, { q: queries() });
-  return Object.entries(collectors).flatMap(([key, collector]) => {
-    if (collector.kind === "rng") {
-      return [];
-    }
-    const domain = domainsByKey[key];
-    if (!domain && collector.kind === "prompt") {
-      return [];
-    }
-    if (!domain) {
-      throw unsupportedDefaultInputError(key, collector);
-    }
-    const dynamicDefault = collector.resolveDefaultValue?.(
-      domainState,
-      playerId,
-      queries(),
-      derived(),
-      domain
-    );
-    const defaultValue = "defaultValue" in collector ? collector.defaultValue : dynamicDefault;
-    warnConcreteDependentChoiceDefault({
-      inputKey: key,
-      collector,
-      domain,
-      defaultValue,
-      dependencyKeys
-    });
-    return [
-      {
-        key,
-        kind: collector.kind,
-        domain,
-        ...defaultValue !== void 0 ? { defaultValue } : {}
-      }
-    ];
-  });
-}
-var concreteDependentChoiceDefaultWarnings = /* @__PURE__ */ new Set();
-function shouldEmitAuthoringWarning() {
-  const env = globalThis.process?.env;
-  return env?.NODE_ENV !== "production" && env?.DREAMBOARD_SUPPRESS_AUTHORING_WARNINGS !== "1";
-}
-function warnConcreteDependentChoiceDefault({
-  inputKey,
-  collector,
-  domain,
-  defaultValue,
-  dependencyKeys
-}) {
-  if (!shouldEmitAuthoringWarning() || !dependencyKeys.has(inputKey) || collector.kind !== "form" || domain.type !== "choice" || defaultValue === void 0 || defaultValue === null) {
-    return;
-  }
-  const warningKey = `${inputKey}:${String(defaultValue)}`;
-  if (concreteDependentChoiceDefaultWarnings.has(warningKey)) {
-    return;
-  }
-  concreteDependentChoiceDefaultWarnings.add(warningKey);
-  console.warn(
-    `[dreamboard] Form choice input "${inputKey}" feeds another collector and defaulted to "${String(
-      defaultValue
-    )}". Dependent choices that select the object an action applies to should usually use defaultValue: () => undefined so collection stays explicit.`
-  );
-}
-function collectFirstCardZoneId(interaction) {
-  const collectors = interactionInputsOf(interaction);
-  for (const collector of Object.values(collectors)) {
-    if (collector.kind === "card") {
-      if (collector.meta.zoneId.length > 0) {
-        return collector.meta.zoneId;
-      }
-    }
-  }
-  return void 0;
-}
-function collectCardZoneIds(interaction) {
-  const collectors = interactionInputsOf(interaction);
-  const zoneIds = /* @__PURE__ */ new Set();
-  for (const collector of Object.values(collectors)) {
-    if (collector.kind === "card") {
-      for (const zoneId of collector.meta.zoneIds ?? [collector.meta.zoneId]) {
-        if (zoneId.length > 0) zoneIds.add(zoneId);
-      }
-    }
-  }
-  return [...zoneIds];
+
+// src/reducer/parse-utils.ts
+function formatIssue(label, issue) {
+  const path = issue.path.map(
+    (segment) => typeof segment === "symbol" ? segment.toString() : String(segment)
+  ).join(".");
+  return `${path || label}: ${issue.message}`;
 }
-function collectPromptOptions(interaction, domainState, playerId, queries) {
-  for (const collector of Object.values(interaction.inputs)) {
-    if (collector.kind !== "prompt") continue;
-    const factory = collector.meta?.options;
-    if (!factory) continue;
-    return factory(domainState, playerId, queries).map((option) => ({
-      id: String(option.id),
-      ...option.label !== void 0 ? { label: option.label } : {}
-    }));
+function safeParseOrThrow(schema, value, label) {
+  const parsed = schema.safeParse(value);
+  if (!parsed.success) {
+    const message = parsed.error.issues.map((issue) => formatIssue(label, issue)).join("; ");
+    throw new Error(message || `Invalid ${label}`);
   }
-  return void 0;
+  return parsed.data;
+}
+
+// src/reducer/bundle/trusted/interaction-types.ts
+function makeValidationError(errorCode, message) {
+  return {
+    valid: false,
+    errorCode,
+    message
+  };
 }
+
+// src/reducer/bundle/trusted/collector-params.ts
 function parseInteractionParams(interaction, rawParams, options = {}) {
   const collectors = interactionInputsOf(interaction);
   const record = rawParams ?? {};
@@ -5490,16 +5199,6 @@ function stableValueKey(value) {
       return `json:${JSON.stringify(value)}`;
   }
 }
-function findCardInputKey(interaction) {
-  return Object.entries(interactionInputsOf(interaction)).find(
-    ([, collector]) => collector.kind === "card"
-  )?.[0];
-}
-function findCardInputKeyForZone(interaction, zoneId) {
-  return Object.entries(interactionInputsOf(interaction)).find(
-    ([, collector]) => collector.kind === "card" && (collector.meta.zoneIds ?? [collector.meta.zoneId]).map(String).includes(zoneId)
-  )?.[0];
-}
 
 // src/reducer/bundle/trusted/interaction-authorization.ts
 function resolvePromptToSet(to) {
@@ -5557,46 +5256,364 @@ function createInteractionAuthorization(scope) {
           },
           projection
         )
-      });
-      return {
-        mode: "actors",
-        actors: resolvePromptToSet(resolved)
+      });
+      return {
+        mode: "actors",
+        actors: resolvePromptToSet(resolved)
+      };
+    }
+    return { mode: "active" };
+  }
+  function isActorAuthorized(state, playerId, authorization) {
+    if (authorization.mode === "addressees") {
+      return authorization.addressees.has(playerId);
+    }
+    if (authorization.mode === "actors") {
+      return authorization.actors.has(playerId);
+    }
+    const active = state.flow.activePlayers;
+    if (active.length === 0) {
+      return true;
+    }
+    return active.includes(playerId);
+  }
+  function isInteractionVisible(interaction, authorization, authorized) {
+    return !(authorization.mode === "addressees" && !authorized) && !(interaction.visibility === "actorsOnly" && !authorized);
+  }
+  return {
+    isActorAuthorized,
+    isInteractionVisible,
+    resolveInteractionActorAuthorization
+  };
+}
+
+// src/reducer/bundle/trusted/collector-domains.ts
+var MAX_EAGER_DEPENDENT_DOMAIN_CASES = 64;
+function withSelection(domain, collector) {
+  if (!collector.selection) return domain;
+  return { ...domain, selection: collector.selection };
+}
+function lazyTargetDomainFromCollectorMetadata(key, collector, dependencies) {
+  const metadata = collectTargetDomainMetadata(collector);
+  if (collector.kind === "card") {
+    return withSelection(
+      {
+        type: "cardTarget",
+        projection: "lazy",
+        targetKind: "card",
+        zoneIds: metadata.zoneIds ?? (metadata.zoneId === void 0 ? [] : [metadata.zoneId]),
+        dependencies: {
+          mode: "lazy",
+          dependsOn: dependencies,
+          resolver: { inputKey: key }
+        }
+      },
+      collector
+    );
+  }
+  if (collector.kind === "board-edge" || collector.kind === "board-space" || collector.kind === "board-tile" || collector.kind === "board-vertex") {
+    return withSelection(
+      {
+        type: "boardTarget",
+        projection: "lazy",
+        targetKind: metadata.targetKind ?? collector.kind.replace("board-", ""),
+        boardId: metadata.boardId ?? "",
+        ...metadata.valueKind ? { valueKind: metadata.valueKind } : {},
+        dependencies: {
+          mode: "lazy",
+          dependsOn: dependencies,
+          resolver: { inputKey: key }
+        }
+      },
+      collector
+    );
+  }
+  return null;
+}
+function finiteValuesForDependency(key, domain) {
+  if (!domain) {
+    throw new Error(
+      `Interaction input '${key}' is declared as a dependency before it has a projected domain.`
+    );
+  }
+  if (domain.type === "cardTarget" || domain.type === "boardTarget") {
+    if (domain.projection !== "resolved") {
+      throw new Error(
+        `Interaction input '${key}' cannot be used as a dependency because its target domain is not finite.`
+      );
+    }
+    return [...domain.eligibleTargets];
+  }
+  if (domain.type === "choice") {
+    return domain.choices.flatMap(
+      (choice) => choice.value === null ? [] : [choice.value]
+    );
+  }
+  throw new Error(
+    `Interaction input '${key}' cannot be used as a dependency. V1 supports finite target and choice dependencies only.`
+  );
+}
+function cartesianDependencyTuples(dependencies, domainsByKey) {
+  return dependencies.reduce(
+    (tuples, key) => {
+      const values = finiteValuesForDependency(key, domainsByKey[key]);
+      return tuples.flatMap(
+        (tuple) => values.map((value) => ({ ...tuple, [key]: value }))
+      );
+    },
+    [{}]
+  );
+}
+function withoutDependentProjection(domain) {
+  const { dependencies: _dependencies, ...rest } = domain;
+  return rest;
+}
+function toLazyTargetDomain(key, domain, dependencies) {
+  if (domain.type === "cardTarget") {
+    return {
+      type: "cardTarget",
+      projection: "lazy",
+      targetKind: "card",
+      zoneIds: domain.zoneIds,
+      ...domain.selection ? { selection: domain.selection } : {},
+      dependencies: {
+        mode: "lazy",
+        dependsOn: dependencies,
+        resolver: { inputKey: key }
+      }
+    };
+  }
+  if (domain.type === "boardTarget") {
+    return {
+      type: "boardTarget",
+      projection: "lazy",
+      targetKind: domain.targetKind,
+      boardId: domain.boardId,
+      ...domain.valueKind ? { valueKind: domain.valueKind } : {},
+      ...domain.selection ? { selection: domain.selection } : {},
+      dependencies: {
+        mode: "lazy",
+        dependsOn: dependencies,
+        resolver: { inputKey: key }
+      }
+    };
+  }
+  return null;
+}
+function dependencyCaseCount(dependencies, domainsByKey) {
+  return dependencies.map((key) => finiteValuesForDependency(key, domainsByKey[key]).length).reduce((total, count) => total * count, 1);
+}
+function unsupportedDefaultInputError(key, collector) {
+  return new Error(
+    `Interaction input '${key}' uses a '${collector.kind}' collector without a default-renderable domain or target metadata. Use formInput.choice(...), formInput.choiceList(...), formInput.number(...), formInput.resourceMap(...), cardInput(...), or boardInput(...). For custom payloads, use a custom interaction surface with paramsSchema instead of the default InteractionForm.`
+  );
+}
+function collectInputDomains(interaction, domainState, playerId, eligibleTargets, options = {}) {
+  const collectors = interactionInputsOf(interaction);
+  let queriesLazy = options.queries ?? null;
+  const queries = () => queriesLazy ??= createStateQueries(
+    domainState
+  );
+  let derivedLazy = options.derived ?? null;
+  const derived = () => derivedLazy ??= createDerivedResolver(domainState, { q: queries() });
+  const result = {};
+  for (const [key, collector] of Object.entries(collectors)) {
+    if (collector.kind === "rng") {
+      continue;
+    }
+    if (collector.kind === "prompt") {
+      const optionFactory = collector.meta?.options;
+      if (!optionFactory) continue;
+      result[key] = {
+        type: "choice",
+        choices: optionFactory(domainState, playerId, queries()).map(
+          (option) => ({
+            value: String(option.id),
+            label: option.label ?? String(option.id),
+            ...(() => {
+              const issue = collector.validateTarget?.(
+                domainState,
+                playerId,
+                queries(),
+                String(option.id)
+              );
+              return issue ? {
+                disabled: true,
+                disabledReason: issue.message ?? issue.errorCode
+              } : {};
+            })()
+          })
+        )
+      };
+      continue;
+    }
+    if (collector.domain) {
+      const domainProjector = collector.domain;
+      const dependencies = collector.dependsOn ?? [];
+      if (options.includeEligibleTargets === false && !Object.prototype.hasOwnProperty.call(eligibleTargets, key)) {
+        const lazyDomain2 = lazyTargetDomainFromCollectorMetadata(
+          key,
+          collector,
+          dependencies
+        );
+        if (lazyDomain2) {
+          result[key] = lazyDomain2;
+          continue;
+        }
+      }
+      const baseDomain = withSelection(
+        domainProjector(
+          domainState,
+          playerId,
+          queries(),
+          derived(),
+          {}
+        ),
+        collector
+      );
+      if (dependencies.length === 0) {
+        result[key] = baseDomain;
+        continue;
+      }
+      const caseCount = dependencyCaseCount(dependencies, result);
+      const lazyDomain = caseCount > MAX_EAGER_DEPENDENT_DOMAIN_CASES ? toLazyTargetDomain(key, baseDomain, dependencies) : null;
+      if (lazyDomain) {
+        result[key] = lazyDomain;
+        continue;
+      }
+      const dependentCases = cartesianDependencyTuples(
+        dependencies,
+        result
+      ).map((values) => ({
+        when: values,
+        domain: withoutDependentProjection(
+          withSelection(
+            domainProjector(
+              domainState,
+              playerId,
+              queries(),
+              derived(),
+              values
+            ),
+            collector
+          )
+        )
+      }));
+      result[key] = {
+        ...baseDomain,
+        dependencies: {
+          mode: "eager",
+          dependentCases
+        }
       };
+      continue;
     }
-    return { mode: "active" };
+    throw unsupportedDefaultInputError(key, collector);
   }
-  function isActorAuthorized(state, playerId, authorization) {
-    if (authorization.mode === "addressees") {
-      return authorization.addressees.has(playerId);
+  return result;
+}
+function collectInteractionInputs(interaction, domainState, playerId, options = {}) {
+  const collectors = interactionInputsOf(interaction);
+  const dependencyKeys = new Set(
+    Object.values(collectors).flatMap((collector) => [
+      ...collector.dependsOn ?? []
+    ])
+  );
+  const collectedEligibleTargets = options.includeEligibleTargets === false && dependencyKeys.size === 0 ? {} : collectEligibleTargets(interaction, domainState, playerId, options);
+  const eligibleTargets = options.includeEligibleTargets === false ? Object.fromEntries(
+    Object.entries(collectedEligibleTargets).filter(
+      ([key]) => dependencyKeys.has(key)
+    )
+  ) : collectedEligibleTargets;
+  const domainsByKey = collectInputDomains(
+    interaction,
+    domainState,
+    playerId,
+    eligibleTargets,
+    options
+  );
+  let queriesLazy = options.queries ?? null;
+  const queries = () => queriesLazy ??= createStateQueries(
+    domainState
+  );
+  let derivedLazy = options.derived ?? null;
+  const derived = () => derivedLazy ??= createDerivedResolver(domainState, { q: queries() });
+  return Object.entries(collectors).flatMap(([key, collector]) => {
+    if (collector.kind === "rng") {
+      return [];
     }
-    if (authorization.mode === "actors") {
-      return authorization.actors.has(playerId);
+    const domain = domainsByKey[key];
+    if (!domain && collector.kind === "prompt") {
+      return [];
     }
-    const active = state.flow.activePlayers;
-    if (active.length === 0) {
-      return true;
+    if (!domain) {
+      throw unsupportedDefaultInputError(key, collector);
     }
-    return active.includes(playerId);
+    const dynamicDefault = collector.resolveDefaultValue?.(
+      domainState,
+      playerId,
+      queries(),
+      derived(),
+      domain
+    );
+    const defaultValue = "defaultValue" in collector ? collector.defaultValue : dynamicDefault;
+    warnConcreteDependentChoiceDefault({
+      inputKey: key,
+      collector,
+      domain,
+      defaultValue,
+      dependencyKeys
+    });
+    return [
+      {
+        key,
+        kind: collector.kind,
+        domain,
+        ...defaultValue !== void 0 ? { defaultValue } : {}
+      }
+    ];
+  });
+}
+var concreteDependentChoiceDefaultWarnings = /* @__PURE__ */ new Set();
+var AUTHORING_WARNINGS_FLAG = "__DREAMBOARD_AUTHORING_WARNINGS__";
+function shouldEmitAuthoringWarning() {
+  return globalThis[AUTHORING_WARNINGS_FLAG] === true;
+}
+function warnConcreteDependentChoiceDefault({
+  inputKey,
+  collector,
+  domain,
+  defaultValue,
+  dependencyKeys
+}) {
+  if (!shouldEmitAuthoringWarning() || !dependencyKeys.has(inputKey) || collector.kind !== "form" || domain.type !== "choice" || defaultValue === void 0 || defaultValue === null) {
+    return;
   }
-  function isInteractionVisible(interaction, authorization, authorized) {
-    return !(authorization.mode === "addressees" && !authorized) && !(interaction.visibility === "actorsOnly" && !authorized);
+  const warningKey = `${inputKey}:${String(defaultValue)}`;
+  if (concreteDependentChoiceDefaultWarnings.has(warningKey)) {
+    return;
   }
-  return {
-    isActorAuthorized,
-    isInteractionVisible,
-    resolveInteractionActorAuthorization
-  };
-}
-
-// src/reducer/bundle/trusted/interaction-decision.ts
-function issueFromRule(rule) {
-  return { errorCode: rule.errorCode, message: rule.message };
+  concreteDependentChoiceDefaultWarnings.add(warningKey);
+  console.warn(
+    `[dreamboard] Form choice input "${inputKey}" feeds another collector and defaulted to "${String(
+      defaultValue
+    )}". Dependent choices that select the object an action applies to should usually use defaultValue: () => undefined so collection stays explicit.`
+  );
 }
-function issueFromRuleValidationResult(rule, result) {
-  if (result === false) return issueFromRule(rule);
-  if (result && typeof result === "object") return result;
+function collectPromptOptions(interaction, domainState, playerId, queries) {
+  for (const collector of Object.values(interaction.inputs)) {
+    if (collector.kind !== "prompt") continue;
+    const factory = collector.meta?.options;
+    if (!factory) continue;
+    return factory(domainState, playerId, queries).map((option) => ({
+      id: String(option.id),
+      ...option.label !== void 0 ? { label: option.label } : {}
+    }));
+  }
   return void 0;
 }
+
+// src/reducer/bundle/trusted/interaction-descriptor.ts
 function humanizeInteractionId(id) {
   if (!id) return id;
   const withSpaces = id.replace(/[-_]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").trim();
@@ -5738,6 +5755,78 @@ function interactionAvailabilityFromDecision(decision) {
     reason: decision.unavailableReason ?? "Interaction unavailable"
   };
 }
+function buildInteractionDescriptor(scope, state, playerId, interactionId, interaction, decision, options = {}) {
+  const domainState = options.projection?.domainState ?? scope.toDomainState(state);
+  const phaseName = state.flow.currentPhase;
+  const interactionInputs = interactionInputsOf(interaction);
+  const metadata = projectInteractionMetadata({
+    ...interaction,
+    inputs: interactionInputs
+  });
+  const queries = options.projection?.q ?? createStateQueries(domainState);
+  const derived = options.projection?.derived;
+  const shouldMaterializeInputDomains = decision.available || decision.unavailableReason !== "Not your turn";
+  const promptContext = metadata.kind === "prompt" ? {
+    to: playerId,
+    title: humanizeInteractionId(interactionId),
+    options: shouldMaterializeInputDomains ? collectPromptOptions(
+      { inputs: interactionInputs },
+      domainState,
+      playerId,
+      queries
+    ) : void 0
+  } : void 0;
+  const inputs = shouldMaterializeInputDomains ? enrichResourceInputPresentation(
+    collectInteractionInputs(interaction, domainState, playerId, {
+      queries,
+      derived,
+      eligibleTargetCache: options.projection?.eligibleTargets,
+      eligibleTargetCachePrefix: `${phaseName}:${String(
+        interactionId
+      )}:${String(playerId)}`,
+      includeEligibleTargets: options.includeEligibleTargets
+    }),
+    scope.definition.contract.manifest
+  ) : [];
+  const baseDescriptor = {
+    phaseName,
+    interactionKey: `${phaseName}.${interactionId}`,
+    interactionId,
+    commit: metadata.commit,
+    zoneId: collectFirstCardZoneId(interaction),
+    zoneIds: collectCardZoneIds(interaction),
+    inputs,
+    cost: decision.cost ? { ...decision.cost } : void 0,
+    currentResources: decision.cost ? {
+      ...queries.player.resources(playerId)
+    } : void 0,
+    availability: interactionAvailabilityFromDecision(decision)
+  };
+  if (metadata.kind === "prompt") {
+    return {
+      ...baseDescriptor,
+      kind: "prompt",
+      context: promptContext ?? {
+        to: playerId,
+        title: humanizeInteractionId(interactionId)
+      }
+    };
+  }
+  return {
+    ...baseDescriptor,
+    kind: "action"
+  };
+}
+
+// src/reducer/bundle/trusted/interaction-decision.ts
+function issueFromRule(rule) {
+  return { errorCode: rule.errorCode, message: rule.message };
+}
+function issueFromRuleValidationResult(rule, result) {
+  if (result === false) return issueFromRule(rule);
+  if (result && typeof result === "object") return result;
+  return void 0;
+}
 function createInteractionDecisionResolver(scope, stages, authorization) {
   function evaluateInteractionCost(state, interaction, playerId, params, projection) {
     if (!interaction.cost) {
@@ -5760,68 +5849,6 @@ function createInteractionDecisionResolver(scope, stages, authorization) {
       return { error };
     }
   }
-  function buildBaseDescriptor(state, playerId, interactionId, interaction, decision, options = {}) {
-    const domainState = options.projection?.domainState ?? scope.toDomainState(state);
-    const phaseName = state.flow.currentPhase;
-    const interactionInputs = interactionInputsOf(interaction);
-    const metadata = projectInteractionMetadata({
-      ...interaction,
-      inputs: interactionInputs
-    });
-    const queries = options.projection?.q ?? createStateQueries(domainState);
-    const derived = options.projection?.derived;
-    const shouldMaterializeInputDomains = decision.available || decision.unavailableReason !== "Not your turn";
-    const promptContext = metadata.kind === "prompt" ? {
-      to: playerId,
-      title: humanizeInteractionId(interactionId),
-      options: shouldMaterializeInputDomains ? collectPromptOptions(
-        { inputs: interactionInputs },
-        domainState,
-        playerId,
-        queries
-      ) : void 0
-    } : void 0;
-    const inputs = shouldMaterializeInputDomains ? enrichResourceInputPresentation(
-      collectInteractionInputs(interaction, domainState, playerId, {
-        queries,
-        derived,
-        eligibleTargetCache: options.projection?.eligibleTargets,
-        eligibleTargetCachePrefix: `${phaseName}:${String(
-          interactionId
-        )}:${String(playerId)}`,
-        includeEligibleTargets: options.includeEligibleTargets
-      }),
-      scope.definition.contract.manifest
-    ) : [];
-    const baseDescriptor = {
-      phaseName,
-      interactionKey: `${phaseName}.${interactionId}`,
-      interactionId,
-      commit: metadata.commit,
-      zoneId: collectFirstCardZoneId(interaction),
-      zoneIds: collectCardZoneIds(interaction),
-      inputs,
-      cost: decision.cost ? { ...decision.cost } : void 0,
-      currentResources: decision.cost ? {
-        ...queries.player.resources(playerId)
-      } : void 0,
-      availability: interactionAvailabilityFromDecision(decision)
-    };
-    if (metadata.kind === "prompt") {
-      return {
-        ...baseDescriptor,
-        kind: "prompt",
-        context: promptContext ?? {
-          to: playerId,
-          title: humanizeInteractionId(interactionId)
-        }
-      };
-    }
-    return {
-      ...baseDescriptor,
-      kind: "action"
-    };
-  }
   function resolveInteractionDecision({
     state,
     playerId,
@@ -5856,7 +5883,8 @@ function createInteractionDecisionResolver(scope, stages, authorization) {
         interaction,
         parsedParams: {},
         visible: true,
-        descriptor: buildBaseDescriptor(
+        descriptor: buildInteractionDescriptor(
+          scope,
           state,
           playerId,
           trustedInteractionId,
@@ -6030,7 +6058,8 @@ function createInteractionDecisionResolver(scope, stages, authorization) {
     }
     const available = stageAllowed && stepAllowed && authorized && !ruleAvailabilityIssue && costAffordable && !authoredValidation;
     const unavailableReason = available ? void 0 : !authorized ? "Not your turn" : !stageAllowed ? "Interaction not allowed in current stage" : !stepAllowed ? "Interaction not allowed in current step" : ruleAvailabilityIssue ? ruleAvailabilityIssue.message ?? ruleAvailabilityIssue.errorCode : !costAffordable ? "INSUFFICIENT_RESOURCES" : mode === "card" ? authoredValidation?.message ?? "Interaction unavailable" : "Interaction unavailable";
-    const descriptor = buildBaseDescriptor(
+    const descriptor = buildInteractionDescriptor(
+      scope,
       state,
       playerId,
       trustedInteractionId,
@@ -6837,14 +6866,18 @@ function createProjectionBuilder(scope, interactions) {
     const byRef = {};
     const byHash = /* @__PURE__ */ new Map();
     return {
-      add(descriptor) {
-        const fingerprint = stableStringify(descriptor);
+      add(descriptor, actorSeat) {
+        const enriched = descriptorWithBrowserReplayDigests(
+          descriptor,
+          actorSeat
+        );
+        const fingerprint = stableStringify(enriched);
         const existing = byHash.get(fingerprint);
         if (existing) return existing;
-        const base = typeof descriptor.interactionId === "string" && descriptor.interactionId.length > 0 ? descriptor.interactionId : "interaction";
+        const base = typeof enriched.interactionId === "string" && enriched.interactionId.length > 0 ? enriched.interactionId : "interaction";
         const ref = `${base}:${fnv1a64(fingerprint)}`;
         byHash.set(fingerprint, ref);
-        byRef[ref] = descriptor;
+        byRef[ref] = enriched;
         return ref;
       },
       entries() {
@@ -6852,7 +6885,7 @@ function createProjectionBuilder(scope, interactions) {
       }
     };
   }
-  function resolveZoneHandlesFor(combinedState, playerId, projection, registry) {
+  function resolveZoneHandlesFor(combinedState, playerId, actorSeat, projection, registry) {
     const phaseName = combinedState.flow.currentPhase;
     const zoneIds = new Set(scope.zonesForPhase(phaseName).map(String));
     for (const [, interaction] of scope.interactionEntriesForPhase(phaseName)) {
@@ -6907,10 +6940,13 @@ function createProjectionBuilder(scope, interactions) {
             continue;
           }
           perCard.push(
-            registry.add({
-              ...decision.descriptor,
-              zoneId
-            })
+            registry.add(
+              {
+                ...decision.descriptor,
+                zoneId
+              },
+              actorSeat
+            )
           );
         }
         playableByCardId[cardId] = perCard;
@@ -6990,16 +7026,17 @@ function createProjectionBuilder(scope, interactions) {
     });
     const registry = createDescriptorRegistry();
     const seats = {};
-    for (const playerId of playerIds) {
+    for (const [actorSeat, playerId] of playerIds.entries()) {
       const availableInteractionRefs = interactions.resolveAvailableInteractionsFor(combinedState, playerId, {
         projection
-      }).map((descriptor) => registry.add(descriptor));
+      }).map((descriptor) => registry.add(descriptor, actorSeat));
       seats[playerId] = {
         ...projectionMode === "full" ? {
           view: resolveViewFor(combinedState, playerId, viewId, projection),
           zones: resolveZoneHandlesFor(
             combinedState,
             playerId,
+            actorSeat,
             projection,
             registry
           )
@@ -7036,6 +7073,126 @@ function createProjectionBuilder(scope, interactions) {
     resolveZoneHandlesFor
   };
 }
+function descriptorWithBrowserReplayDigests(descriptor, actorSeat) {
+  const descriptorDigestValue = descriptor.descriptorDigest ?? interactionDescriptorDigest(descriptor);
+  return {
+    ...descriptor,
+    descriptorDigest: descriptorDigestValue,
+    actorSeat,
+    draftDigest: descriptor.draftDigest ?? interactionDraftDigest({
+      actorSeat,
+      descriptor,
+      descriptorDigest: descriptorDigestValue
+    })
+  };
+}
+function interactionDescriptorDigest(descriptor) {
+  return hashJson({
+    commitMode: descriptor.commit.mode,
+    defaults: toDescriptorDigestJson(defaultsForDescriptor(descriptor)),
+    inputKeys: descriptor.inputs.map((input) => input.key),
+    inputs: descriptor.inputs.map((input) => ({
+      key: input.key,
+      kind: input.kind,
+      domain: toDescriptorDigestJson(input.domain),
+      defaultValue: input.defaultValue === void 0 ? null : toDescriptorDigestJson(input.defaultValue)
+    })),
+    interactionId: descriptor.interactionId,
+    interactionKey: descriptor.interactionKey,
+    stableIdentity: `${descriptor.interactionKey}:${descriptor.interactionId}`
+  });
+}
+function interactionDraftDigest({
+  actorSeat,
+  descriptor,
+  descriptorDigest
+}) {
+  return hashJson({
+    digestVersion: "interaction-draft@2",
+    actorSeat,
+    descriptorDigest,
+    emitted: false,
+    interactionId: descriptor.interactionId,
+    interactionKey: descriptor.interactionKey,
+    values: defaultsForDescriptor(descriptor)
+  });
+}
+function toDescriptorDigestJson(value) {
+  const canonical = toCanonicalJson(value);
+  return normalizeOrderInsensitiveDescriptorFields(canonical);
+}
+function normalizeOrderInsensitiveDescriptorFields(value) {
+  if (Array.isArray(value)) {
+    return value.map(normalizeOrderInsensitiveDescriptorFields);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => {
+      const normalized = normalizeOrderInsensitiveDescriptorFields(item);
+      if ((key === "eligibleTargets" || key === "dependentCases") && Array.isArray(normalized)) {
+        return [
+          key,
+          [...normalized].sort(
+            (left, right) => compareCanonicalJson(canonicalJson(left), canonicalJson(right))
+          )
+        ];
+      }
+      return [key, normalized];
+    })
+  );
+}
+function defaultsForDescriptor(descriptor) {
+  return Object.fromEntries(
+    descriptor.inputs.flatMap(
+      (input) => input.defaultValue === void 0 ? [] : [[input.key, toCanonicalJson(input.defaultValue)]]
+    )
+  );
+}
+function toCanonicalJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toCanonicalJson(item));
+  }
+  if (typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, toCanonicalJson(item)])
+    );
+  }
+  return null;
+}
+function hashJson(value) {
+  return `sha256:${sha256Hex(canonicalJson(value))}`;
+}
+function canonicalJson(value) {
+  return JSON.stringify(canonicalizeJson(value));
+}
+function canonicalizeJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("canonical JSON contains a non-finite number");
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalizeJson(item));
+  }
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, canonicalizeJson(item)])
+  );
+}
+function compareCanonicalJson(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
 function stableStringify(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
@@ -7055,6 +7212,171 @@ function fnv1a64(value) {
   }
   return hash.toString(16).padStart(16, "0");
 }
+var SHA256_K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function sha256Hex(input) {
+  const bytes = utf8Bytes(input);
+  const bitLength = bytes.length * 8;
+  bytes.push(128);
+  while (bytes.length % 64 !== 56) {
+    bytes.push(0);
+  }
+  for (let shift = 56; shift >= 0; shift -= 8) {
+    bytes.push(Math.floor(bitLength / 2 ** shift) & 255);
+  }
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const words = new Array(64);
+  for (let offset = 0; offset < bytes.length; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      const base = offset + index * 4;
+      words[index] = (bytes[base] << 24 | bytes[base + 1] << 16 | bytes[base + 2] << 8 | bytes[base + 3]) >>> 0;
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const s0 = rotateRight(words[index - 15], 7) ^ rotateRight(words[index - 15], 18) ^ words[index - 15] >>> 3;
+      const s1 = rotateRight(words[index - 2], 17) ^ rotateRight(words[index - 2], 19) ^ words[index - 2] >>> 10;
+      words[index] = words[index - 16] + s0 + words[index - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let index = 0; index < 64; index += 1) {
+      const s1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + SHA256_K[index] + words[index] >>> 0;
+      const s0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((word) => word.toString(16).padStart(8, "0")).join("");
+}
+function rotateRight(value, shift) {
+  return value >>> shift | value << 32 - shift;
+}
+function utf8Bytes(input) {
+  const bytes = [];
+  for (let index = 0; index < input.length; index += 1) {
+    let codePoint = input.charCodeAt(index);
+    if (codePoint >= 55296 && codePoint <= 56319 && index + 1 < input.length) {
+      const low = input.charCodeAt(index + 1);
+      if (low >= 56320 && low <= 57343) {
+        codePoint = 65536 + (codePoint - 55296 << 10) + (low - 56320);
+        index += 1;
+      }
+    }
+    if (codePoint < 128) {
+      bytes.push(codePoint);
+    } else if (codePoint < 2048) {
+      bytes.push(192 | codePoint >>> 6, 128 | codePoint & 63);
+    } else if (codePoint < 65536) {
+      bytes.push(
+        224 | codePoint >>> 12,
+        128 | codePoint >>> 6 & 63,
+        128 | codePoint & 63
+      );
+    } else {
+      bytes.push(
+        240 | codePoint >>> 18,
+        128 | codePoint >>> 12 & 63,
+        128 | codePoint >>> 6 & 63,
+        128 | codePoint & 63
+      );
+    }
+  }
+  return bytes;
+}
 
 // src/reducer/bundle/trusted/static-projection.ts
 function stableStringify2(value) {
@@ -7475,7 +7797,7 @@ function createIngressRuntimeCodec(definition) {
     },
     parseState(rawState) {
       const envelope = safeParseOrThrow(
-        ReducerSessionStateSchema,
+        zod_exports.ReducerSessionStateSchema,
         rawState,
         "state"
       );
@@ -7555,44 +7877,6 @@ function createIngressRuntimeCodec(definition) {
   };
 }
 
-// src/generated/reducer-contract/builders.ts
-function createEffectIdMinter() {
-  let i = 0;
-  return () => `ef${i++}`;
-}
-function createEffectBuilders(mint) {
-  return {
-    transition(args, continuation) {
-      const effect = { effectId: mint(), type: "transition", to: args.to };
-      return continuation === void 0 ? effect : Object.assign(effect, { __continuation: continuation });
-    },
-    rollDie(args, continuation) {
-      const effect = { effectId: mint(), type: "rollDie", dieId: args.dieId };
-      return continuation === void 0 ? effect : Object.assign(effect, { __continuation: continuation });
-    },
-    shuffleSharedZone(args, continuation) {
-      const effect = { effectId: mint(), type: "shuffleSharedZone", zoneId: args.zoneId };
-      return continuation === void 0 ? effect : Object.assign(effect, { __continuation: continuation });
-    },
-    shufflePlayerZone(args, continuation) {
-      const effect = { effectId: mint(), type: "shufflePlayerZone", zoneId: args.zoneId, playerId: args.playerId };
-      return continuation === void 0 ? effect : Object.assign(effect, { __continuation: continuation });
-    }
-  };
-}
-function materializeAccept(pending) {
-  const effects = [];
-  const continuations = {};
-  for (const pe of pending) {
-    const { __continuation, ...effect } = pe;
-    effects.push(effect);
-    if (__continuation !== void 0) {
-      continuations[effect.effectId] = __continuation;
-    }
-  }
-  return { effects, continuations };
-}
-
 // src/reducer/bundle/ingress-bundle.ts
 function routeInteraction(input) {
   return {
@@ -7649,12 +7933,12 @@ function toWireReduceResult(result, serializeState) {
       message: result.message
     };
   }
-  const mint = createEffectIdMinter();
-  const fx = createEffectBuilders(mint);
+  const mint = builders_exports.createEffectIdMinter();
+  const fx = builders_exports.createEffectBuilders(mint);
   const pending = (result.instructions ?? []).map(
     (instruction) => toPendingEffect(instruction, fx)
   );
-  const { effects, continuations } = materializeAccept(pending);
+  const { effects, continuations } = builders_exports.materializeAccept(pending);
   return {
     kind: "accept",
     state: serializeState(result.state),
@@ -7670,8 +7954,8 @@ function toWireDispatchResult(result, serializeState) {
       message: result.message
     };
   }
-  const mint = createEffectIdMinter();
-  const fx = createEffectBuilders(mint);
+  const mint = builders_exports.createEffectIdMinter();
+  const fx = builders_exports.createEffectBuilders(mint);
   const trace = [];
   for (const entry of result.trace) {
     switch (entry.type) {
@@ -7704,7 +7988,7 @@ function toWireDispatchResult(result, serializeState) {
           entry.instruction,
           fx
         );
-        const { effects, continuations } = materializeAccept([
+        const { effects, continuations } = builders_exports.materializeAccept([
           pending
         ]);
         const [wireEffect] = effects;