@dreamboard-games/sdk 0.4.0-alpha.0 → 0.4.0-alpha.2

package/dist/{chunk-U5KBV2BA.js → chunk-N6ZDIMRB.js}

@@ -1195,6 +1195,13 @@ function getCardVisibility(table, cardId) {
   return table.visibility[cardId];
 }
 
+// src/reducer/table/numeric.ts
+function assertNonNegativeSafeInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative safe integer.`);
+  }
+}
+
 // src/reducer/table/resource-ops.ts
 function getPlayerOrder(table) {
   return table.playerOrder;
@@ -1212,7 +1219,14 @@ function getPlayerResourceAmount(table, playerId, resourceId) {
   );
   if (!playerResources) return 0;
   const value = playerResources[resourceId];
-  return typeof value === "number" ? value : 0;
+  if (value === void 0) return 0;
+  if (typeof value !== "number") {
+    throw new Error(
+      `Resource '${resourceId}' balance must be a non-negative safe integer.`
+    );
+  }
+  assertNonNegativeSafeInteger(value, `Resource '${resourceId}' balance`);
+  return value;
 }
 function getPlayerResourceTotal(table, playerId) {
   const playerResources = perPlayerGet(
@@ -1223,7 +1237,16 @@ function getPlayerResourceTotal(table, playerId) {
   let total = 0;
   for (const key of Object.keys(playerResources)) {
     const value = playerResources[key];
-    if (typeof value === "number") total += value;
+    if (value === void 0) continue;
+    if (typeof value !== "number") {
+      throw new Error(
+        `Resource '${key}' balance must be a non-negative safe integer.`
+      );
+    }
+    assertNonNegativeSafeInteger(value, `Resource '${key}' balance`);
+    const nextTotal = total + value;
+    assertNonNegativeSafeInteger(nextTotal, "Resource total");
+    total = nextTotal;
   }
   return total;
 }
@@ -1234,17 +1257,23 @@ function getNextPlayerInOrder(table, playerId) {
   if (idx < 0) return null;
   return order[(idx + 1) % order.length] ?? null;
 }
-function forEachResourceEntry(amounts, visit) {
+function resourceEntries(amounts) {
+  const entries = [];
   for (const resourceId of Object.keys(amounts)) {
     const amount = amounts[resourceId];
-    if (typeof amount !== "number" || amount === 0) continue;
-    visit(resourceId, amount);
+    if (amount === void 0 || amount === 0) continue;
+    if (typeof amount !== "number") {
+      throw new Error(
+        `Resource '${resourceId}' amount must be a non-negative safe integer.`
+      );
+    }
+    assertNonNegativeSafeInteger(amount, `Resource '${resourceId}' amount`);
+    entries.push([resourceId, amount]);
   }
+  return entries;
 }
 function canAffordResources(table, playerId, amounts) {
-  for (const resourceId of Object.keys(amounts)) {
-    const required = amounts[resourceId];
-    if (typeof required !== "number" || required <= 0) continue;
+  for (const [resourceId, required] of resourceEntries(amounts)) {
     if (getPlayerResourceAmount(table, playerId, resourceId) < required) {
       return false;
     }
@@ -1253,9 +1282,7 @@ function canAffordResources(table, playerId, amounts) {
 }
 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;
+  for (const [resourceId, required] of resourceEntries(amounts)) {
     const have = getPlayerResourceAmount(table, playerId, resourceId);
     if (have < required) missing[resourceId] = required - have;
   }
@@ -1279,14 +1306,14 @@ function addPlayerResourcesInPlace(table, playerId, amounts) {
     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;
-  });
+  for (const [resourceId, amount] of resourceEntries(amounts)) {
+    const nextAmount = getPlayerResourceAmount(table, playerId, resourceId) + amount;
+    assertNonNegativeSafeInteger(
+      nextAmount,
+      `Resource '${resourceId}' balance`
+    );
+    next[resourceId] = nextAmount;
+  }
   writePlayerResources(table, playerId, next);
 }
 function spendPlayerResources(table, playerId, amounts) {
@@ -1295,6 +1322,7 @@ function spendPlayerResources(table, playerId, amounts) {
   return nextTable;
 }
 function spendPlayerResourcesInPlace(table, playerId, amounts) {
+  const entries = resourceEntries(amounts);
   if (!canAffordResources(table, playerId, amounts)) {
     const missing = getMissingResources(table, playerId, amounts);
     throw new Error(
@@ -1308,14 +1336,14 @@ function spendPlayerResourcesInPlace(table, playerId, amounts) {
     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);
-  });
+  for (const [resourceId, amount] of entries) {
+    const nextAmount = getPlayerResourceAmount(table, playerId, resourceId) - amount;
+    assertNonNegativeSafeInteger(
+      nextAmount,
+      `Resource '${resourceId}' balance`
+    );
+    next[resourceId] = nextAmount;
+  }
   writePlayerResources(table, playerId, next);
 }
 function transferPlayerResources(table, fromPlayerId, toPlayerId, amounts) {
@@ -1324,8 +1352,42 @@ function transferPlayerResources(table, fromPlayerId, toPlayerId, amounts) {
   return nextTable;
 }
 function transferPlayerResourcesInPlace(table, fromPlayerId, toPlayerId, amounts) {
-  spendPlayerResourcesInPlace(table, fromPlayerId, amounts);
-  addPlayerResourcesInPlace(table, toPlayerId, amounts);
+  const entries = resourceEntries(amounts);
+  if (!canAffordResources(table, fromPlayerId, amounts)) {
+    const missing = getMissingResources(table, fromPlayerId, amounts);
+    throw new Error(
+      `spendPlayerResources: player '${fromPlayerId}' cannot afford ${JSON.stringify(
+        missing
+      )}. Check canAfford in your validate step first.`
+    );
+  }
+  if (fromPlayerId === toPlayerId) return;
+  const fromPrev = perPlayerGet(
+    table.resources,
+    fromPlayerId
+  ) ?? {};
+  const toPrev = perPlayerGet(
+    table.resources,
+    toPlayerId
+  ) ?? {};
+  const fromNext = { ...fromPrev };
+  const toNext = { ...toPrev };
+  for (const [resourceId, amount] of entries) {
+    const sourceBalance = getPlayerResourceAmount(table, fromPlayerId, resourceId) - amount;
+    const destinationBalance = getPlayerResourceAmount(table, toPlayerId, resourceId) + amount;
+    assertNonNegativeSafeInteger(
+      sourceBalance,
+      `Resource '${resourceId}' balance`
+    );
+    assertNonNegativeSafeInteger(
+      destinationBalance,
+      `Resource '${resourceId}' balance`
+    );
+    fromNext[resourceId] = sourceBalance;
+    toNext[resourceId] = destinationBalance;
+  }
+  writePlayerResources(table, fromPlayerId, fromNext);
+  writePlayerResources(table, toPlayerId, toNext);
 }
 function setPlayerResource(table, playerId, resourceId, amount) {
   const nextTable = { ...table };
@@ -1333,11 +1395,7 @@ function setPlayerResource(table, playerId, resourceId, amount) {
   return nextTable;
 }
 function setPlayerResourceInPlace(table, playerId, resourceId, amount) {
-  if (!Number.isFinite(amount) || amount < 0) {
-    throw new Error(
-      `setPlayerResource: amount must be a non-negative finite number, got ${amount}.`
-    );
-  }
+  assertNonNegativeSafeInteger(amount, `Resource '${resourceId}' amount`);
   const prev = perPlayerGet(
     table.resources,
     playerId
@@ -1603,6 +1661,116 @@ function moveComponentToVertexInPlace(table, componentId, boardId, vertexId) {
 }
 
 // src/reducer/table/card-mutations.ts
+function sharedZoneCards(table, zoneId) {
+  return [...ensureArray(table.zones.shared[zoneId] ?? table.decks[zoneId])];
+}
+function playerZoneCards(table, zoneId, playerId) {
+  return [
+    ...ensureArray(
+      ppRead(table.zones.perPlayer[zoneId] ?? table.hands[zoneId], playerId)
+    )
+  ];
+}
+function assertCardInSharedZone(table, zoneId, cardId) {
+  if (!sharedZoneCards(table, zoneId).includes(cardId)) {
+    throw new Error(`Card '${cardId}' is not in shared zone '${zoneId}'.`);
+  }
+  const location = table.componentLocations[cardId];
+  if (location?.type !== "InDeck" || location.deckId !== zoneId) {
+    throw new Error(
+      `Card '${cardId}' has a location that disagrees with shared zone '${zoneId}'.`
+    );
+  }
+}
+function assertCardInPlayerZone(table, zoneId, playerId, cardId) {
+  if (!playerZoneCards(table, zoneId, playerId).includes(cardId)) {
+    throw new Error(
+      `Card '${cardId}' is not in zone '${zoneId}' for player '${playerId}'.`
+    );
+  }
+  const location = table.componentLocations[cardId];
+  if (location?.type !== "InHand" || location.handId !== zoneId || location.playerId !== playerId) {
+    throw new Error(
+      `Card '${cardId}' has a location that disagrees with zone '${zoneId}' for player '${playerId}'.`
+    );
+  }
+}
+function assertCardDetached(table, cardId) {
+  const location = table.componentLocations[cardId];
+  if (location?.type !== "Detached") {
+    throw new Error(`Card '${cardId}' must be detached before placement.`);
+  }
+}
+function assertCardAbsentFromSharedZone(table, zoneId, cardId) {
+  if (sharedZoneCards(table, zoneId).includes(cardId)) {
+    throw new Error(`Card '${cardId}' is already in shared zone '${zoneId}'.`);
+  }
+}
+function assertCardAbsentFromPlayerZone(table, zoneId, playerId, cardId) {
+  if (playerZoneCards(table, zoneId, playerId).includes(cardId)) {
+    throw new Error(
+      `Card '${cardId}' is already in zone '${zoneId}' for player '${playerId}'.`
+    );
+  }
+}
+function reindexSharedZoneCards(table, zoneId, cardIds, playedByForCard) {
+  for (const [index, currentCardId] of cardIds.entries()) {
+    const existing = table.componentLocations[currentCardId];
+    table.componentLocations[currentCardId] = {
+      type: "InDeck",
+      deckId: zoneId,
+      playedBy: playedByForCard?.[currentCardId] ?? (existing?.type === "InDeck" ? existing.playedBy : null),
+      position: index
+    };
+  }
+}
+function reindexPlayerZoneCards(table, zoneId, playerId, cardIds) {
+  for (const [index, currentCardId] of cardIds.entries()) {
+    table.componentLocations[currentCardId] = {
+      type: "InHand",
+      handId: zoneId,
+      playerId,
+      position: index
+    };
+  }
+}
+function insertCard(cardIds, cardId, position = "bottom") {
+  return position === "top" ? [cardId, ...cardIds] : [...cardIds, cardId];
+}
+function removeCard(cardIds, cardId) {
+  return cardIds.filter((candidate) => candidate !== cardId);
+}
+function appendCardToSharedZoneCollectionInPlace(table, deckId, cardId, playedBy, position = "bottom") {
+  const nextCards = insertCard(
+    sharedZoneCards(table, deckId),
+    cardId,
+    position
+  );
+  syncSharedZoneWithDeck(
+    table,
+    deckId,
+    nextCards
+  );
+  reindexSharedZoneCards(table, deckId, nextCards, {
+    [cardId]: playedBy
+  });
+}
+function removeCardFromSharedZoneCollectionInPlace(table, deckId, cardId) {
+  const remaining = removeCard(
+    sharedZoneCards(table, deckId),
+    cardId
+  );
+  syncSharedZoneWithDeck(
+    table,
+    deckId,
+    remaining
+  );
+  reindexSharedZoneCards(table, deckId, remaining);
+}
+function setPlayerZoneCardsInPlace(table, zoneId, playerId, cardIds) {
+  syncPlayerZoneWithHand(table, zoneId, playerId, cardIds);
+  reindexPlayerZoneCards(table, zoneId, playerId, cardIds);
+}
 function shufflePlayerZoneCards(table, zoneId, playerId, nextCards) {
   if (nextCards === void 0) {
     const fromZone = ppRead(
@@ -1634,32 +1802,16 @@ function appendToDeckInPlace(table, deckId, cardId, playedBy = null, position =
     "addCardToSharedZone",
     "zoneId"
   );
-  const deckCards = [...ensureArray(table.decks[deckId])];
+  assertCardDetached(table, cardId);
+  assertCardAbsentFromSharedZone(table, deckId, cardId);
   assertCardAllowedInZone(table, deckId, cardId);
-  if (position === "top") {
-    deckCards.unshift(cardId);
-  } else {
-    deckCards.push(cardId);
-  }
-  syncSharedZoneWithDeck(table, deckId, deckCards);
-  for (const [index, currentCardId] of deckCards.entries()) {
-    if (currentCardId === cardId) {
-      table.componentLocations[currentCardId] = {
-        type: "InDeck",
-        deckId,
-        playedBy,
-        position: index
-      };
-      continue;
-    }
-    const existing = table.componentLocations[currentCardId];
-    table.componentLocations[currentCardId] = {
-      type: "InDeck",
-      deckId,
-      playedBy: existing?.type === "InDeck" ? existing.playedBy : null,
-      position: index
-    };
-  }
+  appendCardToSharedZoneCollectionInPlace(
+    table,
+    deckId,
+    cardId,
+    playedBy,
+    position
+  );
   table.ownerOfCard[cardId] = playedBy;
   table.visibility[cardId] = {
     faceUp: true
@@ -1678,19 +1830,9 @@ function removeFromDeckInPlace(table, deckId, cardId) {
     "removeCardFromSharedZone",
     "zoneId"
   );
-  const remaining = ensureArray(table.decks[deckId]).filter(
-    (candidate) => candidate !== cardId
-  );
-  syncSharedZoneWithDeck(table, deckId, remaining);
-  for (const [index, currentCardId] of remaining.entries()) {
-    const currentLocation = table.componentLocations[currentCardId];
-    if (currentLocation?.type === "InDeck") {
-      table.componentLocations[currentCardId] = {
-        ...currentLocation,
-        position: index
-      };
-    }
-  }
+  assertCardInSharedZone(table, deckId, cardId);
+  removeCardFromSharedZoneCollectionInPlace(table, deckId, cardId);
+  table.componentLocations[cardId] = { type: "Detached" };
 }
 function computeVisibilityForPlayerZone(table, zoneId, playerId) {
   const mode = table.handVisibility[zoneId];
@@ -1722,34 +1864,45 @@ function moveFromHandToDeckInPlace(options) {
     "moveCardFromPlayerZoneToSharedZone",
     "toZoneId"
   );
-  const currentHand = ensureArray(
-    ppRead(options.table.hands[options.handId], options.playerId)
-  ).filter((candidate) => candidate !== options.cardId);
-  syncPlayerZoneWithHand(
+  assertCardInPlayerZone(
     options.table,
     options.handId,
     options.playerId,
-    currentHand
+    options.cardId
   );
-  for (const [index, currentCardId] of currentHand.entries()) {
-    options.table.componentLocations[currentCardId] = {
-      type: "InHand",
-      handId: options.handId,
-      playerId: options.playerId,
-      position: index
-    };
-  }
-  options.table.ownerOfCard[options.cardId] = options.playedBy ?? options.playerId;
-  options.table.visibility[options.cardId] = {
-    faceUp: true
-  };
-  appendToDeckInPlace(
+  assertCardAbsentFromSharedZone(
+    options.table,
+    options.deckId,
+    options.cardId
+  );
+  assertCardAllowedInZone(
+    options.table,
+    options.deckId,
+    options.cardId
+  );
+  const currentHand = playerZoneCards(
+    options.table,
+    options.handId,
+    options.playerId
+  );
+  const nextHand = removeCard(currentHand, options.cardId);
+  setPlayerZoneCardsInPlace(
+    options.table,
+    options.handId,
+    options.playerId,
+    nextHand
+  );
+  appendCardToSharedZoneCollectionInPlace(
     options.table,
     options.deckId,
     options.cardId,
     options.playedBy ?? options.playerId,
     options.position ?? "bottom"
   );
+  options.table.ownerOfCard[options.cardId] = options.playedBy ?? options.playerId;
+  options.table.visibility[options.cardId] = {
+    faceUp: true
+  };
 }
 function moveCardFromPlayerZoneToSharedZone(options) {
   return moveFromHandToDeck({
@@ -1782,25 +1935,71 @@ function dealCardsBetweenPlayerZones(options) {
   return nextTable;
 }
 function dealCardsBetweenPlayerZonesInPlace(options) {
-  let nextTable = options.table;
-  for (let i = 0; i < options.count; i += 1) {
-    const sourceCards = ensureArray(
-      ppRead(
-        nextTable.zones.perPlayer[options.fromZoneId] ?? nextTable.hands[options.fromZoneId],
-        options.playerId
-      )
+  assertNonNegativeSafeInteger(options.count, "Deal count");
+  if (options.count === 0) return;
+  assertZoneScope(
+    options.table,
+    options.fromZoneId,
+    "perPlayer",
+    "dealCardsBetweenPlayerZones",
+    "fromZoneId"
+  );
+  assertZoneScope(
+    options.table,
+    options.toZoneId,
+    "perPlayer",
+    "dealCardsBetweenPlayerZones",
+    "toZoneId"
+  );
+  if (options.fromZoneId === options.toZoneId) {
+    throw new Error("Deal source and destination must differ.");
+  }
+  const sourceCards = playerZoneCards(
+    options.table,
+    options.fromZoneId,
+    options.playerId
+  );
+  const selectedCards = sourceCards.slice(0, options.count);
+  const destinationCards = playerZoneCards(
+    options.table,
+    options.toZoneId,
+    options.playerId
+  );
+  for (const cardId of selectedCards) {
+    assertCardInPlayerZone(
+      options.table,
+      options.fromZoneId,
+      options.playerId,
+      cardId
+    );
+    assertCardAbsentFromPlayerZone(
+      options.table,
+      options.toZoneId,
+      options.playerId,
+      cardId
+    );
+    assertCardAllowedInZone(options.table, options.toZoneId, cardId);
+  }
+  const remainingSource = sourceCards.slice(selectedCards.length);
+  const nextDestination = [...destinationCards, ...selectedCards];
+  setPlayerZoneCardsInPlace(
+    options.table,
+    options.fromZoneId,
+    options.playerId,
+    remainingSource
+  );
+  setPlayerZoneCardsInPlace(
+    options.table,
+    options.toZoneId,
+    options.playerId,
+    nextDestination
+  );
+  for (const cardId of selectedCards) {
+    options.table.visibility[cardId] = computeVisibilityForPlayerZone(
+      options.table,
+      options.toZoneId,
+      options.playerId
     );
-    const topCardId = sourceCards[0];
-    if (topCardId === void 0) {
-      break;
-    }
-    moveCardBetweenPlayerZonesInPlace({
-      table: nextTable,
-      playerId: options.playerId,
-      fromZoneId: options.fromZoneId,
-      toZoneId: options.toZoneId,
-      cardId: topCardId
-    });
   }
 }
 function moveCardFromSharedZoneToPlayerZone(options) {
@@ -1826,55 +2025,43 @@ function moveCardFromSharedZoneToPlayerZoneInPlace(options) {
     "moveCardFromSharedZoneToPlayerZone",
     "toZoneId"
   );
-  const sourceCards = ensureArray(
-    options.table.zones.shared[options.fromZoneId] ?? options.table.decks[options.fromZoneId]
+  assertCardInSharedZone(
+    options.table,
+    options.fromZoneId,
+    options.cardId
+  );
+  assertCardAbsentFromPlayerZone(
+    options.table,
+    options.toZoneId,
+    options.playerId,
+    options.cardId
   );
-  if (!sourceCards.includes(options.cardId)) {
-    throw new Error(
-      `Card '${String(options.cardId)}' is not in shared zone '${String(
-        options.fromZoneId
-      )}'.`
-    );
-  }
   assertCardAllowedInZone(
     options.table,
     options.toZoneId,
     options.cardId
   );
-  const remainingSource = sourceCards.filter(
-    (candidate) => candidate !== options.cardId
+  const destinationCards = playerZoneCards(
+    options.table,
+    options.toZoneId,
+    options.playerId
   );
-  syncSharedZoneWithDeck(options.table, options.fromZoneId, remainingSource);
-  for (const [index, currentCardId] of remainingSource.entries()) {
-    const existing = options.table.componentLocations[currentCardId];
-    if (existing?.type === "InDeck") {
-      options.table.componentLocations[currentCardId] = {
-        ...existing,
-        position: index
-      };
-    }
-  }
-  const destinationCards = ensureArray(
-    ppRead(
-      options.table.zones.perPlayer[options.toZoneId] ?? options.table.hands[options.toZoneId],
-      options.playerId
-    )
+  const nextDestination = insertCard(
+    destinationCards,
+    options.cardId,
+    options.position ?? "bottom"
+  );
+  removeCardFromSharedZoneCollectionInPlace(
+    options.table,
+    options.fromZoneId,
+    options.cardId
   );
-  const nextDestination = options.position === "top" ? [options.cardId, ...destinationCards] : [...destinationCards, options.cardId];
-  syncPlayerZoneWithHand(
+  setPlayerZoneCardsInPlace(
     options.table,
     options.toZoneId,
     options.playerId,
     nextDestination
   );
-  for (const [index, currentCardId] of nextDestination.entries()) {
-    options.table.componentLocations[currentCardId] = {
-      type: "InHand",
-      handId: options.toZoneId,
-      playerId: options.playerId,
-      position: index
-    };
-  }
   options.table.ownerOfCard[options.cardId] = options.playerId;
   options.table.visibility[options.cardId] = computeVisibilityForPlayerZone(
     options.table,
@@ -1905,63 +2092,51 @@ function moveCardBetweenPlayerZonesInPlace(options) {
     "moveCardBetweenPlayerZones",
     "toZoneId"
   );
-  const sourceCards = ensureArray(
-    ppRead(
-      options.table.zones.perPlayer[options.fromZoneId] ?? options.table.hands[options.fromZoneId],
-      options.playerId
-    )
+  assertCardInPlayerZone(
+    options.table,
+    options.fromZoneId,
+    options.playerId,
+    options.cardId
+  );
+  assertCardAbsentFromPlayerZone(
+    options.table,
+    options.toZoneId,
+    options.playerId,
+    options.cardId
   );
-  if (!sourceCards.includes(options.cardId)) {
-    throw new Error(
-      `Card '${String(options.cardId)}' is not in zone '${String(
-        options.fromZoneId
-      )}' for player '${String(options.playerId)}'.`
-    );
-  }
   assertCardAllowedInZone(
     options.table,
     options.toZoneId,
     options.cardId
   );
-  const remainingSource = sourceCards.filter(
-    (candidate) => candidate !== options.cardId
+  const sourceCards = playerZoneCards(
+    options.table,
+    options.fromZoneId,
+    options.playerId
   );
-  syncPlayerZoneWithHand(
+  const destinationCards = playerZoneCards(
+    options.table,
+    options.toZoneId,
+    options.playerId
+  );
+  const remainingSource = removeCard(sourceCards, options.cardId);
+  const nextDestination = insertCard(
+    destinationCards,
+    options.cardId,
+    options.position ?? "bottom"
+  );
+  setPlayerZoneCardsInPlace(
     options.table,
     options.fromZoneId,
     options.playerId,
     remainingSource
   );
-  for (const [index, currentCardId] of remainingSource.entries()) {
-    const existing = options.table.componentLocations[currentCardId];
-    if (existing?.type === "InHand") {
-      options.table.componentLocations[currentCardId] = {
-        ...existing,
-        position: index
-      };
-    }
-  }
-  const destinationCards = ensureArray(
-    ppRead(
-      options.table.zones.perPlayer[options.toZoneId] ?? options.table.hands[options.toZoneId],
-      options.playerId
-    )
-  );
-  const nextDestination = options.position === "top" ? [options.cardId, ...destinationCards] : [...destinationCards, options.cardId];
-  syncPlayerZoneWithHand(
+  setPlayerZoneCardsInPlace(
     options.table,
     options.toZoneId,
     options.playerId,
     nextDestination
   );
-  for (const [index, currentCardId] of nextDestination.entries()) {
-    options.table.componentLocations[currentCardId] = {
-      type: "InHand",
-      handId: options.toZoneId,
-      playerId: options.playerId,
-      position: index
-    };
-  }
   options.table.visibility[options.cardId] = computeVisibilityForPlayerZone(
     options.table,
     options.toZoneId,
@@ -1977,14 +2152,51 @@ function moveCardBetweenSharedZones(options) {
   return nextTable;
 }
 function moveCardBetweenSharedZonesInPlace(options) {
-  removeFromDeckInPlace(options.table, options.fromZoneId, options.cardId);
-  appendToDeckInPlace(
+  assertZoneScope(
+    options.table,
+    options.fromZoneId,
+    "shared",
+    "moveCardBetweenSharedZones",
+    "fromZoneId"
+  );
+  assertZoneScope(
+    options.table,
+    options.toZoneId,
+    "shared",
+    "moveCardBetweenSharedZones",
+    "toZoneId"
+  );
+  assertCardInSharedZone(
+    options.table,
+    options.fromZoneId,
+    options.cardId
+  );
+  assertCardAbsentFromSharedZone(
+    options.table,
+    options.toZoneId,
+    options.cardId
+  );
+  assertCardAllowedInZone(
+    options.table,
+    options.toZoneId,
+    options.cardId
+  );
+  removeCardFromSharedZoneCollectionInPlace(
+    options.table,
+    options.fromZoneId,
+    options.cardId
+  );
+  appendCardToSharedZoneCollectionInPlace(
     options.table,
     options.toZoneId,
     options.cardId,
     options.playedBy ?? null,
     options.position ?? "bottom"
   );
+  options.table.ownerOfCard[options.cardId] = options.playedBy ?? null;
+  options.table.visibility[options.cardId] = {
+    faceUp: true
+  };
 }
 function removeCardFromSharedZone(table, deckId, cardId) {
   return removeFromDeck(table, deckId, cardId);
@@ -2010,46 +2222,55 @@ function dealCardsFromDeckToHand(table, fromZoneId, playerId, toZoneId, count) {
   return nextTable;
 }
 function dealCardsFromDeckToHandInPlace(table, fromZoneId, playerId, toZoneId, count) {
-  const publicHands = new Set(
-    Object.entries(table.handVisibility).filter(([, mode]) => mode === "all" || mode === "public").map(([handId]) => handId)
+  assertNonNegativeSafeInteger(count, "Deal count");
+  if (count === 0) return;
+  assertZoneScope(
+    table,
+    fromZoneId,
+    "shared",
+    "dealCardsFromDeckToHand",
+    "fromZoneId"
   );
-  for (let index = 0; index < count; index += 1) {
-    const nextCard = ensureArray(table.decks[fromZoneId])[0];
-    if (!nextCard) {
-      break;
-    }
-    table.decks[fromZoneId] = ensureArray(table.decks[fromZoneId]).slice(
-      1
-    );
-    table.zones.shared[fromZoneId] = [
-      ...ensureArray(table.decks[fromZoneId])
-    ];
-    const prevHand = ppRead(table.hands[toZoneId], playerId);
-    const nextHand = [...ensureArray(prevHand), nextCard];
-    assertCardAllowedInZone(table, toZoneId, nextCard);
-    table.hands[toZoneId] = ppWrite(
-      table.hands[toZoneId],
+  assertZoneScope(
+    table,
+    toZoneId,
+    "perPlayer",
+    "dealCardsFromDeckToHand",
+    "toZoneId"
+  );
+  const sourceCards = sharedZoneCards(table, fromZoneId);
+  const selectedCards = sourceCards.slice(0, count);
+  const destinationCards = playerZoneCards(
+    table,
+    toZoneId,
+    playerId
+  );
+  for (const cardId of selectedCards) {
+    assertCardInSharedZone(table, fromZoneId, cardId);
+    assertCardAbsentFromPlayerZone(
+      table,
+      toZoneId,
       playerId,
-      nextHand
+      cardId
     );
-    table.zones.perPlayer[toZoneId] = ppWrite(
-      table.zones.perPlayer[toZoneId],
-      playerId,
-      [...nextHand]
+    assertCardAllowedInZone(table, toZoneId, cardId);
+  }
+  const remainingSource = sourceCards.slice(selectedCards.length);
+  const nextHand = [...destinationCards, ...selectedCards];
+  syncSharedZoneWithDeck(
+    table,
+    fromZoneId,
+    remainingSource
+  );
+  reindexSharedZoneCards(table, fromZoneId, remainingSource);
+  setPlayerZoneCardsInPlace(table, toZoneId, playerId, nextHand);
+  for (const cardId of selectedCards) {
+    table.ownerOfCard[cardId] = playerId;
+    table.visibility[cardId] = computeVisibilityForPlayerZone(
+      table,
+      toZoneId,
+      playerId
     );
-    table.componentLocations[nextCard] = {
-      type: "InHand",
-      handId: toZoneId,
-      playerId,
-      position: nextHand.length - 1
-    };
-    table.ownerOfCard[nextCard] = playerId;
-    table.visibility[nextCard] = publicHands.has(toZoneId) ? {
-      faceUp: true
-    } : {
-      faceUp: false,
-      visibleTo: [playerId]
-    };
   }
 }
 
@@ -2651,4 +2872,4 @@ export {
   collectReducerDefinitionIndex,
   applySetupBootstrap
 };
-//# sourceMappingURL=chunk-U5KBV2BA.js.map
+//# sourceMappingURL=chunk-N6ZDIMRB.js.map