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

package/dist/chunk-Z7QCREWI.js

@@ -1,3435 +0,0 @@
-// src/reducer/manifest/hex-geometry.ts
-var HEX_CORNERS = ["ne-e", "e-se", "se-sw", "sw-w", "w-nw", "nw-ne"];
-var HEX_CORNER_OFFSETS = {
-  "ne-e": [2, -1, -1],
-  "e-se": [1, -2, 1],
-  "se-sw": [-1, -1, 2],
-  "sw-w": [-2, 1, 1],
-  "w-nw": [-1, 2, -1],
-  "nw-ne": [1, 1, -2]
-};
-function cubeFromAxial(space) {
-  const x = space.q;
-  const z = space.r;
-  return [x, -x - z, z];
-}
-function cornerGeometryKey(space, corner) {
-  const [x, y, z] = cubeFromAxial(space);
-  const [dx, dy, dz] = HEX_CORNER_OFFSETS[corner];
-  return `${3 * x + dx},${3 * y + dy},${3 * z + dz}`;
-}
-function resolveHexVertexGeometryKey(ref, spacesById) {
-  const resolvedSpaces = [...ref.spaces].sort((left, right) => left.localeCompare(right)).map((spaceId) => {
-    const space = spacesById.get(spaceId);
-    if (!space) {
-      throw new Error(
-        `Hex vertex ref references unknown space '${spaceId}'.`
-      );
-    }
-    return space;
-  });
-  const keyCounts = /* @__PURE__ */ new Map();
-  for (const space of resolvedSpaces) {
-    for (const corner of HEX_CORNERS) {
-      const key = cornerGeometryKey(space, corner);
-      keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
-    }
-  }
-  const candidates = [...keyCounts.entries()].filter(([, count]) => count === resolvedSpaces.length).map(([key]) => key).sort((left, right) => left.localeCompare(right));
-  if (candidates.length !== 1) {
-    throw new Error(
-      `Hex vertex ref spaces '${ref.spaces.join(", ")}' do not resolve to exactly one shared vertex.`
-    );
-  }
-  const vertexKey = candidates[0];
-  if (vertexKey === void 0) {
-    throw new Error("internal: expected exactly one hex vertex geometry key");
-  }
-  return vertexKey;
-}
-
-// src/reducer/manifest/preset-card-sets.ts
-var STANDARD_DECK_ID = "standard_52_deck";
-function createEnumPropertySchema(enums, description) {
-  return {
-    type: "enum",
-    description,
-    enums
-  };
-}
-function createStringPropertySchema(description) {
-  return {
-    type: "string",
-    description
-  };
-}
-function createStandard52CardDeck(defaultHome = { type: "detached" }) {
-  const suits = ["SPADES", "HEARTS", "CLUBS", "DIAMONDS"];
-  const ranks = [
-    "3",
-    "4",
-    "5",
-    "6",
-    "7",
-    "8",
-    "9",
-    "10",
-    "J",
-    "Q",
-    "K",
-    "A",
-    "2"
-  ];
-  const cards = [];
-  for (const suit of suits) {
-    for (const rank of ranks) {
-      cards.push({
-        type: `${suit}_${rank}`,
-        name: `${rank} of ${suit}`,
-        imageUrl: `/cards/${suit.toLowerCase()}_${rank.toLowerCase()}.png`,
-        text: `A playing card: ${rank} of ${suit}. Value: ${getBigTwoCardValue(rank)}, Suit value: ${getSuitValue(suit)}`,
-        count: 1,
-        cardType: `${suit}_${rank}`,
-        properties: {
-          suit,
-          rank
-        }
-      });
-    }
-  }
-  return {
-    id: STANDARD_DECK_ID,
-    name: "Standard 52-Card Deck",
-    type: "manual",
-    defaultHome,
-    cards,
-    cardSchema: {
-      properties: {
-        suit: createEnumPropertySchema(
-          ["SPADES", "HEARTS", "CLUBS", "DIAMONDS"],
-          "The suit of the card"
-        ),
-        rank: createStringPropertySchema("The rank of the card")
-      }
-    }
-  };
-}
-function addStandardDecksIfNeeded(manifest) {
-  return {
-    ...manifest,
-    cardSets: manifest.cardSets.map(
-      (cardSet) => cardSet.type === "preset" && cardSet.presetId === STANDARD_DECK_ID ? {
-        ...createStandard52CardDeck(cardSet.defaultHome),
-        id: cardSet.id,
-        name: cardSet.name
-      } : cardSet
-    )
-  };
-}
-function materializePresetCardSet(presetCardSet) {
-  if (presetCardSet.presetId !== STANDARD_DECK_ID) {
-    throw new Error(`Unsupported preset deck: ${presetCardSet.presetId}`);
-  }
-  const standardDeck = createStandard52CardDeck(presetCardSet.defaultHome);
-  return {
-    ...standardDeck,
-    id: presetCardSet.id,
-    name: presetCardSet.name
-  };
-}
-function materializeCardSet(cardSet) {
-  return cardSet.type === "manual" ? cardSet : materializePresetCardSet(cardSet);
-}
-function getBigTwoCardValue(rank) {
-  switch (rank) {
-    case "3":
-      return 3;
-    case "4":
-      return 4;
-    case "5":
-      return 5;
-    case "6":
-      return 6;
-    case "7":
-      return 7;
-    case "8":
-      return 8;
-    case "9":
-      return 9;
-    case "10":
-      return 10;
-    case "J":
-      return 11;
-    case "Q":
-      return 12;
-    case "K":
-      return 13;
-    case "A":
-      return 14;
-    case "2":
-      return 15;
-    default:
-      return 0;
-  }
-}
-function getSuitValue(suit) {
-  switch (suit) {
-    case "DIAMONDS":
-      return 1;
-    case "CLUBS":
-      return 2;
-    case "HEARTS":
-      return 3;
-    case "SPADES":
-      return 4;
-    default:
-      return 0;
-  }
-}
-
-// src/reducer/manifest/manifest-validation.ts
-function isHexBoardTemplateSpec(boardTemplate) {
-  return boardTemplate.layout === "hex";
-}
-function isHexBoardSpec(board) {
-  return board.layout === "hex";
-}
-function collectDuplicateIdIssues(options) {
-  const issues = [];
-  const pathsById = /* @__PURE__ */ new Map();
-  for (const entry of options.entries) {
-    const id = entry.id?.trim();
-    if (!id) {
-      continue;
-    }
-    const paths = pathsById.get(id) ?? [];
-    paths.push(entry.path);
-    pathsById.set(id, paths);
-  }
-  for (const [id, paths] of pathsById.entries()) {
-    if (paths.length > 1) {
-      issues.push(`${paths.join(", ")}: Duplicate ${options.label} '${id}'.`);
-    }
-  }
-  return issues;
-}
-var PROTOTYPE_SENSITIVE_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "prototype",
-  "constructor"
-]);
-function validateRecordKey(value, path) {
-  if (!value || !PROTOTYPE_SENSITIVE_KEYS.has(value)) {
-    return [];
-  }
-  return [
-    `${path}: '${value}' is reserved and cannot be used as a generated record key.`
-  ];
-}
-function collectKeyIssues(entries) {
-  return entries.flatMap(({ value, path }) => validateRecordKey(value, path));
-}
-function toHandleKey(input) {
-  if (!/[_-]/.test(input)) {
-    return input.charAt(0).toLowerCase() + input.slice(1);
-  }
-  const [first = "", ...rest] = input.split(/[_-]/g).filter(Boolean);
-  return [
-    first.toLowerCase(),
-    ...rest.map((part) => {
-      const lower = part.toLowerCase();
-      return lower.charAt(0).toUpperCase() + lower.slice(1);
-    })
-  ].join("");
-}
-function collectHandleKeyCollisions(values, label) {
-  const idsByHandle = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    const handle = toHandleKey(value);
-    idsByHandle.set(handle, [...idsByHandle.get(handle) ?? [], value]);
-  }
-  return [...idsByHandle.entries()].filter(([, ids]) => ids.length > 1).map(
-    ([handle, ids]) => `${label} values ${ids.join(", ")} all generate handle '${handle}'.`
-  );
-}
-function dedupeSorted(values) {
-  return Array.from(new Set(values)).sort();
-}
-function renderCardInstanceIds(card) {
-  return card.count > 1 ? Array.from(
-    { length: card.count },
-    (_, index) => `${card.type}-${index + 1}`
-  ) : [card.type];
-}
-function collectPropertySchemaKeyIssues(schema, path) {
-  if (!schema) {
-    return [];
-  }
-  const issues = [];
-  if (schema.type === "object") {
-    for (const [key, property] of Object.entries(schema.properties ?? {})) {
-      issues.push(
-        ...validateRecordKey(key, `${path}.properties.${key}`),
-        ...collectPropertySchemaKeyIssues(
-          property,
-          `${path}.properties.${key}`
-        )
-      );
-    }
-  }
-  if (schema.type === "array") {
-    issues.push(
-      ...collectPropertySchemaKeyIssues(schema.items, `${path}.items`)
-    );
-  }
-  if (schema.type === "record") {
-    issues.push(
-      ...collectPropertySchemaKeyIssues(schema.values, `${path}.values`)
-    );
-  }
-  return issues;
-}
-function collectObjectSchemaKeyIssues(schema, path) {
-  const issues = [];
-  for (const [key, property] of Object.entries(schema?.properties ?? {})) {
-    issues.push(
-      ...validateRecordKey(key, `${path}.properties.${key}`),
-      ...collectPropertySchemaKeyIssues(property, `${path}.properties.${key}`)
-    );
-  }
-  return issues;
-}
-function collectCardSchemaKeyIssues(cardSet, path) {
-  if (cardSet.type !== "manual") {
-    return [];
-  }
-  const schema = cardSet.cardSchema;
-  if ("variants" in schema) {
-    return [
-      ...Object.entries(schema.shared ?? {}).flatMap(([key, property]) => [
-        ...validateRecordKey(key, `${path}.cardSchema.shared.${key}`),
-        ...collectPropertySchemaKeyIssues(
-          property,
-          `${path}.cardSchema.shared.${key}`
-        )
-      ]),
-      ...Object.entries(schema.variants).flatMap(
-        ([variantKey, variantSchema]) => [
-          ...validateRecordKey(
-            variantKey,
-            `${path}.cardSchema.variants.${variantKey}`
-          ),
-          ...collectObjectSchemaKeyIssues(
-            variantSchema,
-            `${path}.cardSchema.variants.${variantKey}`
-          )
-        ]
-      )
-    ];
-  }
-  return collectObjectSchemaKeyIssues(schema, `${path}.cardSchema`);
-}
-function expandSeedIds(seeds) {
-  return seeds.flatMap((seed) => {
-    const count = seed.count ?? 1;
-    const baseId = seed.id ?? seed.typeId;
-    return count > 1 ? Array.from({ length: count }, (_, index) => `${baseId}-${index + 1}`) : [baseId];
-  });
-}
-function validateTypeSlotDuplicates(options) {
-  const issues = [];
-  for (const [index, pieceType] of options.pieceTypes.entries()) {
-    issues.push(
-      ...collectDuplicateIdIssues({
-        entries: (pieceType.slots ?? []).map((slot, slotIndex) => ({
-          id: slot.id,
-          path: `manifest.pieceTypes[${index}].slots[${slotIndex}].id`
-        })),
-        label: "piece slot id"
-      })
-    );
-  }
-  for (const [index, dieType] of options.dieTypes.entries()) {
-    issues.push(
-      ...collectDuplicateIdIssues({
-        entries: (dieType.slots ?? []).map((slot, slotIndex) => ({
-          id: slot.id,
-          path: `manifest.dieTypes[${index}].slots[${slotIndex}].id`
-        })),
-        label: "die slot id"
-      })
-    );
-  }
-  return issues;
-}
-function validateSlotHostsAndHomes(manifest) {
-  const issues = [];
-  const pieceTypesById = new Map(
-    (manifest.pieceTypes ?? []).map(
-      (pieceType) => [pieceType.id, pieceType]
-    )
-  );
-  const dieTypesById = new Map(
-    (manifest.dieTypes ?? []).map((dieType) => [dieType.id, dieType])
-  );
-  const slotIdsByHostKey = /* @__PURE__ */ new Map();
-  for (const [index, seed] of (manifest.pieceSeeds ?? []).entries()) {
-    const pieceType = pieceTypesById.get(seed.typeId);
-    const slotIds = (pieceType?.slots ?? []).map((slot) => slot.id);
-    if (slotIds.length === 0) {
-      continue;
-    }
-    if (typeof seed.id !== "string" || seed.id.length === 0) {
-      issues.push(
-        `manifest.pieceSeeds[${index}].id: Piece seed for slot-bearing type '${seed.typeId}' must declare an explicit id.`
-      );
-      continue;
-    }
-    if ((seed.count ?? 1) !== 1) {
-      issues.push(
-        `manifest.pieceSeeds[${index}].count: Piece seed '${seed.id}' for slot-bearing type '${seed.typeId}' must omit count or set it to 1.`
-      );
-      continue;
-    }
-    slotIdsByHostKey.set(`piece:${seed.id}`, new Set(slotIds));
-  }
-  for (const [index, seed] of (manifest.dieSeeds ?? []).entries()) {
-    const dieType = dieTypesById.get(seed.typeId);
-    const slotIds = (dieType?.slots ?? []).map((slot) => slot.id);
-    if (slotIds.length === 0) {
-      continue;
-    }
-    if (typeof seed.id !== "string" || seed.id.length === 0) {
-      issues.push(
-        `manifest.dieSeeds[${index}].id: Die seed for slot-bearing type '${seed.typeId}' must declare an explicit id.`
-      );
-      continue;
-    }
-    if ((seed.count ?? 1) !== 1) {
-      issues.push(
-        `manifest.dieSeeds[${index}].count: Die seed '${seed.id}' for slot-bearing type '${seed.typeId}' must omit count or set it to 1.`
-      );
-      continue;
-    }
-    slotIdsByHostKey.set(`die:${seed.id}`, new Set(slotIds));
-  }
-  const validateHome = (home, path) => {
-    if (home?.type !== "slot") {
-      return;
-    }
-    const hostKey = `${home.host.kind}:${home.host.id}`;
-    const slotIds = slotIdsByHostKey.get(hostKey);
-    if (!slotIds) {
-      issues.push(
-        `${path}.host: Unknown strict slot host '${home.host.kind}:${home.host.id}'. Hosts must be singleton piece/die seeds whose type declares slots.`
-      );
-      return;
-    }
-    if (!slotIds.has(home.slotId)) {
-      issues.push(
-        `${path}.slotId: Unknown slot '${home.slotId}' for host '${home.host.kind}:${home.host.id}'.`
-      );
-    }
-  };
-  for (const [cardSetIndex, cardSet] of manifest.cardSets.entries()) {
-    if (cardSet.type !== "manual") {
-      continue;
-    }
-    validateHome(
-      cardSet.defaultHome,
-      `manifest.cardSets[${cardSetIndex}].defaultHome`
-    );
-    for (const [cardIndex, card] of cardSet.cards.entries()) {
-      validateHome(
-        card.home,
-        `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].home`
-      );
-    }
-  }
-  for (const [index, seed] of (manifest.pieceSeeds ?? []).entries()) {
-    validateHome(seed.home, `manifest.pieceSeeds[${index}].home`);
-  }
-  for (const [index, seed] of (manifest.dieSeeds ?? []).entries()) {
-    validateHome(seed.home, `manifest.dieSeeds[${index}].home`);
-  }
-  return issues;
-}
-function validateSetupProfileReferences(manifest) {
-  const issues = [];
-  const optionChoiceIdsByOptionId = new Map(
-    (manifest.setupOptions ?? []).map((option, optionIndex) => {
-      const choiceIds = /* @__PURE__ */ new Set();
-      for (const choice of option.choices ?? []) {
-        choiceIds.add(choice.id);
-      }
-      if (!option.id) {
-        issues.push(
-          `manifest.setupOptions[${optionIndex}].id: Missing option id.`
-        );
-      }
-      return [option.id, choiceIds];
-    })
-  );
-  for (const [profileIndex, profile] of (manifest.setupProfiles ?? []).entries()) {
-    const optionValues = profile.optionValues ?? {};
-    for (const [optionId, choiceId] of Object.entries(optionValues)) {
-      const allowedChoices = optionChoiceIdsByOptionId.get(optionId);
-      if (!allowedChoices) {
-        issues.push(
-          `manifest.setupProfiles[${profileIndex}].optionValues.${optionId}: Unknown setup option '${optionId}'.`
-        );
-        continue;
-      }
-      if (!allowedChoices.has(choiceId)) {
-        issues.push(
-          `manifest.setupProfiles[${profileIndex}].optionValues.${optionId}: Unknown choice '${choiceId}' for setup option '${optionId}'.`
-        );
-      }
-    }
-  }
-  return issues;
-}
-function validatePlayerScopedSeedHomes(manifest) {
-  const issues = [];
-  const boardScopeById = new Map(
-    (manifest.boards ?? []).map((board) => [board.id, board.scope])
-  );
-  const zoneScopeById = new Map(
-    (manifest.zones ?? []).map((zone) => [zone.id, zone.scope])
-  );
-  const validateSeedHome = (seed, path, label) => {
-    const authoredId = seed.id ?? seed.typeId;
-    if (seed.ownerId) {
-      return;
-    }
-    if (homeTargetsBoard(seed.home) && boardScopeById.get(seed.home.boardId) === "perPlayer") {
-      issues.push(
-        `${path}.boardId: ${label} '${authoredId}' requires ownerId because board '${seed.home.boardId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
-      );
-      return;
-    }
-    if (seed.home?.type === "zone" && zoneScopeById.get(seed.home.zoneId) === "perPlayer") {
-      issues.push(
-        `${path}.zoneId: ${label} '${authoredId}' requires ownerId because zone '${seed.home.zoneId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
-      );
-    }
-  };
-  for (const [index, seed] of (manifest.pieceSeeds ?? []).entries()) {
-    validateSeedHome(seed, `manifest.pieceSeeds[${index}].home`, "Piece seed");
-  }
-  for (const [index, seed] of (manifest.dieSeeds ?? []).entries()) {
-    validateSeedHome(seed, `manifest.dieSeeds[${index}].home`, "Die seed");
-  }
-  return issues;
-}
-function validateCardHomes(manifest) {
-  const issues = [];
-  const boardScopeById = new Map(
-    (manifest.boards ?? []).map((board) => [board.id, board.scope])
-  );
-  const zoneScopeById = new Map(
-    (manifest.zones ?? []).map((zone) => [zone.id, zone.scope])
-  );
-  for (const [cardSetIndex, cardSet] of manifest.cardSets.entries()) {
-    if (!cardSet.defaultHome) {
-      issues.push(
-        `manifest.cardSets[${cardSetIndex}].defaultHome: ${cardSet.type === "manual" ? "Manual" : "Preset"} card sets must declare defaultHome.`
-      );
-      continue;
-    }
-    const validateCardHome = (home, path, label) => {
-      if (home?.type === "zone" && zoneScopeById.get(home.zoneId) === "perPlayer") {
-        issues.push(
-          `${path}.zoneId: ${label} cannot target per-player zone '${home.zoneId}' because card inventory has no ownerId. Place it during reducer setup instead.`
-        );
-      }
-      if (homeTargetsBoard(home) && boardScopeById.get(home.boardId) === "perPlayer") {
-        issues.push(
-          `${path}.boardId: ${label} cannot target per-player board '${home.boardId}' because card inventory has no ownerId. Place it during reducer setup instead.`
-        );
-      }
-    };
-    validateCardHome(
-      cardSet.defaultHome,
-      `manifest.cardSets[${cardSetIndex}].defaultHome`,
-      `Card set '${cardSet.id}' defaultHome`
-    );
-    for (const [cardIndex, card] of (cardSet.type === "manual" ? cardSet.cards : []).entries()) {
-      const path = `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].home`;
-      validateCardHome(card.home, path, `Card '${card.type}'`);
-    }
-  }
-  return issues;
-}
-function homeTargetsBoard(home) {
-  return home?.type === "space" || home?.type === "container" || home?.type === "edge" || home?.type === "vertex";
-}
-function validateBoardTemplateDuplicates(boardTemplates) {
-  const issues = [];
-  for (const [index, boardTemplate] of boardTemplates.entries()) {
-    if (isHexBoardTemplateSpec(boardTemplate)) {
-      issues.push(
-        ...collectDuplicateIdIssues({
-          entries: (boardTemplate.spaces ?? []).map((space, spaceIndex) => ({
-            id: space.id,
-            path: `manifest.boardTemplates[${index}].spaces[${spaceIndex}].id`
-          })),
-          label: "space id"
-        })
-      );
-      continue;
-    }
-    issues.push(
-      ...collectDuplicateIdIssues({
-        entries: (boardTemplate.spaces ?? []).map((space, spaceIndex) => ({
-          id: space.id,
-          path: `manifest.boardTemplates[${index}].spaces[${spaceIndex}].id`
-        })),
-        label: "space id"
-      })
-    );
-    issues.push(
-      ...collectDuplicateIdIssues({
-        entries: (boardTemplate.containers ?? []).map(
-          (container, containerIndex) => ({
-            id: container.id,
-            path: `manifest.boardTemplates[${index}].containers[${containerIndex}].id`
-          })
-        ),
-        label: "container id"
-      })
-    );
-    issues.push(
-      ...collectDuplicateIdIssues({
-        entries: (boardTemplate.relations ?? []).map(
-          (relation, relationIndex) => ({
-            id: relation.id,
-            path: `manifest.boardTemplates[${index}].relations[${relationIndex}].id`
-          })
-        ),
-        label: "relation id"
-      })
-    );
-  }
-  return issues;
-}
-function validateBoardDuplicates(boards) {
-  const issues = [];
-  for (const [index, board] of boards.entries()) {
-    if (isHexBoardSpec(board)) {
-      issues.push(
-        ...collectDuplicateIdIssues({
-          entries: (board.spaces ?? []).map((space, spaceIndex) => ({
-            id: space.id,
-            path: `manifest.boards[${index}].spaces[${spaceIndex}].id`
-          })),
-          label: "space id"
-        })
-      );
-      continue;
-    }
-    issues.push(
-      ...collectDuplicateIdIssues({
-        entries: (board.spaces ?? []).map((space, spaceIndex) => ({
-          id: space.id,
-          path: `manifest.boards[${index}].spaces[${spaceIndex}].id`
-        })),
-        label: "space id"
-      })
-    );
-    issues.push(
-      ...collectDuplicateIdIssues({
-        entries: (board.containers ?? []).map((container, containerIndex) => ({
-          id: container.id,
-          path: `manifest.boards[${index}].containers[${containerIndex}].id`
-        })),
-        label: "container id"
-      })
-    );
-    issues.push(
-      ...collectDuplicateIdIssues({
-        entries: (board.relations ?? []).map((relation, relationIndex) => ({
-          id: relation.id,
-          path: `manifest.boards[${index}].relations[${relationIndex}].id`
-        })),
-        label: "relation id"
-      })
-    );
-  }
-  return issues;
-}
-function validateSetupOptionChoiceDuplicates(options) {
-  const issues = [];
-  for (const [optionIndex, option] of options.entries()) {
-    issues.push(
-      ...collectDuplicateIdIssues({
-        entries: (option.choices ?? []).map((choice, choiceIndex) => ({
-          id: choice.id,
-          path: `manifest.setupOptions[${optionIndex}].choices[${choiceIndex}].id`
-        })),
-        label: "setup option choice id"
-      })
-    );
-  }
-  return issues;
-}
-function resolveHexSpaces(board, template) {
-  if (!template) {
-    return [...board.spaces ?? []].sort(
-      (left, right) => left.id.localeCompare(right.id)
-    );
-  }
-  const templateSpacesById = new Map(
-    (template.spaces ?? []).map((space) => [space.id, space])
-  );
-  const overridesById = new Map(
-    (board.spaces ?? []).map((space) => [space.id, space])
-  );
-  for (const overrideId of overridesById.keys()) {
-    if (!templateSpacesById.has(overrideId)) {
-      continue;
-    }
-  }
-  return (template.spaces ?? []).map((templateSpace) => {
-    const override = overridesById.get(templateSpace.id);
-    if (!override) {
-      return templateSpace;
-    }
-    return {
-      ...templateSpace,
-      ...override,
-      id: templateSpace.id,
-      q: templateSpace.q,
-      r: templateSpace.r
-    };
-  }).sort((left, right) => left.id.localeCompare(right.id));
-}
-function validateHexVertexRefs(options) {
-  const issues = [];
-  const spacesById = new Map(
-    options.spaces.map((space) => [space.id, space])
-  );
-  for (const [vertexIndex, vertex] of options.vertices.entries()) {
-    try {
-      resolveHexVertexGeometryKey(vertex.ref, spacesById);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown hex vertex error.";
-      issues.push(
-        `${options.ownerPath}.vertices[${vertexIndex}].ref: ${options.ownerLabel} with spaces '${vertex.ref.spaces.join(", ")}' failed validation. ${message}`
-      );
-    }
-  }
-  return issues;
-}
-function validateHexBoardVertexRefs(manifest) {
-  const issues = [];
-  const hexTemplatesById = new Map(
-    (manifest.boardTemplates ?? []).filter(isHexBoardTemplateSpec).map((boardTemplate) => [boardTemplate.id, boardTemplate])
-  );
-  for (const [templateIndex, template] of (manifest.boardTemplates ?? []).entries()) {
-    if (!isHexBoardTemplateSpec(template)) {
-      continue;
-    }
-    issues.push(
-      ...validateHexVertexRefs({
-        ownerPath: `manifest.boardTemplates[${templateIndex}]`,
-        ownerLabel: `Hex board template '${template.id}'`,
-        spaces: template.spaces ?? [],
-        vertices: template.vertices ?? []
-      })
-    );
-  }
-  for (const [boardIndex, board] of (manifest.boards ?? []).entries()) {
-    if (!isHexBoardSpec(board)) {
-      continue;
-    }
-    issues.push(
-      ...validateHexVertexRefs({
-        ownerPath: `manifest.boards[${boardIndex}]`,
-        ownerLabel: `Hex board '${board.id}'`,
-        spaces: resolveHexSpaces(
-          board,
-          hexTemplatesById.get(board.templateId ?? "")
-        ),
-        vertices: board.vertices ?? []
-      })
-    );
-  }
-  return issues;
-}
-function collectAmbiguousBoardTypeWarnings(manifest) {
-  const warnings = [];
-  const boardTemplatesById = new Map(
-    (manifest.boardTemplates ?? []).map(
-      (template) => [template.id, template]
-    )
-  );
-  const boardsBySpaceType = /* @__PURE__ */ new Map();
-  const boardsByEdgeType = /* @__PURE__ */ new Map();
-  const boardsByVertexType = /* @__PURE__ */ new Map();
-  const addBoardUsage = (target, typeId, boardId) => {
-    if (!typeId) {
-      return;
-    }
-    const boardIds = target.get(typeId) ?? /* @__PURE__ */ new Set();
-    boardIds.add(boardId);
-    target.set(typeId, boardIds);
-  };
-  for (const board of manifest.boards ?? []) {
-    const template = board.templateId ? boardTemplatesById.get(board.templateId) : void 0;
-    for (const space of [
-      ...(template?.layout === board.layout ? template.spaces : void 0) ?? [],
-      ...board.spaces ?? []
-    ]) {
-      addBoardUsage(boardsBySpaceType, space.typeId, board.id);
-    }
-    if (board.layout === "hex" || board.layout === "square") {
-      for (const edge of [
-        ...(template?.layout === board.layout ? template.edges : void 0) ?? [],
-        ...board.edges ?? []
-      ]) {
-        addBoardUsage(boardsByEdgeType, edge.typeId, board.id);
-      }
-      for (const vertex of [
-        ...(template?.layout === board.layout ? template.vertices : void 0) ?? [],
-        ...board.vertices ?? []
-      ]) {
-        addBoardUsage(boardsByVertexType, vertex.typeId, board.id);
-      }
-    }
-  }
-  const pushWarnings = (kind, boardsByType, helperName) => {
-    for (const [typeId, boardIds] of boardsByType.entries()) {
-      if (boardIds.size < 2) {
-        continue;
-      }
-      warnings.push(
-        `Ambiguous ${kind}.typeId '${typeId}' is authored on multiple boards (${Array.from(boardIds).sort().join(", ")}). Prefer ${helperName} for board-scoped lookups.`
-      );
-    }
-  };
-  pushWarnings(
-    "space",
-    boardsBySpaceType,
-    "boardHelpers.spaceIdsByBoardId / boardHelpers.spaceTypeIdByBoardId"
-  );
-  pushWarnings(
-    "edge",
-    boardsByEdgeType,
-    "boardHelpers.edgeIdsByBoardIdAndTypeId"
-  );
-  pushWarnings(
-    "vertex",
-    boardsByVertexType,
-    "boardHelpers.vertexIdsByBoardIdAndTypeId"
-  );
-  return warnings;
-}
-function collectBoardRecordKeyIssues(manifest) {
-  const issues = [];
-  const maxPlayers = manifest.players.maxPlayers;
-  const playerIds = Array.from(
-    { length: maxPlayers },
-    (_, index) => `player-${index + 1}`
-  );
-  for (const [templateIndex, boardTemplate] of (manifest.boardTemplates ?? []).entries()) {
-    const templatePath = `manifest.boardTemplates[${templateIndex}]`;
-    issues.push(
-      ...collectKeyIssues([
-        { value: boardTemplate.id, path: `${templatePath}.id` },
-        { value: boardTemplate.typeId, path: `${templatePath}.typeId` }
-      ]),
-      ...collectObjectSchemaKeyIssues(
-        boardTemplate.boardFieldsSchema,
-        `${templatePath}.boardFieldsSchema`
-      ),
-      ...collectObjectSchemaKeyIssues(
-        boardTemplate.spaceFieldsSchema,
-        `${templatePath}.spaceFieldsSchema`
-      )
-    );
-    if (boardTemplate.layout !== "hex") {
-      issues.push(
-        ...collectObjectSchemaKeyIssues(
-          boardTemplate.relationFieldsSchema,
-          `${templatePath}.relationFieldsSchema`
-        ),
-        ...collectObjectSchemaKeyIssues(
-          boardTemplate.containerFieldsSchema,
-          `${templatePath}.containerFieldsSchema`
-        ),
-        ...collectKeyIssues([
-          ...(boardTemplate.containers ?? []).flatMap(
-            (container, containerIndex) => [
-              {
-                value: container.id,
-                path: `${templatePath}.containers[${containerIndex}].id`
-              },
-              {
-                value: container.host.type === "space" ? container.host.spaceId : void 0,
-                path: `${templatePath}.containers[${containerIndex}].host.spaceId`
-              }
-            ]
-          ),
-          ...(boardTemplate.relations ?? []).flatMap(
-            (relation, relationIndex) => [
-              {
-                value: relation.id,
-                path: `${templatePath}.relations[${relationIndex}].id`
-              },
-              {
-                value: relation.typeId,
-                path: `${templatePath}.relations[${relationIndex}].typeId`
-              },
-              {
-                value: relation.fromSpaceId,
-                path: `${templatePath}.relations[${relationIndex}].fromSpaceId`
-              },
-              {
-                value: relation.toSpaceId,
-                path: `${templatePath}.relations[${relationIndex}].toSpaceId`
-              }
-            ]
-          )
-        ])
-      );
-    }
-    if (boardTemplate.layout !== "generic") {
-      issues.push(
-        ...collectObjectSchemaKeyIssues(
-          boardTemplate.edgeFieldsSchema,
-          `${templatePath}.edgeFieldsSchema`
-        ),
-        ...collectObjectSchemaKeyIssues(
-          boardTemplate.vertexFieldsSchema,
-          `${templatePath}.vertexFieldsSchema`
-        ),
-        ...collectKeyIssues([
-          ...(boardTemplate.edges ?? []).map((edge, edgeIndex) => ({
-            value: edge.typeId,
-            path: `${templatePath}.edges[${edgeIndex}].typeId`
-          })),
-          ...(boardTemplate.vertices ?? []).map((vertex, vertexIndex) => ({
-            value: vertex.typeId,
-            path: `${templatePath}.vertices[${vertexIndex}].typeId`
-          }))
-        ])
-      );
-    }
-    issues.push(
-      ...collectKeyIssues(
-        (boardTemplate.spaces ?? []).flatMap((space, spaceIndex) => [
-          {
-            value: space.id,
-            path: `${templatePath}.spaces[${spaceIndex}].id`
-          },
-          {
-            value: space.typeId,
-            path: `${templatePath}.spaces[${spaceIndex}].typeId`
-          }
-        ])
-      )
-    );
-  }
-  for (const [boardIndex, board] of (manifest.boards ?? []).entries()) {
-    const boardPath = `manifest.boards[${boardIndex}]`;
-    const runtimeBoardIds = board.scope === "perPlayer" ? playerIds.map((playerId) => `${board.id}:${playerId}`) : [board.id];
-    issues.push(
-      ...collectKeyIssues([
-        { value: board.id, path: `${boardPath}.id` },
-        { value: board.typeId, path: `${boardPath}.typeId` },
-        { value: board.templateId, path: `${boardPath}.templateId` },
-        ...runtimeBoardIds.map((runtimeBoardId) => ({
-          value: runtimeBoardId,
-          path: `${boardPath}.runtimeBoardId`
-        }))
-      ]),
-      ...collectObjectSchemaKeyIssues(
-        board.boardFieldsSchema,
-        `${boardPath}.boardFieldsSchema`
-      ),
-      ...collectObjectSchemaKeyIssues(
-        board.spaceFieldsSchema,
-        `${boardPath}.spaceFieldsSchema`
-      )
-    );
-    if (board.layout !== "hex") {
-      issues.push(
-        ...collectObjectSchemaKeyIssues(
-          board.relationFieldsSchema,
-          `${boardPath}.relationFieldsSchema`
-        ),
-        ...collectObjectSchemaKeyIssues(
-          board.containerFieldsSchema,
-          `${boardPath}.containerFieldsSchema`
-        ),
-        ...collectKeyIssues([
-          ...(board.containers ?? []).flatMap((container, containerIndex) => [
-            {
-              value: container.id,
-              path: `${boardPath}.containers[${containerIndex}].id`
-            },
-            {
-              value: container.host.type === "space" ? container.host.spaceId : void 0,
-              path: `${boardPath}.containers[${containerIndex}].host.spaceId`
-            }
-          ]),
-          ...(board.relations ?? []).flatMap((relation, relationIndex) => [
-            {
-              value: relation.id,
-              path: `${boardPath}.relations[${relationIndex}].id`
-            },
-            {
-              value: relation.typeId,
-              path: `${boardPath}.relations[${relationIndex}].typeId`
-            },
-            {
-              value: relation.fromSpaceId,
-              path: `${boardPath}.relations[${relationIndex}].fromSpaceId`
-            },
-            {
-              value: relation.toSpaceId,
-              path: `${boardPath}.relations[${relationIndex}].toSpaceId`
-            }
-          ])
-        ])
-      );
-    }
-    if (board.layout !== "generic") {
-      issues.push(
-        ...collectObjectSchemaKeyIssues(
-          board.edgeFieldsSchema,
-          `${boardPath}.edgeFieldsSchema`
-        ),
-        ...collectObjectSchemaKeyIssues(
-          board.vertexFieldsSchema,
-          `${boardPath}.vertexFieldsSchema`
-        ),
-        ...collectKeyIssues([
-          ...(board.edges ?? []).map((edge, edgeIndex) => ({
-            value: edge.typeId,
-            path: `${boardPath}.edges[${edgeIndex}].typeId`
-          })),
-          ...(board.vertices ?? []).map((vertex, vertexIndex) => ({
-            value: vertex.typeId,
-            path: `${boardPath}.vertices[${vertexIndex}].typeId`
-          }))
-        ])
-      );
-    }
-    issues.push(
-      ...collectKeyIssues(
-        (board.spaces ?? []).flatMap((space, spaceIndex) => [
-          {
-            value: space.id,
-            path: `${boardPath}.spaces[${spaceIndex}].id`
-          },
-          {
-            value: space.typeId,
-            path: `${boardPath}.spaces[${spaceIndex}].typeId`
-          }
-        ])
-      )
-    );
-  }
-  return issues;
-}
-function collectManifestRecordKeyIssues(manifest) {
-  const cardSets = manifest.cardSets;
-  const manualCards = cardSets.flatMap(
-    (cardSet, cardSetIndex) => cardSet.type === "manual" ? cardSet.cards.flatMap(
-      (card, cardIndex) => renderCardInstanceIds(card).map((cardId) => ({
-        card,
-        cardId,
-        cardIndex,
-        cardSetIndex
-      }))
-    ) : []
-  );
-  return [
-    ...collectKeyIssues([
-      ...cardSets.map((cardSet, index) => ({
-        value: cardSet.id,
-        path: `manifest.cardSets[${index}].id`
-      })),
-      ...manualCards.flatMap(({ card, cardId, cardIndex, cardSetIndex }) => [
-        {
-          value: card.type,
-          path: `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].type`
-        },
-        {
-          value: card.cardType,
-          path: `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].cardType`
-        },
-        {
-          value: cardId,
-          path: `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].runtimeId`
-        }
-      ]),
-      ...(manifest.zones ?? []).map((zone, index) => ({
-        value: zone.id,
-        path: `manifest.zones[${index}].id`
-      })),
-      ...(manifest.resources ?? []).map((resource, index) => ({
-        value: resource.id,
-        path: `manifest.resources[${index}].id`
-      })),
-      ...(manifest.pieceTypes ?? []).flatMap((pieceType, typeIndex) => [
-        {
-          value: pieceType.id,
-          path: `manifest.pieceTypes[${typeIndex}].id`
-        },
-        ...(pieceType.slots ?? []).map((slot, slotIndex) => ({
-          value: slot.id,
-          path: `manifest.pieceTypes[${typeIndex}].slots[${slotIndex}].id`
-        }))
-      ]),
-      ...(manifest.dieTypes ?? []).flatMap((dieType, typeIndex) => [
-        {
-          value: dieType.id,
-          path: `manifest.dieTypes[${typeIndex}].id`
-        },
-        ...(dieType.slots ?? []).map((slot, slotIndex) => ({
-          value: slot.id,
-          path: `manifest.dieTypes[${typeIndex}].slots[${slotIndex}].id`
-        }))
-      ]),
-      ...expandSeedIds(manifest.pieceSeeds ?? []).map((pieceId, index) => ({
-        value: pieceId,
-        path: `manifest.pieceSeeds[*][${index}]`
-      })),
-      ...expandSeedIds(manifest.dieSeeds ?? []).map((dieId, index) => ({
-        value: dieId,
-        path: `manifest.dieSeeds[*][${index}]`
-      })),
-      ...(manifest.setupOptions ?? []).flatMap((option, optionIndex) => [
-        {
-          value: option.id,
-          path: `manifest.setupOptions[${optionIndex}].id`
-        },
-        ...(option.choices ?? []).map((choice, choiceIndex) => ({
-          value: choice.id,
-          path: `manifest.setupOptions[${optionIndex}].choices[${choiceIndex}].id`
-        }))
-      ]),
-      ...(manifest.setupProfiles ?? []).flatMap((profile, profileIndex) => [
-        {
-          value: profile.id,
-          path: `manifest.setupProfiles[${profileIndex}].id`
-        },
-        ...(profile.guidance?.steps ?? []).map((step, stepIndex) => ({
-          value: step.id,
-          path: `manifest.setupProfiles[${profileIndex}].guidance.steps[${stepIndex}].id`
-        })),
-        ...Object.entries(profile.optionValues ?? {}).flatMap(
-          ([optionId, choiceId]) => [
-            {
-              value: optionId,
-              path: `manifest.setupProfiles[${profileIndex}].optionValues.${optionId}`
-            },
-            {
-              value: choiceId,
-              path: `manifest.setupProfiles[${profileIndex}].optionValues.${optionId}`
-            }
-          ]
-        )
-      ])
-    ]),
-    ...cardSets.flatMap(
-      (cardSet, cardSetIndex) => collectCardSchemaKeyIssues(cardSet, `manifest.cardSets[${cardSetIndex}]`)
-    ),
-    ...(manifest.pieceTypes ?? []).flatMap(
-      (pieceType, typeIndex) => collectObjectSchemaKeyIssues(
-        pieceType.fieldsSchema,
-        `manifest.pieceTypes[${typeIndex}].fieldsSchema`
-      )
-    ),
-    ...(manifest.dieTypes ?? []).flatMap(
-      (dieType, typeIndex) => collectObjectSchemaKeyIssues(
-        dieType.fieldsSchema,
-        `manifest.dieTypes[${typeIndex}].fieldsSchema`
-      )
-    ),
-    ...collectBoardRecordKeyIssues(manifest),
-    ...collectHandleKeyCollisions(
-      dedupeSorted(manualCards.map(({ card }) => card.cardType ?? card.type)),
-      "Card type"
-    ),
-    ...collectHandleKeyCollisions(
-      dedupeSorted((manifest.zones ?? []).map((zone) => zone.id)),
-      "Zone"
-    )
-  ];
-}
-function validateManifestAuthoring(manifest) {
-  const errors = [];
-  errors.push(...collectManifestRecordKeyIssues(manifest));
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: manifest.cardSets.map((cardSet, index) => ({
-        id: cardSet.id,
-        path: `manifest.cardSets[${index}].id`
-      })),
-      label: "card set id"
-    })
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: manifest.cardSets.flatMap(
-        (cardSet, cardSetIndex) => cardSet.type === "manual" ? cardSet.cards.flatMap(
-          (card, cardIndex) => renderCardInstanceIds(card).map((cardId) => ({
-            id: cardId,
-            path: `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].type`
-          }))
-        ) : []
-      ),
-      label: "card runtime id"
-    })
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: (manifest.zones ?? []).map((zone, index) => ({
-        id: zone.id,
-        path: `manifest.zones[${index}].id`
-      })),
-      label: "zone id"
-    })
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: (manifest.boardTemplates ?? []).map((boardTemplate, index) => ({
-        id: boardTemplate.id,
-        path: `manifest.boardTemplates[${index}].id`
-      })),
-      label: "board template id"
-    })
-  );
-  errors.push(
-    ...validateBoardTemplateDuplicates(manifest.boardTemplates ?? [])
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: (manifest.boards ?? []).map((board, index) => ({
-        id: board.id,
-        path: `manifest.boards[${index}].id`
-      })),
-      label: "board id"
-    })
-  );
-  errors.push(...validateBoardDuplicates(manifest.boards ?? []));
-  errors.push(
-    ...validateTypeSlotDuplicates({
-      pieceTypes: manifest.pieceTypes ?? [],
-      dieTypes: manifest.dieTypes ?? []
-    })
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: (manifest.pieceTypes ?? []).map((pieceType, index) => ({
-        id: pieceType.id,
-        path: `manifest.pieceTypes[${index}].id`
-      })),
-      label: "piece type id"
-    })
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: expandSeedIds(manifest.pieceSeeds ?? []).map(
-        (pieceId, index) => ({
-          id: pieceId,
-          path: `manifest.pieceSeeds[*][${index}]`
-        })
-      ),
-      label: "piece runtime id"
-    })
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: (manifest.dieTypes ?? []).map((dieType, index) => ({
-        id: dieType.id,
-        path: `manifest.dieTypes[${index}].id`
-      })),
-      label: "die type id"
-    })
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: expandSeedIds(manifest.dieSeeds ?? []).map((dieId, index) => ({
-        id: dieId,
-        path: `manifest.dieSeeds[*][${index}]`
-      })),
-      label: "die runtime id"
-    })
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: (manifest.resources ?? []).map((resource, index) => ({
-        id: resource.id,
-        path: `manifest.resources[${index}].id`
-      })),
-      label: "resource id"
-    })
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: (manifest.setupOptions ?? []).map((option, index) => ({
-        id: option.id,
-        path: `manifest.setupOptions[${index}].id`
-      })),
-      label: "setup option id"
-    })
-  );
-  errors.push(
-    ...validateSetupOptionChoiceDuplicates(manifest.setupOptions ?? [])
-  );
-  errors.push(
-    ...collectDuplicateIdIssues({
-      entries: (manifest.setupProfiles ?? []).map((profile, index) => ({
-        id: profile.id,
-        path: `manifest.setupProfiles[${index}].id`
-      })),
-      label: "setup profile id"
-    })
-  );
-  for (const [profileIndex, profile] of (manifest.setupProfiles ?? []).entries()) {
-    errors.push(
-      ...collectDuplicateIdIssues({
-        entries: (profile.guidance?.steps ?? []).map((step, stepIndex) => ({
-          id: step.id,
-          path: `manifest.setupProfiles[${profileIndex}].guidance.steps[${stepIndex}].id`
-        })),
-        label: `setup profile '${profile.id}' guidance step id`
-      })
-    );
-  }
-  errors.push(...validateSlotHostsAndHomes(manifest));
-  errors.push(...validatePlayerScopedSeedHomes(manifest));
-  errors.push(...validateCardHomes(manifest));
-  errors.push(...validateSetupProfileReferences(manifest));
-  errors.push(...validateHexBoardVertexRefs(manifest));
-  return {
-    errors,
-    warnings: collectAmbiguousBoardTypeWarnings(manifest)
-  };
-}
-
-// src/reducer/manifest/materialize.ts
-function isCardPropertySchemaVariants(schema) {
-  return Boolean(schema && "variants" in schema);
-}
-function mergeSharedCardProperties(schema, cardType) {
-  const variant = schema.variants[cardType];
-  if (!variant) {
-    return null;
-  }
-  return {
-    properties: {
-      ...schema.shared ?? {},
-      ...variant.properties
-    }
-  };
-}
-function hasPropertySchemaDefault(property) {
-  return Boolean(property && "default" in property);
-}
-function dedupeSorted2(values) {
-  return Array.from(new Set(values)).sort();
-}
-function sortedObject(entries) {
-  return Object.fromEntries(
-    Array.from(entries).sort(([left], [right]) => left.localeCompare(right))
-  );
-}
-function createRecord() {
-  return /* @__PURE__ */ Object.create(null);
-}
-function renderCardInstanceIds2(card) {
-  if (card.count > 1) {
-    return Array.from(
-      { length: card.count },
-      (_, index) => `${card.type}-${index + 1}`
-    );
-  }
-  return [card.type];
-}
-function expandSeedIds2(seeds) {
-  const expanded = [];
-  for (const seed of seeds) {
-    const count = seed.count ?? 1;
-    const baseId = seed.id ?? seed.typeId;
-    if (count <= 1) {
-      expanded.push(baseId);
-      continue;
-    }
-    for (let index = 1; index <= count; index += 1) {
-      expanded.push(`${baseId}-${index}`);
-    }
-  }
-  return expanded;
-}
-function isHexBoardTemplateSpec2(boardTemplate) {
-  return boardTemplate.layout === "hex";
-}
-function isSquareBoardTemplateSpec(boardTemplate) {
-  return boardTemplate.layout === "square";
-}
-function isGenericBoardTemplateSpec(boardTemplate) {
-  return boardTemplate.layout === "generic";
-}
-function isHexBoardSpec2(board) {
-  return board.layout === "hex";
-}
-function isSquareBoardSpec(board) {
-  return board.layout === "square";
-}
-var HEX_SIDES = ["e", "ne", "nw", "w", "sw", "se"];
-var HEX_CORNERS2 = ["ne-e", "e-se", "se-sw", "sw-w", "w-nw", "nw-ne"];
-var HEX_SIDE_OFFSETS = {
-  e: [1, 0],
-  ne: [1, -1],
-  nw: [0, -1],
-  w: [-1, 0],
-  sw: [-1, 1],
-  se: [0, 1]
-};
-var HEX_CORNER_OFFSETS2 = {
-  "ne-e": [2, -1, -1],
-  "e-se": [1, -2, 1],
-  "se-sw": [-1, -1, 2],
-  "sw-w": [-2, 1, 1],
-  "w-nw": [-1, 2, -1],
-  "nw-ne": [1, 1, -2]
-};
-var HEX_SIDE_CORNERS = {
-  e: ["ne-e", "e-se"],
-  ne: ["nw-ne", "ne-e"],
-  nw: ["w-nw", "nw-ne"],
-  w: ["sw-w", "w-nw"],
-  sw: ["se-sw", "sw-w"],
-  se: ["e-se", "se-sw"]
-};
-var HEX_CORNER_SIDES = {
-  "ne-e": ["ne", "e"],
-  "e-se": ["e", "se"],
-  "se-sw": ["se", "sw"],
-  "sw-w": ["sw", "w"],
-  "w-nw": ["w", "nw"],
-  "nw-ne": ["nw", "ne"]
-};
-function cubeFromAxial2(space) {
-  const x = space.q;
-  const z = space.r;
-  return [x, -x - z, z];
-}
-function cornerGeometryKey2(space, corner) {
-  const [x, y, z] = cubeFromAxial2(space);
-  const [dx, dy, dz] = HEX_CORNER_OFFSETS2[corner];
-  return `${3 * x + dx},${3 * y + dy},${3 * z + dz}`;
-}
-function edgeGeometryKey(space, side) {
-  const [leftCorner, rightCorner] = HEX_SIDE_CORNERS[side];
-  return [
-    cornerGeometryKey2(space, leftCorner),
-    cornerGeometryKey2(space, rightCorner)
-  ].sort((left, right) => left.localeCompare(right)).join("::");
-}
-function edgeIdFromGeometryKey(key) {
-  return `hex-edge:${key}`;
-}
-function vertexIdFromGeometryKey(key) {
-  return `hex-vertex:${key}`;
-}
-var SQUARE_SIDES = ["north", "east", "south", "west"];
-var SQUARE_CORNERS = ["nw", "ne", "se", "sw"];
-function squareEdgeIdFromGeometryKey(key) {
-  return `square-edge:${key}`;
-}
-function squareVertexIdFromGeometryKey(key) {
-  return `square-vertex:${key}`;
-}
-function squareCornerGeometryKey(space, corner) {
-  switch (corner) {
-    case "nw":
-      return `${space.col},${space.row}`;
-    case "ne":
-      return `${space.col + 1},${space.row}`;
-    case "se":
-      return `${space.col + 1},${space.row + 1}`;
-    case "sw":
-      return `${space.col},${space.row + 1}`;
-  }
-}
-function squareEdgeGeometryKey(space, side) {
-  const endpoints = side === "north" ? [`${space.col},${space.row}`, `${space.col + 1},${space.row}`] : side === "east" ? [`${space.col + 1},${space.row}`, `${space.col + 1},${space.row + 1}`] : side === "south" ? [
-    `${space.col},${space.row + 1}`,
-    `${space.col + 1},${space.row + 1}`
-  ] : [`${space.col},${space.row}`, `${space.col},${space.row + 1}`];
-  return endpoints.sort((left, right) => left.localeCompare(right)).join("::");
-}
-function geometryKeyFromSquareEdgeRef(ref, spacesById) {
-  const resolvedSpaces = [...ref.spaces].sort((a, b) => a.localeCompare(b)).map((spaceId) => {
-    const space = spacesById.get(spaceId);
-    if (!space) {
-      throw new Error(
-        `Square edge ref references unknown space '${spaceId}'.`
-      );
-    }
-    return space;
-  });
-  const keyCounts = /* @__PURE__ */ new Map();
-  for (const space of resolvedSpaces) {
-    for (const side of SQUARE_SIDES) {
-      const key = squareEdgeGeometryKey(space, side);
-      keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
-    }
-  }
-  const candidates = [...keyCounts.entries()].filter(([, count]) => count === resolvedSpaces.length).map(([key]) => key).sort((left, right) => left.localeCompare(right));
-  if (candidates.length !== 1) {
-    throw new Error(
-      `Square edge ref spaces '${ref.spaces.join(", ")}' do not resolve to exactly one shared edge.`
-    );
-  }
-  const [only] = candidates;
-  if (only === void 0) {
-    throw new Error(
-      "unreachable: candidates.length === 1 but first is undefined"
-    );
-  }
-  return only;
-}
-function geometryKeyFromSquareVertexRef(ref, spacesById) {
-  const resolvedSpaces = [...ref.spaces].sort((a, b) => a.localeCompare(b)).map((spaceId) => {
-    const space = spacesById.get(spaceId);
-    if (!space) {
-      throw new Error(
-        `Square vertex ref references unknown space '${spaceId}'.`
-      );
-    }
-    return space;
-  });
-  const keyCounts = /* @__PURE__ */ new Map();
-  for (const space of resolvedSpaces) {
-    for (const corner of SQUARE_CORNERS) {
-      const key = squareCornerGeometryKey(space, corner);
-      keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
-    }
-  }
-  const candidates = [...keyCounts.entries()].filter(([, count]) => count === resolvedSpaces.length).map(([key]) => key).sort((left, right) => left.localeCompare(right));
-  if (candidates.length !== 1) {
-    throw new Error(
-      `Square vertex ref spaces '${ref.spaces.join(", ")}' do not resolve to exactly one shared vertex.`
-    );
-  }
-  const [only] = candidates;
-  if (only === void 0) {
-    throw new Error(
-      "unreachable: candidates.length === 1 but first is undefined"
-    );
-  }
-  return only;
-}
-function geometryKeyFromEdgeRef(ref, spacesById) {
-  const [leftId, rightId] = [...ref.spaces].sort((a, b) => a.localeCompare(b));
-  if (leftId === void 0 || rightId === void 0) {
-    throw new Error("Hex edge ref must reference exactly two spaces.");
-  }
-  const leftSpace = spacesById.get(leftId);
-  const rightSpace = spacesById.get(rightId);
-  if (!leftSpace || !rightSpace) {
-    throw new Error(
-      `Hex edge ref references unknown spaces: ${ref.spaces.join(", ")}.`
-    );
-  }
-  const [dq, dr] = [rightSpace.q - leftSpace.q, rightSpace.r - leftSpace.r];
-  const side = Object.entries(HEX_SIDE_OFFSETS).find(([, [sideQ, sideR]]) => sideQ === dq && sideR === dr)?.[0];
-  if (!side) {
-    throw new Error(
-      `Hex edge ref spaces '${leftId}' and '${rightId}' are not adjacent.`
-    );
-  }
-  return edgeGeometryKey(leftSpace, side);
-}
-function geometryKeyFromVertexRef(ref, spacesById) {
-  return resolveHexVertexGeometryKey(ref, spacesById);
-}
-function deriveHexEdges(spaces) {
-  const spacesByCoordinate = /* @__PURE__ */ new Map();
-  for (const space of spaces) {
-    spacesByCoordinate.set(`${space.q},${space.r}`, space);
-  }
-  const edgeMap = /* @__PURE__ */ new Map();
-  for (const space of spaces) {
-    for (const side of HEX_SIDES) {
-      const [dq, dr] = HEX_SIDE_OFFSETS[side];
-      const neighbor = spacesByCoordinate.get(
-        `${space.q + dq},${space.r + dr}`
-      );
-      const geometryKey = edgeGeometryKey(space, side);
-      const existing = edgeMap.get(geometryKey);
-      const nextSpaceIds = dedupeSorted2([
-        ...existing?.spaceIds ?? [],
-        space.id,
-        ...neighbor ? [neighbor.id] : []
-      ]);
-      edgeMap.set(geometryKey, {
-        id: edgeIdFromGeometryKey(geometryKey),
-        geometryKey,
-        spaceIds: nextSpaceIds,
-        typeId: existing?.typeId ?? null,
-        label: existing?.label ?? null,
-        fields: existing?.fields ?? null
-      });
-    }
-  }
-  return [...edgeMap.values()].sort(
-    (left, right) => left.id.localeCompare(right.id)
-  );
-}
-function deriveHexVertices(spaces) {
-  const spacesByCoordinate = /* @__PURE__ */ new Map();
-  for (const space of spaces) {
-    spacesByCoordinate.set(`${space.q},${space.r}`, space);
-  }
-  const vertexMap = /* @__PURE__ */ new Map();
-  for (const space of spaces) {
-    for (const corner of HEX_CORNERS2) {
-      const [leftSide, rightSide] = HEX_CORNER_SIDES[corner];
-      const [leftQ, leftR] = HEX_SIDE_OFFSETS[leftSide];
-      const [rightQ, rightR] = HEX_SIDE_OFFSETS[rightSide];
-      const leftNeighbor = spacesByCoordinate.get(
-        `${space.q + leftQ},${space.r + leftR}`
-      );
-      const rightNeighbor = spacesByCoordinate.get(
-        `${space.q + rightQ},${space.r + rightR}`
-      );
-      const geometryKey = cornerGeometryKey2(space, corner);
-      const existing = vertexMap.get(geometryKey);
-      const nextSpaceIds = dedupeSorted2([
-        ...existing?.spaceIds ?? [],
-        space.id,
-        ...leftNeighbor ? [leftNeighbor.id] : [],
-        ...rightNeighbor ? [rightNeighbor.id] : []
-      ]);
-      vertexMap.set(geometryKey, {
-        id: vertexIdFromGeometryKey(geometryKey),
-        geometryKey,
-        spaceIds: nextSpaceIds,
-        typeId: existing?.typeId ?? null,
-        label: existing?.label ?? null,
-        fields: existing?.fields ?? null
-      });
-    }
-  }
-  return [...vertexMap.values()].sort(
-    (left, right) => left.id.localeCompare(right.id)
-  );
-}
-function mergeBoardSpaces(templateSpaces, boardSpaces) {
-  return Array.from(
-    [...templateSpaces, ...boardSpaces].reduce((accumulator, space) => {
-      accumulator.set(space.id, space);
-      return accumulator;
-    }, /* @__PURE__ */ new Map()).values()
-  ).sort((left, right) => left.id.localeCompare(right.id));
-}
-function mergeBoardContainers(templateContainers, boardContainers) {
-  return Array.from(
-    [...templateContainers, ...boardContainers].reduce((accumulator, container) => {
-      accumulator.set(container.id, container);
-      return accumulator;
-    }, /* @__PURE__ */ new Map()).values()
-  ).sort((left, right) => left.id.localeCompare(right.id));
-}
-function resolveHexSpaces2(board, template) {
-  if (!template) {
-    return [...board.spaces ?? []].sort(
-      (left, right) => left.id.localeCompare(right.id)
-    );
-  }
-  const templateSpacesById = new Map(
-    (template.spaces ?? []).map((space) => [space.id, space])
-  );
-  const overridesById = new Map(
-    (board.spaces ?? []).map((space) => [space.id, space])
-  );
-  for (const overrideId of overridesById.keys()) {
-    if (!templateSpacesById.has(overrideId)) {
-      throw new Error(
-        `Hex board '${board.id}' overrides unknown space '${overrideId}' from template '${template.id}'.`
-      );
-    }
-  }
-  return (template.spaces ?? []).map((templateSpace) => {
-    const override = overridesById.get(templateSpace.id);
-    if (!override) {
-      return templateSpace;
-    }
-    const templateMatch = templateSpacesById.get(override.id);
-    if (!templateMatch) {
-      throw new Error(
-        `Hex board '${board.id}' overrides unknown space '${override.id}' from template '${template.id}'.`
-      );
-    }
-    if (templateMatch.q !== override.q || templateMatch.r !== override.r) {
-      throw new Error(
-        `Hex board '${board.id}' cannot change coordinates for space '${override.id}' from template '${template.id}'.`
-      );
-    }
-    return {
-      ...templateSpace,
-      ...override,
-      id: templateSpace.id,
-      q: templateSpace.q,
-      r: templateSpace.r
-    };
-  }).sort((left, right) => left.id.localeCompare(right.id));
-}
-function resolveAuthoredHexEdges(board, template, spaces) {
-  const spacesById = new Map(spaces.map((space) => [space.id, space]));
-  const derivedByGeometryKey = new Map(
-    deriveHexEdges(spaces).map((edge) => [edge.geometryKey, edge])
-  );
-  const collectSpecsByGeometryKey = (specs, ownerLabel) => {
-    const specsByGeometryKey = /* @__PURE__ */ new Map();
-    for (const spec of specs) {
-      const geometryKey = geometryKeyFromEdgeRef(spec.ref, spacesById);
-      if (specsByGeometryKey.has(geometryKey)) {
-        throw new Error(`${ownerLabel} contains duplicate hex edge refs.`);
-      }
-      specsByGeometryKey.set(geometryKey, spec);
-    }
-    return specsByGeometryKey;
-  };
-  const templateSpecsByGeometryKey = template ? collectSpecsByGeometryKey(
-    template.edges ?? [],
-    `Hex board template '${template.id}'`
-  ) : /* @__PURE__ */ new Map();
-  const overrideSpecsByGeometryKey = collectSpecsByGeometryKey(
-    board.edges ?? [],
-    `Hex board '${board.id}'`
-  );
-  if (template) {
-    for (const overrideKey of overrideSpecsByGeometryKey.keys()) {
-      if (!templateSpecsByGeometryKey.has(overrideKey)) {
-        throw new Error(
-          `Hex board '${board.id}' overrides unknown edge ref from template '${template.id}'.`
-        );
-      }
-    }
-  }
-  const mergedSpecs = template ? Array.from(templateSpecsByGeometryKey.entries()).map(
-    ([geometryKey, templateSpec]) => [
-      geometryKey,
-      overrideSpecsByGeometryKey.get(geometryKey) ?? templateSpec
-    ]
-  ) : Array.from(overrideSpecsByGeometryKey.entries());
-  return mergedSpecs.map(([geometryKey, spec]) => {
-    const derivedEdge = derivedByGeometryKey.get(geometryKey);
-    if (!derivedEdge) {
-      throw new Error(
-        `Hex edge ref on board '${board.id}' does not resolve to a derived edge.`
-      );
-    }
-    return {
-      id: derivedEdge.id,
-      ref: cloneJson(spec.ref),
-      typeId: spec.typeId ?? null,
-      label: spec.label ?? null,
-      fields: spec.fields ?? null
-    };
-  });
-}
-function resolveAuthoredHexVertices(board, template, spaces) {
-  const spacesById = new Map(spaces.map((space) => [space.id, space]));
-  const derivedByGeometryKey = new Map(
-    deriveHexVertices(spaces).map(
-      (vertex) => [vertex.geometryKey, vertex]
-    )
-  );
-  const collectSpecsByGeometryKey = (specs, ownerLabel) => {
-    const specsByGeometryKey = /* @__PURE__ */ new Map();
-    for (const spec of specs) {
-      const geometryKey = geometryKeyFromVertexRef(spec.ref, spacesById);
-      if (specsByGeometryKey.has(geometryKey)) {
-        throw new Error(`${ownerLabel} contains duplicate hex vertex refs.`);
-      }
-      specsByGeometryKey.set(geometryKey, spec);
-    }
-    return specsByGeometryKey;
-  };
-  const templateSpecsByGeometryKey = template ? collectSpecsByGeometryKey(
-    template.vertices ?? [],
-    `Hex board template '${template.id}'`
-  ) : /* @__PURE__ */ new Map();
-  const overrideSpecsByGeometryKey = collectSpecsByGeometryKey(
-    board.vertices ?? [],
-    `Hex board '${board.id}'`
-  );
-  if (template) {
-    for (const overrideKey of overrideSpecsByGeometryKey.keys()) {
-      if (!templateSpecsByGeometryKey.has(overrideKey)) {
-        throw new Error(
-          `Hex board '${board.id}' overrides unknown vertex ref from template '${template.id}'.`
-        );
-      }
-    }
-  }
-  const mergedSpecs = template ? Array.from(templateSpecsByGeometryKey.entries()).map(
-    ([geometryKey, templateSpec]) => [
-      geometryKey,
-      overrideSpecsByGeometryKey.get(geometryKey) ?? templateSpec
-    ]
-  ) : Array.from(overrideSpecsByGeometryKey.entries());
-  return mergedSpecs.map(([geometryKey, spec]) => {
-    const derivedVertex = derivedByGeometryKey.get(geometryKey);
-    if (!derivedVertex) {
-      throw new Error(
-        `Hex vertex ref on board '${board.id}' does not resolve to a derived vertex.`
-      );
-    }
-    return {
-      id: derivedVertex.id,
-      ref: cloneJson(spec.ref),
-      typeId: spec.typeId ?? null,
-      label: spec.label ?? null,
-      fields: spec.fields ?? null
-    };
-  });
-}
-function resolveHexEdges(board, template, spaces) {
-  const derived = deriveHexEdges(spaces);
-  const edgesById = new Map(derived.map((edge) => [edge.id, edge]));
-  for (const authoredEdge of resolveAuthoredHexEdges(board, template, spaces)) {
-    const edge = edgesById.get(authoredEdge.id);
-    if (!edge) {
-      throw new Error(
-        `Hex edge ref on board '${board.id}' does not resolve to a derived edge.`
-      );
-    }
-    edgesById.set(authoredEdge.id, {
-      ...edge,
-      typeId: authoredEdge.typeId ?? null,
-      label: authoredEdge.label ?? null,
-      fields: authoredEdge.fields ?? null
-    });
-  }
-  return [...edgesById.values()].sort(
-    (left, right) => left.id.localeCompare(right.id)
-  );
-}
-function resolveHexVertices(board, template, spaces) {
-  const derived = deriveHexVertices(spaces);
-  const verticesById = new Map(
-    derived.map((vertex) => [vertex.id, vertex])
-  );
-  for (const authoredVertex of resolveAuthoredHexVertices(
-    board,
-    template,
-    spaces
-  )) {
-    const vertex = verticesById.get(authoredVertex.id);
-    if (!vertex) {
-      throw new Error(
-        `Hex vertex ref on board '${board.id}' does not resolve to a derived vertex.`
-      );
-    }
-    verticesById.set(authoredVertex.id, {
-      ...vertex,
-      typeId: authoredVertex.typeId ?? null,
-      label: authoredVertex.label ?? null,
-      fields: authoredVertex.fields ?? null
-    });
-  }
-  return [...verticesById.values()].sort(
-    (left, right) => left.id.localeCompare(right.id)
-  );
-}
-function resolveSquareSpaces(board, template) {
-  if (!template) {
-    return [...board.spaces ?? []].sort(
-      (left, right) => left.id.localeCompare(right.id)
-    );
-  }
-  const templateSpacesById = new Map(
-    (template.spaces ?? []).map((space) => [space.id, space])
-  );
-  const overridesById = new Map(
-    (board.spaces ?? []).map((space) => [space.id, space])
-  );
-  for (const overrideId of overridesById.keys()) {
-    if (!templateSpacesById.has(overrideId)) {
-      throw new Error(
-        `Square board '${board.id}' overrides unknown space '${overrideId}' from template '${template.id}'.`
-      );
-    }
-  }
-  return (template.spaces ?? []).map((templateSpace) => {
-    const override = overridesById.get(templateSpace.id);
-    if (!override) {
-      return templateSpace;
-    }
-    const templateMatch = templateSpacesById.get(override.id);
-    if (!templateMatch) {
-      throw new Error(
-        `Square board '${board.id}' overrides unknown space '${override.id}' from template '${template.id}'.`
-      );
-    }
-    if (templateMatch.row !== override.row || templateMatch.col !== override.col) {
-      throw new Error(
-        `Square board '${board.id}' cannot change coordinates for space '${override.id}' from template '${template.id}'.`
-      );
-    }
-    return {
-      ...templateSpace,
-      ...override,
-      id: templateSpace.id,
-      row: templateSpace.row,
-      col: templateSpace.col
-    };
-  }).sort((left, right) => left.id.localeCompare(right.id));
-}
-function deriveSquareEdges(spaces) {
-  const edgeMap = /* @__PURE__ */ new Map();
-  for (const space of spaces) {
-    for (const side of SQUARE_SIDES) {
-      const geometryKey = squareEdgeGeometryKey(space, side);
-      const existing = edgeMap.get(geometryKey);
-      const nextSpaceIds = dedupeSorted2([
-        ...existing?.spaceIds ?? [],
-        space.id
-      ]);
-      edgeMap.set(geometryKey, {
-        id: squareEdgeIdFromGeometryKey(geometryKey),
-        geometryKey,
-        spaceIds: nextSpaceIds,
-        typeId: existing?.typeId ?? null,
-        label: existing?.label ?? null,
-        fields: existing?.fields ?? null
-      });
-    }
-  }
-  return [...edgeMap.values()].sort(
-    (left, right) => left.id.localeCompare(right.id)
-  );
-}
-function deriveSquareVertices(spaces) {
-  const vertexMap = /* @__PURE__ */ new Map();
-  for (const space of spaces) {
-    for (const corner of SQUARE_CORNERS) {
-      const geometryKey = squareCornerGeometryKey(space, corner);
-      const existing = vertexMap.get(geometryKey);
-      const nextSpaceIds = dedupeSorted2([
-        ...existing?.spaceIds ?? [],
-        space.id
-      ]);
-      vertexMap.set(geometryKey, {
-        id: squareVertexIdFromGeometryKey(geometryKey),
-        geometryKey,
-        spaceIds: nextSpaceIds,
-        typeId: existing?.typeId ?? null,
-        label: existing?.label ?? null,
-        fields: existing?.fields ?? null
-      });
-    }
-  }
-  return [...vertexMap.values()].sort(
-    (left, right) => left.id.localeCompare(right.id)
-  );
-}
-function indexSquareEdgeMetadata(specs, spacesById, ownerLabel) {
-  const metadataByKey = /* @__PURE__ */ new Map();
-  for (const spec of specs) {
-    const geometryKey = geometryKeyFromSquareEdgeRef(spec.ref, spacesById);
-    if (metadataByKey.has(geometryKey)) {
-      throw new Error(`${ownerLabel} contains duplicate square edge refs.`);
-    }
-    metadataByKey.set(geometryKey, {
-      geometryKey,
-      typeId: spec.typeId ?? null,
-      label: spec.label ?? null,
-      fields: spec.fields ?? null
-    });
-  }
-  return metadataByKey;
-}
-function indexSquareVertexMetadata(specs, spacesById, ownerLabel) {
-  const metadataByKey = /* @__PURE__ */ new Map();
-  for (const spec of specs) {
-    const geometryKey = geometryKeyFromSquareVertexRef(spec.ref, spacesById);
-    if (metadataByKey.has(geometryKey)) {
-      throw new Error(`${ownerLabel} contains duplicate square vertex refs.`);
-    }
-    metadataByKey.set(geometryKey, {
-      geometryKey,
-      typeId: spec.typeId ?? null,
-      label: spec.label ?? null,
-      fields: spec.fields ?? null
-    });
-  }
-  return metadataByKey;
-}
-function resolveSquareEdges(board, template, spaces) {
-  const spacesById = new Map(spaces.map((space) => [space.id, space]));
-  const derived = deriveSquareEdges(spaces);
-  const edgesByGeometryKey = new Map(
-    derived.map((edge) => [edge.geometryKey, edge])
-  );
-  const templateMetadata = template ? indexSquareEdgeMetadata(
-    template.edges ?? [],
-    spacesById,
-    `Square board template '${template.id}'`
-  ) : /* @__PURE__ */ new Map();
-  const overrideMetadata = indexSquareEdgeMetadata(
-    board.edges ?? [],
-    spacesById,
-    `Square board '${board.id}'`
-  );
-  if (template) {
-    for (const overrideKey of overrideMetadata.keys()) {
-      if (!templateMetadata.has(overrideKey)) {
-        throw new Error(
-          `Square board '${board.id}' overrides unknown edge ref from template '${template.id}'.`
-        );
-      }
-    }
-  }
-  const mergedMetadata = template ? new Map(
-    [...templateMetadata.entries()].map(([key, metadata]) => [
-      key,
-      {
-        ...metadata,
-        ...overrideMetadata.get(key) ?? {},
-        geometryKey: key
-      }
-    ])
-  ) : overrideMetadata;
-  for (const [geometryKey, metadata] of mergedMetadata.entries()) {
-    const edge = edgesByGeometryKey.get(geometryKey);
-    if (!edge) {
-      throw new Error(
-        `Square edge ref on board '${board.id}' does not resolve to a derived edge.`
-      );
-    }
-    edgesByGeometryKey.set(geometryKey, {
-      ...edge,
-      typeId: metadata.typeId ?? null,
-      label: metadata.label ?? null,
-      fields: metadata.fields ?? null
-    });
-  }
-  return [...edgesByGeometryKey.values()].sort(
-    (left, right) => left.id.localeCompare(right.id)
-  );
-}
-function resolveSquareVertices(board, template, spaces) {
-  const spacesById = new Map(spaces.map((space) => [space.id, space]));
-  const derived = deriveSquareVertices(spaces);
-  const verticesByGeometryKey = new Map(
-    derived.map((vertex) => [vertex.geometryKey, vertex])
-  );
-  const templateMetadata = template ? indexSquareVertexMetadata(
-    template.vertices ?? [],
-    spacesById,
-    `Square board template '${template.id}'`
-  ) : /* @__PURE__ */ new Map();
-  const overrideMetadata = indexSquareVertexMetadata(
-    board.vertices ?? [],
-    spacesById,
-    `Square board '${board.id}'`
-  );
-  if (template) {
-    for (const overrideKey of overrideMetadata.keys()) {
-      if (!templateMetadata.has(overrideKey)) {
-        throw new Error(
-          `Square board '${board.id}' overrides unknown vertex ref from template '${template.id}'.`
-        );
-      }
-    }
-  }
-  const mergedMetadata = template ? new Map(
-    [...templateMetadata.entries()].map(([key, metadata]) => [
-      key,
-      {
-        ...metadata,
-        ...overrideMetadata.get(key) ?? {},
-        geometryKey: key
-      }
-    ])
-  ) : overrideMetadata;
-  for (const [geometryKey, metadata] of mergedMetadata.entries()) {
-    const vertex = verticesByGeometryKey.get(geometryKey);
-    if (!vertex) {
-      throw new Error(
-        `Square vertex ref on board '${board.id}' does not resolve to a derived vertex.`
-      );
-    }
-    verticesByGeometryKey.set(geometryKey, {
-      ...vertex,
-      typeId: metadata.typeId ?? null,
-      label: metadata.label ?? null,
-      fields: metadata.fields ?? null
-    });
-  }
-  return [...verticesByGeometryKey.values()].sort(
-    (left, right) => left.id.localeCompare(right.id)
-  );
-}
-function analyzeBoards(manifest, playerIds) {
-  const boardTemplates = manifest.boardTemplates ?? [];
-  const genericTemplateById = new Map(
-    boardTemplates.filter(isGenericBoardTemplateSpec).map((boardTemplate) => [boardTemplate.id, boardTemplate])
-  );
-  const hexTemplateById = new Map(
-    boardTemplates.filter(isHexBoardTemplateSpec2).map((boardTemplate) => [boardTemplate.id, boardTemplate])
-  );
-  const squareTemplateById = new Map(
-    boardTemplates.filter(isSquareBoardTemplateSpec).map((boardTemplate) => [boardTemplate.id, boardTemplate])
-  );
-  return (manifest.boards ?? []).map((board) => {
-    const runtimeBoardIds = board.scope === "perPlayer" ? playerIds.map((playerId) => `${board.id}:${playerId}`) : [board.id];
-    if (isHexBoardSpec2(board)) {
-      const hexBoard = board;
-      const template2 = board.templateId ? hexTemplateById.get(board.templateId) : void 0;
-      const spaces = resolveHexSpaces2(hexBoard, template2);
-      return {
-        layout: "hex",
-        board: hexBoard,
-        template: template2,
-        boardTypeId: hexBoard.typeId ?? template2?.typeId,
-        runtimeBoardIds,
-        boardFieldsSchema: hexBoard.boardFieldsSchema ?? template2?.boardFieldsSchema,
-        spaceFieldsSchema: hexBoard.spaceFieldsSchema ?? template2?.spaceFieldsSchema,
-        edgeFieldsSchema: hexBoard.edgeFieldsSchema ?? template2?.edgeFieldsSchema,
-        vertexFieldsSchema: hexBoard.vertexFieldsSchema ?? template2?.vertexFieldsSchema,
-        spaces,
-        authoredEdges: resolveAuthoredHexEdges(hexBoard, template2, spaces),
-        authoredVertices: resolveAuthoredHexVertices(
-          hexBoard,
-          template2,
-          spaces
-        ),
-        edges: resolveHexEdges(hexBoard, template2, spaces),
-        vertices: resolveHexVertices(hexBoard, template2, spaces)
-      };
-    }
-    if (isSquareBoardSpec(board)) {
-      const squareBoard = board;
-      const template2 = board.templateId ? squareTemplateById.get(board.templateId) : void 0;
-      const spaces = resolveSquareSpaces(squareBoard, template2);
-      return {
-        layout: "square",
-        board: squareBoard,
-        template: template2,
-        boardTypeId: squareBoard.typeId ?? template2?.typeId,
-        runtimeBoardIds,
-        boardFieldsSchema: squareBoard.boardFieldsSchema ?? template2?.boardFieldsSchema,
-        spaceFieldsSchema: squareBoard.spaceFieldsSchema ?? template2?.spaceFieldsSchema,
-        relationFieldsSchema: squareBoard.relationFieldsSchema ?? template2?.relationFieldsSchema,
-        containerFieldsSchema: squareBoard.containerFieldsSchema ?? template2?.containerFieldsSchema,
-        edgeFieldsSchema: squareBoard.edgeFieldsSchema ?? template2?.edgeFieldsSchema,
-        vertexFieldsSchema: squareBoard.vertexFieldsSchema ?? template2?.vertexFieldsSchema,
-        spaces,
-        relations: [
-          ...template2?.relations ?? [],
-          ...squareBoard.relations ?? []
-        ],
-        containers: mergeBoardContainers(
-          template2?.containers ?? [],
-          squareBoard.containers ?? []
-        ),
-        edges: resolveSquareEdges(squareBoard, template2, spaces),
-        vertices: resolveSquareVertices(squareBoard, template2, spaces)
-      };
-    }
-    const genericBoard = board;
-    const template = board.templateId ? genericTemplateById.get(board.templateId) : void 0;
-    return {
-      layout: "generic",
-      board: genericBoard,
-      template,
-      boardTypeId: genericBoard.typeId ?? template?.typeId,
-      runtimeBoardIds,
-      boardFieldsSchema: genericBoard.boardFieldsSchema ?? template?.boardFieldsSchema,
-      spaceFieldsSchema: genericBoard.spaceFieldsSchema ?? template?.spaceFieldsSchema,
-      relationFieldsSchema: genericBoard.relationFieldsSchema ?? template?.relationFieldsSchema,
-      containerFieldsSchema: genericBoard.containerFieldsSchema ?? template?.containerFieldsSchema,
-      spaces: mergeBoardSpaces(
-        template?.spaces ?? [],
-        genericBoard.spaces ?? []
-      ),
-      relations: [
-        ...template?.relations ?? [],
-        ...genericBoard.relations ?? []
-      ],
-      containers: mergeBoardContainers(
-        template?.containers ?? [],
-        genericBoard.containers ?? []
-      )
-    };
-  });
-}
-function isSingletonExplicitSeed(seed) {
-  return typeof seed.id === "string" && seed.id.length > 0 && (seed.count ?? 1) === 1;
-}
-function analyzeManifest(inputManifest, runtimePlayerIds) {
-  const manifest = addStandardDecksIfNeeded(inputManifest);
-  const playerIds = runtimePlayerIds ? [...runtimePlayerIds] : Array.from(
-    { length: manifest.players.maxPlayers },
-    (_, index) => `player-${index + 1}`
-  );
-  const sharedZones = (manifest.zones ?? []).filter(
-    (zone) => zone.scope === "shared"
-  );
-  const playerZones = (manifest.zones ?? []).filter(
-    (zone) => zone.scope === "perPlayer"
-  );
-  const zoneIds = dedupeSorted2((manifest.zones ?? []).map((zone) => zone.id));
-  const cardSets = manifest.cardSets.map(materializeCardSet);
-  const cardSetIds = dedupeSorted2(cardSets.map((cardSet) => cardSet.id));
-  const cardTypes = dedupeSorted2(
-    cardSets.flatMap((cardSet) => cardSet.cards.map((card) => card.type))
-  );
-  const cardIds = dedupeSorted2(
-    cardSets.flatMap((cardSet) => cardSet.cards.flatMap(renderCardInstanceIds2))
-  );
-  const cardSetIdByCardId = /* @__PURE__ */ new Map();
-  const cardTypeByCardId = /* @__PURE__ */ new Map();
-  for (const cardSet of cardSets) {
-    for (const card of cardSet.cards) {
-      for (const cardId of renderCardInstanceIds2(card)) {
-        cardSetIdByCardId.set(cardId, cardSet.id);
-        cardTypeByCardId.set(cardId, card.cardType ?? card.type);
-      }
-    }
-  }
-  const sharedZoneCardSetIds = /* @__PURE__ */ new Map();
-  for (const zone of sharedZones) {
-    sharedZoneCardSetIds.set(
-      zone.id,
-      dedupeSorted2(zone.allowedCardSetIds ?? [])
-    );
-  }
-  const playerZoneCardSetIds = /* @__PURE__ */ new Map();
-  for (const zone of playerZones) {
-    playerZoneCardSetIds.set(
-      zone.id,
-      dedupeSorted2(zone.allowedCardSetIds ?? [])
-    );
-  }
-  const zoneCardSetIdsById = /* @__PURE__ */ new Map();
-  for (const [zoneId, cardSetIds2] of sharedZoneCardSetIds.entries()) {
-    zoneCardSetIdsById.set(zoneId, cardSetIds2);
-  }
-  for (const [zoneId, cardSetIds2] of playerZoneCardSetIds.entries()) {
-    zoneCardSetIdsById.set(zoneId, cardSetIds2);
-  }
-  const sharedZoneIdsByCardSetId = new Map(
-    cardSetIds.map((cardSetId) => [cardSetId, []])
-  );
-  for (const [zoneId, allowedCardSetIds] of sharedZoneCardSetIds.entries()) {
-    for (const cardSetId of allowedCardSetIds) {
-      const zoneIds2 = sharedZoneIdsByCardSetId.get(cardSetId) ?? [];
-      zoneIds2.push(zoneId);
-      sharedZoneIdsByCardSetId.set(cardSetId, zoneIds2);
-    }
-  }
-  for (const [cardSetId, zoneIds2] of sharedZoneIdsByCardSetId.entries()) {
-    sharedZoneIdsByCardSetId.set(cardSetId, dedupeSorted2(zoneIds2));
-  }
-  const sharedZoneIdSet = new Set(sharedZones.map((zone) => zone.id));
-  const homeSharedZoneIdsByCardType = new Map(
-    cardTypes.map((cardType) => [cardType, []])
-  );
-  for (const cardSet of cardSets) {
-    for (const card of cardSet.cards) {
-      if (card.home?.type !== "zone" || !sharedZoneIdSet.has(card.home.zoneId)) {
-        continue;
-      }
-      const zoneIds2 = homeSharedZoneIdsByCardType.get(card.type) ?? [];
-      zoneIds2.push(card.home.zoneId);
-      homeSharedZoneIdsByCardType.set(card.type, zoneIds2);
-    }
-  }
-  const homeSharedZoneIdByCardType = /* @__PURE__ */ new Map();
-  for (const [cardType, zoneIds2] of homeSharedZoneIdsByCardType.entries()) {
-    const uniqueZoneIds = dedupeSorted2(zoneIds2);
-    homeSharedZoneIdsByCardType.set(cardType, uniqueZoneIds);
-    const [homeZoneId] = uniqueZoneIds;
-    if (uniqueZoneIds.length === 1 && homeZoneId !== void 0) {
-      homeSharedZoneIdByCardType.set(cardType, homeZoneId);
-    }
-  }
-  const zoneVisibilityById = new Map(
-    (manifest.zones ?? []).map((zone) => [
-      zone.id,
-      zone.visibility ?? "public"
-    ])
-  );
-  const resourceIds = dedupeSorted2(
-    (manifest.resources ?? []).map((resource) => resource.id)
-  );
-  const resourcePresentationById = sortedObject(
-    (manifest.resources ?? []).map((resource) => [
-      resource.id,
-      {
-        label: resource.name,
-        ...resource.icon ? { icon: resource.icon } : {}
-      }
-    ])
-  );
-  const setupOptionIds = dedupeSorted2(
-    (manifest.setupOptions ?? []).map((option) => option.id)
-  );
-  const setupProfileIds = dedupeSorted2(
-    (manifest.setupProfiles ?? []).map((profile) => profile.id)
-  );
-  const setupChoiceIdsByOptionId = new Map(
-    (manifest.setupOptions ?? []).map((option) => [
-      option.id,
-      dedupeSorted2((option.choices ?? []).map((choice) => choice.id))
-    ])
-  );
-  const setupOptionsById = Object.fromEntries(
-    (manifest.setupOptions ?? []).slice().sort((left, right) => left.id.localeCompare(right.id)).map((option) => [
-      option.id,
-      {
-        id: option.id,
-        name: option.name,
-        description: option.description ?? null,
-        choices: (option.choices ?? []).map((choice) => ({
-          id: choice.id,
-          label: choice.label,
-          description: choice.description ?? null
-        }))
-      }
-    ])
-  );
-  const setupProfilesById = Object.fromEntries(
-    (manifest.setupProfiles ?? []).slice().sort((left, right) => left.id.localeCompare(right.id)).map((profile) => [
-      profile.id,
-      {
-        id: profile.id,
-        name: profile.name,
-        description: profile.description ?? null,
-        optionValues: profile.optionValues ? Object.fromEntries(
-          Object.entries(profile.optionValues).filter(
-            (entry) => typeof entry[1] === "string"
-          )
-        ) : null,
-        guidance: profile.guidance ? {
-          summary: profile.guidance.summary ?? null,
-          steps: (profile.guidance.steps ?? []).map((step) => ({
-            id: step.id,
-            label: step.label,
-            description: step.description ?? null
-          }))
-        } : null
-      }
-    ])
-  );
-  const pieceTypeIds = dedupeSorted2(
-    (manifest.pieceTypes ?? []).map((pieceType) => pieceType.id)
-  );
-  const pieceTypeSchemasById = new Map(
-    (manifest.pieceTypes ?? []).map((pieceType) => [
-      pieceType.id,
-      pieceType.fieldsSchema
-    ])
-  );
-  const pieceTypeSlotIdsById = new Map(
-    (manifest.pieceTypes ?? []).map((pieceType) => [
-      pieceType.id,
-      dedupeSorted2((pieceType.slots ?? []).map((slot) => slot.id))
-    ])
-  );
-  const pieceTypeIdByPieceId = /* @__PURE__ */ new Map();
-  for (const seed of manifest.pieceSeeds ?? []) {
-    for (const pieceId of expandSeedIds2([seed])) {
-      pieceTypeIdByPieceId.set(pieceId, seed.typeId);
-    }
-  }
-  const pieceIds = dedupeSorted2(pieceTypeIdByPieceId.keys());
-  const dieTypeIds = dedupeSorted2(
-    (manifest.dieTypes ?? []).map((dieType) => dieType.id)
-  );
-  const dieTypeSchemasById = new Map(
-    (manifest.dieTypes ?? []).map((dieType) => [
-      dieType.id,
-      dieType.fieldsSchema
-    ])
-  );
-  const dieTypeSlotIdsById = new Map(
-    (manifest.dieTypes ?? []).map((dieType) => [
-      dieType.id,
-      dedupeSorted2((dieType.slots ?? []).map((slot) => slot.id))
-    ])
-  );
-  const dieTypeIdByDieId = /* @__PURE__ */ new Map();
-  for (const seed of manifest.dieSeeds ?? []) {
-    for (const dieId of expandSeedIds2([seed])) {
-      dieTypeIdByDieId.set(dieId, seed.typeId);
-    }
-  }
-  const dieIds = dedupeSorted2(dieTypeIdByDieId.keys());
-  const strictSlotHosts = [
-    ...(manifest.pieceSeeds ?? []).flatMap((seed) => {
-      if (!isSingletonExplicitSeed(seed)) {
-        return [];
-      }
-      const slotIds = pieceTypeSlotIdsById.get(seed.typeId) ?? [];
-      return slotIds.length > 0 ? [
-        {
-          kind: "piece",
-          id: seed.id,
-          slotIds
-        }
-      ] : [];
-    }),
-    ...(manifest.dieSeeds ?? []).flatMap((seed) => {
-      if (!isSingletonExplicitSeed(seed)) {
-        return [];
-      }
-      const slotIds = dieTypeSlotIdsById.get(seed.typeId) ?? [];
-      return slotIds.length > 0 ? [
-        {
-          kind: "die",
-          id: seed.id,
-          slotIds
-        }
-      ] : [];
-    })
-  ].sort(
-    (left, right) => left.kind.localeCompare(right.kind) || left.id.localeCompare(right.id)
-  );
-  const analyzedBoards = analyzeBoards(manifest, playerIds);
-  const boardTemplateIds = dedupeSorted2(
-    (manifest.boardTemplates ?? []).map((boardTemplate) => boardTemplate.id)
-  );
-  const boardBaseIds = dedupeSorted2(
-    analyzedBoards.map(({ board }) => board.id)
-  );
-  const boardIds = dedupeSorted2(
-    analyzedBoards.flatMap((entry) => entry.runtimeBoardIds)
-  );
-  const boardTypeIds = dedupeSorted2(
-    analyzedBoards.map((board) => board.boardTypeId).filter((typeId) => typeof typeId === "string")
-  );
-  const boardLayoutById = /* @__PURE__ */ new Map();
-  const boardIdsByLayout = /* @__PURE__ */ new Map();
-  const boardBaseIdsByLayout = /* @__PURE__ */ new Map();
-  const boardIdsByBaseId = /* @__PURE__ */ new Map();
-  const boardBaseIdsByTemplateId = /* @__PURE__ */ new Map();
-  const boardTemplateLayoutById = /* @__PURE__ */ new Map();
-  const boardIdsByTypeId = /* @__PURE__ */ new Map();
-  const spaceIdsByBoardId = /* @__PURE__ */ new Map();
-  const spaceTypeIdByBoardId = /* @__PURE__ */ new Map();
-  const spaceIdsByTypeId = /* @__PURE__ */ new Map();
-  const containerIdsByBoardId = /* @__PURE__ */ new Map();
-  const containerHostByBoardId = /* @__PURE__ */ new Map();
-  const relationTypeIdsByBoardId = /* @__PURE__ */ new Map();
-  const edgeIdsByTypeId = /* @__PURE__ */ new Map();
-  const edgeIdsByBoardIdAndTypeId = /* @__PURE__ */ new Map();
-  const vertexIdsByTypeId = /* @__PURE__ */ new Map();
-  const vertexIdsByBoardIdAndTypeId = /* @__PURE__ */ new Map();
-  for (const boardTemplate of manifest.boardTemplates ?? []) {
-    boardTemplateLayoutById.set(boardTemplate.id, boardTemplate.layout);
-    boardBaseIdsByLayout.set(
-      boardTemplate.layout,
-      dedupeSorted2([...boardBaseIdsByLayout.get(boardTemplate.layout) ?? []])
-    );
-  }
-  for (const analyzedBoard of analyzedBoards) {
-    boardIdsByBaseId.set(analyzedBoard.board.id, analyzedBoard.runtimeBoardIds);
-    boardIdsByLayout.set(
-      analyzedBoard.board.layout,
-      dedupeSorted2([
-        ...boardIdsByLayout.get(analyzedBoard.board.layout) ?? [],
-        ...analyzedBoard.runtimeBoardIds
-      ])
-    );
-    boardBaseIdsByLayout.set(
-      analyzedBoard.board.layout,
-      dedupeSorted2([
-        ...boardBaseIdsByLayout.get(analyzedBoard.board.layout) ?? [],
-        analyzedBoard.board.id
-      ])
-    );
-    if (analyzedBoard.board.templateId) {
-      boardBaseIdsByTemplateId.set(
-        analyzedBoard.board.templateId,
-        dedupeSorted2([
-          ...boardBaseIdsByTemplateId.get(analyzedBoard.board.templateId) ?? [],
-          analyzedBoard.board.id
-        ])
-      );
-    }
-    const runtimeSpaceIds = analyzedBoard.spaces.map((space) => space.id);
-    const runtimeSpaceTypeIds = sortedObject(
-      analyzedBoard.spaces.map(
-        (space) => [space.id, space.typeId ?? null]
-      )
-    );
-    const runtimeContainerIds = analyzedBoard.layout === "hex" ? [] : analyzedBoard.containers.map((container) => container.id);
-    const runtimeContainerHosts = analyzedBoard.layout === "hex" ? {} : sortedObject(
-      analyzedBoard.containers.map((container) => [
-        container.id,
-        container.host.type === "space" ? { type: "space", spaceId: container.host.spaceId } : { type: "board" }
-      ])
-    );
-    const runtimeRelationTypeIds = analyzedBoard.layout === "hex" ? ["adjacent"] : analyzedBoard.layout === "square" ? dedupeSorted2([
-      "adjacent",
-      ...analyzedBoard.relations.map((relation) => relation.typeId)
-    ]) : dedupeSorted2(
-      analyzedBoard.relations.map((relation) => relation.typeId)
-    );
-    for (const runtimeBoardId of analyzedBoard.runtimeBoardIds) {
-      boardLayoutById.set(runtimeBoardId, analyzedBoard.board.layout);
-      spaceIdsByBoardId.set(runtimeBoardId, runtimeSpaceIds);
-      spaceTypeIdByBoardId.set(runtimeBoardId, runtimeSpaceTypeIds);
-      containerIdsByBoardId.set(runtimeBoardId, runtimeContainerIds);
-      containerHostByBoardId.set(runtimeBoardId, runtimeContainerHosts);
-      relationTypeIdsByBoardId.set(runtimeBoardId, runtimeRelationTypeIds);
-    }
-    if (analyzedBoard.boardTypeId) {
-      boardIdsByTypeId.set(
-        analyzedBoard.boardTypeId,
-        dedupeSorted2([
-          ...boardIdsByTypeId.get(analyzedBoard.boardTypeId) ?? [],
-          ...analyzedBoard.runtimeBoardIds
-        ])
-      );
-    }
-    for (const space of analyzedBoard.spaces) {
-      if (!space.typeId) {
-        continue;
-      }
-      spaceIdsByTypeId.set(
-        space.typeId,
-        dedupeSorted2([...spaceIdsByTypeId.get(space.typeId) ?? [], space.id])
-      );
-    }
-    if (analyzedBoard.layout !== "generic") {
-      const edgeIdsForBoardByType = {};
-      for (const edge of analyzedBoard.edges) {
-        if (!edge.typeId) {
-          continue;
-        }
-        edgeIdsByTypeId.set(
-          edge.typeId,
-          dedupeSorted2([...edgeIdsByTypeId.get(edge.typeId) ?? [], edge.id])
-        );
-        edgeIdsForBoardByType[edge.typeId] = dedupeSorted2([
-          ...edgeIdsForBoardByType[edge.typeId] ?? [],
-          edge.id
-        ]);
-      }
-      const vertexIdsForBoardByType = {};
-      for (const vertex of analyzedBoard.vertices) {
-        if (!vertex.typeId) {
-          continue;
-        }
-        vertexIdsByTypeId.set(
-          vertex.typeId,
-          dedupeSorted2([
-            ...vertexIdsByTypeId.get(vertex.typeId) ?? [],
-            vertex.id
-          ])
-        );
-        vertexIdsForBoardByType[vertex.typeId] = dedupeSorted2([
-          ...vertexIdsForBoardByType[vertex.typeId] ?? [],
-          vertex.id
-        ]);
-      }
-      for (const runtimeBoardId of analyzedBoard.runtimeBoardIds) {
-        edgeIdsByBoardIdAndTypeId.set(runtimeBoardId, edgeIdsForBoardByType);
-        vertexIdsByBoardIdAndTypeId.set(
-          runtimeBoardId,
-          vertexIdsForBoardByType
-        );
-      }
-    }
-  }
-  const relationTypeIds = dedupeSorted2(
-    Array.from(relationTypeIdsByBoardId.values()).flat()
-  );
-  const edgeIds = dedupeSorted2(
-    analyzedBoards.flatMap(
-      (board) => board.layout === "generic" ? [] : board.edges.map((edge) => edge.id)
-    )
-  );
-  const edgeTypeIds = dedupeSorted2(edgeIdsByTypeId.keys());
-  const vertexIds = dedupeSorted2(
-    analyzedBoards.flatMap(
-      (board) => board.layout === "generic" ? [] : board.vertices.map((vertex) => vertex.id)
-    )
-  );
-  const vertexTypeIds = dedupeSorted2(vertexIdsByTypeId.keys());
-  const boardContainerIds = dedupeSorted2(
-    analyzedBoards.flatMap(
-      (board) => board.layout === "hex" ? [] : board.containers.map((container) => container.id)
-    )
-  );
-  const spaceIds = dedupeSorted2(
-    analyzedBoards.flatMap((board) => board.spaces.map((space) => space.id))
-  );
-  const spaceTypeIds = dedupeSorted2(
-    analyzedBoards.flatMap(
-      (board) => board.spaces.map((space) => space.typeId).filter((typeId) => typeof typeId === "string")
-    )
-  );
-  return {
-    manifest,
-    playerIds,
-    sharedZones,
-    playerZones,
-    zoneIds,
-    cardSets,
-    cardSetIds,
-    cardTypes,
-    cardIds,
-    cardSetIdByCardId,
-    cardTypeByCardId,
-    sharedZoneCardSetIds,
-    sharedZoneIdsByCardSetId,
-    homeSharedZoneIdsByCardType,
-    homeSharedZoneIdByCardType,
-    playerZoneCardSetIds,
-    zoneCardSetIdsById,
-    zoneVisibilityById,
-    resourceIds,
-    resourcePresentationById,
-    setupOptionIds,
-    setupProfileIds,
-    setupChoiceIdsByOptionId,
-    setupOptionsById,
-    setupProfilesById,
-    pieceTypeIds,
-    pieceIds,
-    pieceTypeIdByPieceId,
-    dieTypeIds,
-    dieIds,
-    dieTypeIdByDieId,
-    strictSlotHosts,
-    boardTemplateIds,
-    boardBaseIds,
-    boardIds,
-    boardContainerIds,
-    boardTypeIds,
-    boardLayoutById,
-    boardIdsByLayout,
-    boardBaseIdsByLayout,
-    boardIdsByBaseId,
-    boardBaseIdsByTemplateId,
-    boardTemplateLayoutById,
-    boardIdsByTypeId,
-    spaceIdsByBoardId,
-    spaceTypeIdByBoardId,
-    spaceIdsByTypeId,
-    containerIdsByBoardId,
-    containerHostByBoardId,
-    relationTypeIds,
-    relationTypeIdsByBoardId,
-    edgeIds,
-    edgeTypeIds,
-    edgeIdsByTypeId,
-    edgeIdsByBoardIdAndTypeId,
-    vertexIds,
-    vertexTypeIds,
-    vertexIdsByTypeId,
-    vertexIdsByBoardIdAndTypeId,
-    spaceIds,
-    spaceTypeIds,
-    analyzedBoards,
-    pieceTypeSchemasById,
-    dieTypeSchemasById
-  };
-}
-function cloneJson(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-function boardSpaceRefKey(spaceIds) {
-  return [...spaceIds].sort((left, right) => left.localeCompare(right)).join("$$");
-}
-function materializePropertySchemaDefault(property, analysis, runtimeBoardId) {
-  if (hasPropertySchemaDefault(property)) {
-    return cloneJson(property.default);
-  }
-  if (property.optional) {
-    return void 0;
-  }
-  if (property.nullable) {
-    return null;
-  }
-  switch (property.type) {
-    case "string":
-      return "";
-    case "integer":
-    case "number":
-      return 0;
-    case "boolean":
-      return false;
-    case "enum":
-      return property.enums?.[0] ?? "";
-    case "array":
-      return [];
-    case "object":
-      return materializeObjectSchemaDefaults(
-        property.properties ? { properties: property.properties } : void 0,
-        analysis,
-        runtimeBoardId
-      );
-    case "record":
-      return {};
-    case "zoneId":
-      return analysis.zoneIds[0] ?? "";
-    case "cardId":
-      return analysis.cardIds[0] ?? "";
-    case "playerId":
-      return analysis.playerIds[0] ?? "";
-    case "boardId":
-      return runtimeBoardId ?? analysis.boardIds[0] ?? "";
-    case "edgeId":
-      return analysis.edgeIds[0] ?? "";
-    case "vertexId":
-      return analysis.vertexIds[0] ?? "";
-    case "spaceId":
-      return (runtimeBoardId ? analysis.spaceIdsByBoardId.get(runtimeBoardId)?.[0] : void 0) ?? analysis.spaceIds[0] ?? "";
-    case "pieceId":
-      return analysis.pieceIds[0] ?? "";
-    case "dieId":
-      return analysis.dieIds[0] ?? "";
-    case "resourceId":
-      return analysis.resourceIds[0] ?? "";
-  }
-}
-function materializeObjectSchemaDefaults(schema, analysis, runtimeBoardId) {
-  if (!schema?.properties) {
-    return {};
-  }
-  return Object.fromEntries(
-    Object.entries(schema.properties).flatMap(([key, property]) => {
-      const value = materializePropertySchemaDefault(
-        property,
-        analysis,
-        runtimeBoardId
-      );
-      return value === void 0 ? [] : [[key, value]];
-    })
-  );
-}
-function materializeCardPropertiesDefaults(schema, cardType, analysis) {
-  const objectSchema = isCardPropertySchemaVariants(schema) ? mergeSharedCardProperties(schema, cardType) : schema;
-  return materializeObjectSchemaDefaults(objectSchema, analysis);
-}
-function materializeManifestTable(options) {
-  const validation = validateManifestAuthoring(options.manifest);
-  if (validation.errors.length > 0) {
-    throw new Error(
-      `Cannot materialize invalid topology manifest:
-${validation.errors.join("\n")}`
-    );
-  }
-  const analysis = analyzeManifest(options.manifest, options.playerIds);
-  const manifest = analysis.manifest;
-  const playerIds = [...options.playerIds];
-  const cards = createRecord();
-  const pieces = createRecord();
-  const dice = createRecord();
-  const componentLocations = createRecord();
-  const locationOrder = /* @__PURE__ */ new Map();
-  const boardAnalysisByBaseId = new Map(
-    analysis.analyzedBoards.map((board) => [board.board.id, board])
-  );
-  const edgeIdByBoardBaseIdAndSpaces = /* @__PURE__ */ new Map();
-  const vertexIdByBoardBaseIdAndSpaces = /* @__PURE__ */ new Map();
-  for (const analyzedBoard of analysis.analyzedBoards) {
-    if (analyzedBoard.layout === "generic") {
-      continue;
-    }
-    edgeIdByBoardBaseIdAndSpaces.set(
-      analyzedBoard.board.id,
-      new Map(
-        analyzedBoard.edges.map((edge) => [
-          boardSpaceRefKey(edge.spaceIds),
-          edge.id
-        ])
-      )
-    );
-    vertexIdByBoardBaseIdAndSpaces.set(
-      analyzedBoard.board.id,
-      new Map(
-        analyzedBoard.vertices.map((vertex) => [
-          boardSpaceRefKey(vertex.spaceIds),
-          vertex.id
-        ])
-      )
-    );
-  }
-  const nextLocationPosition = (location) => {
-    const key = JSON.stringify(location);
-    const position = locationOrder.get(key) ?? 0;
-    locationOrder.set(key, position + 1);
-    return position;
-  };
-  const zoneScopeById = new Map([
-    ...analysis.sharedZones.map((zone) => [zone.id, "shared"]),
-    ...analysis.playerZones.map((zone) => [zone.id, "perPlayer"])
-  ]);
-  const resolveRuntimeBoardId = (boardBaseId, ownerId, context) => {
-    const analyzedBoard = boardAnalysisByBaseId.get(boardBaseId);
-    if (!analyzedBoard) {
-      throw new Error(
-        `${context ?? "Component home"}.boardId: Unknown board '${boardBaseId}'.`
-      );
-    }
-    if (analyzedBoard?.board.scope === "perPlayer") {
-      if (!ownerId) {
-        throw new Error(
-          `${context ?? `Home on board '${boardBaseId}'`} requires ownerId because board '${boardBaseId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
-        );
-      }
-      return `${boardBaseId}:${ownerId}`;
-    }
-    return boardBaseId;
-  };
-  const resolveBoardEdgeId = (boardBaseId, spaceIds) => {
-    const edgeId = edgeIdByBoardBaseIdAndSpaces.get(boardBaseId)?.get(boardSpaceRefKey(spaceIds));
-    if (!edgeId) {
-      throw new Error(
-        `Unknown edge on board '${boardBaseId}' for spaces [${spaceIds.join(", ")}].`
-      );
-    }
-    return edgeId;
-  };
-  const resolveBoardVertexId = (boardBaseId, spaceIds) => {
-    const vertexId = vertexIdByBoardBaseIdAndSpaces.get(boardBaseId)?.get(boardSpaceRefKey(spaceIds));
-    if (!vertexId) {
-      throw new Error(
-        `Unknown vertex on board '${boardBaseId}' for spaces [${spaceIds.join(", ")}].`
-      );
-    }
-    return vertexId;
-  };
-  const materializeComponentLocation = (home, context) => {
-    if (home.type === "detached") {
-      return { type: "Detached" };
-    }
-    if (home.type === "slot") {
-      return {
-        type: "InSlot",
-        host: home.host,
-        slotId: home.slotId,
-        position: nextLocationPosition({
-          type: "InSlot",
-          host: home.host,
-          slotId: home.slotId
-        })
-      };
-    }
-    if (home.type === "zone") {
-      const zoneScope = zoneScopeById.get(home.zoneId);
-      if (!zoneScope) {
-        throw new Error(
-          `${context.path}.zoneId: ${context.label} targets unknown zone '${home.zoneId}'.`
-        );
-      }
-      if (zoneScope === "perPlayer") {
-        throw new Error(
-          `${context.path}.zoneId: ${context.label} cannot target per-player zone '${home.zoneId}' because card inventory has no ownerId. Place it during reducer setup instead.`
-        );
-      }
-      return {
-        type: "InDeck",
-        deckId: home.zoneId,
-        playedBy: null,
-        position: nextLocationPosition({
-          type: "InDeck",
-          deckId: home.zoneId,
-          playedBy: null
-        })
-      };
-    }
-    if (home.type === "space") {
-      const boardId = resolveRuntimeBoardId(
-        home.boardId,
-        null,
-        `${context.path}.boardId: ${context.label}`
-      );
-      if (!analysis.spaceIdsByBoardId.get(home.boardId)?.includes(home.spaceId)) {
-        throw new Error(
-          `${context.path}.spaceId: ${context.label} targets unknown space '${home.spaceId}' on board '${home.boardId}'.`
-        );
-      }
-      return {
-        type: "OnSpace",
-        boardId,
-        spaceId: home.spaceId,
-        position: nextLocationPosition({
-          type: "OnSpace",
-          boardId,
-          spaceId: home.spaceId
-        })
-      };
-    }
-    if (home.type === "container") {
-      const boardId = resolveRuntimeBoardId(
-        home.boardId,
-        null,
-        `${context.path}.boardId: ${context.label}`
-      );
-      if (!analysis.containerIdsByBoardId.get(home.boardId)?.includes(home.containerId)) {
-        throw new Error(
-          `${context.path}.containerId: ${context.label} targets unknown container '${home.containerId}' on board '${home.boardId}'.`
-        );
-      }
-      return {
-        type: "InContainer",
-        boardId,
-        containerId: home.containerId,
-        position: nextLocationPosition({
-          type: "InContainer",
-          boardId,
-          containerId: home.containerId
-        })
-      };
-    }
-    if (home.type === "edge") {
-      const boardId = resolveRuntimeBoardId(
-        home.boardId,
-        null,
-        `${context.path}.boardId: ${context.label}`
-      );
-      const edgeId = resolveBoardEdgeId(home.boardId, home.ref.spaces);
-      return {
-        type: "OnEdge",
-        boardId,
-        edgeId,
-        position: nextLocationPosition({
-          type: "OnEdge",
-          boardId,
-          edgeId
-        })
-      };
-    }
-    if (home.type === "vertex") {
-      const boardId = resolveRuntimeBoardId(
-        home.boardId,
-        null,
-        `${context.path}.boardId: ${context.label}`
-      );
-      const vertexId = resolveBoardVertexId(home.boardId, home.ref.spaces);
-      return {
-        type: "OnVertex",
-        boardId,
-        vertexId,
-        position: nextLocationPosition({
-          type: "OnVertex",
-          boardId,
-          vertexId
-        })
-      };
-    }
-    const exhaustive = home;
-    throw new Error(
-      `Unsupported component home: ${JSON.stringify(exhaustive)}`
-    );
-  };
-  for (const [cardSetIndex, cardSet] of manifest.cardSets.entries()) {
-    const materializedCardSet = materializeCardSet(cardSet);
-    for (const [cardIndex, card] of materializedCardSet.cards.entries()) {
-      const cardInstanceIds = renderCardInstanceIds2(card);
-      for (const [instanceIndex, cardId] of cardInstanceIds.entries()) {
-        cards[cardId] = {
-          id: cardId,
-          cardSetId: materializedCardSet.id,
-          cardType: card.type,
-          name: card.name,
-          text: card.text,
-          properties: {
-            ...materializeCardPropertiesDefaults(
-              materializedCardSet.cardSchema,
-              card.type,
-              analysis
-            ),
-            ...card.properties ?? {}
-          }
-        };
-        const resolvedHome = card.home ?? materializedCardSet.defaultHome;
-        const path = card.home === void 0 ? `manifest.cardSets[${cardSetIndex}].defaultHome` : `manifest.cardSets[${cardSetIndex}].cards[${cardIndex}].home`;
-        componentLocations[cardId] = materializeComponentLocation(
-          resolvedHome,
-          {
-            path,
-            label: `Card '${card.type}' instance ${instanceIndex + 1}`
-          }
-        );
-      }
-    }
-  }
-  if (Object.keys(cards).length !== analysis.cardIds.length) {
-    throw new Error(
-      "Materialized card record cardinality drifted from analysis."
-    );
-  }
-  if (Object.keys(componentLocations).length !== analysis.cardIds.length) {
-    throw new Error(
-      "Materialized card locations drifted from analysis before seed placement."
-    );
-  }
-  const pieceTypesById = new Map(
-    (manifest.pieceTypes ?? []).map((pieceType) => [pieceType.id, pieceType])
-  );
-  const dieTypesById = new Map(
-    (manifest.dieTypes ?? []).map((dieType) => [dieType.id, dieType])
-  );
-  const assignSeedLocation = (componentId, ownerId, home, context) => {
-    if (!home) {
-      componentLocations[componentId] = { type: "Detached" };
-      return;
-    }
-    if (home.type === "slot") {
-      componentLocations[componentId] = {
-        type: "InSlot",
-        host: home.host,
-        slotId: home.slotId,
-        position: nextLocationPosition({
-          type: "InSlot",
-          host: home.host,
-          slotId: home.slotId
-        })
-      };
-      return;
-    }
-    if (home.type === "zone") {
-      if (zoneScopeById.get(home.zoneId) === "perPlayer") {
-        if (!ownerId) {
-          throw new Error(
-            `${context.path}.zoneId: ${context.label} requires ownerId because zone '${home.zoneId}' has scope 'perPlayer'. Add ownerId to resolve the player-scoped destination.`
-          );
-        }
-        componentLocations[componentId] = {
-          type: "InHand",
-          handId: home.zoneId,
-          playerId: ownerId,
-          position: nextLocationPosition({
-            type: "InHand",
-            handId: home.zoneId,
-            playerId: ownerId
-          })
-        };
-        return;
-      }
-      componentLocations[componentId] = {
-        type: "InZone",
-        zoneId: home.zoneId,
-        playedBy: null,
-        position: nextLocationPosition({
-          type: "InZone",
-          zoneId: home.zoneId
-        })
-      };
-      return;
-    }
-    if (home.type === "space") {
-      const boardId = resolveRuntimeBoardId(
-        home.boardId,
-        ownerId,
-        `${context.path}.boardId: ${context.label}`
-      );
-      componentLocations[componentId] = {
-        type: "OnSpace",
-        boardId,
-        spaceId: home.spaceId,
-        position: nextLocationPosition({
-          type: "OnSpace",
-          boardId,
-          spaceId: home.spaceId
-        })
-      };
-      return;
-    }
-    if (home.type === "container") {
-      const boardId = resolveRuntimeBoardId(
-        home.boardId,
-        ownerId,
-        `${context.path}.boardId: ${context.label}`
-      );
-      componentLocations[componentId] = {
-        type: "InContainer",
-        boardId,
-        containerId: home.containerId,
-        position: nextLocationPosition({
-          type: "InContainer",
-          boardId,
-          containerId: home.containerId
-        })
-      };
-      return;
-    }
-    if (home.type === "edge") {
-      const boardId = resolveRuntimeBoardId(
-        home.boardId,
-        ownerId,
-        `${context.path}.boardId: ${context.label}`
-      );
-      const edgeId = resolveBoardEdgeId(home.boardId, home.ref.spaces);
-      componentLocations[componentId] = {
-        type: "OnEdge",
-        boardId,
-        edgeId,
-        position: nextLocationPosition({
-          type: "OnEdge",
-          boardId,
-          edgeId
-        })
-      };
-      return;
-    }
-    if (home.type === "vertex") {
-      const boardId = resolveRuntimeBoardId(
-        home.boardId,
-        ownerId,
-        `${context.path}.boardId: ${context.label}`
-      );
-      const vertexId = resolveBoardVertexId(home.boardId, home.ref.spaces);
-      componentLocations[componentId] = {
-        type: "OnVertex",
-        boardId,
-        vertexId,
-        position: nextLocationPosition({
-          type: "OnVertex",
-          boardId,
-          vertexId
-        })
-      };
-      return;
-    }
-    componentLocations[componentId] = { type: "Detached" };
-  };
-  for (const [seedIndex, seed] of (manifest.pieceSeeds ?? []).entries()) {
-    const pieceType = pieceTypesById.get(seed.typeId);
-    for (const componentId of expandSeedIds2([seed])) {
-      pieces[componentId] = {
-        componentType: "piece",
-        id: componentId,
-        pieceTypeId: seed.typeId,
-        pieceName: pieceType?.name ?? seed.typeId,
-        ownerId: seed.ownerId ?? null,
-        properties: {
-          ...materializeObjectSchemaDefaults(
-            analysis.pieceTypeSchemasById.get(seed.typeId),
-            analysis
-          ),
-          ...seed.fields ?? {}
-        }
-      };
-      assignSeedLocation(componentId, seed.ownerId, seed.home, {
-        path: `manifest.pieceSeeds[${seedIndex}].home`,
-        label: `Piece seed '${seed.id ?? seed.typeId}'`
-      });
-    }
-  }
-  for (const [seedIndex, seed] of (manifest.dieSeeds ?? []).entries()) {
-    const dieType = dieTypesById.get(seed.typeId);
-    for (const componentId of expandSeedIds2([seed])) {
-      dice[componentId] = {
-        componentType: "die",
-        id: componentId,
-        dieTypeId: seed.typeId,
-        dieName: dieType?.name ?? seed.typeId,
-        ownerId: seed.ownerId ?? null,
-        sides: dieType?.sides ?? 6,
-        value: null,
-        properties: {
-          ...materializeObjectSchemaDefaults(
-            analysis.dieTypeSchemasById.get(seed.typeId),
-            analysis
-          ),
-          ...seed.fields ?? {}
-        }
-      };
-      assignSeedLocation(componentId, seed.ownerId, seed.home, {
-        path: `manifest.dieSeeds[${seedIndex}].home`,
-        label: `Die seed '${seed.id ?? seed.typeId}'`
-      });
-    }
-  }
-  const boardStatesById = createRecord();
-  const hexBoardStatesById = createRecord();
-  const squareBoardStatesById = createRecord();
-  for (const analyzedBoard of analysis.analyzedBoards) {
-    const sharedBoardState = {
-      baseId: analyzedBoard.board.id,
-      layout: analyzedBoard.layout,
-      typeId: analyzedBoard.boardTypeId ?? null,
-      scope: analyzedBoard.board.scope,
-      templateId: analyzedBoard.board.templateId ?? null,
-      fields: {
-        ...materializeObjectSchemaDefaults(
-          analyzedBoard.boardFieldsSchema,
-          analysis
-        ),
-        ...analyzedBoard.board.fields ?? {}
-      }
-    };
-    const buildSpaces = () => Object.fromEntries(
-      analyzedBoard.spaces.map((space) => {
-        const spaceId = space.id;
-        const baseSpaceState = {
-          id: spaceId,
-          name: "name" in space ? space.name ?? null : null,
-          typeId: space?.typeId ?? null,
-          fields: {
-            ...materializeObjectSchemaDefaults(
-              analyzedBoard.spaceFieldsSchema,
-              analysis
-            ),
-            ...space.fields ?? {}
-          },
-          zoneId: "zoneId" in space ? space.zoneId ?? null : null
-        };
-        if (analyzedBoard.layout === "hex") {
-          const hexSpace = space;
-          return [
-            spaceId,
-            {
-              ...baseSpaceState,
-              q: hexSpace.q,
-              r: hexSpace.r
-            }
-          ];
-        }
-        if (analyzedBoard.layout === "square") {
-          const squareSpace = space;
-          return [
-            spaceId,
-            {
-              ...baseSpaceState,
-              row: squareSpace.row,
-              col: squareSpace.col
-            }
-          ];
-        }
-        return [spaceId, baseSpaceState];
-      })
-    );
-    const relations = analyzedBoard.layout === "hex" ? [] : analyzedBoard.relations.map((relation) => ({
-      id: relation.id ?? null,
-      typeId: relation.typeId,
-      fromSpaceId: relation.fromSpaceId,
-      toSpaceId: relation.toSpaceId,
-      directed: relation.directed ?? false,
-      fields: {
-        ...materializeObjectSchemaDefaults(
-          analyzedBoard.relationFieldsSchema,
-          analysis
-        ),
-        ...relation.fields ?? {}
-      }
-    }));
-    const buildContainers = (runtimeBoardId) => analyzedBoard.layout === "hex" ? {} : Object.fromEntries(
-      analyzedBoard.containers.map((container) => {
-        const containerId = container.id;
-        return [
-          containerId,
-          {
-            id: containerId,
-            name: container.name ?? containerId,
-            host: container.host.type === "space" ? { type: "space", spaceId: container.host.spaceId } : { type: "board" },
-            allowedCardSetIds: container.allowedCardSetIds,
-            zoneId: `board:${runtimeBoardId}:container:${containerId}`,
-            fields: {
-              ...materializeObjectSchemaDefaults(
-                analyzedBoard.containerFieldsSchema,
-                analysis,
-                runtimeBoardId
-              ),
-              ...container.fields ?? {}
-            }
-          }
-        ];
-      })
-    );
-    const edges = analyzedBoard.layout === "generic" ? [] : analyzedBoard.edges.map((edge) => ({
-      id: edge.id,
-      spaceIds: [...edge.spaceIds],
-      typeId: edge.typeId ?? null,
-      label: edge.label ?? null,
-      ownerId: null,
-      fields: {
-        ...materializeObjectSchemaDefaults(
-          analyzedBoard.edgeFieldsSchema,
-          analysis
-        ),
-        ...edge.fields ?? {}
-      }
-    }));
-    const vertices = analyzedBoard.layout === "generic" ? [] : analyzedBoard.vertices.map((vertex) => ({
-      id: vertex.id,
-      spaceIds: [...vertex.spaceIds],
-      typeId: vertex.typeId ?? null,
-      label: vertex.label ?? null,
-      ownerId: null,
-      fields: {
-        ...materializeObjectSchemaDefaults(
-          analyzedBoard.vertexFieldsSchema,
-          analysis
-        ),
-        ...vertex.fields ?? {}
-      }
-    }));
-    for (const runtimeBoardId of analyzedBoard.runtimeBoardIds) {
-      const playerId = analyzedBoard.board.scope === "perPlayer" ? runtimeBoardId.slice(analyzedBoard.board.id.length + 1) : null;
-      const boardState = {
-        id: runtimeBoardId,
-        ...sharedBoardState,
-        playerId,
-        spaces: cloneJson(buildSpaces()),
-        relations: cloneJson(relations),
-        containers: cloneJson(buildContainers(runtimeBoardId)),
-        ...analyzedBoard.layout === "hex" ? {
-          orientation: analyzedBoard.board.orientation ?? "pointy-top",
-          edges: cloneJson(edges),
-          vertices: cloneJson(vertices)
-        } : analyzedBoard.layout === "square" ? {
-          edges: cloneJson(edges),
-          vertices: cloneJson(vertices)
-        } : {}
-      };
-      boardStatesById[runtimeBoardId] = boardState;
-      if (analyzedBoard.layout === "hex") {
-        hexBoardStatesById[runtimeBoardId] = boardState;
-      }
-      if (analyzedBoard.layout === "square") {
-        squareBoardStatesById[runtimeBoardId] = boardState;
-      }
-    }
-  }
-  const sharedZones = Object.fromEntries(
-    analysis.sharedZones.map((zone) => [zone.id, []])
-  );
-  const perPlayerZones = Object.fromEntries(
-    analysis.playerZones.map((zone) => [
-      zone.id,
-      Object.fromEntries(
-        playerIds.map((playerId) => [playerId, []])
-      )
-    ])
-  );
-  const zoneVisibility = Object.fromEntries(
-    (manifest.zones ?? []).map((zone) => [
-      zone.id,
-      zone.visibility ?? "public"
-    ])
-  );
-  const zoneCardSetIdsByZoneId = Object.fromEntries(
-    Array.from(analysis.zoneCardSetIdsById.entries()).sort(
-      ([left], [right]) => left.localeCompare(right)
-    )
-  );
-  const handVisibility = Object.fromEntries(
-    analysis.playerZones.map((zone) => [
-      zone.id,
-      zone.visibility ?? "ownerOnly"
-    ])
-  );
-  const componentSortPosition = (position) => typeof position === "number" ? position : Number.MAX_SAFE_INTEGER;
-  const pushSharedComponent = (zoneId, componentId) => {
-    const zone = sharedZones[zoneId];
-    if (!zone) {
-      return;
-    }
-    zone.push(componentId);
-    zone.sort(
-      (left, right) => componentSortPosition(componentLocations[left]?.position) - componentSortPosition(componentLocations[right]?.position)
-    );
-  };
-  const pushPlayerComponent = (zoneId, playerId, componentId) => {
-    const zone = perPlayerZones[zoneId]?.[playerId];
-    if (!zone) {
-      return;
-    }
-    zone.push(componentId);
-    zone.sort(
-      (left, right) => componentSortPosition(componentLocations[left]?.position) - componentSortPosition(componentLocations[right]?.position)
-    );
-  };
-  for (const [componentId, location] of Object.entries(componentLocations)) {
-    switch (location.type) {
-      case "InDeck":
-        pushSharedComponent(location.deckId, componentId);
-        break;
-      case "InHand":
-        pushPlayerComponent(
-          location.handId,
-          location.playerId,
-          componentId
-        );
-        break;
-      case "InZone":
-        pushSharedComponent(location.zoneId, componentId);
-        break;
-      default:
-        break;
-    }
-  }
-  const ownerOfCard = Object.fromEntries(
-    Object.keys(cards).map((cardId) => [cardId, null])
-  );
-  const visibility = Object.fromEntries(
-    Object.keys(cards).map((cardId) => [cardId, { faceUp: true }])
-  );
-  const resourcesByPlayer = Object.fromEntries(
-    playerIds.map((playerId) => [
-      playerId,
-      Object.fromEntries(
-        analysis.resourceIds.map((resourceId) => [resourceId, 0])
-      )
-    ])
-  );
-  const toPerPlayerWireFormat = (entries) => ({
-    __perPlayer: true,
-    entries: playerIds.map(
-      (playerId) => [playerId, entries[playerId]]
-    )
-  });
-  const perPlayerZonesWire = Object.fromEntries(
-    Object.entries(perPlayerZones).map(([zoneId, entries]) => [
-      zoneId,
-      toPerPlayerWireFormat(entries)
-    ])
-  );
-  const resourcesWire = toPerPlayerWireFormat(resourcesByPlayer);
-  return cloneJson({
-    playerOrder: playerIds,
-    zones: {
-      shared: sharedZones,
-      perPlayer: perPlayerZonesWire,
-      visibility: zoneVisibility,
-      cardSetIdsByZoneId: zoneCardSetIdsByZoneId
-    },
-    decks: cloneJson(sharedZones),
-    hands: cloneJson(perPlayerZonesWire),
-    handVisibility,
-    cards,
-    pieces,
-    componentLocations,
-    ownerOfCard,
-    visibility,
-    resources: resourcesWire,
-    boards: {
-      byId: boardStatesById,
-      hex: hexBoardStatesById,
-      square: squareBoardStatesById,
-      network: {},
-      track: {}
-    },
-    dice
-  });
-}
-
-export {
-  analyzeManifest,
-  materializeManifestTable
-};
-//# sourceMappingURL=chunk-Z7QCREWI.js.map