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

package/dist/index.js

@@ -1,12 +1,1996 @@
 import {
-  DREAMBOARD_SDK_PACKAGES,
-  DREAMBOARD_SDK_PACKAGE_SET,
-  DREAMBOARD_SDK_VERSION
-} from "./chunk-Y75CFE77.js";
-import "./chunk-PZ5AY32C.js";
+  AmbiguousTargetError,
+  GESTURE_THRESHOLDS,
+  createGameInstance,
+  createGestureRecognizer,
+  isSameDropTarget,
+  magneticDropPoint,
+  runtimeFeatures
+} from "./chunk-3RFGPBES.js";
+import {
+  CancelInteractionCommandSchema,
+  DREAMBOARD_PLUGIN_PROTOCOL,
+  DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
+  GameEventDetailSchema,
+  GameEventSchema,
+  GameOutcomeSchema,
+  GameplayBasisSchema,
+  HostToPluginEnvelopeSchema,
+  HostToPluginPayloadSchema,
+  InteractionResultSchema,
+  PluginGameplayFrameSchema,
+  PluginPlayerSummarySchema,
+  PluginSessionDescriptorSchema,
+  PluginToHostEnvelopeSchema,
+  PluginToHostPayloadSchema,
+  SeatFrameSchema,
+  SeatProjectionBundleSchema,
+  SimultaneousPhaseSnapshotSchema,
+  SubmitInteractionCommandSchema,
+  SystemActionEventSchema,
+  ZoneHandlesSnapshotSchema,
+  computePluginActionSetVersion,
+  createPluginProtocolEnvelopeSchema,
+  createSourceLifecycle,
+  digestPluginCommandRequest,
+  digestPluginGameplayFrame,
+  materializePluginGameplayFrame,
+  parseHostToPluginEnvelope,
+  parsePluginGameplayFrame,
+  parsePluginSessionDescriptor,
+  parsePluginToHostEnvelope,
+  staticSource
+} from "./chunk-YT3RPO5J.js";
+import {
+  InputDomainSchema,
+  InteractionAvailabilitySchema,
+  InteractionCommitPolicySchema,
+  InteractionDescriptorSchema,
+  InteractionInputDescriptorSchema,
+  ViewCardSchema,
+  boardSpaceHostId,
+  isHiddenCardId,
+  parseBoardSpaceHostId
+} from "./chunk-U6R7FAH4.js";
+import {
+  RuntimeJsonSchema,
+  SeatBoardTopologySchema,
+  boardEdgeId,
+  boardVertexId,
+  canonicalizePluginRuntimeJson,
+  createHexTopology,
+  createHexTopologyCache,
+  digestPluginRuntimeJson,
+  encodeCanonicalPluginRuntimeJson,
+  getPublicTileFootprint,
+  immutableCopy,
+  inputValueInDomain,
+  parseBoardElementId,
+  parsePerPlayerInstanceId,
+  perPlayerInstanceId,
+  requireLookup,
+  zonePositions
+} from "./chunk-CZRPUWCT.js";
+
+// src/package-set.ts
+var DREAMBOARD_SDK_VERSION = true ? "0.5.0-alpha.21" : "0.0.0-development";
+var DREAMBOARD_SDK_PACKAGES = {
+  "@dreamboard-games/sdk": DREAMBOARD_SDK_VERSION
+};
+var DREAMBOARD_SDK_PACKAGE_SET = {
+  version: 1,
+  sdkVersion: DREAMBOARD_SDK_VERSION,
+  packages: DREAMBOARD_SDK_PACKAGES
+};
+
+// src/headless/sources/iframe.ts
+function iframeSource(options = {}) {
+  const target = window;
+  const parent = target.parent;
+  let channel = null;
+  let sequence = 0;
+  let receivedSequence = -1;
+  const send = (payload) => {
+    if (!channel) throw new Error("Iframe source is not initialized.");
+    parent.postMessage(
+      {
+        protocol: DREAMBOARD_PLUGIN_PROTOCOL,
+        version: DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
+        channelId: channel.id,
+        sequence: ++sequence,
+        payload
+      },
+      channel.origin
+    );
+  };
+  const lifecycle = createSourceLifecycle({
+    timeoutMs: options.timeoutMs,
+    followHostSeat: options.followHostSeat,
+    send,
+    recover: () => send({ type: "runtime.resume" }),
+    close: () => target.removeEventListener("message", receive)
+  });
+  const isOpen = () => {
+    const { connection } = lifecycle.source.store.get();
+    return connection !== "closed" && connection !== "failed";
+  };
+  function receive(event) {
+    if (event.source !== parent) return;
+    const parsed = HostToPluginEnvelopeSchema.safeParse(event.data);
+    if (!parsed.success) {
+      const data = event.data;
+      if (channel && event.origin === channel.origin && typeof data === "object" && data !== null && "channelId" in data && data.channelId === channel.id) {
+        try {
+          send({
+            type: "runtime.error",
+            code: "host-runtime-protocol-mismatch",
+            message: "Iframe source received an invalid host envelope."
+          });
+        } finally {
+          lifecycle.fail(new Error("Invalid iframe host envelope."));
+        }
+      }
+      return;
+    }
+    const envelope = parsed.data;
+    if (!channel) {
+      if (envelope.payload.type !== "runtime.init") return;
+      channel = { id: envelope.channelId, origin: event.origin };
+    }
+    if (channel.id !== envelope.channelId || channel.origin !== event.origin || envelope.sequence <= receivedSequence)
+      return;
+    receivedSequence = envelope.sequence;
+    const payload = envelope.payload;
+    if (payload.type === "runtime.init") {
+      lifecycle.session(payload.session);
+      if (isOpen()) send({ type: "runtime.ready" });
+    } else if (payload.type === "gameplay.frame")
+      lifecycle.frame(payload.frame);
+    else lifecycle.result(payload);
+    if (isOpen()) send({ type: "runtime.ack", sequence: envelope.sequence });
+  }
+  target.addEventListener("message", receive);
+  return lifecycle.source;
+}
+
+// src/shared/protocol/gameplay-wire.ts
+import * as z from "zod";
+var GameplayCloseCode = {
+  GoingAway: 1001,
+  CredentialExpired: 4e3,
+  CredentialInvalid: 4001,
+  RefreshContextMismatch: 4002,
+  PermissionDenied: 4100,
+  ProtocolViolation: 4200,
+  FrameBeforeAuth: 4201,
+  SlowConsumer: 4300,
+  TooManyRequests: 4301
+};
+var GameplayCredentialSchema = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("user"), token: z.string().min(1).max(16384) }).strict(),
+  z.object({ kind: z.literal("demo"), secret: z.string().min(1).max(1024) }).strict()
+]);
+var AuthConnectFrameSchema = z.object({
+  type: z.literal("auth.connect"),
+  credential: GameplayCredentialSchema,
+  sessionId: z.string().uuid(),
+  playerId: z.string().min(1).max(128)
+}).strict();
+var AuthRefreshFrameSchema = z.object({
+  type: z.literal("auth.refresh"),
+  credential: GameplayCredentialSchema
+}).strict();
+var SessionResumeFrameSchema = z.object({
+  type: z.literal("session.resume"),
+  lastSeenLogCursor: z.number().int().nonnegative().nullable(),
+  unacknowledgedClientActionIds: z.array(z.string().min(1)).max(32)
+});
+var AuthAcceptedFrameSchema = z.object({
+  type: z.literal("auth.accepted"),
+  expiresAt: z.string().datetime()
+});
+var GameplayBackpressureReasonSchema = z.enum([
+  "queue_full",
+  "capacity_full"
+]);
+var GameplayBackpressureOperationSchema = z.enum([
+  "session.resume",
+  "interaction.submit",
+  "interaction.cancel"
+]);
+var GameplayBackpressureFrameSchema = z.object({
+  type: z.literal("gameplay.backpressure"),
+  reason: GameplayBackpressureReasonSchema,
+  retryAfterMs: z.number().int().positive(),
+  message: z.string().min(1),
+  operation: GameplayBackpressureOperationSchema,
+  clientActionId: z.string().min(1).optional()
+});
+var SessionSnapshotFrameSchema = z.object({
+  type: z.literal("session.snapshot"),
+  frame: PluginGameplayFrameSchema
+});
+var ClientGameplayFrameSchema = z.discriminatedUnion("type", [
+  AuthConnectFrameSchema,
+  AuthRefreshFrameSchema,
+  SessionResumeFrameSchema,
+  SubmitInteractionCommandSchema,
+  CancelInteractionCommandSchema
+]);
+var ServerGameplayFrameSchema = z.discriminatedUnion("type", [
+  AuthAcceptedFrameSchema,
+  GameplayBackpressureFrameSchema,
+  SessionSnapshotFrameSchema,
+  InteractionResultSchema
+]);
+
+// src/headless/sources/host-websocket.ts
+function hostSource(options) {
+  const { url, playerId, getCredential } = options;
+  const sessionId = options.session.sessionId;
+  let socket = null;
+  let generation = 0;
+  let disposed = false;
+  let authenticated = false;
+  let queued = null;
+  let reconnects = 0;
+  let refreshTimer;
+  let snapshotTimer;
+  let openTimer;
+  let cleanup = () => {
+  };
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const send = (frame) => {
+    if (!socket || socket.readyState !== WebSocket.OPEN)
+      throw new Error("Gameplay socket is not open.");
+    socket.send(JSON.stringify(ClientGameplayFrameSchema.parse(frame)));
+  };
+  const resume = () => send({
+    type: "session.resume",
+    lastSeenLogCursor: null,
+    unacknowledgedClientActionIds: queued ? [queued.clientActionId] : []
+  });
+  const lifecycle = createSourceLifecycle({
+    context: {
+      sessionId,
+      playerId
+    },
+    timeoutMs,
+    send(command) {
+      if (!authenticated) {
+        queued = command;
+        return;
+      }
+      send(command);
+    },
+    recover() {
+      if (authenticated) resume();
+      else if (!openTimer) void connect();
+    },
+    close() {
+      disposed = true;
+      generation++;
+      clearTimeout(refreshTimer);
+      clearTimeout(openTimer);
+      clearTimeout(snapshotTimer);
+      cleanup();
+      socket?.close();
+      socket = null;
+      queued = null;
+    }
+  });
+  lifecycle.session(options.session);
+  async function connect() {
+    if (disposed) return;
+    const current = ++generation;
+    authenticated = false;
+    clearTimeout(refreshTimer);
+    clearTimeout(openTimer);
+    clearTimeout(snapshotTimer);
+    cleanup();
+    socket?.close();
+    socket = null;
+    openTimer = setTimeout(
+      () => lifecycle.fail(new Error("Gameplay socket authentication timed out.")),
+      timeoutMs
+    );
+    try {
+      const credential = await getCredential();
+      if (disposed || current !== generation) return;
+      const next = new WebSocket(url);
+      socket = next;
+      const active = () => !disposed && current === generation;
+      const onOpen = () => {
+        if (!active()) return;
+        try {
+          send({
+            type: "auth.connect",
+            credential,
+            sessionId,
+            playerId
+          });
+        } catch (error) {
+          lifecycle.fail(asError(error));
+        }
+      };
+      const onMessage = (event) => {
+        if (!active()) return;
+        try {
+          const value = JSON.parse(String(event.data));
+          if (typeof value !== "object" || value === null || !("type" in value))
+            throw new Error("Invalid gameplay frame.");
+          if (![
+            "auth.accepted",
+            "session.snapshot",
+            "interaction.result",
+            "gameplay.backpressure"
+          ].includes(String(value.type)))
+            return;
+          const frame = ServerGameplayFrameSchema.parse(value);
+          if (frame.type === "auth.accepted") {
+            clearTimeout(openTimer);
+            openTimer = void 0;
+            const first = !authenticated;
+            authenticated = true;
+            if (first) {
+              snapshotTimer = setTimeout(
+                () => lifecycle.fail(new Error("Gameplay snapshot timed out.")),
+                timeoutMs
+              );
+              resume();
+              if (queued) {
+                send(queued);
+                queued = null;
+              }
+            }
+            clearTimeout(refreshTimer);
+            if (credential.kind === "user") {
+              const ttl = Date.parse(frame.expiresAt) - Date.now();
+              if (ttl <= 0)
+                throw new Error("Gameplay credential is already expired.");
+              refreshTimer = setTimeout(
+                () => {
+                  openTimer = setTimeout(
+                    () => lifecycle.fail(
+                      new Error("Gameplay credential refresh timed out.")
+                    ),
+                    timeoutMs
+                  );
+                  void getCredential().then((updated) => {
+                    if (active())
+                      send({ type: "auth.refresh", credential: updated });
+                  }).catch((error) => {
+                    if (active()) lifecycle.fail(asError(error));
+                  });
+                },
+                Math.max(0, ttl - Math.min(6e4, ttl * 0.2))
+              );
+            }
+          } else if (!authenticated)
+            throw new Error("Gameplay frame arrived before authentication.");
+          else if (frame.type === "session.snapshot") {
+            clearTimeout(snapshotTimer);
+            snapshotTimer = void 0;
+            reconnects = 0;
+            lifecycle.frame(frame.frame);
+          } else if (frame.type === "interaction.result")
+            lifecycle.result(frame);
+          else lifecycle.fail(new Error(frame.message));
+        } catch (error) {
+          lifecycle.fail(asError(error));
+        }
+      };
+      const onClose = (event) => {
+        if (!active()) return;
+        authenticated = false;
+        lifecycle.recovering();
+        if ((/* @__PURE__ */ new Set([
+          GameplayCloseCode.CredentialInvalid,
+          GameplayCloseCode.RefreshContextMismatch,
+          GameplayCloseCode.PermissionDenied,
+          GameplayCloseCode.ProtocolViolation,
+          GameplayCloseCode.FrameBeforeAuth
+        ])).has(event.code) || reconnects++ > 0) {
+          lifecycle.fail(new Error(`Gameplay socket closed (${event.code}).`));
+          return;
+        }
+        void connect();
+        lifecycle.retry();
+      };
+      const onError = () => {
+        if (active()) next.close();
+      };
+      next.addEventListener("open", onOpen);
+      next.addEventListener("message", onMessage);
+      next.addEventListener("close", onClose);
+      next.addEventListener("error", onError);
+      cleanup = () => {
+        next.removeEventListener("open", onOpen);
+        next.removeEventListener("message", onMessage);
+        next.removeEventListener("close", onClose);
+        next.removeEventListener("error", onError);
+      };
+    } catch (error) {
+      if (!disposed && current === generation) lifecycle.fail(asError(error));
+    }
+  }
+  void connect();
+  return lifecycle.source;
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// src/headless/features/shortcuts.ts
+import { createStore } from "@tanstack/store";
+function shortcutsFeature(_game, context) {
+  const game = context[runtimeFeatures].game;
+  const configuration = createStore(null);
+  let registration = null;
+  function bindings() {
+    return configuration.get()?.bindings ?? [];
+  }
+  let disposed = false;
+  function resolve(binding, key, target, activity) {
+    if (disposed || game.connection !== "ready") return null;
+    if (binding.kind === "local") {
+      if (!activity || activity.pointerActive) return null;
+      const focused = activity.focusedTarget;
+      const card = focused?.kind === "card" ? game.cards.find(focused.value) : void 0;
+      const zone = focused?.kind === "zone" ? focused : card ? { kind: "zone", zoneId: card.zone, hostId: card.hostId } : null;
+      if (!zone || zone.zoneId !== binding.zoneId || !game.zones.find(zone.zoneId, zone.hostId))
+        return null;
+      const action = { key, target: zone };
+      return binding.getIsAvailable?.(action) === false ? null : { kind: "local", binding, action };
+    }
+    if (!target || game.request || target.kind !== binding.target) return null;
+    const routes = target.kind === "card" ? game.cards.find(target.value)?.getInteractions() ?? [] : game.interactions.list();
+    const interaction = routes.find((item) => item.key === binding.interaction);
+    if (!interaction || interaction.getStatus() !== "open") return null;
+    if (target.kind === "zone") {
+      if (target.zoneId !== binding.zoneId || !game.zones.find(target.zoneId, target.hostId))
+        return null;
+    } else {
+      const input = interaction.getInputs().find((item) => item.key === binding.input);
+      if (!input || !input.getIsEligible(target.value)) return null;
+      const domain = input.getDomain();
+      if (target.kind === "card" && input.kind !== "card") return null;
+      if (target.kind === "tile" && input.kind !== "tile") return null;
+      if (target.kind === "space" || target.kind === "edge" || target.kind === "vertex") {
+        if (domain.type !== "boardTarget" || domain.targetKind !== target.kind || domain.valueKind !== target.valueKind)
+          return null;
+        if (domain.valueKind === "board-id" && target.valueKind === "board-id" && domain.boardId !== target.boardId)
+          return null;
+      }
+    }
+    const params = binding.inputs({ key, target });
+    return interaction.getIsAvailable(params) && interaction.getIsReady(params) ? { kind: "interaction", interaction, params } : null;
+  }
+  const controller = {
+    configuration,
+    register(options) {
+      if (registration)
+        throw new Error("Mount useGameShortcuts once per GameProvider.");
+      const owned = {};
+      registration = owned;
+      configuration.setState(() => options);
+      return {
+        update(options2) {
+          if (registration !== owned) return;
+          configuration.setState(() => options2);
+        },
+        dispose() {
+          if (registration !== owned) return;
+          registration = null;
+          configuration.setState(() => null);
+        }
+      };
+    },
+    handle(key, target, activity) {
+      const candidates = bindings().filter((binding) => binding.keys.includes(key)).flatMap((binding) => {
+        const resolved = resolve(binding, key, target, activity);
+        return resolved ? [resolved] : [];
+      });
+      if (candidates.length !== 1) return null;
+      const candidate = candidates[0];
+      if (candidate.kind === "interaction")
+        return candidate.interaction.submit(candidate.params).then((result) => ({ kind: "interaction", result }));
+      try {
+        return Promise.resolve(candidate.binding.run(candidate.action)).then(
+          () => ({ kind: "local" })
+        );
+      } catch (cause) {
+        return Promise.reject(cause);
+      }
+    },
+    getHints(target, activity) {
+      const eligible = bindings().map((binding) => ({
+        binding,
+        keys: binding.keys.filter(
+          (key) => resolve(binding, key, target, activity)
+        )
+      }));
+      const counts = /* @__PURE__ */ new Map();
+      for (const { keys } of eligible)
+        for (const key of new Set(keys))
+          counts.set(key, (counts.get(key) ?? 0) + 1);
+      return eligible.flatMap(({ binding, keys }) => {
+        const unique = [...new Set(keys)].filter(
+          (key) => counts.get(key) === 1
+        );
+        return unique.length ? [
+          {
+            keys: unique,
+            label: binding.label,
+            ...binding.kind === "interaction" ? {
+              kind: "interaction",
+              interaction: binding.interaction
+            } : { kind: "local" }
+          }
+        ] : [];
+      });
+    }
+  };
+  return {
+    root: { shortcuts: controller },
+    dispose() {
+      disposed = true;
+      registration = null;
+      configuration.setState(() => null);
+    }
+  };
+}
+
+// src/headless/features/hand.ts
+var seatCardId = (card) => card.id;
+function handFeature(game, context, options = {}) {
+  const zones = /* @__PURE__ */ new Map();
+  for (const [id, value] of Object.entries(options.zones ?? {})) {
+    if (value === void 0) continue;
+    const sorts = new Map(
+      Object.entries(value.sorts).map(([mode, sort]) => [mode, sort.compare])
+    );
+    const defaultSort = value.defaultSort ?? null;
+    if (defaultSort !== null && !sorts.has(defaultSort)) {
+      throw new Error(
+        `Unknown default hand sort "${defaultSort}" for zone "${id}".`
+      );
+    }
+    zones.set(id, {
+      modes: Object.freeze(Object.keys(value.sorts)),
+      defaultSort,
+      sorts
+    });
+  }
+  const keyOf = (zone) => JSON.stringify([zone.id, zone.hostId]);
+  let source = game.getOptions().source;
+  let seat = game.snapshot?.me;
+  let selected = /* @__PURE__ */ new Map();
+  let lifetime = {};
+  let disposed = false;
+  let branch = snapshot();
+  function syncLifetime() {
+    const nextSource = game.getOptions().source;
+    const nextSeat = game.snapshot?.me;
+    if (nextSource !== source || nextSeat !== seat) {
+      source = nextSource;
+      seat = nextSeat;
+      selected = /* @__PURE__ */ new Map();
+      lifetime = {};
+      branch = snapshot();
+    }
+  }
+  function snapshot() {
+    const captured = selected;
+    const capturedLifetime = lifetime;
+    const getMode = (zone) => captured.get(keyOf(zone)) ?? zones.get(zone.id)?.defaultSort ?? null;
+    return Object.freeze({
+      getSortModes(zone) {
+        return zones.get(zone.id)?.modes ?? Object.freeze([]);
+      },
+      getSortMode(zone) {
+        return getMode(zone);
+      },
+      setSortMode(zone, mode) {
+        syncLifetime();
+        if (disposed || lifetime !== capturedLifetime) return;
+        if (!zones.get(zone.id)?.sorts.has(mode)) return;
+        if ((selected.get(keyOf(zone)) ?? zones.get(zone.id)?.defaultSort ?? null) === mode)
+          return;
+        selected = new Map(selected).set(keyOf(zone), mode);
+        branch = snapshot();
+        context.invalidate();
+      },
+      getSortedCardIds(zone) {
+        const mode = getMode(zone);
+        const compare = mode === null ? void 0 : zones.get(zone.id)?.sorts.get(mode);
+        return Object.freeze(
+          zone.getCards({ sort: compare }).map(seatCardId)
+        );
+      }
+    });
+  }
+  return {
+    root: {
+      get hand() {
+        syncLifetime();
+        return branch;
+      }
+    },
+    zone: {
+      getSelectedCardIds() {
+        return this.getCards().filter((card) => card.getIsSelected()).map(seatCardId);
+      },
+      getSelectableCardIds() {
+        return this.getCards().filter((card) => card.getCanSelect()).map(seatCardId);
+      }
+    },
+    dispose() {
+      disposed = true;
+    }
+  };
+}
+
+// src/shared/tile-board-layout.ts
+function assertFinite(values) {
+  if (!values.every(Number.isFinite))
+    throw new Error("Derived tile layout geometry must be finite.");
+}
+var frozenPoint = (point) => {
+  assertFinite([point.x, point.y]);
+  return Object.freeze({ ...point });
+};
+function outlines(cells) {
+  const sides = /* @__PURE__ */ new Map();
+  for (const cell of cells) {
+    for (const [index, from] of cell.corners.entries()) {
+      const to = cell.corners[(index + 1) % cell.corners.length];
+      const key = [from.key, to.key].sort().join("|");
+      if (sides.has(key)) sides.delete(key);
+      else sides.set(key, { from, to });
+    }
+  }
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const side of sides.values()) {
+    const next = outgoing.get(side.from.key) ?? [];
+    next.push(side);
+    outgoing.set(side.from.key, next);
+  }
+  const loops = [];
+  while (sides.size) {
+    const first = sides.values().next().value;
+    const start = first.from.key;
+    let side = first;
+    const loop = [];
+    while (true) {
+      loop.push(frozenPoint(side.from.point));
+      sides.delete([side.from.key, side.to.key].sort().join("|"));
+      const remaining = outgoing.get(side.from.key);
+      remaining.splice(remaining.indexOf(side), 1);
+      if (side.to.key === start) break;
+      const candidates = [...outgoing.get(side.to.key) ?? []];
+      if (!candidates.length)
+        throw new Error("Tile footprint boundary is not closed.");
+      const angle = Math.atan2(
+        side.to.point.y - side.from.point.y,
+        side.to.point.x - side.from.point.x
+      );
+      const turn = (next) => {
+        const delta = Math.atan2(
+          next.to.point.y - next.from.point.y,
+          next.to.point.x - next.from.point.x
+        ) - angle;
+        return Math.atan2(Math.sin(delta), Math.cos(delta));
+      };
+      candidates.sort(
+        (a, b) => turn(b) - turn(a) || (a.to.key < b.to.key ? -1 : a.to.key > b.to.key ? 1 : 0)
+      );
+      side = candidates[0];
+    }
+    loops.push(Object.freeze(loop));
+  }
+  return Object.freeze(loops);
+}
+function hexCells(boardId, orientation, coordinates, size, origin) {
+  const topology = createHexTopology({
+    id: boardId,
+    orientation,
+    spaces: coordinates.map((coordinate, index) => ({
+      ...coordinate,
+      id: String(index)
+    }))
+  });
+  const layout = topology.getLayout({ hexSize: size, origin });
+  const vertices = new Map(
+    layout.vertices.map((vertex) => [vertex.id, vertex.center])
+  );
+  return layout.spaces.map((space) => ({
+    center: space.center,
+    corners: topology.verticesOf(space.id).map((key) => ({ key, point: vertices.get(key) })).sort(
+      (a, b) => Math.atan2(a.point.y - space.center.y, a.point.x - space.center.x) - Math.atan2(b.point.y - space.center.y, b.point.x - space.center.x)
+    )
+  }));
+}
+function squareCells(coordinates, size, origin) {
+  return coordinates.map(({ col, row }) => ({
+    center: {
+      x: origin.x + (col + 0.5) * size,
+      y: origin.y + (row + 0.5) * size
+    },
+    corners: [
+      [col, row],
+      [col + 1, row],
+      [col + 1, row + 1],
+      [col, row + 1]
+    ].map(([x, y]) => ({
+      key: `${x},${y}`,
+      point: { x: origin.x + x * size, y: origin.y + y * size }
+    }))
+  }));
+}
+function build(board, size, origin) {
+  if (board.layout === "generic")
+    throw new Error("Generic boards have no tile layout.");
+  const visibleByTile = /* @__PURE__ */ new Map();
+  const group = (spaces, cells) => {
+    spaces.forEach((space, index) => {
+      const grouped = visibleByTile.get(space.tileRef) ?? {
+        cells: [],
+        ids: []
+      };
+      grouped.cells.push(cells[index]);
+      grouped.ids.push(space.id);
+      visibleByTile.set(space.tileRef, grouped);
+    });
+  };
+  if (board.layout === "hex") {
+    const spaces = Object.values(board.spaces);
+    group(spaces, hexCells(board.id, board.orientation, spaces, size, origin));
+  } else {
+    const spaces = Object.values(board.spaces);
+    group(spaces, squareCells(spaces, size, origin));
+  }
+  const tiles = board.tiles.map((tile) => {
+    const visible = visibleByTile.get(tile.ref);
+    const footprint = tile.disclosure === "concealed" ? getPublicTileFootprint(tile.appearance, tile.placement) : null;
+    let cells;
+    let anchor;
+    if (board.layout === "hex" && tile.placement.layout === "hex") {
+      const placement = tile.placement;
+      cells = tile.disclosure === "visible" ? visible?.cells ?? [] : footprint?.layout === "hex" ? hexCells(
+        board.id,
+        board.orientation,
+        footprint.cells,
+        size,
+        origin
+      ) : [];
+      anchor = hexCells(
+        board.id,
+        board.orientation,
+        [{ q: placement.q, r: placement.r }],
+        size,
+        origin
+      )[0].center;
+    } else if (board.layout === "square" && tile.placement.layout === "square") {
+      const placement = tile.placement;
+      cells = tile.disclosure === "visible" ? visible?.cells ?? [] : footprint?.layout === "square" ? squareCells(footprint.cells, size, origin) : [];
+      anchor = squareCells(
+        [{ col: placement.col, row: placement.row }],
+        size,
+        origin
+      )[0].center;
+    } else throw new Error("Tile placement layout does not match board.");
+    if (!cells.length)
+      throw new Error("A projected tile requires a nonempty footprint.");
+    const center = {
+      x: cells.reduce((sum, cell) => sum + cell.center.x, 0) / cells.length,
+      y: cells.reduce((sum, cell) => sum + cell.center.y, 0) / cells.length
+    };
+    return Object.freeze({
+      ref: tile.ref,
+      data: tile,
+      spaceIds: Object.freeze(visible?.ids ?? []),
+      outlines: outlines(cells),
+      center: frozenPoint(center),
+      anchor: frozenPoint(anchor),
+      rotationDegrees: tile.placement.rotation * (board.layout === "hex" ? 60 : 90)
+    });
+  });
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const tile of tiles)
+    for (const loop of tile.outlines)
+      for (const point of loop) {
+        minX = Math.min(minX, point.x);
+        minY = Math.min(minY, point.y);
+        maxX = Math.max(maxX, point.x);
+        maxY = Math.max(maxY, point.y);
+      }
+  const viewBox = {
+    x: tiles.length ? minX : 0,
+    y: tiles.length ? minY : 0,
+    width: tiles.length ? maxX - minX : 0,
+    height: tiles.length ? maxY - minY : 0
+  };
+  assertFinite([viewBox.x, viewBox.y, viewBox.width, viewBox.height]);
+  return Object.freeze({
+    tiles: Object.freeze(tiles),
+    viewBox: Object.freeze(viewBox)
+  });
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function createTileBoardLayout(board, size, suppliedOrigin = { x: 0, y: 0 }) {
+  if (!Number.isFinite(size) || size <= 0)
+    throw new Error("Tile cell size must be positive and finite.");
+  if (![suppliedOrigin.x, suppliedOrigin.y].every(Number.isFinite))
+    throw new Error("Tile layout origin must be finite.");
+  const key = JSON.stringify([size, suppliedOrigin.x, suppliedOrigin.y]);
+  const cached = cache.get(board);
+  if (cached?.key === key) return cached.value;
+  const value = build(
+    immutableCopy(SeatBoardTopologySchema.parse(board)),
+    size,
+    {
+      ...suppliedOrigin
+    }
+  );
+  cache.set(board, { key, value });
+  return value;
+}
+
+// src/shared/square-board-layout.ts
+function createSquareBoardLayout(board, size, origin) {
+  if (!Number.isFinite(size) || size <= 0)
+    throw new Error("Square cell size must be positive and finite.");
+  if (![origin.x, origin.y].every(Number.isFinite))
+    throw new Error("Layout origin must be finite.");
+  const spaces = Object.values(board.spaces).map((space) => {
+    const x2 = origin.x + space.col * size;
+    const y2 = origin.y + space.row * size;
+    return {
+      id: space.id,
+      center: { x: x2 + size / 2, y: y2 + size / 2 },
+      corners: [
+        { x: x2, y: y2 },
+        { x: x2 + size, y: y2 },
+        { x: x2 + size, y: y2 + size },
+        { x: x2, y: y2 + size }
+      ]
+    };
+  });
+  const vertices = board.vertices.map((vertex) => {
+    const identity = parseBoardElementId(vertex.id);
+    if (!identity || identity.kind !== "vertex" || identity.layout !== "square" || identity.boardId !== board.id)
+      throw new Error(
+        `Square vertex '${vertex.id}' does not belong to board '${board.id}'.`
+      );
+    const [col, row] = identity.latticeId.split(",").map(Number);
+    return {
+      id: vertex.id,
+      center: { x: origin.x + col * size, y: origin.y + row * size }
+    };
+  });
+  const vertexPoints = new Map(
+    vertices.map((vertex) => [vertex.id, vertex.center])
+  );
+  const edges = board.edges.map((edge) => {
+    const from = vertexPoints.get(edge.vertexIds[0]);
+    const to = vertexPoints.get(edge.vertexIds[1]);
+    if (!from || !to)
+      throw new Error(`Square edge '${edge.id}' references a missing vertex.`);
+    return { id: edge.id, from, to };
+  });
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const space of spaces) {
+    for (const point of space.corners) {
+      minX = Math.min(minX, point.x);
+      minY = Math.min(minY, point.y);
+      maxX = Math.max(maxX, point.x);
+      maxY = Math.max(maxY, point.y);
+    }
+  }
+  const x = spaces.length ? minX : 0;
+  const y = spaces.length ? minY : 0;
+  return {
+    viewBox: {
+      x,
+      y,
+      width: spaces.length ? maxX - x : 0,
+      height: spaces.length ? maxY - y : 0
+    },
+    spaces,
+    edges,
+    vertices,
+    pointToSpace(point) {
+      const col = Math.floor((point.x - origin.x) / size);
+      const row = Math.floor((point.y - origin.y) / size);
+      return Object.values(board.spaces).find(
+        (space) => space.col === col && space.row === row
+      )?.id;
+    }
+  };
+}
+
+// src/headless/features/board.ts
+function createRuntimeBoardFeature(context) {
+  const game = context.game;
+  const captures = /* @__PURE__ */ new WeakMap();
+  const cachedHexTopology = createHexTopologyCache();
+  let cached;
+  function collection() {
+    const model = game.getSnapshot();
+    const source = game.getOptions().source;
+    const projectedBoards = context.getBoards();
+    if (cached && cached.view === model.view && cached.boards === projectedBoards && cached.interactions === model.interactions && cached.source === source)
+      return cached.collection;
+    const boards = Object.values(projectedBoards).map((data) => {
+      const board = context.createBoard(data);
+      const geometry = data.layout === "hex" ? cachedHexTopology({
+        id: data.id,
+        orientation: data.orientation,
+        spaces: Object.values(data.spaces)
+      }) : void 0;
+      captures.set(board, { model, source, geometry });
+      return board;
+    });
+    const byId = new Map(boards.map((board) => [board.id, board]));
+    const result = Object.freeze({
+      get: (id) => requireLookup(byId.get(id), "Board", id),
+      find: (id) => byId.get(id),
+      getAll: () => Object.freeze(boards)
+    });
+    cached = {
+      view: model.view,
+      boards: projectedBoards,
+      interactions: model.interactions,
+      source,
+      collection: result
+    };
+    return result;
+  }
+  function targetsFor(owner) {
+    const board = owner.data;
+    const captured = captures.get(owner);
+    function matchingTargets(model, kind, id) {
+      return model.interactions.list().flatMap(
+        (interaction) => interaction.getInputs().filter((input) => {
+          const domain = input.getDomain();
+          return domain.type === "boardTarget" && domain.targetKind === kind && (domain.valueKind === "board-space" ? board.scope === "perPlayer" && domain.boardBaseId === board.baseId : domain.boardId === board.id);
+        }).map((input) => {
+          const domain = input.getDomain();
+          return {
+            interaction,
+            input,
+            value: domain.type === "boardTarget" && domain.valueKind === "board-space" ? Object.freeze({
+              boardId: board.id,
+              spaceId: id
+            }) : id
+          };
+        })
+      );
+    }
+    function target(kind, id) {
+      const matches = matchingTargets(captured.model, kind, id);
+      const eligible = matches.some(
+        ({ input, value }) => input.getIsEligible(value)
+      );
+      const selected = matches.some(
+        ({ input, value }) => input.getIsSelected(value)
+      );
+      const selectable = matches.some(
+        ({ input, value }) => !input.getTargetProps(value).disabled
+      );
+      function select(options) {
+        if (game.getOptions().source !== captured.source || game.snapshot?.me !== captured.model.snapshot?.me)
+          return;
+        const matching = matchingTargets(game.getSnapshot(), kind, id).filter(
+          ({ interaction, input, value: value2 }) => (!options?.interaction || options.interaction === interaction.key) && (!options?.input || options.input === input.key) && !input.getTargetProps(value2).disabled
+        );
+        if (!matching.length) return;
+        if (matching.length > 1) throw new AmbiguousTargetError(id);
+        const domain = matching[0].input.getDomain();
+        if (domain.type !== "boardTarget") return;
+        const value = matching[0].value;
+        const target2 = domain.valueKind === "board-space" && typeof value !== "string" ? { kind: "space", valueKind: domain.valueKind, value } : {
+          kind,
+          valueKind: "board-id",
+          value: id,
+          boardId: board.id
+        };
+        context.routeTarget(target2, {
+          interaction: matching[0].interaction.key,
+          input: matching[0].input.key
+        });
+      }
+      return {
+        id,
+        getIsEligible: () => eligible,
+        getIsSelectable: () => selectable,
+        getIsSelected: () => selected,
+        getSelectHandler: (options) => () => select(options),
+        getTargetProps(options) {
+          const candidates = matches.filter(
+            ({ interaction, input, value }) => (!options?.interaction || interaction.key === options.interaction) && (!options?.input || options.input === input.key) && !input.getTargetProps(value).disabled
+          );
+          const only = candidates.length === 1 ? candidates[0] : void 0;
+          return {
+            type: "button",
+            disabled: candidates.length === 0,
+            "data-action": "select",
+            "data-value": only && typeof only.value !== "string" ? JSON.stringify(only.value) : id,
+            "data-board": board.id,
+            "data-interaction": options?.interaction ?? only?.interaction.key,
+            "data-input": only?.input.key,
+            "data-eligible": eligible,
+            "data-selected": selected,
+            "data-disabled": candidates.length === 0,
+            onClick: () => select(options)
+          };
+        }
+      };
+    }
+    return target;
+  }
+  const spaceCollections = /* @__PURE__ */ new WeakMap();
+  function spacesFor(owner) {
+    const cached2 = spaceCollections.get(owner);
+    if (cached2) return cached2;
+    const target = targetsFor(owner);
+    const data = owner.data;
+    const values = Object.freeze(
+      Object.values(data.spaces).map(
+        (space) => Object.freeze({
+          ...target("space", space.id),
+          data: space,
+          board: owner
+        })
+      )
+    );
+    const byId = new Map(values.map((space) => [space.id, space]));
+    const spaces = Object.freeze({
+      get: (id) => requireLookup(byId.get(id), `Space on board ${owner.id}`, id),
+      find: (id) => byId.get(id),
+      getAll: () => values
+    });
+    spaceCollections.set(owner, spaces);
+    return spaces;
+  }
+  return {
+    root: {
+      get boards() {
+        return collection();
+      }
+    },
+    board: {
+      get spaces() {
+        return spacesFor(this);
+      },
+      getLayout(options) {
+        const board = this.data;
+        if (board.layout === "generic")
+          throw new Error(
+            `Board '${board.id}' has no spatial geometry; use board.spaces for semantic selection.`
+          );
+        const {
+          hexSize,
+          origin: suppliedOrigin = { x: 0, y: 0 },
+          viewport: suppliedViewport = { x: 0, y: 0, scale: 1 }
+        } = options;
+        const origin = { ...suppliedOrigin };
+        const viewport = { ...suppliedViewport };
+        if (!Number.isFinite(hexSize) || hexSize <= 0)
+          throw new Error("hexSize must be positive and finite.");
+        if (![origin.x, origin.y, viewport.x, viewport.y, viewport.scale].every(
+          Number.isFinite
+        ) || viewport.scale <= 0)
+          throw new Error(
+            "Layout transform must be finite with positive scale."
+          );
+        const captured = captures.get(this);
+        const geometry = board.layout === "hex" ? captured.geometry.getLayout({ hexSize, origin }) : createSquareBoardLayout(board, hexSize, origin);
+        const point = (value) => {
+          const transformed = {
+            x: value.x * viewport.scale + viewport.x,
+            y: value.y * viewport.scale + viewport.y
+          };
+          if (![transformed.x, transformed.y].every(Number.isFinite))
+            throw new Error("Derived layout transform must be finite.");
+          return Object.freeze(transformed);
+        };
+        const tileGeometry = createTileBoardLayout(board, hexSize, origin);
+        const tiles = Object.freeze(
+          tileGeometry.tiles.map(
+            (tile) => Object.freeze({
+              ...tile,
+              center: point(tile.center),
+              anchor: point(tile.anchor),
+              outlines: Object.freeze(
+                tile.outlines.map((loop) => Object.freeze(loop.map(point)))
+              )
+            })
+          )
+        );
+        const target = targetsFor(this);
+        const semanticSpaces = spacesFor(this);
+        const spaces = Object.freeze(
+          geometry.spaces.map((space) => {
+            const corners = Object.freeze(space.corners.map(point));
+            const center = point(space.center);
+            return Object.freeze({
+              ...semanticSpaces.get(space.id),
+              center,
+              points: () => corners,
+              transform: `translate(${center.x} ${center.y})`
+            });
+          })
+        );
+        const edges = Object.freeze(
+          geometry.edges.map(
+            (edge) => Object.freeze({
+              ...target("edge", edge.id),
+              data: board.edges.find((data) => data.id === edge.id),
+              center: point({
+                x: (edge.from.x + edge.to.x) / 2,
+                y: (edge.from.y + edge.to.y) / 2
+              }),
+              line: Object.freeze([point(edge.from), point(edge.to)])
+            })
+          )
+        );
+        const vertices = Object.freeze(
+          geometry.vertices.map(
+            (vertex) => Object.freeze({
+              ...target("vertex", vertex.id),
+              data: board.vertices.find((data) => data.id === vertex.id),
+              center: point(vertex.center)
+            })
+          )
+        );
+        return Object.freeze({
+          viewBox: tileGeometry.viewBox,
+          getTiles: () => tiles,
+          getSpaces: () => spaces,
+          getEdges: () => edges,
+          getVertices: () => vertices,
+          pointToSpace(x, y) {
+            return geometry.pointToSpace({
+              x: (x - viewport.x) / viewport.scale,
+              y: (y - viewport.y) / viewport.scale
+            });
+          }
+        });
+      }
+    }
+  };
+}
+function boardFeature(_game, context) {
+  return createRuntimeBoardFeature(
+    context[runtimeFeatures]
+  );
+}
+
+// src/headless/features/drag.ts
+function createRuntimeDragFeature(context, getSelection) {
+  const game = context.game;
+  let active = null;
+  let selection;
+  let source = game.getOptions().source;
+  let seat = game.snapshot?.me;
+  let disposed = false;
+  let version = game.snapshot?.version;
+  let lastInteractions = game.interactions;
+  let lastCards = game.cards;
+  let branch = snapshot();
+  function update(next) {
+    if (disposed) return;
+    active = next === null ? null : Object.freeze(next);
+    branch = snapshot();
+    context.invalidate();
+  }
+  function targets(cardId = active?.cardId, selected = selection) {
+    if (!cardId || game.connection !== "ready") return [];
+    const options = selected;
+    const group = active?.cardId === cardId && active.group ? active.cardIds : getSelection?.(cardId, options);
+    const resolved = (game.cards.find(cardId)?.getInteractions() ?? []).flatMap(
+      (candidate) => {
+        if (!candidate.getIsAvailable() || options?.interaction && candidate.key !== options.interaction)
+          return [];
+        const inputs = candidate.getInputs();
+        const cardInputs = inputs.filter((input) => {
+          const domain = input.getDomain();
+          return domain.type === "cardTarget" && (!options?.input || input.key === options.input) && (group ? domain.selection?.mode === "many" && inputValueInDomain(domain, group, domain.selection) : input.getIsEligible(cardId));
+        });
+        const positions = cardInputs.flatMap(
+          (cardInput) => inputs.flatMap((input) => {
+            const domain = input.getDomain();
+            return domain.type === "zonePosition" ? zonePositions(domain.zones).filter((value) => !input.getTargetProps(value).disabled).map(
+              (value) => Object.freeze({
+                kind: "position",
+                interactionKey: candidate.key,
+                cardInputKey: cardInput.key,
+                inputKey: input.key,
+                value
+              })
+            ) : [];
+          })
+        );
+        if (!inputs.some((input) => input.getDomain().type === "boardTarget"))
+          return [
+            ...cardInputs.map(
+              (cardInput) => Object.freeze({
+                kind: "interaction",
+                interactionKey: candidate.key,
+                cardInputKey: cardInput.key
+              })
+            ),
+            ...positions
+          ];
+        const boardTargets = cardInputs.flatMap(
+          (cardInput) => inputs.flatMap((input) => {
+            const domain = input.getDomain();
+            if (domain.type !== "boardTarget") return [];
+            const route = {
+              interactionKey: candidate.key,
+              cardInputKey: cardInput.key,
+              inputKey: input.key
+            };
+            if (domain.valueKind === "board-space")
+              return domain.eligibleTargets.filter((value) => !input.getTargetProps(value).disabled).map(
+                (value) => Object.freeze({
+                  kind: "space",
+                  valueKind: domain.valueKind,
+                  value,
+                  ...route
+                })
+              );
+            return domain.eligibleTargets.filter((value) => !input.getTargetProps(value).disabled).map(
+              (value) => Object.freeze({
+                kind: domain.targetKind,
+                valueKind: domain.valueKind,
+                value,
+                boardId: domain.boardId,
+                ...route
+              })
+            );
+          })
+        );
+        return [...boardTargets, ...positions];
+      }
+    );
+    return resolved;
+  }
+  function isEligible(target) {
+    if (!active || disposed) return false;
+    const route = target.kind === "interaction" ? { ...target, params: void 0 } : target;
+    return targets().some((candidate) => isSameDropTarget(candidate, route)) && (active.group ? context.getCanDropCardGroup(active.cardIds, target) : context.getCanDropCard(active.cardId, target));
+  }
+  function cancel() {
+    if (active) update(null);
+  }
+  function snapshot() {
+    const captured = active;
+    const dropTargets = Object.freeze(targets());
+    return Object.freeze({
+      active: captured,
+      getCanDrag: (cardId, options) => !disposed && targets(cardId, options).length > 0,
+      begin(cardId, options) {
+        if (disposed || !targets(cardId, options).length) return false;
+        selection = options;
+        const selected = getSelection?.(cardId, options);
+        const cardIds = Object.freeze(selected ? [...selected] : [cardId]);
+        if (!cardIds.includes(cardId)) return false;
+        update({
+          cardId,
+          cardIds,
+          group: selected !== void 0,
+          target: null
+        });
+        return true;
+      },
+      getDropTargets: () => dropTargets,
+      getIsDropTarget: isEligible,
+      setDropTarget(target) {
+        if (!active || disposed) return;
+        if (target && !isEligible(target)) {
+          update({ ...active, target: null });
+          return;
+        }
+        update({ ...active, target });
+      },
+      drop() {
+        const finished = active;
+        const eligible = finished?.target && isEligible(finished.target);
+        cancel();
+        if (!disposed && finished?.target && eligible)
+          if (finished.group)
+            context.routeCardGroupDrop(finished.cardIds, finished.target);
+          else context.routeCardDrop(finished.cardId, finished.target);
+      },
+      cancel
+    });
+  }
+  const unsubscribe = game.subscribe(() => {
+    const nextSource = game.getOptions().source;
+    const nextSeat = game.snapshot?.me;
+    const nextVersion = game.snapshot?.version;
+    if (nextSource !== source || nextSeat !== seat || nextVersion !== version || game.connection !== "ready") {
+      source = nextSource;
+      seat = nextSeat;
+      version = nextVersion;
+      cancel();
+    }
+  });
+  return {
+    root: {
+      get drag() {
+        if (lastInteractions !== game.interactions || lastCards !== game.cards) {
+          lastInteractions = game.interactions;
+          lastCards = game.cards;
+          branch = snapshot();
+        }
+        return branch;
+      }
+    },
+    dispose() {
+      unsubscribe();
+      cancel();
+      disposed = true;
+    }
+  };
+}
+function dragFeature(_game, context, options) {
+  return createRuntimeDragFeature(
+    context[runtimeFeatures],
+    options?.getSelection
+  );
+}
+
+// src/headless/features/pointer-session.ts
+function createPointerSession(callbacks) {
+  let disposed = false;
+  let active;
+  function value() {
+    const { origin, point } = active;
+    return {
+      origin,
+      point,
+      delta: { x: point.x - origin.x, y: point.y - origin.y }
+    };
+  }
+  function release() {
+    const previous = active;
+    active = void 0;
+    if (previous?.surface.hasPointerCapture(previous.id)) {
+      previous.surface.releasePointerCapture(previous.id);
+    }
+  }
+  function cancel() {
+    if (!active) return;
+    release();
+    callbacks.cancel();
+  }
+  return {
+    start(event) {
+      if (disposed || active || event.button !== 0) return false;
+      event.currentTarget.setPointerCapture(event.pointerId);
+      const point = { x: event.clientX, y: event.clientY };
+      active = {
+        id: event.pointerId,
+        surface: event.currentTarget,
+        origin: point,
+        point
+      };
+      event.preventDefault();
+      return true;
+    },
+    move(event) {
+      if (event.pointerId !== active?.id) return;
+      active.point = { x: event.clientX, y: event.clientY };
+      event.preventDefault();
+      callbacks.move(value());
+    },
+    end(event) {
+      if (event.pointerId !== active?.id) return;
+      active.point = { x: event.clientX, y: event.clientY };
+      const result = value();
+      release();
+      callbacks.end(result);
+    },
+    cancel(event) {
+      if (event && event.pointerId !== active?.id) return;
+      cancel();
+    },
+    dispose() {
+      disposed = true;
+      cancel();
+    }
+  };
+}
+
+// src/headless/features/pan-zoom.ts
+function panZoomFeature(game, context, options = {}) {
+  const minScale = options.minScale ?? 0.25;
+  const maxScale = options.maxScale ?? 4;
+  if (!Number.isFinite(minScale) || !Number.isFinite(maxScale) || minScale <= 0 || maxScale < minScale) {
+    throw new Error(
+      "Viewport scale limits must be positive, finite, and ordered."
+    );
+  }
+  const initial = options.initial ?? { x: 0, y: 0, scale: 1 };
+  let disposed = false;
+  let source = game.getOptions().source;
+  let seat = game.snapshot?.me;
+  let dragOrigin = initial;
+  let transform = admit(initial);
+  let branch = snapshot();
+  function admit(value) {
+    if (![value.x, value.y, value.scale].every(Number.isFinite) || value.scale <= 0) {
+      throw new Error(
+        "Viewport transform must have finite coordinates and positive scale."
+      );
+    }
+    return Object.freeze({
+      x: value.x,
+      y: value.y,
+      scale: Math.min(maxScale, Math.max(minScale, value.scale))
+    });
+  }
+  function update(value) {
+    if (disposed) return;
+    const next = admit(value);
+    if (next.x === transform.x && next.y === transform.y && next.scale === transform.scale)
+      return;
+    transform = next;
+    branch = snapshot();
+    context.invalidate();
+  }
+  const pointer = createPointerSession({
+    move: ({ delta }) => update({
+      ...dragOrigin,
+      x: dragOrigin.x + delta.x,
+      y: dragOrigin.y + delta.y
+    }),
+    end: ({ delta }) => update({
+      ...dragOrigin,
+      x: dragOrigin.x + delta.x,
+      y: dragOrigin.y + delta.y
+    }),
+    cancel() {
+    }
+  });
+  function props() {
+    return {
+      style: { touchAction: "none" },
+      onPointerDown(event) {
+        if (pointer.start(event)) dragOrigin = transform;
+      },
+      onPointerMove: pointer.move,
+      onPointerUp: pointer.end,
+      onPointerCancel: pointer.cancel,
+      onLostPointerCapture: pointer.cancel,
+      onWheel(event) {
+        if (disposed) return;
+        event.preventDefault();
+        const rect = event.currentTarget.getBoundingClientRect();
+        const unit = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? rect.height : 1;
+        const scale = Math.min(
+          maxScale,
+          Math.max(
+            minScale,
+            transform.scale * Math.exp(-event.deltaY * unit * 2e-3)
+          )
+        );
+        const x = event.clientX - rect.left;
+        const y = event.clientY - rect.top;
+        const ratio = scale / transform.scale;
+        update({
+          x: x - (x - transform.x) * ratio,
+          y: y - (y - transform.y) * ratio,
+          scale
+        });
+      }
+    };
+  }
+  function snapshot() {
+    const captured = transform;
+    return Object.freeze({
+      transform: captured,
+      getTransform: () => captured,
+      getProps: props,
+      setTransform: update,
+      reset: () => {
+        pointer.cancel();
+        update(initial);
+      }
+    });
+  }
+  const unsubscribe = game.subscribe(() => {
+    const nextSource = game.getOptions().source;
+    const nextSeat = game.snapshot?.me;
+    if (nextSource !== source || nextSeat !== seat) {
+      source = nextSource;
+      seat = nextSeat;
+      pointer.cancel();
+      update(initial);
+    }
+  });
+  return {
+    root: {
+      get viewport() {
+        return branch;
+      }
+    },
+    dispose() {
+      disposed = true;
+      unsubscribe();
+      pointer.dispose();
+    }
+  };
+}
+
+// src/headless/features/origins.ts
+var flatten = (zones) => Object.fromEntries(
+  Object.entries(zones).flatMap(
+    ([zoneId, hosts]) => Object.entries(hosts).map(([hostId, zone]) => [
+      JSON.stringify([zoneId, hostId]),
+      zone
+    ])
+  )
+);
+var hiddenCount = (zones, zone) => zones[zone]?.cardIds.filter(isHiddenCardId).length ?? 0;
+function singleOrigin(departures, count) {
+  const origin = departures[0];
+  return origin && departures.length >= count && departures.every(
+    (card) => card.zone === origin.zone && card.hidden === origin.hidden
+  ) ? Object.freeze(origin) : null;
+}
+function findCardOrigins(previousNested, nextNested, mover) {
+  const previous = flatten(previousNested);
+  const next = flatten(nextNested);
+  const shownBefore = /* @__PURE__ */ new Map();
+  for (const [zone, { cardIds }] of Object.entries(previous))
+    for (const cardId of cardIds)
+      if (!isHiddenCardId(cardId)) shownBefore.set(cardId, zone);
+  const shownNow = new Set(
+    Object.values(next).flatMap(
+      ({ cardIds }) => cardIds.filter((cardId) => !isHiddenCardId(cardId))
+    )
+  );
+  let left = Object.entries(previous).flatMap(([zone, { cardIds }]) => [
+    ...cardIds.filter((cardId) => !isHiddenCardId(cardId) && !shownNow.has(cardId)).map(() => ({ zone, hidden: false })),
+    ...Array.from(
+      {
+        length: Math.max(
+          0,
+          hiddenCount(previous, zone) - hiddenCount(next, zone)
+        )
+      },
+      () => ({ zone, hidden: true })
+    )
+  ]);
+  const origins = /* @__PURE__ */ new Map();
+  const shownArrivals = [];
+  const hiddenArrivals = [];
+  for (const [zone, { cardIds }] of Object.entries(next)) {
+    for (const cardId of cardIds) {
+      if (isHiddenCardId(cardId)) continue;
+      const from = shownBefore.get(cardId);
+      if (from === void 0) shownArrivals.push(cardId);
+      else if (from !== zone)
+        origins.set(cardId, Object.freeze({ zone: from, hidden: false }));
+    }
+    const hidden = cardIds.filter(isHiddenCardId);
+    const before = hiddenCount(previous, zone);
+    hiddenArrivals.push(
+      ...Array.from(
+        { length: Math.max(0, hidden.length - before) },
+        (_, index) => before === 0 ? hidden[index] : null
+      )
+    );
+  }
+  if (left.some(
+    (card) => !card.hidden && hiddenCount(previous, card.zone) > 0 && hiddenCount(next, card.zone) > 0
+  ))
+    return decodedOrigins(origins);
+  const hiddenLeft = left.filter((card) => card.hidden);
+  if (shownArrivals.length) {
+    const origin = singleOrigin(hiddenLeft, shownArrivals.length);
+    if (origin) {
+      for (const cardId of shownArrivals) origins.set(cardId, origin);
+      left = [
+        ...left.filter((card) => !card.hidden),
+        ...hiddenLeft.slice(shownArrivals.length)
+      ];
+    } else if (hiddenLeft.length) {
+      return decodedOrigins(origins);
+    } else if (mover !== null) {
+      const origin2 = Object.freeze({ player: mover, hidden: true });
+      for (const cardId of shownArrivals) origins.set(cardId, origin2);
+    }
+  }
+  const hiddenOrigin = singleOrigin(left, hiddenArrivals.length) ?? (left.length === 0 && mover !== null ? Object.freeze({ player: mover, hidden: true }) : null);
+  if (hiddenOrigin) {
+    for (const cardId of hiddenArrivals)
+      if (cardId !== null) origins.set(cardId, hiddenOrigin);
+  }
+  return decodedOrigins(origins);
+}
+function moverOf(snapshot) {
+  const active = snapshot.frame.flow.activePlayers;
+  return active.length === 1 && active[0] !== snapshot.me ? active[0] : null;
+}
+function originsFeature(game) {
+  let frame = game.snapshot;
+  let source = game.getOptions().source;
+  let origins = /* @__PURE__ */ new Map();
+  function sync() {
+    const next = game.snapshot;
+    const nextSource = game.getOptions().source;
+    if (next?.version === frame?.version && next?.me === frame?.me && nextSource === source)
+      return;
+    origins = frame && next && next.me === frame.me && nextSource === source && next.version === frame.version + 1 ? findCardOrigins(
+      frame.frame.zones,
+      next.frame.zones,
+      moverOf(frame)
+    ) : /* @__PURE__ */ new Map();
+    frame = next;
+    source = nextSource;
+  }
+  const unsubscribe = game.subscribe(sync);
+  return {
+    card: {
+      getOrigin() {
+        sync();
+        return origins.get(this.id) ?? null;
+      }
+    },
+    dispose: unsubscribe
+  };
+}
+function decodedOrigins(origins) {
+  return new Map(
+    [...origins].map(([id, origin]) => {
+      if (!("zone" in origin)) return [id, origin];
+      const [zone, hostId] = JSON.parse(origin.zone);
+      return [id, Object.freeze({ ...origin, zone, hostId })];
+    })
+  );
+}
+
+// src/headless/fan.ts
+var RADIANS = Math.PI / 180;
+function fanLayout({
+  count,
+  width,
+  cardWidth,
+  cardHeight,
+  step = cardWidth * 0.6,
+  angle = 5,
+  maxSpread = 30
+}) {
+  if (count < 1) return { cards: [], width: 0, height: 0, step: 0 };
+  const gaps = count - 1;
+  const delta = gaps ? Math.min(angle, maxSpread / gaps) * RADIANS : 0;
+  const edge = gaps * delta / 2;
+  const span = delta ? 2 * Math.sin(edge) / delta : gaps;
+  const ends = cardWidth * Math.cos(edge) + cardHeight * Math.sin(edge);
+  const spacing = span ? Math.max(0, Math.min(step, (width - ends) / span)) : 0;
+  const radius = delta ? spacing / delta : 0;
+  const centres = Array.from({ length: count }, (_, index) => {
+    if (!delta) return { theta: 0, x: (index - gaps / 2) * spacing, y: 0 };
+    const theta = (index - gaps / 2) * delta;
+    return {
+      theta,
+      x: radius * Math.sin(theta),
+      y: radius * (1 - Math.cos(theta))
+    };
+  });
+  const halfHeight = (theta) => cardHeight / 2 * Math.cos(theta) + cardWidth / 2 * Math.abs(Math.sin(theta));
+  const top = Math.min(
+    ...centres.map((card) => card.y - halfHeight(card.theta))
+  );
+  const bottom = Math.max(
+    ...centres.map((card) => card.y + halfHeight(card.theta))
+  );
+  const fanWidth = spacing * span + ends;
+  return {
+    cards: centres.map((card) => ({
+      x: card.x + (fanWidth - cardWidth) / 2,
+      y: card.y - top - cardHeight / 2,
+      rotate: card.theta / RADIANS
+    })),
+    width: fanWidth,
+    height: bottom - top,
+    step: spacing
+  };
+}
+function liftFanCard(card, distance) {
+  const theta = card.rotate * RADIANS;
+  return {
+    x: card.x + distance * Math.sin(theta),
+    y: card.y - distance * Math.cos(theta),
+    rotate: card.rotate
+  };
+}
+
+// src/headless/hand-fan.ts
+var handFanPresets = {
+  /** Whole resting cards; focusing enlarges the card. */
+  open: {
+    tuck: 0,
+    focusScale: 2,
+    focusMaxHeight: 0.55,
+    push: [0.29, 0.19, 0.1],
+    exposed: 0.35
+  },
+  /**
+   * Larger cards tucked below the bottom edge and spaced like a dealt hand;
+   * focusing mostly reveals the card.
+   */
+  tucked: {
+    spacing: 0.75,
+    tuck: 0.15,
+    focusScale: 1.4,
+    focusMaxHeight: 0.4,
+    push: [0.29, 0.19, 0.1],
+    exposed: 0.35
+  },
+  /** Coarse pointers: a shallower tuck and wider strips to tap. */
+  touch: {
+    spacing: 0.75,
+    tuck: 0.1,
+    focusScale: 1.6,
+    focusMaxHeight: 0.5,
+    push: [0.35, 0.2, 0.1],
+    exposed: 0.45
+  }
+};
+function handFan({
+  count,
+  width,
+  cardWidth,
+  cardHeight,
+  focused = -1,
+  visible,
+  windowHeight = Infinity,
+  room = Infinity,
+  options
+}) {
+  const o = { ...handFanPresets.open, ...options };
+  const fan = fanLayout({
+    count,
+    width,
+    cardWidth,
+    cardHeight,
+    angle: o.angle,
+    maxSpread: o.maxSpread,
+    step: o.spacing === void 0 ? void 0 : o.spacing * cardWidth
+  });
+  const band = o.tuck ? Math.min(fan.height, (1 - o.tuck) * cardHeight) : fan.height;
+  const view = visible ?? {
+    left: (fan.width - width) / 2,
+    width
+  };
+  const exposed = cardWidth * o.exposed;
+  const largest = Math.max(
+    cardWidth,
+    Math.min(
+      cardWidth * o.focusScale,
+      windowHeight * o.focusMaxHeight * cardWidth / cardHeight,
+      room * cardWidth / cardHeight,
+      view.width
+    )
+  );
+  const headroom = Math.max(0, largest * cardHeight / cardWidth - band);
+  const cards = fan.cards.map((card, index) => ({
+    ...card,
+    scale: 1,
+    layer: index
+  }));
+  if (focused < 0 || focused >= count)
+    return { cards, width: fan.width, height: band, headroom };
+  const leftStrip = focused > 0 ? exposed : 0;
+  const rightStrip = focused < count - 1 ? exposed : 0;
+  const face = Math.max(
+    cardWidth,
+    Math.min(largest, view.width - leftStrip - rightStrip)
+  );
+  const scale = face / cardWidth;
+  const half = face / 2;
+  const centre = Math.max(
+    view.left + leftStrip + half,
+    Math.min(
+      view.left + view.width - rightStrip - half,
+      cards[focused].x + cardWidth / 2
+    )
+  );
+  cards[focused] = {
+    x: centre - cardWidth / 2,
+    y: band - cardHeight * (scale + 1) / 2,
+    rotate: 0,
+    scale,
+    layer: count
+  };
+  const extra = Math.max(0, half - cardWidth / 2);
+  const reach = o.push.length;
+  for (const direction of [-1, 1]) {
+    let previous = centre;
+    for (let distance = 1, index = focused + direction; index >= 0 && index < count; distance++, index += direction) {
+      const card = cards[index];
+      const shift = (o.push[distance - 1] ?? 0) * cardWidth + (reach ? extra * Math.max(0, 1 - (distance - 1) / reach) : 0);
+      const desired = card.x + cardWidth / 2 + direction * shift;
+      const angle = card.rotate * Math.PI / 180;
+      const halfWidth = (cardWidth * Math.cos(angle) + cardHeight * Math.abs(Math.sin(angle))) / 2;
+      const middleHalfWidth = cardWidth * Math.cos(angle) / 2;
+      const clearance = distance === 1 ? Math.max(exposed, half - middleHalfWidth + exposed) : exposed;
+      const boundary = direction === 1 && distance > 1 ? Math.max(previous + clearance, centre + half + exposed + halfWidth) : previous + direction * clearance;
+      let next = direction === 1 ? Math.max(desired, boundary) : Math.min(desired, boundary);
+      if (distance === 1)
+        next = direction === 1 ? Math.min(
+          next,
+          view.left + view.width - middleHalfWidth,
+          centre + half + middleHalfWidth
+        ) : Math.max(
+          next,
+          view.left + middleHalfWidth,
+          centre - half - middleHalfWidth
+        );
+      cards[index] = { ...card, x: next - cardWidth / 2 };
+      previous = next;
+    }
+  }
+  return { cards, width: fan.width, height: band, headroom };
+}
+function exponentialOut(progress) {
+  return (1 - Math.exp(-4.5 * progress)) / (1 - Math.exp(-4.5));
+}
+var handFanTiming = {
+  /** The focused face rises: 90% in about 45ms. */
+  focus: { duration: 0.09, ease: exponentialOut },
+  /** Sideways travel, neighbours and returning cards: 90% in about 300ms. */
+  settle: { duration: 0.6, ease: exponentialOut }
+};
+function cssEasing(ease, samples = 24) {
+  const points = Array.from(
+    { length: samples + 1 },
+    (_, index) => Number(ease(index / samples).toFixed(4))
+  );
+  return `linear(${points.join(", ")})`;
+}
+
+// src/headless/features/card-selection.ts
+function cardSelectionFeature(game, context) {
+  let ids = Object.freeze([]);
+  let source = game.getOptions().source;
+  let snapshot = game.snapshot;
+  let disposed = false;
+  function set(values) {
+    if (disposed) return;
+    const next = [...new Set(values)].filter((id) => game.cards.find(id));
+    if (next.length === ids.length && next.every((id, index) => id === ids[index]))
+      return;
+    ids = Object.freeze(next);
+    branch = capture();
+    context.invalidate();
+  }
+  function capture() {
+    return Object.freeze({
+      cardIds: ids,
+      set,
+      toggle(id) {
+        set(
+          ids.includes(id) ? ids.filter((value) => value !== id) : [...ids, id]
+        );
+      },
+      clear: () => set([])
+    });
+  }
+  let branch = capture();
+  const unsubscribe = game.subscribe(() => {
+    if (source !== game.getOptions().source || snapshot !== game.snapshot) {
+      source = game.getOptions().source;
+      snapshot = game.snapshot;
+      set([]);
+    }
+  });
+  return {
+    root: {
+      get cardSelection() {
+        return branch;
+      }
+    },
+    dispose() {
+      disposed = true;
+      unsubscribe();
+    }
+  };
+}
 export {
+  AmbiguousTargetError,
+  AuthAcceptedFrameSchema,
+  AuthConnectFrameSchema,
+  AuthRefreshFrameSchema,
+  CancelInteractionCommandSchema,
+  ClientGameplayFrameSchema,
+  DREAMBOARD_PLUGIN_PROTOCOL,
+  DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
   DREAMBOARD_SDK_PACKAGES,
   DREAMBOARD_SDK_PACKAGE_SET,
-  DREAMBOARD_SDK_VERSION
+  DREAMBOARD_SDK_VERSION,
+  GESTURE_THRESHOLDS,
+  GameEventDetailSchema,
+  GameEventSchema,
+  GameOutcomeSchema,
+  GameplayBackpressureFrameSchema,
+  GameplayBackpressureOperationSchema,
+  GameplayBackpressureReasonSchema,
+  GameplayBasisSchema,
+  GameplayCloseCode,
+  GameplayCredentialSchema,
+  HostToPluginEnvelopeSchema,
+  HostToPluginPayloadSchema,
+  InputDomainSchema,
+  InteractionAvailabilitySchema,
+  InteractionCommitPolicySchema,
+  InteractionDescriptorSchema,
+  InteractionInputDescriptorSchema,
+  InteractionResultSchema,
+  PluginGameplayFrameSchema,
+  PluginPlayerSummarySchema,
+  PluginSessionDescriptorSchema,
+  PluginToHostEnvelopeSchema,
+  PluginToHostPayloadSchema,
+  RuntimeJsonSchema,
+  SeatFrameSchema,
+  SeatProjectionBundleSchema,
+  ServerGameplayFrameSchema,
+  SessionResumeFrameSchema,
+  SessionSnapshotFrameSchema,
+  SimultaneousPhaseSnapshotSchema,
+  SubmitInteractionCommandSchema,
+  SystemActionEventSchema,
+  ViewCardSchema,
+  ZoneHandlesSnapshotSchema,
+  boardEdgeId,
+  boardFeature,
+  boardSpaceHostId,
+  boardVertexId,
+  canonicalizePluginRuntimeJson,
+  cardSelectionFeature,
+  computePluginActionSetVersion,
+  createGameInstance,
+  createGestureRecognizer,
+  createPluginProtocolEnvelopeSchema,
+  cssEasing,
+  digestPluginCommandRequest,
+  digestPluginGameplayFrame,
+  digestPluginRuntimeJson,
+  dragFeature,
+  encodeCanonicalPluginRuntimeJson,
+  exponentialOut,
+  fanLayout,
+  handFan,
+  handFanPresets,
+  handFanTiming,
+  handFeature,
+  hostSource,
+  iframeSource,
+  liftFanCard,
+  magneticDropPoint,
+  materializePluginGameplayFrame,
+  originsFeature,
+  panZoomFeature,
+  parseBoardElementId,
+  parseBoardSpaceHostId,
+  parseHostToPluginEnvelope,
+  parsePerPlayerInstanceId,
+  parsePluginGameplayFrame,
+  parsePluginSessionDescriptor,
+  parsePluginToHostEnvelope,
+  perPlayerInstanceId,
+  shortcutsFeature,
+  staticSource
 };
 //# sourceMappingURL=index.js.map