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

package/dist/chunk-CZRPUWCT.js

@@ -0,0 +1,1602 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/domain/per-player-instance.ts
+import * as z from "zod";
+var GENERATED_ID_PREFIX = "@db/";
+var instanceTuple = z.tuple([
+  z.enum(["board", "card", "piece", "die", "tile"]),
+  z.string().min(1),
+  z.string().min(1)
+]);
+function perPlayerInstanceId(family, baseId, playerId) {
+  instanceTuple.parse([family, baseId, playerId]);
+  return `${GENERATED_ID_PREFIX}${JSON.stringify([family, baseId, playerId])}`;
+}
+function parsePerPlayerInstanceId(value) {
+  if (typeof value !== "string" || !value.startsWith(GENERATED_ID_PREFIX))
+    return null;
+  let candidate;
+  try {
+    candidate = JSON.parse(value.slice(GENERATED_ID_PREFIX.length));
+  } catch {
+    return null;
+  }
+  const parsed = instanceTuple.safeParse(candidate);
+  if (!parsed.success) return null;
+  const [family, baseId, playerId] = parsed.data;
+  const id = perPlayerInstanceId(family, baseId, playerId);
+  if (id !== value) return null;
+  return { id, family, baseId, playerId };
+}
+function perPlayerInstanceSchema(family, bases) {
+  const known = new Set(bases);
+  return z.custom(
+    (value) => {
+      const parsed = parsePerPlayerInstanceId(value);
+      return parsed?.family === family && known.has(parsed.baseId);
+    },
+    { error: "Expected a canonical instance of a declared family and base." }
+  );
+}
+
+// src/shared/domain/board-element.ts
+import * as z2 from "zod";
+var elementTuple = z2.tuple([
+  z2.enum(["board-edge", "board-vertex"]),
+  z2.enum(["hex", "square"]),
+  z2.string().min(1),
+  z2.string().min(1)
+]);
+function validLattice(kind, layout, value) {
+  const pattern = layout === "hex" ? kind === "board-edge" ? /^(-?\d+),(-?\d+):e[012]$/ : /^(-?\d+),(-?\d+):v[01]$/ : kind === "board-edge" ? /^(-?\d+),(-?\d+):[hv]$/ : /^(-?\d+),(-?\d+)$/;
+  const match = pattern.exec(value);
+  return match !== null && [match[1], match[2]].every(
+    (part) => Number.isSafeInteger(Number(part)) && String(Number(part)) === part
+  );
+}
+function encode(kind, layout, boardId, latticeId) {
+  elementTuple.parse([kind, layout, boardId, latticeId]);
+  if (!validLattice(kind, layout, latticeId))
+    throw new Error("Invalid canonical board lattice identity.");
+  return `${GENERATED_ID_PREFIX}${JSON.stringify([kind, layout, boardId, latticeId])}`;
+}
+function boardEdgeId(layout, boardId, latticeId) {
+  return encode(
+    "board-edge",
+    layout,
+    boardId,
+    latticeId
+  );
+}
+function boardVertexId(layout, boardId, latticeId) {
+  return encode(
+    "board-vertex",
+    layout,
+    boardId,
+    latticeId
+  );
+}
+function parseBoardElementId(value) {
+  if (typeof value !== "string" || !value.startsWith(GENERATED_ID_PREFIX))
+    return null;
+  let candidate;
+  try {
+    candidate = JSON.parse(value.slice(GENERATED_ID_PREFIX.length));
+  } catch {
+    return null;
+  }
+  const parsed = elementTuple.safeParse(candidate);
+  if (!parsed.success) return null;
+  const [kind, layout, boardId, latticeId] = parsed.data;
+  if (!validLattice(kind, layout, latticeId) || encode(kind, layout, boardId, latticeId) !== value)
+    return null;
+  return {
+    kind: kind === "board-edge" ? "edge" : "vertex",
+    layout,
+    boardId,
+    latticeId
+  };
+}
+
+// src/shared/domain/tile-space.ts
+import * as z3 from "zod";
+var tileSpaceTuple = z3.tuple([
+  z3.literal("tile-space"),
+  z3.string().min(1),
+  z3.string().min(1)
+]);
+function tileSpaceId(tileId, cellId) {
+  tileSpaceTuple.parse(["tile-space", tileId, cellId]);
+  return `${GENERATED_ID_PREFIX}${JSON.stringify(["tile-space", tileId, cellId])}`;
+}
+function parseTileSpaceId(value) {
+  if (typeof value !== "string" || !value.startsWith(GENERATED_ID_PREFIX))
+    return null;
+  let candidate;
+  try {
+    candidate = JSON.parse(value.slice(GENERATED_ID_PREFIX.length));
+  } catch {
+    return null;
+  }
+  const parsed = tileSpaceTuple.safeParse(candidate);
+  if (!parsed.success) return null;
+  const [, tileId, cellId] = parsed.data;
+  if (tileSpaceId(tileId, cellId) !== value) return null;
+  return { tileId, cellId };
+}
+
+// src/shared/runtime-json.ts
+import * as z4 from "zod";
+import { en } from "zod/locales";
+z4.config(en());
+var RuntimeJsonSchema = z4.json();
+
+// src/shared/protocol/json.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
+function canonicalizePluginRuntimeJson(value) {
+  return canonicalizeJson(
+    RuntimeJsonSchema.parse(omitOptionalProperties(value))
+  );
+}
+function encodeCanonicalPluginRuntimeJson(value) {
+  return JSON.stringify(canonicalizePluginRuntimeJson(value));
+}
+function digestPluginRuntimeJson(value) {
+  return `sha256:${sha256Hex(encodeCanonicalPluginRuntimeJson(value))}`;
+}
+function canonicalizeJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number") return value;
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalizeJson(item));
+  }
+  return Object.fromEntries(
+    Object.entries(value).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, item]) => [key, canonicalizeJson(item)])
+  );
+}
+function omitOptionalProperties(value) {
+  if (Array.isArray(value)) return value.map(omitOptionalProperties);
+  if (value !== null && typeof value === "object" && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).map(([key, item]) => [key, omitOptionalProperties(item)])
+    );
+  }
+  return value;
+}
+function sha256Hex(input) {
+  return bytesToHex(sha256(utf8ToBytes(input)));
+}
+
+// src/shared/position-target.ts
+import * as z5 from "zod";
+var PositionTargetSchema = z5.strictObject({
+  zoneId: z5.string(),
+  hostId: z5.string(),
+  index: z5.number().int().nonnegative()
+});
+function isPositionTarget(value) {
+  return typeof value === "object" && value !== null && Object.keys(value).length === 3 && "zoneId" in value && typeof value.zoneId === "string" && "hostId" in value && typeof value.hostId === "string" && "index" in value && Number.isSafeInteger(value.index) && value.index >= 0;
+}
+function zonePositions(zones) {
+  return zones.flatMap(
+    ({ zoneId, hostId, size }) => Array.from({ length: size + 1 }, (_, index) => ({ zoneId, hostId, index }))
+  );
+}
+
+// src/shared/immutable.ts
+function immutableCopy(value) {
+  return freeze(structuredClone(value));
+}
+function freeze(value) {
+  if (value !== null && typeof value === "object") {
+    for (const child of Object.values(value)) freeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+// src/shared/domain/board-coordinates.ts
+var MAXIMUM_BOARD_COORDINATE = Math.floor(Number.MAX_SAFE_INTEGER / 4);
+
+// src/shared/hex-board.ts
+import {
+  defineHex,
+  Grid,
+  Orientation,
+  ring as ringTraversal,
+  line as lineTraversal
+} from "honeycomb-grid";
+var maximumCoordinate = MAXIMUM_BOARD_COORDINATE;
+var coordinateKey = ({ q, r }) => `${q},${r}`;
+var directions = [
+  { q: 1, r: 0 },
+  { q: 0, r: 1 },
+  { q: -1, r: 1 },
+  { q: -1, r: 0 },
+  { q: 0, r: -1 },
+  { q: 1, r: -1 }
+];
+var add = (a, b) => ({
+  q: a.q + b.q,
+  r: a.r + b.r
+});
+function edgeKey(hex, side) {
+  return side < 3 ? `${coordinateKey(hex)}:e${side}` : edgeKey(add(hex, directions[side]), side - 3);
+}
+function vertexCoordinates(hex, corner) {
+  return [
+    hex,
+    add(hex, directions[corner]),
+    add(hex, directions[(corner + 1) % 6])
+  ];
+}
+function vertexKey(hex, corner) {
+  const hexes = vertexCoordinates(hex, corner);
+  for (const base of hexes) {
+    for (let shape = 0; shape < 2; shape++) {
+      if ([directions[shape], directions[shape + 1]].every(
+        (offset) => hexes.some(
+          (hex2) => coordinateKey(hex2) === coordinateKey(add(base, offset))
+        )
+      ))
+        return `${coordinateKey(base)}:v${shape}`;
+    }
+  }
+  throw new Error("Invalid hex vertex.");
+}
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function hexClass(orientation, dimensions = 1) {
+  return defineHex({
+    dimensions,
+    orientation: orientation === "flat" ? Orientation.FLAT : Orientation.POINTY,
+    origin: { x: 0, y: 0 }
+  });
+}
+function createHexTopology(board2) {
+  const boardId = board2.id;
+  const spaces = board2.spaces.map(({ id, q, r }) => ({ id, q, r })).sort((a, b) => compare(a.id, b.id));
+  for (const space of spaces) {
+    if (!Number.isSafeInteger(space.q) || !Number.isSafeInteger(space.r))
+      throw new Error("Hex coordinates must be safe integers.");
+    if (Math.abs(space.q) > maximumCoordinate || Math.abs(space.r) > maximumCoordinate)
+      throw new Error(
+        `Hex coordinates must be within +/-${maximumCoordinate} for exact cube arithmetic and safe one-step neighbours.`
+      );
+  }
+  const orientation = board2.orientation ?? "pointy";
+  const grid = new Grid(hexClass(orientation), spaces);
+  const spacesById = new Map(spaces.map((space) => [space.id, space]));
+  if (spacesById.size !== spaces.length || grid.size !== spaces.length)
+    throw new Error(
+      `Hex board '${boardId}' contains duplicate space IDs or coordinates.`
+    );
+  const spacesByCoordinate = new Map(
+    spaces.map((space) => [coordinateKey(space), space])
+  );
+  const cornersBySpace = /* @__PURE__ */ new Map();
+  const edgesBySpace = /* @__PURE__ */ new Map();
+  const edgesById = /* @__PURE__ */ new Map();
+  const verticesById = /* @__PURE__ */ new Map();
+  const vertexPoints = /* @__PURE__ */ new Map();
+  const Tile = hexClass(orientation);
+  const cornerId = (space, corner) => boardVertexId("hex", boardId, vertexKey(space, corner));
+  for (const space of spaces) {
+    const cornerIds = Array.from(
+      { length: 6 },
+      (_, corner) => cornerId(space, corner)
+    );
+    cornersBySpace.set(space.id, cornerIds);
+    const edgeIds = Array.from({ length: 6 }, (_, side) => {
+      const id = boardEdgeId("hex", boardId, edgeKey(space, side));
+      let edge = edgesById.get(id);
+      if (!edge) {
+        edge = {
+          id,
+          spaceIds: [],
+          vertexIds: [cornerIds[(side + 5) % 6], cornerIds[side]].sort(
+            compare
+          )
+        };
+        edgesById.set(id, edge);
+      }
+      edge.spaceIds.push(space.id);
+      return id;
+    });
+    edgesBySpace.set(space.id, edgeIds);
+    cornerIds.forEach((id, corner) => {
+      let vertex = verticesById.get(id);
+      if (!vertex) {
+        vertex = { id, spaceIds: [], edgeIds: [] };
+        verticesById.set(id, vertex);
+        const centers = vertexCoordinates(space, corner).map(
+          (coordinate7) => new Tile(coordinate7)
+        );
+        vertexPoints.set(id, {
+          x: centers.reduce((sum, hex) => sum + hex.x, 0) / 3,
+          y: centers.reduce((sum, hex) => sum + hex.y, 0) / 3
+        });
+      }
+      vertex.spaceIds.push(space.id);
+      for (const edgeId2 of [edgeIds[corner], edgeIds[(corner + 1) % 6]])
+        if (!vertex.edgeIds.includes(edgeId2)) vertex.edgeIds.push(edgeId2);
+    });
+  }
+  const edges = Object.freeze(
+    [...edgesById.values()].sort((a, b) => compare(a.id, b.id)).map(
+      (edge) => Object.freeze({
+        ...edge,
+        spaceIds: Object.freeze(edge.spaceIds),
+        vertexIds: Object.freeze(edge.vertexIds)
+      })
+    )
+  );
+  const vertices = Object.freeze(
+    [...verticesById.values()].sort((a, b) => compare(a.id, b.id)).map(
+      (vertex) => Object.freeze({
+        ...vertex,
+        spaceIds: Object.freeze(vertex.spaceIds),
+        edgeIds: Object.freeze(vertex.edgeIds.sort(compare))
+      })
+    )
+  );
+  const requireSpace = (id) => {
+    const space = spacesById.get(id);
+    if (!space) throw new Error(`Unknown space '${id}' on board '${boardId}'.`);
+    return space;
+  };
+  const selectedIds = (coordinates) => Array.from(coordinates).flatMap((coordinate7) => {
+    const space = spacesByCoordinate.get(coordinateKey(coordinate7));
+    return space ? [space.id] : [];
+  });
+  const topology = {
+    edges,
+    vertices,
+    neighbors(id) {
+      const space = requireSpace(id);
+      return directions.flatMap((direction) => {
+        const neighbor = spacesByCoordinate.get(
+          coordinateKey(add(space, direction))
+        );
+        return neighbor ? [neighbor.id] : [];
+      });
+    },
+    distance(from, to) {
+      requireSpace(from);
+      requireSpace(to);
+      const queue = [from];
+      const distances = /* @__PURE__ */ new Map([[from, 0]]);
+      for (let index = 0; index < queue.length; index++) {
+        const id = queue[index];
+        const distance = distances.get(id);
+        if (id === to) return distance;
+        const space = requireSpace(id);
+        for (const direction of directions) {
+          const neighbor = spacesByCoordinate.get(
+            coordinateKey(add(space, direction))
+          );
+          if (neighbor && !distances.has(neighbor.id)) {
+            distances.set(neighbor.id, distance + 1);
+            queue.push(neighbor.id);
+          }
+        }
+      }
+      return Infinity;
+    },
+    gridDistance(from, to) {
+      return grid.distance(requireSpace(from), requireSpace(to));
+    },
+    ring(id, radius) {
+      return selectedIds(
+        new Grid(
+          hexClass(orientation),
+          ringTraversal({ center: requireSpace(id), radius })
+        )
+      );
+    },
+    line(from, to) {
+      return selectedIds(
+        new Grid(
+          hexClass(orientation),
+          lineTraversal({ start: requireSpace(from), stop: requireSpace(to) })
+        )
+      );
+    },
+    edgesOf(id) {
+      requireSpace(id);
+      return [...edgesBySpace.get(id)];
+    },
+    verticesOf(id) {
+      requireSpace(id);
+      return [...cornersBySpace.get(id)];
+    },
+    edgeAt(id, side) {
+      requireSpace(id);
+      const key = edgesBySpace.get(id)[side];
+      if (!key)
+        throw new Error("Hex side must be an integer from 0 through 5.");
+      return key;
+    },
+    vertexAt(id, corner) {
+      requireSpace(id);
+      const key = cornersBySpace.get(id)[corner];
+      if (!key)
+        throw new Error("Hex corner must be an integer from 0 through 5.");
+      return key;
+    },
+    edge(a, b) {
+      requireSpace(a);
+      requireSpace(b);
+      const edge = edgesBySpace.get(a).map((id) => edgesById.get(id)).find((edge2) => edge2.spaceIds.includes(b));
+      if (!edge || a === b)
+        throw new Error(`Spaces '${a}' and '${b}' do not share an edge.`);
+      return edge.id;
+    },
+    vertex(a, b, c) {
+      requireSpace(a);
+      requireSpace(b);
+      requireSpace(c);
+      const vertex = cornersBySpace.get(a).map((id) => verticesById.get(id)).find(
+        (vertex2) => vertex2.spaceIds.includes(b) && vertex2.spaceIds.includes(c)
+      );
+      if (!vertex || (/* @__PURE__ */ new Set([a, b, c])).size !== 3)
+        throw new Error("Spaces do not share exactly one vertex.");
+      return vertex.id;
+    },
+    incidentEdges(vertexId2) {
+      const vertex = verticesById.get(vertexId2);
+      if (!vertex) throw new Error(`Unknown vertex '${vertexId2}'.`);
+      return [...vertex.edgeIds];
+    },
+    incidentVertices(edgeId2) {
+      const edge = edgesById.get(edgeId2);
+      if (!edge) throw new Error(`Unknown edge '${edgeId2}'.`);
+      return [...edge.vertexIds];
+    },
+    spacesAt(vertexId2) {
+      const vertex = verticesById.get(vertexId2);
+      if (!vertex) throw new Error(`Unknown vertex '${vertexId2}'.`);
+      return [...vertex.spaceIds];
+    },
+    spacesAlong(edgeId2) {
+      const edge = edgesById.get(edgeId2);
+      if (!edge) throw new Error(`Unknown edge '${edgeId2}'.`);
+      return [...edge.spaceIds];
+    },
+    getLayout({
+      hexSize,
+      origin: suppliedOrigin = { x: 0, y: 0 }
+    }) {
+      const origin = { x: suppliedOrigin.x, y: suppliedOrigin.y };
+      if (!Number.isFinite(hexSize) || hexSize <= 0)
+        throw new Error("hexSize must be positive and finite.");
+      if (![origin.x, origin.y].every(Number.isFinite))
+        throw new Error("Layout origin must be finite.");
+      const scaled = new Grid(hexClass(orientation, hexSize), spaces);
+      const layoutSpaces = spaces.map((space) => {
+        const hex = scaled.getHex(space);
+        return {
+          id: space.id,
+          center: { x: hex.x + origin.x, y: hex.y + origin.y },
+          corners: hex.corners.map((point) => ({
+            x: point.x + origin.x,
+            y: point.y + origin.y
+          }))
+        };
+      });
+      const points = layoutSpaces.flatMap((space) => space.corners);
+      const minX = points.length ? Math.min(...points.map((point) => point.x)) : 0;
+      const minY = points.length ? Math.min(...points.map((point) => point.y)) : 0;
+      const maxX = points.length ? Math.max(...points.map((point) => point.x)) : 0;
+      const maxY = points.length ? Math.max(...points.map((point) => point.y)) : 0;
+      const scaledVertexPoints = new Map(
+        [...vertexPoints].map(([id, point]) => [
+          id,
+          { x: point.x * hexSize + origin.x, y: point.y * hexSize + origin.y }
+        ])
+      );
+      return {
+        viewBox: Object.freeze({
+          x: minX,
+          y: minY,
+          width: maxX - minX,
+          height: maxY - minY
+        }),
+        spaces: Object.freeze(
+          layoutSpaces.map(
+            (space) => Object.freeze({
+              ...space,
+              center: Object.freeze(space.center),
+              corners: Object.freeze(
+                space.corners.map((point) => Object.freeze(point))
+              )
+            })
+          )
+        ),
+        edges: Object.freeze(
+          edges.map(
+            (edge) => Object.freeze({
+              id: edge.id,
+              from: Object.freeze(scaledVertexPoints.get(edge.vertexIds[0])),
+              to: Object.freeze(scaledVertexPoints.get(edge.vertexIds[1]))
+            })
+          )
+        ),
+        vertices: Object.freeze(
+          vertices.map(
+            (vertex) => Object.freeze({
+              id: vertex.id,
+              center: Object.freeze(scaledVertexPoints.get(vertex.id))
+            })
+          )
+        ),
+        pointToSpace(point) {
+          const hex = scaled.pointToHex(
+            { x: point.x - origin.x, y: point.y - origin.y },
+            { allowOutside: false }
+          );
+          return hex ? spacesByCoordinate.get(coordinateKey(hex))?.id : void 0;
+        }
+      };
+    }
+  };
+  let cachedLayout;
+  const buildLayout = topology.getLayout;
+  topology.getLayout = (options) => {
+    const key = JSON.stringify([
+      options.hexSize,
+      options.origin?.x ?? 0,
+      options.origin?.y ?? 0
+    ]);
+    if (cachedLayout?.key !== key) {
+      const value = buildLayout(options);
+      cachedLayout = { key, value: Object.freeze(value) };
+    }
+    return cachedLayout.value;
+  };
+  return Object.freeze(topology);
+}
+function createHexTopologyCache() {
+  const entries = /* @__PURE__ */ new Map();
+  return (board2) => {
+    const orientation = board2.orientation ?? "pointy";
+    const cached = entries.get(board2.id);
+    if (cached?.orientation === orientation && cached.spaces.size === board2.spaces.length) {
+      const seen = /* @__PURE__ */ new Set();
+      const equal = board2.spaces.every((space) => {
+        const previous = cached.spaces.get(space.id);
+        if (seen.has(space.id)) return false;
+        seen.add(space.id);
+        return previous?.q === space.q && previous?.r === space.r;
+      });
+      if (equal) return cached.value;
+    }
+    const value = createHexTopology(board2);
+    if (!entries.has(board2.id) && entries.size >= 64)
+      entries.delete(entries.keys().next().value);
+    entries.set(board2.id, {
+      orientation,
+      spaces: new Map(board2.spaces.map(({ id, q, r }) => [id, { q, r }])),
+      value
+    });
+    return value;
+  };
+}
+
+// src/shared/board-topology.ts
+var BoardTopologyError = class extends Error {
+  name = "BoardTopologyError";
+};
+function coordinate(value) {
+  if (!Number.isSafeInteger(value) || Math.abs(value) > MAXIMUM_BOARD_COORDINATE)
+    throw new BoardTopologyError(
+      `Board coordinate must be an integer within +/-${MAXIMUM_BOARD_COORDINATE}.`
+    );
+  return value === 0 ? 0 : value;
+}
+function rotateHex(q, r, rotation) {
+  coordinate(q);
+  coordinate(r);
+  if (!Number.isInteger(rotation) || rotation < 0 || rotation > 5)
+    throw new BoardTopologyError(
+      "Hex rotation must be an integer from 0 through 5."
+    );
+  for (let step = 0; step < rotation; step++) [q, r] = [-r, q + r];
+  return { q: coordinate(q), r: coordinate(r) };
+}
+function rotateSquare(col, row, rotation) {
+  coordinate(col);
+  coordinate(row);
+  if (!Number.isInteger(rotation) || rotation < 0 || rotation > 3)
+    throw new BoardTopologyError(
+      "Square rotation must be an integer from 0 through 3."
+    );
+  for (let step = 0; step < rotation; step++) [col, row] = [-row, col];
+  return { col: coordinate(col), row: coordinate(row) };
+}
+function annotate(element, annotation) {
+  const merge = (key) => {
+    const before = element[key];
+    const after = annotation[key];
+    if (before !== void 0 && after !== void 0 && before !== after)
+      throw new BoardTopologyError(
+        `Conflicting ${key} metadata on '${element.id}'.`
+      );
+    return after ?? before;
+  };
+  const fields3 = { ...element.fields };
+  for (const [key, value] of Object.entries(annotation.fields)) {
+    if (Object.hasOwn(fields3, key) && encodeCanonicalPluginRuntimeJson(fields3[key]) !== encodeCanonicalPluginRuntimeJson(value))
+      throw new BoardTopologyError(
+        `Conflicting field '${key}' metadata on '${element.id}'.`
+      );
+    Object.defineProperty(fields3, key, {
+      value,
+      enumerable: true,
+      writable: true,
+      configurable: true
+    });
+  }
+  return { ...element, typeId: merge("typeId"), label: merge("label"), fields: fields3 };
+}
+function deriveBoardTopology(table, definitions, boardId) {
+  if (!Object.hasOwn(table.boards, boardId))
+    throw new BoardTopologyError(`Unknown board '${boardId}'.`);
+  const instance = table.boards[boardId];
+  if (!Object.hasOwn(definitions.boardDefinitions, instance.baseId))
+    throw new BoardTopologyError(
+      `Unknown board definition '${instance.baseId}'.`
+    );
+  const definition = definitions.boardDefinitions[instance.baseId];
+  const playerId = definition.scope === "perPlayer" ? parsePerPlayerInstanceId(boardId)?.playerId : void 0;
+  const base = {
+    id: boardId,
+    baseId: instance.baseId,
+    name: definition.name,
+    scope: definition.scope,
+    ...playerId === void 0 ? {} : { playerId },
+    typeId: definition.typeId,
+    fields: definition.fields,
+    relations: instance.relations
+  };
+  if (definition.layout === "generic") {
+    for (const tileId of Object.keys(table.tiles)) {
+      const location = table.componentLocations[tileId];
+      if (location?.type === "OnBoard" && "boardId" in location && location.boardId === boardId)
+        throw new BoardTopologyError(
+          `Tile '${tileId}' cannot be placed on generic board '${boardId}'.`
+        );
+    }
+    const result2 = {
+      ...base,
+      layout: "generic",
+      spaces: definition.spaces
+    };
+    validateRelations(result2);
+    return immutableCopy(result2);
+  }
+  const hexSpaces = {};
+  const squareSpaces = {};
+  const occupied = /* @__PURE__ */ new Map();
+  const placed = [];
+  for (const [tileId, tile] of Object.entries(table.tiles).sort(
+    ([a], [b]) => a < b ? -1 : a > b ? 1 : 0
+  )) {
+    const location = table.componentLocations[tileId];
+    if (location?.type !== "OnBoard" || !("boardId" in location) || location.boardId !== boardId)
+      continue;
+    if (!Object.hasOwn(definitions.tileDefinitions, tile.tileTypeId))
+      throw new BoardTopologyError(`Unknown tile type '${tile.tileTypeId}'.`);
+    const tileDefinition = definitions.tileDefinitions[tile.tileTypeId];
+    if (!("layout" in location) || location.layout !== definition.layout || tileDefinition.layout !== definition.layout)
+      throw new BoardTopologyError(
+        `Tile '${tileId}' layout does not match board '${boardId}'.`
+      );
+    const placement2 = location;
+    placed.push({ tileId, definition: tileDefinition, placement: placement2 });
+    if (tileDefinition.layout === "hex" && placement2.layout === "hex") {
+      coordinate(placement2.q);
+      coordinate(placement2.r);
+      for (const cell2 of tileDefinition.cells) {
+        const rotated = rotateHex(cell2.at.q, cell2.at.r, placement2.rotation);
+        const q = coordinate(rotated.q + placement2.q), r = coordinate(rotated.r + placement2.r);
+        const key = `${q},${r}`;
+        if (occupied.has(key))
+          throw new BoardTopologyError(
+            `Overlapping tile cells from tiles '${occupied.get(key)}' and '${tileId}' on board '${boardId}' at ${key}.`
+          );
+        occupied.set(key, tileId);
+        const id = tileSpaceId(tileId, cell2.id);
+        hexSpaces[id] = {
+          id,
+          tileId,
+          localCellId: cell2.id,
+          q,
+          r,
+          name: cell2.name,
+          typeId: cell2.typeId,
+          fields: cell2.fields
+        };
+      }
+    } else if (tileDefinition.layout === "square" && placement2.layout === "square") {
+      coordinate(placement2.col);
+      coordinate(placement2.row);
+      for (const cell2 of tileDefinition.cells) {
+        const rotated = rotateSquare(
+          cell2.at.col,
+          cell2.at.row,
+          placement2.rotation
+        );
+        const col = coordinate(rotated.col + placement2.col), row = coordinate(rotated.row + placement2.row);
+        const key = `${col},${row}`;
+        if (occupied.has(key))
+          throw new BoardTopologyError(
+            `Overlapping tile cells from tiles '${occupied.get(key)}' and '${tileId}' on board '${boardId}' at ${key}.`
+          );
+        occupied.set(key, tileId);
+        const id = tileSpaceId(tileId, cell2.id);
+        squareSpaces[id] = {
+          id,
+          tileId,
+          localCellId: cell2.id,
+          col,
+          row,
+          name: cell2.name,
+          typeId: cell2.typeId,
+          fields: cell2.fields
+        };
+      }
+    }
+  }
+  if (definition.layout === "hex") {
+    const lattice2 = createHexTopology({
+      id: boardId,
+      orientation: definition.orientation,
+      spaces: Object.values(hexSpaces)
+    });
+    const edges = new Map(
+      lattice2.edges.map((edge) => [edge.id, { ...edge, fields: {} }])
+    );
+    const vertices = new Map(
+      lattice2.vertices.map((vertex) => [vertex.id, { ...vertex, fields: {} }])
+    );
+    for (const tile of placed) {
+      if (tile.definition.layout !== "hex" || tile.placement.layout !== "hex")
+        continue;
+      for (const annotation of tile.definition.edges) {
+        const id = lattice2.edgeAt(
+          tileSpaceId(tile.tileId, annotation.cellId),
+          hexSide(annotation.side + tile.placement.rotation)
+        );
+        edges.set(id, annotate(edges.get(id), annotation));
+      }
+      for (const annotation of tile.definition.vertices) {
+        const id = lattice2.vertexAt(
+          tileSpaceId(tile.tileId, annotation.cellId),
+          hexSide(annotation.corner + tile.placement.rotation)
+        );
+        vertices.set(id, annotate(vertices.get(id), annotation));
+      }
+    }
+    const result2 = {
+      ...base,
+      layout: "hex",
+      orientation: definition.orientation,
+      spaces: hexSpaces,
+      edges: [...edges.values()].sort(
+        (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0
+      ),
+      vertices: [...vertices.values()].sort(
+        (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0
+      )
+    };
+    validateRelations(result2);
+    return immutableCopy(result2);
+  }
+  const lattice = squareLattice(boardId, Object.values(squareSpaces));
+  for (const tile of placed) {
+    if (tile.definition.layout !== "square" || tile.placement.layout !== "square")
+      continue;
+    for (const annotation of tile.definition.edges) {
+      const id = lattice.edgeAt(
+        squareSpaces[tileSpaceId(tile.tileId, annotation.cellId)],
+        (annotation.side + tile.placement.rotation) % 4
+      );
+      lattice.edges.set(id, annotate(lattice.edges.get(id), annotation));
+    }
+    for (const annotation of tile.definition.vertices) {
+      const id = lattice.vertexAt(
+        squareSpaces[tileSpaceId(tile.tileId, annotation.cellId)],
+        (annotation.corner + tile.placement.rotation) % 4
+      );
+      lattice.vertices.set(id, annotate(lattice.vertices.get(id), annotation));
+    }
+  }
+  const result = {
+    ...base,
+    layout: "square",
+    spaces: squareSpaces,
+    edges: [...lattice.edges.values()].sort(
+      (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0
+    ),
+    vertices: [...lattice.vertices.values()].sort(
+      (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0
+    )
+  };
+  validateRelations(result);
+  return immutableCopy(result);
+}
+function hexSide(value) {
+  const side = value % 6;
+  switch (side) {
+    case 0:
+    case 1:
+    case 2:
+    case 3:
+    case 4:
+    case 5:
+      return side;
+    default:
+      throw new BoardTopologyError("Invalid hex side.");
+  }
+}
+function validateRelations(board2) {
+  const identities = /* @__PURE__ */ new Set();
+  for (const relation of board2.relations) {
+    if (typeof relation.id !== "string" || relation.id.length === 0)
+      throw new BoardTopologyError(
+        `Relation identity must be nonempty on board '${board2.id}'.`
+      );
+    if (identities.has(relation.id))
+      throw new BoardTopologyError(
+        `Duplicate relation identity '${relation.id}' on board '${board2.id}'.`
+      );
+    identities.add(relation.id);
+    if (!Object.hasOwn(board2.spaces, relation.fromSpaceId) || !Object.hasOwn(board2.spaces, relation.toSpaceId))
+      throw new BoardTopologyError(
+        `Relation on board '${board2.id}' references an absent space.`
+      );
+  }
+}
+function squareLattice(boardId, spaces) {
+  const edges = /* @__PURE__ */ new Map();
+  const vertices = /* @__PURE__ */ new Map();
+  const corners = [
+    [1, 1],
+    [0, 1],
+    [0, 0],
+    [1, 0]
+  ];
+  const vertexAt = (space, corner) => {
+    const offset = corners[corner];
+    if (!space || !offset)
+      throw new BoardTopologyError("Unknown square cell or corner.");
+    return boardVertexId(
+      "square",
+      boardId,
+      `${space.col + offset[0]},${space.row + offset[1]}`
+    );
+  };
+  const edgeAt = (space, side) => {
+    if (!space || !Number.isInteger(side) || side < 0 || side > 3)
+      throw new BoardTopologyError("Unknown square cell or side.");
+    switch (side) {
+      case 0:
+        return boardEdgeId(
+          "square",
+          boardId,
+          `${space.col + 1},${space.row}:v`
+        );
+      case 1:
+        return boardEdgeId(
+          "square",
+          boardId,
+          `${space.col},${space.row + 1}:h`
+        );
+      case 2:
+        return boardEdgeId("square", boardId, `${space.col},${space.row}:v`);
+      default:
+        return boardEdgeId("square", boardId, `${space.col},${space.row}:h`);
+    }
+  };
+  for (const space of spaces) {
+    for (let side = 0; side < 4; side++) {
+      const id = edgeAt(space, side);
+      const vertexIds = [vertexAt(space, (side + 3) % 4), vertexAt(space, side)];
+      const before = edges.get(id);
+      edges.set(id, {
+        id,
+        spaceIds: [...before?.spaceIds ?? [], space.id].sort(),
+        vertexIds: vertexIds.sort(),
+        fields: {}
+      });
+      for (const vertexId2 of vertexIds) {
+        const vertex = vertices.get(vertexId2);
+        vertices.set(vertexId2, {
+          id: vertexId2,
+          spaceIds: [
+            .../* @__PURE__ */ new Set([...vertex?.spaceIds ?? [], space.id])
+          ].sort(),
+          edgeIds: [.../* @__PURE__ */ new Set([...vertex?.edgeIds ?? [], id])].sort(),
+          fields: {}
+        });
+      }
+    }
+  }
+  return { edges, vertices, edgeAt, vertexAt };
+}
+function createBoardTopologyCache() {
+  const entries = /* @__PURE__ */ new Map();
+  return (table, definitions, boardId) => {
+    if (!Object.hasOwn(table.boards, boardId))
+      throw new BoardTopologyError(`Unknown board '${boardId}'.`);
+    const instance = table.boards[boardId];
+    const placements = Object.entries(table.tiles).flatMap(([id, tile]) => {
+      const location = table.componentLocations[id];
+      return location?.type === "OnBoard" && "boardId" in location && location.boardId === boardId ? [
+        {
+          id,
+          tileTypeId: tile.tileTypeId,
+          location,
+          definition: definitions.tileDefinitions[tile.tileTypeId]
+        }
+      ] : [];
+    }).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+    const key = encodeCanonicalPluginRuntimeJson({
+      instance,
+      definition: definitions.boardDefinitions[instance.baseId],
+      placements
+    });
+    const previous = entries.get(boardId);
+    if (previous?.key === key) return previous.topology;
+    const topology = deriveBoardTopology(table, definitions, boardId);
+    if (!entries.has(boardId) && entries.size >= 64)
+      entries.delete(entries.keys().next().value);
+    entries.set(boardId, { key, topology });
+    return topology;
+  };
+}
+
+// src/shared/board-topology-schema.ts
+import * as z6 from "zod";
+var coordinate2 = z6.number().int().min(-MAXIMUM_BOARD_COORDINATE).max(MAXIMUM_BOARD_COORDINATE);
+var fields = z6.record(z6.string(), RuntimeJsonSchema);
+var BoardRelationSchema = z6.strictObject({
+  id: z6.string().min(1),
+  typeId: z6.string().min(1),
+  fromSpaceId: z6.string().min(1),
+  toSpaceId: z6.string().min(1),
+  directed: z6.boolean(),
+  fields
+});
+var BoardSpaceSchema = z6.strictObject({
+  id: z6.string().min(1),
+  name: z6.string().nullable().optional(),
+  typeId: z6.string().min(1).nullable().optional(),
+  fields
+});
+var tileCell = BoardSpaceSchema.extend({
+  id: z6.custom((value) => parseTileSpaceId(value) !== null),
+  tileId: z6.string().min(1),
+  localCellId: z6.string().min(1)
+});
+function checkTileCell(cell2, ctx) {
+  const identity = parseTileSpaceId(cell2.id);
+  if (identity?.tileId !== cell2.tileId || identity?.cellId !== cell2.localCellId)
+    ctx.addIssue({
+      code: "custom",
+      path: ["id"],
+      message: "Tile space identity must match tileId and localCellId."
+    });
+}
+var HexSpaceSchema = tileCell.extend({ q: coordinate2, r: coordinate2 }).superRefine(checkTileCell);
+var SquareSpaceSchema = tileCell.extend({ col: coordinate2, row: coordinate2 }).superRefine(checkTileCell);
+var edgeId = z6.custom(
+  (value) => parseBoardElementId(value)?.kind === "edge"
+);
+var vertexId = z6.custom(
+  (value) => parseBoardElementId(value)?.kind === "vertex"
+);
+var BoardEdgeSchema = z6.strictObject({
+  id: edgeId,
+  spaceIds: z6.array(z6.string().min(1)).min(1),
+  vertexIds: z6.tuple([vertexId, vertexId]),
+  typeId: z6.string().min(1).optional(),
+  label: z6.string().optional(),
+  fields
+});
+var BoardVertexSchema = z6.strictObject({
+  id: vertexId,
+  spaceIds: z6.array(z6.string().min(1)).min(1),
+  edgeIds: z6.array(edgeId).min(1),
+  typeId: z6.string().min(1).optional(),
+  label: z6.string().optional(),
+  fields
+});
+function identityRecord(schema) {
+  return z6.record(z6.string().min(1), schema).superRefine((entries, ctx) => {
+    for (const [key, value] of Object.entries(entries)) {
+      if (value.id !== key)
+        ctx.addIssue({
+          code: "custom",
+          path: [key, "id"],
+          message: "Record key must match item identity."
+        });
+    }
+  });
+}
+var board = z6.strictObject({
+  id: z6.string().min(1),
+  baseId: z6.string().min(1),
+  name: z6.string(),
+  scope: z6.enum(["shared", "perPlayer"]),
+  playerId: z6.string().min(1).optional(),
+  typeId: z6.string().min(1).optional(),
+  fields,
+  relations: z6.array(BoardRelationSchema)
+});
+var GenericBoardTopologySchema = board.extend({
+  layout: z6.literal("generic"),
+  spaces: identityRecord(BoardSpaceSchema)
+});
+var HexBoardTopologySchema = board.extend({
+  layout: z6.literal("hex"),
+  orientation: z6.enum(["pointy", "flat"]),
+  spaces: identityRecord(HexSpaceSchema),
+  edges: z6.array(BoardEdgeSchema),
+  vertices: z6.array(BoardVertexSchema)
+});
+var SquareBoardTopologySchema = board.extend({
+  layout: z6.literal("square"),
+  spaces: identityRecord(SquareSpaceSchema),
+  edges: z6.array(BoardEdgeSchema),
+  vertices: z6.array(BoardVertexSchema)
+});
+function validateTopologyGraph(topology, ctx) {
+  const issue = (path, message) => ctx.addIssue({ code: "custom", path, message });
+  const replica = parsePerPlayerInstanceId(topology.id);
+  if (topology.scope === "perPlayer") {
+    if (replica?.family !== "board" || replica.baseId !== topology.baseId || replica.playerId !== topology.playerId)
+      issue(
+        ["playerId"],
+        "Per-player board identity must match baseId and playerId."
+      );
+  } else if (topology.playerId !== void 0 || replica !== null || topology.id !== topology.baseId) {
+    issue(
+      ["playerId"],
+      "Shared board identity must match baseId and cannot carry a player identity."
+    );
+  }
+  const spaces = new Set(Object.keys(topology.spaces));
+  const relationIds = /* @__PURE__ */ new Set();
+  for (const [index, relation] of topology.relations.entries()) {
+    if (!spaces.has(relation.fromSpaceId) || !spaces.has(relation.toSpaceId))
+      issue(
+        ["relations", index],
+        "Relation endpoints must belong to this topology."
+      );
+    if (relation.id != null) {
+      if (relationIds.has(relation.id))
+        issue(
+          ["relations", index, "id"],
+          "Relation identities must be unique."
+        );
+      relationIds.add(relation.id);
+    }
+  }
+  if (topology.layout === "generic") return;
+  const edges = new Map(topology.edges.map((edge) => [edge.id, edge]));
+  const vertices = new Map(
+    topology.vertices.map((vertex) => [vertex.id, vertex])
+  );
+  if (edges.size !== topology.edges.length)
+    issue(["edges"], "Edge identities must be unique.");
+  if (vertices.size !== topology.vertices.length)
+    issue(["vertices"], "Vertex identities must be unique.");
+  const references = (ids, known, path) => {
+    const seen = /* @__PURE__ */ new Set();
+    for (const [index, id] of ids.entries()) {
+      if (seen.has(id))
+        issue([...path, index], "Incidence references must be unique.");
+      if (!known.has(id))
+        issue(
+          [...path, index],
+          "Incidence reference must belong to this topology."
+        );
+      seen.add(id);
+    }
+  };
+  const edgeIds = new Set(edges.keys());
+  const vertexIds = new Set(vertices.keys());
+  const vertexEdges = new Map(
+    topology.vertices.map((vertex) => [vertex.id, new Set(vertex.edgeIds)])
+  );
+  for (const [index, edge] of topology.edges.entries()) {
+    references(edge.spaceIds, spaces, ["edges", index, "spaceIds"]);
+    references(edge.vertexIds, vertexIds, ["edges", index, "vertexIds"]);
+    for (const vertexId2 of edge.vertexIds) {
+      if (vertices.has(vertexId2) && !vertexEdges.get(vertexId2)?.has(edge.id))
+        issue(
+          ["edges", index, "vertexIds"],
+          "Edge and vertex incidence must agree."
+        );
+    }
+  }
+  for (const [index, vertex] of topology.vertices.entries()) {
+    references(vertex.spaceIds, spaces, ["vertices", index, "spaceIds"]);
+    references(vertex.edgeIds, edgeIds, ["vertices", index, "edgeIds"]);
+    for (const edgeId2 of vertex.edgeIds) {
+      const edge = edges.get(edgeId2);
+      if (edge && !edge.vertexIds.includes(vertex.id))
+        issue(
+          ["vertices", index, "edgeIds"],
+          "Edge and vertex incidence must agree."
+        );
+    }
+  }
+  for (const [kind, items] of [
+    ["edges", topology.edges],
+    ["vertices", topology.vertices]
+  ]) {
+    for (const [index, item] of items.entries()) {
+      const ids = [
+        item.id,
+        ..."vertexIds" in item ? item.vertexIds : item.edgeIds
+      ];
+      if (ids.some((id) => {
+        const identity = parseBoardElementId(id);
+        return identity?.boardId !== topology.id || identity?.layout !== topology.layout;
+      }))
+        ctx.addIssue({
+          code: "custom",
+          path: [kind, index],
+          message: "World element identity must match its board and layout."
+        });
+    }
+  }
+}
+var BoardTopologySchema = z6.discriminatedUnion("layout", [
+  GenericBoardTopologySchema,
+  HexBoardTopologySchema,
+  SquareBoardTopologySchema
+]).superRefine(validateTopologyGraph);
+var BoardTopologyMapSchema = identityRecord(BoardTopologySchema);
+
+// src/shared/domain/player-identity.ts
+import * as z7 from "zod";
+function isPlayerIdValue(value) {
+  return typeof value === "string" && value.length > 0 && value !== "__proto__";
+}
+var PlayerIdSchema = z7.string().min(1).refine((value) => isPlayerIdValue(value), {
+  error: "Player id '__proto__' is reserved for record/parser interoperability."
+});
+var PlayerRosterSchema = z7.array(PlayerIdSchema).refine((ids) => new Set(ids).size === ids.length, {
+  error: "Duplicate player id"
+});
+
+// src/shared/domain/seat-reference.ts
+import * as z8 from "zod";
+var SeatTileRefSchema = z8.string().regex(/^tile-ref:sha256:[0-9a-f]{64}$/).brand();
+var SeatSpaceRefSchema = z8.string().regex(/^space-ref:sha256:[0-9a-f]{64}$/).brand();
+
+// src/shared/tile-appearance.ts
+function coordinate3(value) {
+  if (!Number.isSafeInteger(value) || Math.abs(value) > MAXIMUM_BOARD_COORDINATE)
+    throw new Error(
+      "Public tile footprint exceeds the board coordinate domain."
+    );
+  return value === 0 ? 0 : value;
+}
+function getPublicTileFootprint(appearance, placement2) {
+  if (appearance.layout === "hex" && placement2.layout === "hex")
+    return {
+      layout: "hex",
+      cells: appearance.cells.map((cell2) => {
+        const rotated = rotateHex(cell2.q, cell2.r, placement2.rotation);
+        return {
+          q: coordinate3(rotated.q + placement2.q),
+          r: coordinate3(rotated.r + placement2.r)
+        };
+      })
+    };
+  if (appearance.layout === "square" && placement2.layout === "square")
+    return {
+      layout: "square",
+      cells: appearance.cells.map((cell2) => {
+        const rotated = rotateSquare(cell2.col, cell2.row, placement2.rotation);
+        return {
+          col: coordinate3(rotated.col + placement2.col),
+          row: coordinate3(rotated.row + placement2.row)
+        };
+      })
+    };
+  throw new Error(
+    "Tile public appearance must match its board placement layout."
+  );
+}
+
+// src/shared/seat-topology-schema.ts
+import * as z11 from "zod";
+
+// src/shared/domain/tile-disclosure.ts
+import * as z9 from "zod";
+var coordinate4 = z9.int().min(-MAXIMUM_BOARD_COORDINATE).max(MAXIMUM_BOARD_COORDINATE);
+var backImage = z9.string().regex(
+  /^assets\/(?:[\w-][\w.-]*\/)*[\w-][\w.-]*\.(?:avif|gif|jpe?g|png|svg|webp)$/i,
+  { error: "Tile back image must be an image path under assets/." }
+);
+var PublicTileAppearanceSchema = z9.discriminatedUnion("layout", [
+  z9.strictObject({
+    layout: z9.literal("hex"),
+    cells: z9.array(z9.strictObject({ q: coordinate4, r: coordinate4 })).nonempty(),
+    backImage: backImage.optional()
+  }),
+  z9.strictObject({
+    layout: z9.literal("square"),
+    cells: z9.array(z9.strictObject({ col: coordinate4, row: coordinate4 })).nonempty(),
+    backImage: backImage.optional()
+  })
+]).superRefine((appearance, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, cell2] of appearance.cells.entries()) {
+    const key = "q" in cell2 ? `${cell2.q},${cell2.r}` : `${cell2.col},${cell2.row}`;
+    if (seen.has(key))
+      ctx.addIssue({
+        code: "custom",
+        path: ["cells", index],
+        message: "Public footprint coordinates must be unique."
+      });
+    seen.add(key);
+  }
+});
+var publicFace = z9.strictObject({ audience: z9.literal("public") });
+var ownerFace = z9.strictObject({ audience: z9.literal("owner") });
+var noFace = z9.strictObject({ audience: z9.literal("none") });
+var AuthoredTileFaceAudienceSchema = z9.discriminatedUnion("audience", [
+  publicFace,
+  ownerFace,
+  noFace
+]);
+var TileFaceAudienceSchema = z9.discriminatedUnion("audience", [
+  publicFace,
+  ownerFace,
+  noFace,
+  z9.strictObject({
+    audience: z9.literal("seats"),
+    playerIds: z9.array(PlayerIdSchema).nonempty()
+  }).superRefine((face, ctx) => {
+    if (new Set(face.playerIds).size !== face.playerIds.length)
+      ctx.addIssue({
+        code: "custom",
+        path: ["playerIds"],
+        message: "Face audience seats must be unique."
+      });
+  })
+]);
+var AuthoredTileDisclosureSchema = z9.strictObject({
+  face: AuthoredTileFaceAudienceSchema,
+  appearance: PublicTileAppearanceSchema.optional()
+});
+var TileDisclosureSchema = z9.strictObject({
+  face: TileFaceAudienceSchema,
+  appearance: PublicTileAppearanceSchema.optional()
+});
+
+// src/shared/domain/tile-placement.ts
+import * as z10 from "zod";
+var coordinate5 = z10.number().int().min(-MAXIMUM_BOARD_COORDINATE).max(MAXIMUM_BOARD_COORDINATE);
+var TilePlacementSchema = z10.discriminatedUnion("layout", [
+  z10.strictObject({
+    type: z10.literal("OnBoard"),
+    layout: z10.literal("hex"),
+    boardId: z10.string().min(1),
+    q: coordinate5,
+    r: coordinate5,
+    rotation: z10.union([
+      z10.literal(0),
+      z10.literal(1),
+      z10.literal(2),
+      z10.literal(3),
+      z10.literal(4),
+      z10.literal(5)
+    ])
+  }),
+  z10.strictObject({
+    type: z10.literal("OnBoard"),
+    layout: z10.literal("square"),
+    boardId: z10.string().min(1),
+    col: coordinate5,
+    row: coordinate5,
+    rotation: z10.union([z10.literal(0), z10.literal(1), z10.literal(2), z10.literal(3)])
+  })
+]);
+
+// src/shared/seat-topology-schema.ts
+var coordinate6 = z11.int().min(-MAXIMUM_BOARD_COORDINATE).max(MAXIMUM_BOARD_COORDINATE);
+var fields2 = z11.record(z11.string(), RuntimeJsonSchema);
+var ProjectedTileSchema = z11.discriminatedUnion("disclosure", [
+  z11.strictObject({
+    disclosure: z11.literal("visible"),
+    ref: SeatTileRefSchema,
+    tileTypeId: z11.string().min(1),
+    name: z11.string(),
+    frontImage: z11.string().optional(),
+    ownerId: z11.string().min(1).nullable(),
+    fields: fields2,
+    properties: fields2
+  }),
+  z11.strictObject({
+    disclosure: z11.literal("concealed"),
+    ref: SeatTileRefSchema,
+    appearance: PublicTileAppearanceSchema
+  })
+]);
+var placement = z11.discriminatedUnion("layout", [
+  TilePlacementSchema.options[0].omit({ type: true, boardId: true }),
+  TilePlacementSchema.options[1].omit({ type: true, boardId: true })
+]);
+var placedTile = z11.discriminatedUnion("disclosure", [
+  ProjectedTileSchema.options[0].extend({ placement }),
+  ProjectedTileSchema.options[1].extend({ placement })
+]);
+var cell = BoardSpaceSchema.extend({
+  id: SeatSpaceRefSchema,
+  tileRef: SeatTileRefSchema,
+  localCellId: z11.string().min(1)
+});
+var SeatHexSpaceSchema = cell.extend({ q: coordinate6, r: coordinate6 });
+var SeatSquareSpaceSchema = cell.extend({
+  col: coordinate6,
+  row: coordinate6
+});
+var SeatBoardTopologySchema = z11.discriminatedUnion("layout", [
+  GenericBoardTopologySchema,
+  HexBoardTopologySchema.extend({
+    spaces: identityRecord(SeatHexSpaceSchema),
+    tiles: z11.array(placedTile)
+  }),
+  SquareBoardTopologySchema.extend({
+    spaces: identityRecord(SeatSquareSpaceSchema),
+    tiles: z11.array(placedTile)
+  })
+]).superRefine((board2, ctx) => {
+  validateTopologyGraph(board2, ctx);
+  if (board2.layout === "generic") return;
+  const tiles = new Map(board2.tiles.map((tile) => [tile.ref, tile]));
+  if (tiles.size !== board2.tiles.length)
+    ctx.addIssue({
+      code: "custom",
+      path: ["tiles"],
+      message: "Tile references must be unique."
+    });
+  for (const [index, tile] of board2.tiles.entries()) {
+    if (tile.placement.layout !== board2.layout || tile.disclosure === "concealed" && tile.appearance.layout !== board2.layout)
+      ctx.addIssue({
+        code: "custom",
+        path: ["tiles", index],
+        message: "Tile presentation must match its board layout."
+      });
+  }
+  for (const [index, tile] of board2.tiles.entries()) {
+    if (tile.disclosure !== "concealed") continue;
+    try {
+      getPublicTileFootprint(tile.appearance, tile.placement);
+    } catch (error) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["tiles", index, "appearance"],
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  const cellsByTile = /* @__PURE__ */ new Map();
+  for (const [id, space] of Object.entries(board2.spaces)) {
+    const cells = cellsByTile.get(space.tileRef) ?? /* @__PURE__ */ new Set();
+    if (cells.has(space.localCellId))
+      ctx.addIssue({
+        code: "custom",
+        path: ["spaces", id],
+        message: "A visible tile cell may be projected only once."
+      });
+    cells.add(space.localCellId);
+    cellsByTile.set(space.tileRef, cells);
+    if (tiles.get(space.tileRef)?.disclosure !== "visible")
+      ctx.addIssue({
+        code: "custom",
+        path: ["spaces", id],
+        message: "A projected cell must belong to a visible tile."
+      });
+  }
+  for (const [index, tile] of board2.tiles.entries())
+    if (tile.disclosure === "visible" && !cellsByTile.get(tile.ref)?.size)
+      ctx.addIssue({
+        code: "custom",
+        path: ["tiles", index],
+        message: "A visible tile requires at least one projected cell."
+      });
+});
+var BoardProjectionSchema = identityRecord(SeatBoardTopologySchema);
+
+// src/shared/lookup.ts
+function requireLookup(value, kind, id) {
+  if (value === void 0) throw new Error(`${kind} "${id}" is not present.`);
+  return value;
+}
+
+// src/shared/board-target.ts
+import * as z12 from "zod";
+var BoardSpaceTargetSchema = z12.strictObject({
+  boardId: z12.string(),
+  spaceId: z12.string()
+});
+function isBoardSpaceTarget(value) {
+  return typeof value === "object" && value !== null && Object.keys(value).length === 2 && "boardId" in value && typeof value.boardId === "string" && "spaceId" in value && typeof value.spaceId === "string";
+}
+function sameBoardSpaceTarget(left, right) {
+  return left.boardId === right.boardId && left.spaceId === right.spaceId;
+}
+
+// src/shared/input-domain.ts
+function inputDomainErrors(domain, value, selection, options = {}) {
+  if (selection?.mode === "many") {
+    if (!Array.isArray(value)) return ["Expected a list of values."];
+    const errors = cardinalityErrors(
+      value,
+      selection.min,
+      selection.max,
+      "value",
+      options.ignoreMinimum
+    );
+    if (selection.distinct && new Set(value.map(inputValueKey)).size !== value.length)
+      errors.push("Choose each value only once.");
+    if (value.some(
+      (item) => inputDomainErrors(domain, item, void 0, options).length > 0
+    ))
+      errors.push(ineligibleMessage(domain));
+    return errors;
+  }
+  switch (domain.type) {
+    case "choice":
+      return inputTargetInDomain(domain, value) ? [] : [ineligibleMessage(domain)];
+    case "choiceList": {
+      if (!Array.isArray(value)) return ["Expected a list of choices."];
+      const errors = cardinalityErrors(
+        value,
+        domain.min ?? 0,
+        domain.max ?? domain.choices.length,
+        "option",
+        options.ignoreMinimum
+      );
+      if (value.some((item) => !inputTargetInDomain(domain, item)))
+        errors.push(ineligibleMessage(domain));
+      return errors;
+    }
+    case "tileTarget":
+    case "cardTarget":
+    case "boardTarget":
+    case "zonePosition":
+      return inputTargetInDomain(domain, value) ? [] : [ineligibleMessage(domain)];
+    case "boundedNumber":
+      return typeof value === "number" && value >= domain.min && value <= domain.max && Math.abs(
+        (value - domain.min) / (domain.step ?? 1) - Math.round((value - domain.min) / (domain.step ?? 1))
+      ) < 1e-9 ? [] : ["Value is outside the current input domain."];
+    case "resourceMap":
+      return typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).every(
+        (key) => domain.resources.some((entry) => entry.resourceId === key)
+      ) && domain.resources.every((entry) => {
+        const amount = value[entry.resourceId] ?? 0;
+        return typeof amount === "number" && Number.isInteger(amount) && amount >= (entry.min ?? 0) && amount <= (entry.max ?? Infinity);
+      }) ? [] : ["Value is outside the current input domain."];
+  }
+}
+function inputValueInDomain(domain, value, selection, options = {}) {
+  return inputDomainErrors(domain, value, selection, options).length === 0;
+}
+function inputTargetInDomain(domain, value) {
+  switch (domain.type) {
+    case "choice":
+    case "choiceList":
+      return domain.choices.some(
+        (choice) => !choice.disabled && Object.is(choice.value, value)
+      );
+    case "tileTarget":
+    case "cardTarget":
+      return typeof value === "string" && domain.eligibleTargets.includes(value);
+    case "boardTarget":
+      return domain.valueKind === "board-space" ? isBoardSpaceTarget(value) && domain.eligibleTargets.some(
+        (candidate) => sameBoardSpaceTarget(candidate, value)
+      ) : typeof value === "string" && domain.eligibleTargets.includes(value);
+    case "zonePosition":
+      return isPositionTarget(value) && domain.zones.some(
+        (zone) => zone.zoneId === value.zoneId && zone.hostId === value.hostId && value.index <= zone.size
+      );
+    default:
+      return inputValueInDomain(domain, value);
+  }
+}
+function cardinalityErrors(value, min, max, unit, ignoreMinimum = false) {
+  const errors = [];
+  if (!ignoreMinimum && value.length < min)
+    errors.push(`Choose at least ${min} ${pluralize(unit, min)}.`);
+  if (max !== void 0 && value.length > max)
+    errors.push(`Choose at most ${max} ${pluralize(unit, max)}.`);
+  return errors;
+}
+function ineligibleMessage(domain) {
+  return domain.type === "choice" || domain.type === "choiceList" ? "Selected choice is not eligible." : domain.type === "cardTarget" || domain.type === "tileTarget" || domain.type === "boardTarget" || domain.type === "zonePosition" ? "Selected target is not eligible." : "Value is outside the current input domain.";
+}
+function inputValueKey(value) {
+  if (value === null) return "null";
+  if (isBoardSpaceTarget(value))
+    return `board-space:${JSON.stringify([value.boardId, value.spaceId])}`;
+  if (isPositionTarget(value))
+    return `position:${JSON.stringify([value.zoneId, value.hostId, value.index])}`;
+  switch (typeof value) {
+    case "string":
+      return `string:${value}`;
+    case "number":
+    case "boolean":
+    case "undefined":
+      return `${typeof value}:${String(value)}`;
+    default:
+      return `json:${JSON.stringify(value)}`;
+  }
+}
+function pluralize(word, count) {
+  return count === 1 ? word : `${word}s`;
+}
+
+export {
+  __export,
+  PositionTargetSchema,
+  isPositionTarget,
+  zonePositions,
+  immutableCopy,
+  GENERATED_ID_PREFIX,
+  perPlayerInstanceId,
+  parsePerPlayerInstanceId,
+  perPlayerInstanceSchema,
+  boardEdgeId,
+  boardVertexId,
+  parseBoardElementId,
+  tileSpaceId,
+  parseTileSpaceId,
+  MAXIMUM_BOARD_COORDINATE,
+  createHexTopology,
+  createHexTopologyCache,
+  RuntimeJsonSchema,
+  canonicalizePluginRuntimeJson,
+  encodeCanonicalPluginRuntimeJson,
+  digestPluginRuntimeJson,
+  BoardTopologyError,
+  deriveBoardTopology,
+  createBoardTopologyCache,
+  getPublicTileFootprint,
+  BoardRelationSchema,
+  isPlayerIdValue,
+  PlayerIdSchema,
+  PlayerRosterSchema,
+  AuthoredTileDisclosureSchema,
+  TileDisclosureSchema,
+  SeatTileRefSchema,
+  SeatSpaceRefSchema,
+  TilePlacementSchema,
+  ProjectedTileSchema,
+  SeatBoardTopologySchema,
+  BoardProjectionSchema,
+  requireLookup,
+  BoardSpaceTargetSchema,
+  isBoardSpaceTarget,
+  sameBoardSpaceTarget,
+  inputDomainErrors,
+  inputValueInDomain,
+  inputTargetInDomain,
+  inputValueKey
+};
+//# sourceMappingURL=chunk-CZRPUWCT.js.map