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

package/dist/chunk-3RFGPBES.js

@@ -0,0 +1,1792 @@
+import {
+  BoardProjectionSchema,
+  immutableCopy,
+  inputDomainErrors,
+  inputTargetInDomain,
+  inputValueInDomain,
+  inputValueKey,
+  requireLookup,
+  zonePositions
+} from "./chunk-CZRPUWCT.js";
+
+// src/headless/runtime-features.ts
+var runtimeFeatures = /* @__PURE__ */ Symbol("runtimeFeatures");
+
+// src/headless/input-control.ts
+function resourceValue(domain, value) {
+  const record = value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+  return Object.fromEntries(
+    domain.resources.map((resource) => {
+      const amount = record[resource.resourceId];
+      return [resource.resourceId, typeof amount === "number" ? amount : 0];
+    })
+  );
+}
+function createInputControl(input, props) {
+  const domain = input.getDomain();
+  const current = input.getValue();
+  const common = { key: input.key, disabled: props.disabled, props };
+  if (domain.type === "boundedNumber") {
+    if (domain.selection?.mode === "many")
+      return {
+        ...common,
+        type: "boundedNumber",
+        domain,
+        mode: "many",
+        value: Array.isArray(current) ? current.filter(
+          (value) => typeof value === "number"
+        ) : [],
+        setValue: (value) => input.setValue(value)
+      };
+    return {
+      ...common,
+      type: "boundedNumber",
+      domain,
+      mode: "single",
+      value: typeof current === "number" ? current : void 0,
+      setValue: (value) => value === void 0 ? input.clear() : input.setValue(value)
+    };
+  }
+  if (domain.type === "resourceMap") {
+    if (domain.selection?.mode === "many")
+      return {
+        ...common,
+        type: "resourceMap",
+        domain,
+        mode: "many",
+        value: Array.isArray(current) ? current.map((value) => resourceValue(domain, value)) : [],
+        setValue: (value) => input.setValue(value)
+      };
+    return {
+      ...common,
+      type: "resourceMap",
+      domain,
+      mode: "single",
+      value: current === void 0 ? void 0 : resourceValue(domain, current),
+      setValue: (value) => value === void 0 ? input.clear() : input.setValue(value)
+    };
+  }
+  return { ...common, type: "targets", options: input.getTargetOptions() };
+}
+
+// src/headless/instance.ts
+import { createStore } from "@tanstack/store";
+
+// src/headless/interaction-inputs.ts
+function interactionInputKeys(descriptor) {
+  return descriptor.inputs.map((input) => input.key);
+}
+function applyInteractionInputDefaults(descriptor, params) {
+  const next = descriptor.step ? Object.fromEntries(
+    Object.entries(params).filter(
+      ([key]) => descriptor.inputs.some((input) => input.key === key)
+    )
+  ) : { ...params };
+  for (const input of descriptor.inputs) {
+    if (next[input.key] !== void 0) continue;
+    if (!("defaultValue" in input)) continue;
+    next[input.key] = input.defaultValue;
+  }
+  return next;
+}
+function validateInteractionInputDomains(descriptor, params) {
+  const fieldErrors = {};
+  for (const rawInput of descriptor.inputs) {
+    const input = rawInput;
+    const value = params[input.key];
+    if (value === void 0) continue;
+    for (const error of inputDomainErrors(
+      input.domain,
+      value,
+      input.domain.selection
+    ))
+      pushFieldError(fieldErrors, input.key, error);
+  }
+  return fieldErrors;
+}
+function isInputValueReady(input, value) {
+  if (value === void 0) return false;
+  if (value === null)
+    return input.domain.type === "choice" && (input.domain.choices ?? []).some(
+      (choice) => choice.value === null && !choice.disabled
+    );
+  const selection = inputSelection(input);
+  if (selection?.mode !== "many") return true;
+  return Array.isArray(value) && value.length >= selection.min;
+}
+function isManyInput(input) {
+  return inputSelection(input)?.mode === "many";
+}
+function toggleManyValue(current, value, selection) {
+  if (selection.mode !== "many") return [value];
+  const previous = Array.isArray(current) ? current : [];
+  const existing = previous.findIndex((item) => sameValue(item, value));
+  if (existing >= 0) {
+    return previous.filter((item) => !sameValue(item, value));
+  }
+  if (selection.max !== void 0 && previous.length >= selection.max) {
+    return previous;
+  }
+  return [...previous, value];
+}
+function isManyTargetSelectable(input, current, targetId) {
+  const selection = inputSelection(input);
+  if (selection?.mode !== "many") return true;
+  const currentValues = Array.isArray(current) ? current : [];
+  if (currentValues.some((item) => sameValue(item, targetId))) return true;
+  return selection.max === void 0 || currentValues.length < selection.max;
+}
+function hasInteractionFieldErrors(fieldErrors) {
+  return Object.values(fieldErrors).some(
+    (messages) => (messages?.length ?? 0) > 0
+  );
+}
+function inputByKey(descriptor, key) {
+  return descriptor.inputs.find((input) => input.key === key);
+}
+function inputSelection(input) {
+  if (input.domain.selection) return input.domain.selection;
+  if (input.domain.type === "choiceList")
+    return {
+      mode: "many",
+      min: input.domain.min ?? 0,
+      max: input.domain.max ?? input.domain.choices.length
+    };
+  return void 0;
+}
+function pushFieldError(fieldErrors, key, message) {
+  fieldErrors[key] = [...fieldErrors[key] ?? [], message];
+}
+function sameValue(left, right) {
+  return inputValueKey(left) === inputValueKey(right);
+}
+
+// src/headless/interaction-router.ts
+function applyInteractionDraftMutation(store, descriptor, mutations) {
+  const originalDraft = {
+    ...store.getDraft(descriptor.interactionKey)
+  };
+  const nextDraft = {
+    ...originalDraft
+  };
+  const currentKeys = new Set(interactionInputKeys(descriptor));
+  for (const { key, value } of mutations) {
+    if (!descriptor.step || currentKeys.has(key)) nextDraft[key] = value;
+  }
+  if (descriptor.step) {
+    for (const key of Object.keys(nextDraft))
+      if (!currentKeys.has(key)) delete nextDraft[key];
+  }
+  const allKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(originalDraft),
+    ...Object.keys(nextDraft)
+  ]);
+  for (const key of allKeys) {
+    if (!(key in nextDraft)) {
+      store.clearInput(descriptor.interactionKey, key);
+      continue;
+    }
+    if (originalDraft[key] !== nextDraft[key]) {
+      store.setInput(descriptor.interactionKey, key, nextDraft[key]);
+    }
+  }
+  return nextDraft;
+}
+function getInteractionDraftReadiness(descriptor, draft) {
+  const values = applyInteractionInputDefaults(
+    descriptor,
+    draft
+  );
+  const missingInputs = interactionInputKeys(descriptor).filter((key) => {
+    const input = inputByKey(descriptor, key);
+    const value = values[key];
+    return input ? !isInputValueReady(input, value) : value === null || value === void 0;
+  });
+  const fieldErrors = validateInteractionInputDomains(descriptor, values);
+  return {
+    values,
+    missingInputs,
+    fieldErrors,
+    ready: missingInputs.length === 0 && !hasInteractionFieldErrors(fieldErrors)
+  };
+}
+function routeInteractionTarget(store, descriptor, target) {
+  const input = inputByKey(descriptor, target.inputKey);
+  const currentDraft = store.getDraft(descriptor.interactionKey);
+  const selection = input ? inputSelection(input) : void 0;
+  const targetValue = selection?.mode === "many" ? toggleManyValue(
+    currentDraft[target.inputKey] ?? input?.defaultValue,
+    target.value,
+    selection
+  ) : target.value;
+  const params = applyInteractionDraftMutation(store, descriptor, [
+    ...Object.entries(target.extraInputs ?? {}).map(([key, value]) => ({
+      key,
+      value
+    })),
+    { key: target.inputKey, value: targetValue }
+  ]);
+  return {
+    params,
+    readiness: getInteractionDraftReadiness(descriptor, params)
+  };
+}
+function routeCardInputIntent(store, descriptor, intent) {
+  return routeInteractionTarget(store, descriptor, {
+    inputKey: intent.cardInputKey,
+    value: intent.cardId,
+    extraInputs: intent.dropTarget ? { [intent.dropTarget.inputKey]: intent.dropTarget.value } : void 0
+  });
+}
+function shouldAutoSubmitInteraction(descriptor) {
+  return descriptor.commit.mode === "autoWhenReady" && !descriptor.inputs.some((input) => input.domain.selection?.mode === "many");
+}
+
+// src/headless/instance.ts
+var EMPTY = Object.freeze({});
+var EMPTY_DRAFTS = Object.freeze({});
+var equalValue = (a, b) => Object.is(a, b) || typeof a === "object" && typeof b === "object" && inputValueKey(a) === inputValueKey(b);
+function inDomain(input, value, partial = false) {
+  return inputValueInDomain(input.domain, value, input.domain.selection, {
+    ignoreMinimum: partial
+  });
+}
+function matchesBoardTarget(input, target) {
+  const domain = input.domain;
+  return domain.type === "boardTarget" && domain.valueKind === target.valueKind && domain.targetKind === target.kind && (domain.valueKind === "board-id" && target.valueKind === "board-id" ? domain.boardId === target.boardId : domain.valueKind === "board-space" && target.valueKind === "board-space" && domain.eligibleTargets.some(
+    (candidate) => candidate.boardId === target.value.boardId
+  ));
+}
+function immutableValues(value) {
+  return immutableCopy(value);
+}
+function data(action, interaction, input, value) {
+  return {
+    "data-action": action,
+    "data-interaction": interaction,
+    ...input ? { "data-input": input } : {},
+    ...value === void 0 ? {} : {
+      "data-value": typeof value === "string" ? value : JSON.stringify(value)
+    }
+  };
+}
+var AmbiguousTargetError = class extends Error {
+  constructor(id) {
+    super(
+      `Target '${id}' belongs to more than one eligible input. Choose an interaction and input explicitly.`
+    );
+    this.name = "AmbiguousTargetError";
+  }
+};
+var InteractionObject = class {
+  constructor(owner, descriptor, draft, status, connected) {
+    this.owner = owner;
+    this.descriptor = descriptor;
+    this.status = status;
+    this.connected = connected;
+    this.seat = descriptor.actorSeat ?? owner.sourceState.snapshot?.players.findIndex(
+      (player) => player.playerId === owner.sourceState.snapshot?.me
+    ) ?? -1;
+    this.draftIdentity = draft;
+    this.draft = immutableValues(draft);
+    this.source = owner.options.source;
+    this.epoch = owner.epoch;
+    this.key = descriptor.interactionKey;
+    this.id = descriptor.interactionId;
+    this.phase = descriptor.phaseName;
+    this.label = descriptor.label;
+    this.help = descriptor.help;
+    this.kind = descriptor.step ? "steps" : "inputs";
+    this.inputObjects = Object.freeze(
+      descriptor.inputs.map(
+        (input) => owner.object("input", new InputObject(this, input))
+      )
+    );
+  }
+  owner;
+  descriptor;
+  status;
+  connected;
+  key;
+  id;
+  phase;
+  label;
+  help;
+  kind;
+  inputObjects;
+  seat;
+  draft;
+  draftIdentity;
+  source;
+  epoch;
+  get game() {
+    return this.owner.instance;
+  }
+  getAvailability() {
+    return this.descriptor.availability;
+  }
+  getIsAvailable(params) {
+    const descriptor = params === void 0 ? this.descriptor : this.owner.descriptorFor(this.descriptor, params);
+    return descriptor.availability.status === "available";
+  }
+  getUnavailableReason() {
+    return this.descriptor.availability.status === "available" ? null : this.descriptor.availability.reason;
+  }
+  getStep() {
+    return this.descriptor.step ?? null;
+  }
+  getStepIndex() {
+    return this.descriptor.step?.index ?? null;
+  }
+  getInput(key) {
+    return requireLookup(
+      this.findInput(key),
+      `Input in interaction ${this.key}`,
+      key
+    );
+  }
+  findInput(key) {
+    return this.inputObjects.find((input) => input.key === key);
+  }
+  getInputs() {
+    return this.inputObjects;
+  }
+  readiness(params = this.draft) {
+    return getInteractionDraftReadiness(
+      this.owner.descriptorFor(this.descriptor, params),
+      params
+    );
+  }
+  getIsReady(params) {
+    return this.readiness(params).ready;
+  }
+  getMissingInputs() {
+    return this.readiness().missingInputs;
+  }
+  getStatus() {
+    return this.status;
+  }
+  currentLifetime() {
+    return this.source === this.owner.options.source && this.epoch === this.owner.epoch && !this.owner.disposed;
+  }
+  submit(params) {
+    return this.currentLifetime() ? this.owner.submit(this.key, false, params) : Promise.resolve({ accepted: false, errorCode: "CLOSED" });
+  }
+  cancel() {
+    return this.currentLifetime() ? this.owner.submit(this.key, true) : Promise.resolve({ accepted: false, errorCode: "CLOSED" });
+  }
+  reset() {
+    if (this.currentLifetime()) this.owner.reset(this.key);
+  }
+  activate() {
+    if (this.currentLifetime()) this.owner.activate(this.key);
+  }
+  getSubmitHandler(params) {
+    return (event) => {
+      event?.preventDefault();
+      this.owner.handle(() => this.submit(params));
+    };
+  }
+  getSubmitProps(params) {
+    const disabled = !this.getIsAvailable(params) || !this.getIsReady(params) || this.status !== "open" || !this.connected;
+    return {
+      ...data("submit", this.key),
+      "data-seat": this.seat,
+      type: "button",
+      disabled,
+      "data-ready": this.getIsReady(params),
+      "data-disabled": disabled,
+      onClick: this.getSubmitHandler(params)
+    };
+  }
+};
+function createInputTargetLabels(domain, snapshot, boards) {
+  const targetLabels = /* @__PURE__ */ new Map();
+  const hosts = Object.values(snapshot?.frame.zones ?? {}).flatMap(
+    (zones) => Object.values(zones)
+  );
+  if (domain.type === "cardTarget") {
+    domain.eligibleTargets.forEach((id, index) => {
+      const card = hosts.map((zone) => zone.cardViewsById[id]).find((card2) => card2 !== void 0);
+      targetLabels.set(
+        inputValueKey(id),
+        card ? card.name || `Card ${index + 1}` : `Card back ${index + 1}`
+      );
+    });
+  }
+  if (domain.type === "zonePosition")
+    for (const value of zonePositions(domain.zones)) {
+      const zone = snapshot?.frame.zones[value.zoneId]?.[value.hostId];
+      const id = zone?.cardIds[value.index];
+      const name = id === void 0 ? void 0 : zone?.cardViewsById[id]?.name;
+      const place = id === void 0 ? "At the end" : `Before ${name || `card ${value.index + 1}`}`;
+      targetLabels.set(
+        inputValueKey(value),
+        domain.zones.length === 1 ? place : `${value.zoneId} (${value.hostId}): ${place}`
+      );
+    }
+  if (domain.type === "tileTarget" || domain.type === "boardTarget") {
+    if (domain.type === "tileTarget") {
+      const presentations = [
+        ...hosts.flatMap((zone) => zone.tiles),
+        ...Object.values(boards).flatMap(
+          (board) => board.layout === "generic" ? [] : board.tiles
+        )
+      ];
+      domain.eligibleTargets.forEach((ref, index) => {
+        const tile = presentations.find((tile2) => tile2.ref === ref);
+        targetLabels.set(
+          inputValueKey(ref),
+          tile?.disclosure === "visible" ? tile.name || `Tile ${index + 1}` : `Tile back ${index + 1}`
+        );
+      });
+    } else {
+      domain.eligibleTargets.forEach((value, index) => {
+        const boardId = typeof value === "string" ? domain.valueKind === "board-id" ? domain.boardId : void 0 : value.boardId;
+        const id = typeof value === "string" ? value : value.spaceId;
+        const board = boardId === void 0 ? void 0 : boards[boardId];
+        const name = domain.targetKind === "space" ? board?.spaces[id]?.name : board && board.layout !== "generic" ? (domain.targetKind === "edge" ? board.edges : board.vertices).find((target) => target.id === id)?.label : void 0;
+        const kind = domain.targetKind === "space" ? "Space" : domain.targetKind === "edge" ? "Edge" : "Vertex";
+        targetLabels.set(inputValueKey(value), name || `${kind} ${index + 1}`);
+      });
+    }
+  }
+  return targetLabels;
+}
+var InputObject = class {
+  constructor(interaction, descriptor) {
+    this.interaction = interaction;
+    this.descriptor = descriptor;
+    this.key = descriptor.key;
+    this.kind = descriptor.kind;
+    const snapshot = interaction.owner.sourceState.snapshot;
+    this.snapshot = snapshot;
+    this.targetLabels = createInputTargetLabels(
+      descriptor.domain,
+      snapshot,
+      descriptor.domain.type === "tileTarget" || descriptor.domain.type === "boardTarget" ? interaction.owner.getBoardProjections(snapshot?.frame.view) : {}
+    );
+  }
+  interaction;
+  descriptor;
+  targetLabels;
+  snapshot;
+  key;
+  kind;
+  currentLifetime() {
+    return this.interaction.currentLifetime() && (this.descriptor.domain.type !== "tileTarget" || this.snapshot === this.interaction.owner.sourceState.snapshot);
+  }
+  get game() {
+    return this.interaction.game;
+  }
+  get domainType() {
+    return this.descriptor.domain.type;
+  }
+  get selectionMode() {
+    return isManyInput(this.descriptor) ? "many" : "single";
+  }
+  getTargetOptions() {
+    const domain = this.getDomain();
+    return this.getEligibleTargets().map((value) => ({
+      value,
+      label: this.targetLabels.get(inputValueKey(value)) ?? (domain.type === "choice" || domain.type === "choiceList" ? domain.choices.find((choice) => Object.is(choice.value, value))?.label : void 0) ?? (value === null ? "None" : typeof value === "object" ? JSON.stringify(value) : String(value)),
+      selected: this.getIsSelected(value),
+      props: this.getTargetProps(value)
+    }));
+  }
+  getDomain() {
+    return this.descriptor.domain;
+  }
+  getValue() {
+    return this.interaction.draft[this.key] ?? (Object.hasOwn(this.interaction.draft, this.key) ? null : this.descriptor.defaultValue);
+  }
+  setValue(value) {
+    if (!this.currentLifetime()) return;
+    this.interaction.owner.setInput(this.interaction.key, this.key, value);
+  }
+  clear() {
+    if (!this.currentLifetime()) return;
+    this.interaction.owner.clearInput(this.interaction.key, this.key);
+  }
+  getIsReady() {
+    const descriptor = {
+      ...this.interaction.descriptor,
+      inputs: [this.descriptor]
+    };
+    return getInteractionDraftReadiness(descriptor, {
+      [this.key]: this.getValue()
+    }).ready;
+  }
+  getEligibleTargets() {
+    const domain = this.descriptor.domain;
+    if (domain.type === "cardTarget" || domain.type === "boardTarget" || domain.type === "tileTarget")
+      return domain.eligibleTargets;
+    if (domain.type === "choice" || domain.type === "choiceList")
+      return domain.choices.filter((choice) => !choice.disabled).map((choice) => choice.value);
+    if (domain.type === "zonePosition") return zonePositions(domain.zones);
+    return [];
+  }
+  getIsEligible(value) {
+    const input = this.descriptor;
+    return inputTargetInDomain(input.domain, value) && isManyTargetSelectable(input, this.getValue(), value);
+  }
+  getIsSelected(value) {
+    const current = this.getValue();
+    return isManyInput(this.descriptor) && Array.isArray(current) ? current.some((item) => equalValue(item, value)) : equalValue(current, value);
+  }
+  getSelectHandler(value) {
+    return () => {
+      if (this.currentLifetime())
+        this.interaction.owner.select(this.interaction.key, this.key, value);
+    };
+  }
+  getTargetProps(value) {
+    const eligible = this.getIsEligible(value);
+    const disabled = !eligible || !this.interaction.getIsAvailable() || this.interaction.status !== "open" || !this.interaction.connected;
+    return {
+      ...data("select", this.interaction.key, this.key, value),
+      "data-seat": this.interaction.seat,
+      type: "button",
+      disabled,
+      "data-eligible": eligible,
+      "data-selected": this.getIsSelected(value),
+      "data-disabled": disabled,
+      onClick: () => this.getSelectHandler(value)()
+    };
+  }
+  getControl() {
+    const disabled = !this.interaction.getIsAvailable() || this.interaction.status !== "open" || !this.interaction.connected;
+    return createInputControl(this, {
+      ...data("option", this.interaction.key, this.key),
+      "data-seat": this.interaction.seat,
+      disabled,
+      "data-disabled": disabled
+    });
+  }
+};
+var CardObject = class {
+  constructor(owner, id, zone, hostId, index, view, backImage, routes) {
+    this.owner = owner;
+    this.id = id;
+    this.zone = zone;
+    this.hostId = hostId;
+    this.index = index;
+    this.routes = routes;
+    this.epoch = owner.epoch;
+    this.seat = owner.sourceState.snapshot?.players.findIndex(
+      (player) => player.playerId === owner.sourceState.snapshot?.me
+    ) ?? -1;
+    this.view = view ?? null;
+    this.hidden = this.view === null;
+    this.backImage = backImage ?? null;
+  }
+  owner;
+  id;
+  zone;
+  hostId;
+  index;
+  routes;
+  epoch;
+  seat;
+  view;
+  hidden;
+  backImage;
+  get game() {
+    return this.owner.instance;
+  }
+  getInteractions() {
+    return this.routes;
+  }
+  getIsEligible() {
+    return this.routes.some((route) => route.getIsAvailable());
+  }
+  getIsSelected() {
+    return this.routes.some(
+      (route) => route.getInputs().some(
+        (input) => input.descriptor.domain.type === "cardTarget" && input.getIsSelected(this.id)
+      )
+    );
+  }
+  getCanSelect(options) {
+    return this.routes.some(
+      (route) => route.getIsAvailable() && (!options?.interaction || route.key === options.interaction) && route.status === "open" && route.connected && route.getInputs().some(
+        (input) => input.descriptor.domain.type === "cardTarget" && (!options?.input || input.key === options.input) && input.getIsEligible(this.id)
+      )
+    );
+  }
+  select(options) {
+    if (this.epoch !== this.owner.epoch || this.owner.disposed) return;
+    this.owner.selectCard(this.id, options);
+  }
+  getSelectHandler(options) {
+    return () => this.select(options);
+  }
+  getProps(options) {
+    return {
+      type: "button",
+      disabled: !this.getCanSelect(options),
+      "data-action": "select",
+      "data-value": this.id,
+      "data-interaction": options?.interaction,
+      "data-input": options?.input,
+      "data-eligible": this.getIsEligible(),
+      "data-selected": this.getIsSelected(),
+      "data-disabled": !this.getCanSelect(options),
+      "data-hidden": this.hidden,
+      "data-seat": this.seat,
+      onClick: this.getSelectHandler(options)
+    };
+  }
+};
+var TileObject = class {
+  constructor(owner, data2, zone, hostId, index, routes) {
+    this.owner = owner;
+    this.data = data2;
+    this.zone = zone;
+    this.hostId = hostId;
+    this.index = index;
+    this.routes = routes;
+    this.epoch = owner.epoch;
+    this.snapshot = owner.sourceState.snapshot;
+  }
+  owner;
+  data;
+  zone;
+  hostId;
+  index;
+  routes;
+  epoch;
+  snapshot;
+  get ref() {
+    return this.data.ref;
+  }
+  get game() {
+    return this.owner.instance;
+  }
+  getInteractions() {
+    return this.routes;
+  }
+  getIsEligible() {
+    return this.routes.some(
+      (route) => route.getInputs().some(
+        (input) => input.descriptor.domain.type === "tileTarget" && input.getIsEligible(this.ref)
+      )
+    );
+  }
+  getIsSelected() {
+    return this.routes.some(
+      (route) => route.getInputs().some(
+        (input) => input.descriptor.domain.type === "tileTarget" && input.getIsSelected(this.ref)
+      )
+    );
+  }
+  getCanSelect(options) {
+    return this.routes.some(
+      (route) => route.getIsAvailable() && (!options?.interaction || route.key === options.interaction) && route.getInputs().some(
+        (input) => input.descriptor.domain.type === "tileTarget" && (!options?.input || input.key === options.input) && !input.getTargetProps(this.ref).disabled
+      )
+    );
+  }
+  select(options) {
+    if (this.owner.disposed || this.epoch !== this.owner.epoch || this.snapshot !== this.owner.sourceState.snapshot)
+      return;
+    this.owner.routeTarget({ kind: "tile", value: this.ref }, options);
+  }
+  getSelectHandler(options) {
+    return () => this.select(options);
+  }
+  getTargetProps(options) {
+    const disabled = !this.getCanSelect(options);
+    return {
+      type: "button",
+      disabled,
+      "data-action": "select",
+      "data-value": this.ref,
+      "data-interaction": options?.interaction,
+      "data-input": options?.input,
+      "data-eligible": this.getIsEligible(),
+      "data-selected": this.getIsSelected(),
+      "data-disabled": disabled,
+      "data-hidden": this.data.disclosure === "concealed",
+      onClick: this.getSelectHandler(options)
+    };
+  }
+};
+var ZoneObject = class {
+  constructor(owner, id, hostId, cards, tiles) {
+    this.owner = owner;
+    this.id = id;
+    this.hostId = hostId;
+    this.cards = cards;
+    this.tiles = tiles;
+  }
+  owner;
+  id;
+  hostId;
+  cards;
+  tiles;
+  get game() {
+    return this.owner.instance;
+  }
+  get count() {
+    return this.cards.length + this.tiles.length;
+  }
+  getIsEmpty() {
+    return this.count === 0;
+  }
+  getTiles() {
+    return this.tiles;
+  }
+  getTile(ref) {
+    return requireLookup(this.findTile(ref), `Tile in zone ${this.id}`, ref);
+  }
+  findTile(ref) {
+    return this.tiles.find((tile) => tile.ref === ref);
+  }
+  getCard(id) {
+    return requireLookup(this.findCard(id), `Card in zone ${this.id}`, id);
+  }
+  findCard(id) {
+    return this.cards.find((card) => card.id === id);
+  }
+  getCards(options) {
+    return options?.sort ? [...this.cards].sort(options.sort) : this.cards;
+  }
+};
+var PlayerObject = class {
+  constructor(owner, summary, index, isMe, active) {
+    this.owner = owner;
+    this.index = index;
+    this.isMe = isMe;
+    this.active = active;
+    this.id = summary.playerId;
+    this.name = summary.displayName;
+    this.color = summary.color;
+  }
+  owner;
+  index;
+  isMe;
+  active;
+  id;
+  name;
+  color;
+  get game() {
+    return this.owner.instance;
+  }
+};
+var PhaseObject = class {
+  constructor(current) {
+    this.current = current;
+  }
+  current;
+  is(name) {
+    return this.current === name;
+  }
+  switch(routes) {
+    return this.current === null ? null : routes[this.current]();
+  }
+};
+var Controller = class {
+  boardProjections = /* @__PURE__ */ new WeakMap();
+  getBoardProjections(view) {
+    if (view === null || typeof view !== "object" || Array.isArray(view))
+      return {};
+    const cached = this.boardProjections.get(view);
+    if (cached) return cached;
+    const payload = Reflect.get(view, "boards");
+    const boards = payload === void 0 ? {} : immutableCopy(BoardProjectionSchema.parse(payload));
+    this.boardProjections.set(view, boards);
+    return boards;
+  }
+  epoch = 0;
+  options;
+  localDrafts;
+  localActive;
+  disposed = false;
+  instance;
+  store;
+  prototypes = {
+    interaction: Object.create(InteractionObject.prototype),
+    input: Object.create(InputObject.prototype),
+    card: Object.create(CardObject.prototype),
+    zone: Object.create(ZoneObject.prototype),
+    board: {}
+  };
+  subscription;
+  sourceState;
+  reportedFailures = /* @__PURE__ */ new WeakMap();
+  pending = null;
+  building;
+  rootProperties = /* @__PURE__ */ new Map();
+  featureDisposals = [];
+  warned = /* @__PURE__ */ new Set();
+  invalidControlledState;
+  observed = /* @__PURE__ */ new Set();
+  revisions = /* @__PURE__ */ new Map();
+  lastDrafts = EMPTY_DRAFTS;
+  lastInteractions = [];
+  lastSnapshotDrafts;
+  trackDrafts() {
+    const drafts = this.drafts();
+    for (const key of /* @__PURE__ */ new Set([
+      ...Object.keys(this.lastDrafts),
+      ...Object.keys(drafts)
+    ]))
+      if (this.lastDrafts[key] !== drafts[key])
+        this.revisions.set(key, (this.revisions.get(key) ?? 0) + 1);
+    this.lastDrafts = drafts;
+  }
+  constructor(options, features) {
+    this.options = options;
+    this.localDrafts = options.initialState?.drafts ?? EMPTY_DRAFTS;
+    this.localActive = options.initialState?.activeInteraction ?? null;
+    this.sourceState = options.source.store.get();
+    const current = () => this.building ?? this.store.get();
+    const root = {
+      get snapshot() {
+        return current().snapshot;
+      },
+      get view() {
+        return current().view;
+      },
+      get version() {
+        return current().version;
+      },
+      get connection() {
+        return current().connection;
+      },
+      get failure() {
+        return current().failure;
+      },
+      get request() {
+        return current().request;
+      },
+      get state() {
+        return current().state;
+      },
+      get phase() {
+        return current().phase;
+      },
+      get turn() {
+        return current().turn;
+      },
+      get me() {
+        return current().me;
+      },
+      get players() {
+        return current().players;
+      },
+      get interactions() {
+        return current().interactions;
+      },
+      get inputs() {
+        return current().inputs;
+      },
+      get zones() {
+        return current().zones;
+      },
+      get cards() {
+        return current().cards;
+      },
+      get events() {
+        return current().events;
+      },
+      store: {
+        get: () => this.store.get(),
+        subscribe: (listener) => this.store.subscribe(listener)
+      },
+      getSnapshot: () => this.building ?? this.store.get(),
+      getOptions: () => this.options,
+      setOptions: (next) => this.setOptions(next),
+      subscribe: (listener) => {
+        const sub = this.store.subscribe(listener);
+        return () => sub.unsubscribe();
+      },
+      dispose: () => this.dispose(),
+      assertCoverage: () => this.assertCoverage()
+    };
+    for (const [key, descriptor] of Object.entries(
+      Object.getOwnPropertyDescriptors(root)
+    )) {
+      if (descriptor.get) {
+        Object.defineProperty(root, key, {
+          enumerable: false,
+          configurable: false
+        });
+      }
+    }
+    Object.defineProperty(root, "store", {
+      enumerable: false,
+      configurable: false,
+      writable: false
+    });
+    this.instance = root;
+    this.store = createStore(Object.freeze(this.build()));
+    if ("apply" in options.source)
+      Object.defineProperty(root, "apply", {
+        value: (action) => this.options.source.apply(action)
+      });
+    if ("explore" in options.source)
+      Object.defineProperty(root, "explore", {
+        value: (...args) => this.options.source.explore(...args)
+      });
+    const runtime = {
+      game: this.instance,
+      getBoards: () => this.getBoardProjections(this.instance.view),
+      createBoard: (data2) => this.object("board", {
+        id: data2.id,
+        data: immutableCopy(data2),
+        game: this.instance
+      }),
+      routeTarget: (target, options2) => this.routeTarget(target, options2),
+      getCanDropCard: (cardId, target) => this.prepareCardDrop(cardId, target) !== void 0,
+      routeCardDrop: (cardId, target) => this.routeCardDrop(cardId, target),
+      getCanDropCardGroup: (cardIds, target) => !!this.prepareCardDrop(cardIds, target),
+      routeCardGroupDrop: (cardIds, target) => this.routeCardDrop(cardIds, target),
+      invalidate: () => {
+        if (!this.disposed) this.refresh();
+      }
+    };
+    const context = { ...runtime, [runtimeFeatures]: runtime };
+    for (const feature of Object.values(
+      features?.(this.instance, context) ?? {}
+    )) {
+      if (feature.root)
+        for (const key of Reflect.ownKeys(feature.root)) {
+          if (key in root || this.rootProperties.has(key))
+            throw new Error(`Overlapping feature property '${String(key)}'.`);
+          this.rootProperties.set(
+            key,
+            Object.getOwnPropertyDescriptor(feature.root, key)
+          );
+          Object.defineProperty(root, key, {
+            get: () => Reflect.get(this.building ?? this.store.get(), key)
+          });
+        }
+      for (const hook of [
+        "interaction",
+        "input",
+        "zone",
+        "card",
+        "board"
+      ])
+        this.install(this.prototypes[hook], feature[hook]);
+      if (feature.dispose) this.featureDisposals.push(feature.dispose);
+    }
+    this.refresh();
+    this.subscribeSource();
+    this.reportSourceFailure();
+  }
+  install(target, extension) {
+    if (!extension) return;
+    for (const key of Reflect.ownKeys(extension)) {
+      if (key in target || [
+        "game",
+        "owner",
+        "descriptor",
+        "draft",
+        "inputObjects",
+        "status",
+        "connected",
+        "key",
+        "id",
+        "phase",
+        "label",
+        "help",
+        "kind",
+        "interaction",
+        "view",
+        "hidden",
+        "zone",
+        "index",
+        "routes",
+        "cards"
+      ].includes(String(key)))
+        throw new Error(`Overlapping feature property '${String(key)}'.`);
+    }
+    Object.defineProperties(
+      target,
+      Object.getOwnPropertyDescriptors(extension)
+    );
+  }
+  object(hook, value) {
+    Object.setPrototypeOf(value, this.prototypes[hook]);
+    return Object.freeze(value);
+  }
+  drafts() {
+    if (this.options.state && this.options.state === this.invalidControlledState)
+      return EMPTY_DRAFTS;
+    return this.options.state?.drafts ?? this.localDrafts;
+  }
+  active() {
+    if (this.options.state && this.options.state === this.invalidControlledState)
+      return null;
+    return this.options.state?.activeInteraction !== void 0 ? this.options.state.activeInteraction : this.localActive;
+  }
+  writeDrafts(next) {
+    if (this.options.state?.drafts === void 0) this.localDrafts = next;
+    this.options.onDraftsChange?.(next);
+    this.refresh();
+  }
+  writeDraft(key, value) {
+    const drafts = this.drafts();
+    const next = { ...drafts };
+    if (value === void 0) delete next[key];
+    else next[key] = immutableValues(value);
+    this.writeDrafts(Object.freeze(next));
+  }
+  activate(key) {
+    if (this.disposed || key !== null && !this.current(key)) return;
+    if (this.options.state?.activeInteraction === void 0)
+      this.localActive = key;
+    this.options.onActiveInteractionChange?.(key);
+    this.refresh();
+  }
+  descriptorFor(base, draft) {
+    const zones = this.sourceState.snapshot?.frame.zones ?? {};
+    for (const input of base.inputs) {
+      const card = draft[input.key];
+      if (input.domain.type !== "cardTarget" || typeof card !== "string")
+        continue;
+      for (const zone of Object.values(zones).flatMap(
+        (hosts) => Object.values(hosts)
+      )) {
+        const route = zone.playableByCardId[card]?.find(
+          (value) => value.interactionKey === base.interactionKey
+        );
+        if (route) return route;
+      }
+    }
+    return base;
+  }
+  current(key) {
+    return this.store.get().interactions.find(key);
+  }
+  editable(key) {
+    const interaction = this.current(key);
+    return !this.disposed && this.sourceState.connection === "ready" && !this.sourceState.request && interaction?.getIsAvailable() ? interaction : void 0;
+  }
+  setInput(key, inputKey, value) {
+    const interaction = this.editable(key);
+    if (!interaction?.findInput(inputKey)) return;
+    this.writeDraft(key, { ...this.drafts()[key], [inputKey]: value });
+  }
+  clearInput(key, inputKey) {
+    if (!this.editable(key)?.findInput(inputKey)) return;
+    const value = { ...this.drafts()[key] };
+    delete value[inputKey];
+    this.writeDraft(key, value);
+  }
+  reset(key) {
+    if (this.disposed) return;
+    this.writeDraft(key, void 0);
+    if (this.active() === key) this.activate(null);
+  }
+  select(key, inputKey, value, route) {
+    const interaction = route ?? this.editable(key);
+    if (route && (!route.currentLifetime() || !route.getIsAvailable() || this.sourceState.connection !== "ready" || this.sourceState.request || this.pending))
+      return;
+    const input = interaction?.findInput(inputKey);
+    if (!interaction || !input?.getIsEligible(value)) return;
+    if (isManyInput(input.descriptor) || typeof value === "string" && (input.descriptor.domain.type === "cardTarget" || input.descriptor.domain.type === "boardTarget" || input.descriptor.domain.type === "tileTarget")) {
+      let next = { ...this.drafts()[key] };
+      routeInteractionTarget(
+        {
+          getDraft: () => next,
+          setInput: (_key, k, v) => {
+            next = { ...next, [k]: v };
+          },
+          clearInput: (_key, k) => {
+            if (k) delete next[k];
+          }
+        },
+        interaction.descriptor,
+        { inputKey, value }
+      );
+      this.writeDraft(key, next);
+    } else this.setInput(key, inputKey, value);
+    this.activate(key);
+    const current = this.current(key);
+    if (current && Object.hasOwn(this.drafts()[key] ?? EMPTY, inputKey) && shouldAutoSubmitInteraction(current.descriptor) && current.getIsReady())
+      this.handle(() => this.submit(key, false));
+  }
+  selectCard(id, options) {
+    const card = this.store.get().cards.find(id);
+    if (!card || this.sourceState.request || this.sourceState.connection !== "ready")
+      return;
+    const candidates = card.routes.flatMap((interaction) => {
+      if (!interaction.getIsAvailable() || !interaction.currentLifetime() || options?.interaction && interaction.key !== options.interaction)
+        return [];
+      return interaction.getInputs().filter(
+        (input) => input.descriptor.domain.type === "cardTarget" && (!options?.input || input.key === options.input) && input.getIsEligible(id)
+      ).map((input) => ({ interaction, input }));
+    });
+    if (candidates.length > 1) throw new AmbiguousTargetError(id);
+    const candidate = candidates[0];
+    if (candidate)
+      this.select(
+        candidate.interaction.key,
+        candidate.input.key,
+        id,
+        candidate.interaction
+      );
+  }
+  handle(submit) {
+    const source = this.options.source;
+    const active = () => !this.disposed && this.options.source === source;
+    void submit().then(
+      (result) => {
+        if (active() && !result.accepted)
+          this.options.onError?.(
+            new Error(result.message ?? result.errorCode, { cause: result })
+          );
+      },
+      (error) => {
+        if (!active()) return;
+        const state = source.store.get();
+        if (state.failure === error || state.connection === "closed") return;
+        this.options.onError?.(error);
+      }
+    );
+  }
+  async submit(key, cancel, params) {
+    const source = this.options.source;
+    const interaction = this.current(key);
+    if (this.disposed || this.sourceState.connection !== "ready" || this.sourceState.request || this.pending)
+      return { accepted: false, errorCode: "BUSY" };
+    if (!interaction) return { accepted: false, errorCode: "UNAVAILABLE" };
+    if (cancel ? !interaction.getStep()?.canCancel : !interaction.getIsAvailable(params) || !interaction.getIsReady(params))
+      return { accepted: false, errorCode: "UNAVAILABLE" };
+    if (!("submit" in source) || !("cancel" in source))
+      return { accepted: false, errorCode: "READ_ONLY" };
+    const commandSource = source;
+    const operation = {
+      source,
+      key,
+      draftRevision: params === void 0 ? this.revisions.get(key) ?? 0 : void 0,
+      version: this.sourceState.snapshot.version,
+      epoch: this.epoch,
+      accepted: false,
+      cancel
+    };
+    this.pending = operation;
+    try {
+      const result = await (cancel ? commandSource.cancel(interaction.id) : commandSource.submit(
+        interaction.id,
+        interaction.readiness(params).values
+      ));
+      if (this.pending !== operation) return result;
+      if (!result.accepted) {
+        this.pending = null;
+        this.refresh();
+        return result;
+      }
+      operation.accepted = true;
+      this.finishBarrier();
+      return result;
+    } catch (error) {
+      if (this.pending === operation) {
+        this.pending = null;
+        this.refresh();
+      }
+      throw error;
+    }
+  }
+  finishBarrier() {
+    const operation = this.pending;
+    if (!operation?.accepted || this.sourceState.request || operation.source !== this.options.source || operation.epoch !== this.epoch)
+      return;
+    if (this.sourceState.connection === "closed" || this.sourceState.connection === "failed") {
+      this.pending = null;
+      this.refresh();
+      return;
+    }
+    if (this.sourceState.connection !== "ready" || (this.sourceState.snapshot?.version ?? -1) <= operation.version)
+      return;
+    this.pending = null;
+    if (operation.draftRevision !== void 0 && (this.revisions.get(operation.key) ?? 0) === operation.draftRevision)
+      this.reset(operation.key);
+    else this.refresh();
+  }
+  reportSourceFailure() {
+    const failure = this.sourceState.failure;
+    if (!failure || !this.options.onError || this.reportedFailures.get(this.options.source) === failure)
+      return;
+    this.reportedFailures.set(this.options.source, failure);
+    this.options.onError?.(failure);
+  }
+  subscribeSource() {
+    const source = this.options.source;
+    this.subscription = source.store.subscribe(() => {
+      if (this.disposed || this.options.source !== source) return;
+      const next = source.store.get();
+      const previousSnapshot = this.sourceState.snapshot;
+      this.sourceState = next;
+      if (previousSnapshot && next.snapshot && previousSnapshot.me !== next.snapshot.me) {
+        this.epoch++;
+        this.invalidControlledState = this.options.state;
+        this.pending = null;
+        this.localDrafts = EMPTY_DRAFTS;
+        this.localActive = null;
+        this.options.onDraftsChange?.({});
+        this.options.onActiveInteractionChange?.(null);
+      }
+      this.reconcile();
+      this.refresh();
+      this.finishBarrier();
+      this.reportSourceFailure();
+    });
+  }
+  setOptions(next) {
+    if (this.disposed) throw new Error("Game instance is disposed.");
+    const changed = next.source !== this.options.source;
+    if (changed) {
+      this.epoch++;
+      this.subscription?.unsubscribe();
+      this.options.source.dispose();
+      this.pending = null;
+    }
+    this.options = next;
+    if (changed) {
+      this.invalidControlledState = next.state;
+      this.localDrafts = EMPTY_DRAFTS;
+      this.localActive = null;
+      this.sourceState = next.source.store.get();
+      this.options.onDraftsChange?.({});
+      this.options.onActiveInteractionChange?.(null);
+      this.subscribeSource();
+    }
+    this.reconcile();
+    this.refresh();
+    this.reportSourceFailure();
+  }
+  reconcile() {
+    const snapshot = this.sourceState.snapshot;
+    if (!snapshot) return;
+    const drafts = this.drafts();
+    let changed = false;
+    const next = { ...drafts };
+    for (const [key, values] of Object.entries(drafts)) {
+      if (!values) continue;
+      const base = snapshot.frame.availableInteractions.find(
+        (value) => value.interactionKey === key
+      );
+      if (!base) {
+        if (this.pending?.key !== key) {
+          delete next[key];
+          changed = true;
+        }
+        continue;
+      }
+      const descriptor = this.descriptorFor(base, values);
+      const kept = { ...values };
+      let fieldChanged = false;
+      for (const [name, value] of Object.entries(values)) {
+        const input = descriptor.inputs.find((input2) => input2.key === name);
+        if (!input && this.pending?.key === key) continue;
+        const selection = input && inputSelection(input);
+        if (input && selection?.mode === "many" && Array.isArray(value)) {
+          const eligible = value.filter(
+            (item) => inputTargetInDomain(input.domain, item)
+          );
+          const max = selection.max;
+          const retained = max === void 0 ? eligible : eligible.slice(0, max);
+          if (retained.length !== value.length) {
+            kept[name] = retained;
+            changed = true;
+            fieldChanged = true;
+          }
+          continue;
+        }
+        if (!input || !inDomain(input, value, true)) {
+          delete kept[name];
+          changed = true;
+          fieldChanged = true;
+        }
+      }
+      if (fieldChanged) next[key] = immutableValues(kept);
+    }
+    if (changed) {
+      const operation = this.pending;
+      const submitted = operation?.draftRevision !== void 0 && (this.revisions.get(operation.key) ?? 0) === operation.draftRevision;
+      this.writeDrafts(Object.freeze(next));
+      if (submitted)
+        operation.draftRevision = this.revisions.get(operation.key);
+    }
+    const active = this.active();
+    if (active && !snapshot.frame.availableInteractions.some(
+      (value) => value.interactionKey === active
+    ))
+      this.activate(null);
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.featureDisposals.forEach((dispose) => dispose());
+    this.subscription?.unsubscribe();
+    this.pending = null;
+    this.options.source.dispose();
+    this.sourceState = this.options.source.store.get();
+    this.refresh();
+  }
+  assertCoverage() {
+    const missing = this.sourceState.snapshot?.frame.availableInteractions.filter(
+      (d) => d.availability.status === "available" && !this.observed.has(d.interactionKey)
+    ).map((d) => d.interactionKey) ?? [];
+    if (missing.length)
+      throw new Error(`Interactions not read: ${missing.join(", ")}`);
+  }
+  routeTarget(target, options) {
+    if (target.kind === "card") {
+      this.selectCard(target.value, options);
+      return;
+    }
+    const candidates = this.lastInteractions.flatMap(
+      (interaction) => interaction.getInputs().filter(
+        (input) => (target.kind === "tile" ? input.descriptor.domain.type === "tileTarget" : matchesBoardTarget(input.descriptor, target)) && input.getIsEligible(target.value) && interaction.getIsAvailable() && (!options?.interaction || interaction.key === options.interaction) && (!options?.input || input.key === options.input)
+      ).map((input) => ({ interaction, input }))
+    );
+    if (candidates.length > 1)
+      throw new AmbiguousTargetError(JSON.stringify(target.value));
+    const match = candidates[0];
+    if (match)
+      this.select(match.interaction.key, match.input.key, target.value);
+  }
+  prepareCardDrop(cards, target) {
+    if (this.disposed || this.sourceState.request || this.pending || this.sourceState.connection !== "ready")
+      return;
+    const group = typeof cards !== "string";
+    const cardIds = group ? cards : [cards];
+    const cardId = cardIds[0];
+    if (!cardId || new Set(cardIds).size !== cardIds.length) return;
+    const card = this.store.get().cards.find(cardId);
+    const interaction = card?.routes.find(
+      (route) => route.key === target.interactionKey
+    );
+    if (!interaction?.currentLifetime() || !interaction.getIsAvailable())
+      return;
+    const cardInput = interaction.findInput(target.cardInputKey);
+    if (!cardInput || cardInput.descriptor.domain.type !== "cardTarget" || (group ? !isManyInput(cardInput.descriptor) || !inputValueInDomain(
+      cardInput.descriptor.domain,
+      cardIds,
+      cardInput.descriptor.domain.selection
+    ) : !cardInput.getIsEligible(cardId)))
+      return;
+    const input = target.kind === "interaction" ? void 0 : interaction.findInput(target.inputKey);
+    if (target.kind !== "interaction" && (!input || !(target.kind === "position" ? input.descriptor.domain.type === "zonePosition" : matchesBoardTarget(input.descriptor, target)) || !input.getIsEligible(target.value)))
+      return;
+    const params = target.kind === "interaction" ? target.params : void 0;
+    const submitBound = group || params !== void 0 || target.kind === "position";
+    if (params && Object.keys(params).some(
+      (key) => key === cardInput.key || !interaction.findInput(key)
+    ))
+      return;
+    let next = {
+      ...this.drafts()[interaction.key],
+      ...params
+    };
+    const chosen = next[cardInput.key];
+    const alreadyChosen = !submitBound && !input && isManyInput(cardInput.descriptor) && Array.isArray(chosen) && chosen.includes(cardId);
+    if (submitBound) {
+      next[cardInput.key] = isManyInput(cardInput.descriptor) ? [...cardIds] : cardId;
+      if (input && target.kind !== "interaction")
+        next[input.key] = target.value;
+    } else if (!alreadyChosen)
+      routeCardInputIntent(
+        {
+          getDraft: () => next,
+          setInput: (_key, key, value) => {
+            next = { ...next, [key]: value };
+          },
+          clearInput: (_key, key) => {
+            if (key) delete next[key];
+          }
+        },
+        interaction.descriptor,
+        {
+          cardId,
+          cardInputKey: cardInput.key,
+          dropTarget: input && target.kind !== "interaction" ? { inputKey: input.key, value: target.value } : void 0
+        }
+      );
+    if (submitBound && (!interaction.getIsAvailable(next) || !interaction.getIsReady(next)))
+      return;
+    return {
+      interaction,
+      next,
+      alreadyChosen,
+      submitBound
+    };
+  }
+  routeCardDrop(cardId, target) {
+    const prepared = this.prepareCardDrop(cardId, target);
+    if (!prepared) return;
+    const { interaction, next, alreadyChosen, submitBound } = prepared;
+    if (!alreadyChosen || target.kind === "interaction" && target.params !== void 0)
+      this.writeDraft(interaction.key, next);
+    this.activate(interaction.key);
+    const current = this.current(interaction.key);
+    if (!alreadyChosen && current && (submitBound || shouldAutoSubmitInteraction(current.descriptor)) && current.getIsReady())
+      this.handle(() => current.submit());
+  }
+  warnUnread() {
+    const environment = import.meta.env?.DEV ?? globalThis.process?.env?.NODE_ENV === "development";
+    if (!(this.options.debug ?? environment)) return;
+    queueMicrotask(() => {
+      if (this.disposed) return;
+      for (const descriptor of this.sourceState.snapshot?.frame.availableInteractions ?? []) {
+        const key = descriptor.interactionKey;
+        if (descriptor.availability.status === "available" && !this.observed.has(key) && !this.warned.has(key)) {
+          this.warned.add(key);
+          console.warn(`Available interaction '${key}' has not been read.`);
+        }
+      }
+    });
+  }
+  build(previous) {
+    this.trackDrafts();
+    const { snapshot, connection, request, failure } = this.sourceState;
+    const old = previous?.snapshot;
+    const drafts = this.drafts();
+    const active = this.active();
+    const sameSnapshot = snapshot === old;
+    const sameActors = sameSnapshot;
+    const summaries = snapshot?.players ?? [];
+    const activeIds = snapshot?.frame.flow.activePlayers ?? [];
+    const playerObjects = sameActors && previous ? previous.players.getAll() : Object.freeze(
+      summaries.map(
+        (player, index) => Object.freeze(
+          new PlayerObject(
+            this,
+            player,
+            index,
+            player.playerId === snapshot?.me,
+            activeIds.includes(player.playerId)
+          )
+        )
+      )
+    );
+    const players = sameActors && previous ? previous.players : {
+      order: Object.freeze(playerObjects.map((p) => p.id)),
+      get: (id) => requireLookup(
+        playerObjects.find((p) => p.id === id),
+        "Player",
+        id
+      ),
+      find: (id) => playerObjects.find((p) => p.id === id),
+      getAll: () => playerObjects,
+      next: (id) => {
+        const index = playerObjects.findIndex((p) => p.id === id);
+        return requireLookup(
+          index < 0 ? void 0 : playerObjects[(index + 1) % playerObjects.length],
+          "Next player after",
+          id
+        );
+      }
+    };
+    const me = sameActors && previous ? previous.me : snapshot ? {
+      id: snapshot.me,
+      player: players.get(snapshot.me),
+      getCanAct: () => snapshot.frame.availableInteractions.some(
+        (value) => value.availability.status === "available"
+      )
+    } : null;
+    const descriptors = snapshot?.frame.availableInteractions ?? [];
+    const interactionObjects = descriptors.map((base) => {
+      const key = base.interactionKey;
+      const draft = drafts[key] ?? EMPTY;
+      const descriptor = this.descriptorFor(base, draft);
+      const status = request || this.pending ? request?.interactionId === descriptor.interactionId && request.phase === "awaiting-frame" ? "submitted" : "submitting" : "open";
+      const oldObject = this.lastInteractions.find(
+        (value) => value.key === key
+      );
+      return oldObject?.descriptor === descriptor && oldObject.epoch === this.epoch && oldObject.source === this.options.source && oldObject.draftIdentity === draft && oldObject.status === status && oldObject.connected === (connection === "ready") ? oldObject : this.object(
+        "interaction",
+        new InteractionObject(
+          this,
+          descriptor,
+          draft,
+          status,
+          connection === "ready"
+        )
+      );
+    });
+    const interactionsSame = previous && interactionObjects.length === this.lastInteractions.length && interactionObjects.every(
+      (value, index) => value === this.lastInteractions[index]
+    );
+    this.lastInteractions = Object.freeze(interactionObjects);
+    const interactions = interactionsSame ? previous.interactions : {
+      get: (key) => {
+        this.observed.add(key);
+        return requireLookup(
+          interactionObjects.find((value) => value.key === key),
+          "Interaction",
+          key
+        );
+      },
+      find: (key) => {
+        this.observed.add(key);
+        return interactionObjects.find((value) => value.key === key);
+      },
+      list: () => {
+        interactionObjects.forEach((value) => this.observed.add(value.key));
+        return Object.freeze(interactionObjects);
+      },
+      listAvailable: () => {
+        const available = interactionObjects.filter(
+          (value) => value.getIsAvailable()
+        );
+        available.forEach((value) => this.observed.add(value.key));
+        return Object.freeze(available);
+      }
+    };
+    const inputs = interactionsSame && previous ? previous.inputs : {
+      get: (key, name) => requireLookup(
+        interactions.find(key)?.findInput(name),
+        `Input in interaction ${key}`,
+        name
+      ),
+      find: (key, name) => interactions.find(key)?.findInput(name)
+    };
+    const zonesSame = sameSnapshot && interactionsSame && previous;
+    const zones = zonesSame ? previous.zones : (() => {
+      const objects = Object.entries(snapshot?.frame.zones ?? {}).flatMap(
+        ([id, hosts]) => Object.entries(hosts).map(
+          ([hostId, zone]) => this.object(
+            "zone",
+            new ZoneObject(
+              this,
+              id,
+              hostId,
+              Object.freeze(
+                zone.cardIds.map(
+                  (cardId, index) => this.object(
+                    "card",
+                    new CardObject(
+                      this,
+                      cardId,
+                      id,
+                      hostId,
+                      index,
+                      zone.cardViewsById[cardId],
+                      zone.cardBacksById[cardId],
+                      Object.freeze(
+                        (zone.playableByCardId[cardId] ?? []).map(
+                          (descriptor) => this.object(
+                            "interaction",
+                            new InteractionObject(
+                              this,
+                              descriptor,
+                              drafts[descriptor.interactionKey] ?? EMPTY,
+                              request || this.pending ? "submitting" : "open",
+                              connection === "ready"
+                            )
+                          )
+                        )
+                      )
+                    )
+                  )
+                )
+              ),
+              Object.freeze(
+                zone.tiles.map(
+                  (tile, index) => new TileObject(
+                    this,
+                    tile,
+                    id,
+                    hostId,
+                    index,
+                    Object.freeze(
+                      interactionObjects.filter(
+                        (interaction) => interaction.getInputs().some(
+                          (input) => input.descriptor.domain.type === "tileTarget" && input.getIsEligible(tile.ref)
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      );
+      const find = (id, hostId) => objects.find((zone) => zone.id === id && zone.hostId === hostId);
+      return {
+        get: (id, hostId) => requireLookup(find(id, hostId), "Zone", id),
+        find,
+        getAll: () => Object.freeze(objects)
+      };
+    })();
+    const cards = zonesSame ? previous.cards : {
+      get: (id) => requireLookup(
+        zones.getAll().map((zone) => zone.findCard(id)).find((card) => card !== void 0),
+        "Card",
+        id
+      ),
+      find: (id) => zones.getAll().map((zone) => zone.findCard(id)).find((card) => card !== void 0)
+    };
+    const capturedState = this.lastSnapshotDrafts === drafts && previous?.state.activeInteraction === active ? previous.state : immutableCopy({ drafts, activeInteraction: active });
+    this.lastSnapshotDrafts = drafts;
+    for (const value of [players, me, interactions, inputs, zones, cards])
+      if (value) Object.freeze(value);
+    const model = {
+      snapshot,
+      view: snapshot?.frame.view ?? null,
+      version: snapshot?.version ?? null,
+      connection,
+      request,
+      failure,
+      state: capturedState,
+      phase: sameSnapshot && previous ? previous.phase : Object.freeze(
+        new PhaseObject(snapshot?.frame.flow.currentPhase ?? null)
+      ),
+      turn: sameSnapshot && previous ? previous.turn : Object.freeze({
+        activePlayerIds: activeIds,
+        currentPlayerId: activeIds.length === 1 ? activeIds[0] : null,
+        order: players.order,
+        isMine: snapshot ? activeIds.includes(snapshot.me) : false
+      }),
+      me,
+      players,
+      interactions,
+      inputs,
+      zones,
+      cards,
+      events: sameSnapshot && previous ? previous.events : Object.freeze({
+        recent: snapshot?.frame.events ?? Object.freeze([])
+      })
+    };
+    this.building = model;
+    try {
+      for (const [key, descriptor] of this.rootProperties)
+        Object.defineProperty(model, key, {
+          value: descriptor.get ? descriptor.get.call(this.instance) : descriptor.value,
+          enumerable: true
+        });
+    } finally {
+      this.building = void 0;
+    }
+    return model;
+  }
+  refresh() {
+    if (!this.store) return;
+    this.store.setState((previous) => Object.freeze(this.build(previous)));
+    this.warnUnread();
+  }
+};
+function createGameInstance() {
+  return function(options) {
+    const controller = new Controller(
+      options,
+      options.features
+    );
+    return controller.instance;
+  };
+}
+
+// src/headless/gesture.ts
+var GESTURE_THRESHOLDS = Object.freeze({
+  /** Movement, in CSS pixels, before a press becomes a drag or a browse. */
+  slop: 8,
+  /** A touch or pen held this long without moving inspects the card. */
+  holdMs: 350,
+  /** A mouse resting on a card this long inspects it. */
+  hoverMs: 250,
+  /** A finger drags when upward travel exceeds this multiple of sideways travel. */
+  axisBias: 1.25
+});
+function createGestureRecognizer(down, callbacks, options = {}) {
+  const origin = { x: down.clientX, y: down.clientY };
+  const mouse = down.pointerType === "mouse";
+  let kind = "tap";
+  let finished = false;
+  let pull = origin;
+  const holdTimer = mouse ? void 0 : setTimeout(() => {
+    kind = "hold";
+    callbacks.hold();
+  }, GESTURE_THRESHOLDS.holdMs);
+  const point = (event) => ({
+    x: event.clientX,
+    y: event.clientY
+  });
+  const ours = (event) => !finished && (!event || event.pointerId === down.pointerId);
+  function finish() {
+    finished = true;
+    clearTimeout(holdTimer);
+  }
+  const rises = (from, to) => from.y - to.y > GESTURE_THRESHOLDS.axisBias * Math.abs(to.x - from.x);
+  function drag(from, to) {
+    if (!callbacks.dragStart(from)) return false;
+    kind = "drag";
+    callbacks.dragMove(to);
+    return true;
+  }
+  return {
+    move(event) {
+      if (!ours(event)) return;
+      const at = point(event);
+      if (kind === "drag") return callbacks.dragMove(at);
+      if (kind === "browse") {
+        if (!options.scrub) return;
+        callbacks.browse?.(at);
+        if (!rises(pull, at) || pull.y - at.y >= GESTURE_THRESHOLDS.slop && !drag(pull, at))
+          pull = at;
+        return;
+      }
+      if (kind !== "tap" || Math.hypot(at.x - origin.x, at.y - origin.y) < GESTURE_THRESHOLDS.slop)
+        return;
+      clearTimeout(holdTimer);
+      const lifts = mouse || options.dragDirection === "any" || rises(origin, at);
+      if (lifts && drag(origin, at)) return;
+      kind = "browse";
+      pull = at;
+      if (options.scrub) callbacks.browse?.(at);
+    },
+    up(event) {
+      if (!ours(event)) return;
+      finish();
+      callbacks.end(kind, point(event));
+    },
+    cancel(event) {
+      if (!ours(event)) return;
+      finish();
+      callbacks.cancel(kind);
+    }
+  };
+}
+function magneticDropPoint(point, box, retained, coarse) {
+  const radius = coarse ? retained ? 52 : 28 : retained ? 36 : 18;
+  if (box.width <= 0 || box.height <= 0) return null;
+  const x = Math.max(box.x, Math.min(point.x, box.x + box.width));
+  const y = Math.max(box.y, Math.min(point.y, box.y + box.height));
+  return Math.hypot(point.x - x, point.y - y) <= radius ? { x, y } : null;
+}
+
+// src/headless/drop-targets.ts
+function isSameDropTarget(left, right) {
+  if (left.interactionKey !== right.interactionKey || left.cardInputKey !== right.cardInputKey)
+    return false;
+  if (left.kind === "interaction" || right.kind === "interaction")
+    return left.kind === "interaction" && right.kind === "interaction" && sameParams(left.params, right.params);
+  if (left.kind === "position" || right.kind === "position")
+    return left.kind === "position" && right.kind === "position" && left.inputKey === right.inputKey && inputValueKey(left.value) === inputValueKey(right.value);
+  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.inputKey === right.inputKey;
+}
+function sameParams(left, right) {
+  if (left === void 0 || right === void 0) return left === right;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every(
+    (key) => key in right && inputValueKey(left[key]) === inputValueKey(right[key])
+  );
+}
+
+export {
+  runtimeFeatures,
+  AmbiguousTargetError,
+  createGameInstance,
+  isSameDropTarget,
+  GESTURE_THRESHOLDS,
+  createGestureRecognizer,
+  magneticDropPoint
+};
+//# sourceMappingURL=chunk-3RFGPBES.js.map