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

package/dist/index.js

@@ -1,12 +1,1102 @@
 import {
-  DREAMBOARD_SDK_PACKAGES,
-  DREAMBOARD_SDK_PACKAGE_SET,
-  DREAMBOARD_SDK_VERSION
-} from "./chunk-Y75CFE77.js";
-import "./chunk-PZ5AY32C.js";
+  AmbiguousTargetError,
+  createGameInstance
+} from "./chunk-OOFMBCFF.js";
+import {
+  BoardStaticProjectionSchema,
+  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-UG2Q4NLG.js";
+import "./chunk-DMFVAZI2.js";
+import {
+  InputDomainSchema,
+  InteractionAvailabilitySchema,
+  InteractionCommitPolicySchema,
+  InteractionDescriptorSchema,
+  InteractionInputDescriptorSchema,
+  RuntimeJsonSchema,
+  canonicalizePluginRuntimeJson,
+  createHexBoardGeometry,
+  digestPluginRuntimeJson,
+  encodeCanonicalPluginRuntimeJson
+} from "./chunk-XU6WJW6K.js";
+import {
+  inputValueKey,
+  requireLookup
+} from "./chunk-3JXUL4VN.js";
+
+// src/package-set.ts
+var DREAMBOARD_SDK_VERSION = true ? "0.5.0-alpha.4" : "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,
+    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 { 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/hand.ts
+function handFeature(_game, options = {}) {
+  return {
+    zone: {
+      getSortedCardIds() {
+        return this.getCards({ sort: options.sort }).map((card) => card.id);
+      },
+      getSelectedCardIds() {
+        return this.getCards().filter((card) => card.getIsSelected()).map((card) => card.id);
+      },
+      getSelectableCardIds() {
+        return this.getCards().filter((card) => card.getCanSelect()).map((card) => card.id);
+      }
+    }
+  };
+}
+
+// src/headless/features/board.ts
+function squareGeometry(board, size, origin) {
+  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 byId = new Map(spaces.map((space) => [space.id, space]));
+  function sharedCorners(ids) {
+    const first = byId.get(ids[0] ?? "")?.corners ?? [];
+    return first.filter(
+      (point) => ids.every(
+        (id) => byId.get(id)?.corners.some(
+          (candidate) => candidate.x === point.x && candidate.y === point.y
+        )
+      )
+    );
+  }
+  const points = spaces.flatMap((space) => space.corners);
+  const xs = points.map((point) => point.x);
+  const ys = points.map((point) => point.y);
+  const x = xs.length ? Math.min(...xs) : 0;
+  const y = ys.length ? Math.min(...ys) : 0;
+  return {
+    viewBox: {
+      x,
+      y,
+      width: xs.length ? Math.max(...xs) - x : 0,
+      height: ys.length ? Math.max(...ys) - y : 0
+    },
+    spaces,
+    // Incidence is authored. Only a unique geometric line/point is representable.
+    edges: board.edges.flatMap((edge) => {
+      const corners = sharedCorners(edge.spaceIds);
+      return corners.length === 2 ? [{ id: edge.id, from: corners[0], to: corners[1] }] : [];
+    }),
+    vertices: board.vertices.flatMap((vertex) => {
+      const corners = sharedCorners(vertex.spaceIds);
+      return corners.length === 1 ? [{ id: vertex.id, center: corners[0] }] : [];
+    }),
+    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;
+    }
+  };
+}
+function boardFeature(game, context) {
+  const captures = /* @__PURE__ */ new WeakMap();
+  const geometries = /* @__PURE__ */ new WeakMap();
+  let cached;
+  function collection() {
+    const model = game.getSnapshot();
+    const source = game.getOptions().source;
+    if (cached?.view === model.view && cached.interactions === model.interactions && cached.source === source)
+      return cached.collection;
+    const projected = model.view;
+    const boards = Object.values(projected?.boards?.byId ?? {}).map((data) => {
+      const board = context.createBoard(
+        data.id,
+        data
+      );
+      let geometry = geometries.get(data);
+      if (!geometry && data.layout === "hex") {
+        geometry = createHexBoardGeometry({
+          id: data.baseId ?? data.id,
+          orientation: data.orientation,
+          spaces: Object.values(data.spaces)
+        });
+        geometries.set(data, geometry);
+      }
+      captures.set(board, { model, source, geometry });
+      return board;
+    });
+    const byId = new Map(boards.map((board) => [board.id, board]));
+    const result = Object.freeze({
+      get(id) {
+        return requireLookup(byId.get(id), "Board", id);
+      },
+      find(id) {
+        return byId.get(id);
+      },
+      getAll: () => Object.freeze(boards)
+    });
+    cached = {
+      view: model.view,
+      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) {
+      const inputKinds = kind === "space" ? ["space", "tile"] : [kind];
+      return model.interactions.list().flatMap(
+        (interaction) => interaction.getInputs().filter((input) => {
+          const domain = input.getDomain();
+          return domain.type === "boardTarget" && inputKinds.includes(String(domain.targetKind)) && (domain.valueKind === "player-board-space" ? board.scope === "perPlayer" && domain.boardId === board.baseId : domain.boardId === board.id);
+        }).map((input) => {
+          const domain = input.getDomain();
+          return {
+            interaction,
+            input,
+            value: domain.type === "boardTarget" && domain.valueKind === "player-board-space" ? Object.freeze({
+              boardId: board.baseId,
+              playerId: board.playerId,
+              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 === "player-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 }) : squareGeometry(board, hexSize, origin);
+        const point = (value) => Object.freeze({
+          x: value.x * viewport.scale + viewport.x,
+          y: value.y * viewport.scale + viewport.y
+        });
+        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: Object.freeze({ ...geometry.viewBox }),
+          getSpaces: () => spaces,
+          getEdges: () => edges,
+          getVertices: () => vertices,
+          pointToSpace(x, y) {
+            return geometry.pointToSpace({
+              x: (x - viewport.x) / viewport.scale,
+              y: (y - viewport.y) / viewport.scale
+            });
+          }
+        });
+      }
+    }
+  };
+}
+
+// src/headless/features/drag.ts
+function dragFeature(game, context) {
+  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 runtime = game;
+    const options = selected;
+    const resolved = (runtime.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) => input.getDomain().type === "cardTarget" && (!options?.input || input.key === options.input) && input.getIsEligible(cardId)
+      );
+      return 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 === "player-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 resolved;
+  }
+  function sameTarget(left, right) {
+    return left.kind === right.kind && left.valueKind === right.valueKind && inputValueKey(left.value) === inputValueKey(right.value) && (left.valueKind !== "board-id" || right.valueKind === "board-id" && left.boardId === right.boardId) && left.interactionKey === right.interactionKey && left.cardInputKey === right.cardInputKey && left.inputKey === right.inputKey;
+  }
+  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;
+        update({ cardId, target: null });
+        return true;
+      },
+      getDropTargets: () => dropTargets,
+      setDropTarget(target) {
+        if (!active || disposed) return;
+        if (target && !targets().some((candidate) => sameTarget(candidate, target))) {
+          update({ ...active, target: null });
+          return;
+        }
+        update({ ...active, target });
+      },
+      drop() {
+        const finished = active;
+        const eligible = finished?.target && targets().some((target) => sameTarget(target, finished.target));
+        cancel();
+        if (!disposed && finished?.target && eligible)
+          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;
+    }
+  };
+}
+
+// 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();
+    }
+  };
+}
 export {
+  AmbiguousTargetError,
+  AuthAcceptedFrameSchema,
+  AuthConnectFrameSchema,
+  AuthRefreshFrameSchema,
+  BoardStaticProjectionSchema,
+  CancelInteractionCommandSchema,
+  ClientGameplayFrameSchema,
+  DREAMBOARD_PLUGIN_PROTOCOL,
+  DREAMBOARD_PLUGIN_PROTOCOL_VERSION,
   DREAMBOARD_SDK_PACKAGES,
   DREAMBOARD_SDK_PACKAGE_SET,
-  DREAMBOARD_SDK_VERSION
+  DREAMBOARD_SDK_VERSION,
+  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,
+  ZoneHandlesSnapshotSchema,
+  boardFeature,
+  canonicalizePluginRuntimeJson,
+  computePluginActionSetVersion,
+  createGameInstance,
+  createPluginProtocolEnvelopeSchema,
+  digestPluginCommandRequest,
+  digestPluginGameplayFrame,
+  digestPluginRuntimeJson,
+  dragFeature,
+  encodeCanonicalPluginRuntimeJson,
+  handFeature,
+  hostSource,
+  iframeSource,
+  materializePluginGameplayFrame,
+  panZoomFeature,
+  parseHostToPluginEnvelope,
+  parsePluginGameplayFrame,
+  parsePluginSessionDescriptor,
+  parsePluginToHostEnvelope,
+  staticSource
 };
 //# sourceMappingURL=index.js.map