@dreamboard-games/sdk 0.5.0-alpha.3 → 0.5.0-alpha.30

package/dist/{chunk-SP234IY4.js → chunk-BVWJS3AB.js}

@@ -1,9 +1,73 @@
 import {
-  immutableCopy
-} from "./chunk-DMFVAZI2.js";
-import {
-  inputValueInDomain
-} from "./chunk-VUWNJXLJ.js";
+  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";
@@ -30,68 +94,13 @@ function validateInteractionInputDomains(descriptor, params) {
   for (const rawInput of descriptor.inputs) {
     const input = rawInput;
     const value = params[input.key];
-    if (value === void 0 || value === null) continue;
-    const selectionErrors = validateInputSelection(input, value);
-    for (const error of selectionErrors) {
+    if (value === void 0) continue;
+    for (const error of inputDomainErrors(
+      input.domain,
+      value,
+      input.domain.selection
+    ))
       pushFieldError(fieldErrors, input.key, error);
-    }
-    if (input.domain.type === "choiceList") {
-      if (!Array.isArray(value)) {
-        pushFieldError(fieldErrors, input.key, "Expected a list of choices.");
-        continue;
-      }
-      const min = input.domain.min ?? 0;
-      const max = input.domain.max ?? input.domain.choices?.length ?? Number.POSITIVE_INFINITY;
-      if (value.length < min) {
-        pushFieldError(
-          fieldErrors,
-          input.key,
-          `Choose at least ${min} ${pluralize("option", min)}.`
-        );
-      }
-      if (value.length > max) {
-        pushFieldError(
-          fieldErrors,
-          input.key,
-          `Choose at most ${max} ${pluralize("option", max)}.`
-        );
-      }
-      const allowed = new Set(
-        input.domain.choices?.map((choice) => choice.value)
-      );
-      if (allowed.size > 0 && value.some((item) => !allowed.has(String(item)))) {
-        pushFieldError(
-          fieldErrors,
-          input.key,
-          "Selected choice is not eligible."
-        );
-      }
-    }
-    if (input.domain.type === "choice") {
-      const allowed = new Set(
-        input.domain.choices?.map((choice) => choice.value)
-      );
-      if (allowed.size > 0 && !allowed.has(value)) {
-        pushFieldError(
-          fieldErrors,
-          input.key,
-          "Selected choice is not eligible."
-        );
-      }
-    }
-    if (isResolvedTargetDomain(input.domain)) {
-      const values = valuesForSelection(input.domain.selection, value);
-      for (const item of values) {
-        if (!input.domain.eligibleTargets.includes(String(item))) {
-          pushFieldError(
-            fieldErrors,
-            input.key,
-            "Selected target is not eligible."
-          );
-          break;
-        }
-      }
-    }
   }
   return fieldErrors;
 }
@@ -110,10 +119,10 @@ function isManyInput(input) {
 }
 function toggleManyValue(current, value, selection) {
   if (selection.mode !== "many") return [value];
-  const previous = Array.isArray(current) ? current.map((item) => String(item)) : [];
-  const existing = previous.indexOf(value);
+  const previous = Array.isArray(current) ? current : [];
+  const existing = previous.findIndex((item) => sameValue(item, value));
   if (existing >= 0) {
-    return previous.filter((item) => item !== value);
+    return previous.filter((item) => !sameValue(item, value));
   }
   if (selection.max !== void 0 && previous.length >= selection.max) {
     return previous;
@@ -123,9 +132,8 @@ function toggleManyValue(current, value, selection) {
 function isManyTargetSelectable(input, current, targetId) {
   const selection = inputSelection(input);
   if (selection?.mode !== "many") return true;
-  const currentValues = Array.isArray(current) ? current.map((item) => String(item)) : [];
-  if (currentValues.includes(targetId)) return true;
-  if (selection.distinct && currentValues.includes(targetId)) return false;
+  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) {
@@ -136,52 +144,21 @@ function hasInteractionFieldErrors(fieldErrors) {
 function inputByKey(descriptor, key) {
   return descriptor.inputs.find((input) => input.key === key);
 }
-function isTargetDomain(domain) {
-  if (!domain) return false;
-  return domain.type === "cardTarget" || domain.type === "boardTarget";
-}
-function isResolvedTargetDomain(domain) {
-  return (domain.type === "cardTarget" || domain.type === "boardTarget") && domain.projection === "resolved";
-}
-function validateInputSelection(input, value) {
-  const selection = inputSelection(input);
-  if (selection?.mode !== "many") return [];
-  if (!Array.isArray(value)) return ["Expected a list of values."];
-  const errors = [];
-  const min = selection.min;
-  if (value.length < min) {
-    errors.push(`Choose at least ${min} ${pluralize("value", min)}.`);
-  }
-  if (selection.max !== void 0 && value.length > selection.max) {
-    errors.push(
-      `Choose at most ${selection.max} ${pluralize("value", selection.max)}.`
-    );
-  }
-  if (selection.distinct) {
-    const seen = /* @__PURE__ */ new Set();
-    for (const item of value) {
-      const key = String(item);
-      if (seen.has(key)) {
-        errors.push("Choose each value only once.");
-        break;
-      }
-      seen.add(key);
-    }
-  }
-  return errors;
-}
-function valuesForSelection(selection, value) {
-  if (selection?.mode === "many") return Array.isArray(value) ? value : [];
-  return [value];
-}
 function inputSelection(input) {
-  return "selection" in input.domain ? input.domain.selection : void 0;
+  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 pluralize(word, count) {
-  return count === 1 ? word : `${word}s`;
+function sameValue(left, right) {
+  return inputValueKey(left) === inputValueKey(right);
 }
 
 // src/headless/interaction-router.ts
@@ -236,8 +213,12 @@ function getInteractionDraftReadiness(descriptor, draft) {
 function routeInteractionTarget(store, descriptor, target) {
   const input = inputByKey(descriptor, target.inputKey);
   const currentDraft = store.getDraft(descriptor.interactionKey);
-  const selection = isTargetDomain(input?.domain) ? input.domain.selection : void 0;
-  const targetValue = selection?.mode === "many" ? toggleManyValue(currentDraft[target.inputKey], target.value, selection) : target.value;
+  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,
@@ -258,18 +239,24 @@ function routeCardInputIntent(store, descriptor, intent) {
   });
 }
 function shouldAutoSubmitInteraction(descriptor) {
-  return descriptor.commit.mode === "autoWhenReady" && !descriptor.inputs.some((input) => isManyInput(input));
+  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" && JSON.stringify(a) === JSON.stringify(b);
+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);
 }
@@ -286,7 +273,7 @@ function data(action, interaction, input, value) {
 var AmbiguousTargetError = class extends Error {
   constructor(id) {
     super(
-      `Target '${id}' belongs to more than one interaction. Choose an interaction explicitly.`
+      `Target '${id}' belongs to more than one eligible input. Choose an interaction and input explicitly.`
     );
     this.name = "AmbiguousTargetError";
   }
@@ -338,8 +325,9 @@ var InteractionObject = class {
   getAvailability() {
     return this.descriptor.availability;
   }
-  getIsAvailable() {
-    return this.descriptor.availability.status === "available";
+  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;
@@ -351,22 +339,26 @@ var InteractionObject = class {
     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() {
-    const readiness = getInteractionDraftReadiness(this.descriptor, this.draft);
-    return {
-      ...readiness,
-      ready: readiness.ready && this.descriptor.inputs.every(
-        (input) => inDomain(input, readiness.values[input.key])
-      )
-    };
+  readiness(params = this.draft) {
+    return getInteractionDraftReadiness(
+      this.owner.descriptorFor(this.descriptor, params),
+      params
+    );
   }
-  getIsReady() {
-    return this.readiness().ready;
+  getIsReady(params) {
+    return this.readiness(params).ready;
   }
   getMissingInputs() {
     return this.readiness().missingInputs;
@@ -377,8 +369,8 @@ var InteractionObject = class {
   currentLifetime() {
     return this.source === this.owner.options.source && this.epoch === this.owner.epoch && !this.owner.disposed;
   }
-  submit() {
-    return this.currentLifetime() ? this.owner.submit(this.key, false) : Promise.resolve({ accepted: false, errorCode: "CLOSED" });
+  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" });
@@ -389,39 +381,119 @@ var InteractionObject = class {
   activate() {
     if (this.currentLifetime()) this.owner.activate(this.key);
   }
-  getSubmitHandler() {
+  getSubmitHandler(params) {
     return (event) => {
       event?.preventDefault();
-      this.owner.handle(this.submit());
+      this.owner.handle(() => this.submit(params));
     };
   }
-  getSubmitProps() {
-    const disabled = !this.getIsAvailable() || !this.getIsReady() || this.status !== "open" || !this.connected;
+  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(),
+      "data-ready": this.getIsReady(params),
       "data-disabled": disabled,
-      onClick: this.getSubmitHandler()
+      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;
   }
@@ -429,11 +501,11 @@ var InputObject = class {
     return this.interaction.draft[this.key] ?? (Object.hasOwn(this.interaction.draft, this.key) ? null : this.descriptor.defaultValue);
   }
   setValue(value) {
-    if (!this.interaction.currentLifetime()) return;
+    if (!this.currentLifetime()) return;
     this.interaction.owner.setInput(this.interaction.key, this.key, value);
   }
   clear() {
-    if (!this.interaction.currentLifetime()) return;
+    if (!this.currentLifetime()) return;
     this.interaction.owner.clearInput(this.interaction.key, this.key);
   }
   getIsReady() {
@@ -443,23 +515,20 @@ var InputObject = class {
     };
     return getInteractionDraftReadiness(descriptor, {
       [this.key]: this.getValue()
-    }).ready && inDomain(this.descriptor, this.getValue());
+    }).ready;
   }
   getEligibleTargets() {
     const domain = this.descriptor.domain;
-    if (domain.type === "cardTarget" || domain.type === "boardTarget")
+    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;
-    const selection = input.domain.selection;
-    return inDomain(
-      { ...input, domain: { ...input.domain, selection: void 0 } },
-      value
-    ) && (!selection || selection.mode !== "many" || isManyTargetSelectable(input, this.getValue(), String(value)));
+    return inputTargetInDomain(input.domain, value) && isManyTargetSelectable(input, this.getValue(), value);
   }
   getIsSelected(value) {
     const current = this.getValue();
@@ -467,7 +536,7 @@ var InputObject = class {
   }
   getSelectHandler(value) {
     return () => {
-      if (this.interaction.currentLifetime())
+      if (this.currentLifetime())
         this.interaction.owner.select(this.interaction.key, this.key, value);
     };
   }
@@ -485,49 +554,43 @@ var InputObject = class {
       onClick: () => this.getSelectHandler(value)()
     };
   }
-  getFieldProps() {
+  getControl() {
     const disabled = !this.interaction.getIsAvailable() || this.interaction.status !== "open" || !this.interaction.connected;
-    return {
+    return createInputControl(this, {
       ...data("option", this.interaction.key, this.key),
       "data-seat": this.interaction.seat,
-      value: this.getValue() ?? "",
       disabled,
-      "data-disabled": disabled,
-      onChange: (event) => {
-        if (event.currentTarget.value === "") {
-          this.clear();
-          return;
-        }
-        this.setValue(
-          this.descriptor.domain.type === "boundedNumber" ? Number(event.currentTarget.value) : event.currentTarget.value
-        );
-      }
-    };
+      "data-disabled": disabled
+    });
   }
 };
 var CardObject = class {
-  constructor(owner, id, zone, index, encoded, routes) {
+  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 = encoded ? immutableCopy(JSON.parse(encoded)) : null;
+    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;
   }
@@ -544,16 +607,16 @@ var CardObject = class {
       )
     );
   }
-  getCanSelect() {
+  getCanSelect(options) {
     return this.routes.some(
-      (route) => route.getIsAvailable() && route.status === "open" && route.connected && route.getInputs().some(
-        (input) => input.descriptor.domain.type === "cardTarget" && input.getIsEligible(this.id)
+      (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?.interaction);
+    this.owner.selectCard(this.id, options);
   }
   getSelectHandler(options) {
     return () => this.select(options);
@@ -561,38 +624,129 @@ var CardObject = class {
   getProps(options) {
     return {
       type: "button",
-      disabled: !this.getCanSelect(),
+      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(),
+      "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, cards) {
+  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;
+    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) {
@@ -633,6 +787,17 @@ var PhaseObject = class {
   }
 };
 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;
@@ -649,6 +814,7 @@ var Controller = class {
   };
   subscription;
   sourceState;
+  reportedFailures = /* @__PURE__ */ new WeakMap();
   pending = null;
   building;
   rootProperties = /* @__PURE__ */ new Map();
@@ -675,7 +841,60 @@ var Controller = class {
     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),
@@ -684,37 +903,25 @@ var Controller = class {
         return () => sub.unsubscribe();
       },
       dispose: () => this.dispose(),
-      assertCoverage: () => this.assertCoverage(),
-      inspect: () => this.store.get()
+      assertCoverage: () => this.assertCoverage()
     };
-    this.instance = root;
-    for (const key of [
-      "snapshot",
-      "view",
-      "version",
-      "connection",
-      "request",
-      "state",
-      "phase",
-      "turn",
-      "me",
-      "players",
-      "interactions",
-      "inputs",
-      "zones",
-      "cards",
-      "events"
-    ])
-      Object.defineProperty(root, key, {
-        get: () => (this.building ?? this.store.get())[key]
-      });
-    this.store = createStore(Object.freeze(this.build()));
-    Object.defineProperty(root, "store", {
-      value: {
-        get: () => this.store.get(),
-        subscribe: (listener) => this.store.subscribe(listener)
+    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)
@@ -723,18 +930,24 @@ var Controller = class {
       Object.defineProperty(root, "explore", {
         value: (...args) => this.options.source.explore(...args)
       });
-    const context = {
-      createBoard: (id, data2) => this.object("board", {
-        id,
+    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: (kind, id, options2) => this.routeTarget(kind, id, options2?.interaction, options2?.boardId),
+      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) ?? {}
     )) {
@@ -762,6 +975,7 @@ var Controller = class {
     }
     this.refresh();
     this.subscribeSource();
+    this.reportSourceFailure();
   }
   install(target, extension) {
     if (!extension) return;
@@ -796,7 +1010,8 @@ var Controller = class {
     );
   }
   object(hook, value) {
-    return Object.freeze(Object.setPrototypeOf(value, this.prototypes[hook]));
+    Object.setPrototypeOf(value, this.prototypes[hook]);
+    return Object.freeze(value);
   }
   drafts() {
     if (this.options.state && this.options.state === this.invalidControlledState)
@@ -833,7 +1048,9 @@ var Controller = class {
       const card = draft[input.key];
       if (input.domain.type !== "cardTarget" || typeof card !== "string")
         continue;
-      for (const zone of Object.values(zones)) {
+      for (const zone of Object.values(zones).flatMap(
+        (hosts) => Object.values(hosts)
+      )) {
         const route = zone.playableByCardId[card]?.find(
           (value) => value.interactionKey === base.interactionKey
         );
@@ -843,7 +1060,7 @@ var Controller = class {
     return base;
   }
   current(key) {
-    return this.store.get().interactions.get(key);
+    return this.store.get().interactions.find(key);
   }
   editable(key) {
     const interaction = this.current(key);
@@ -851,11 +1068,11 @@ var Controller = class {
   }
   setInput(key, inputKey, value) {
     const interaction = this.editable(key);
-    if (!interaction?.getInput(inputKey)) return;
+    if (!interaction?.findInput(inputKey)) return;
     this.writeDraft(key, { ...this.drafts()[key], [inputKey]: value });
   }
   clearInput(key, inputKey) {
-    if (!this.editable(key)?.getInput(inputKey)) return;
+    if (!this.editable(key)?.findInput(inputKey)) return;
     const value = { ...this.drafts()[key] };
     delete value[inputKey];
     this.writeDraft(key, value);
@@ -869,9 +1086,9 @@ var Controller = class {
     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?.getInput(inputKey);
+    const input = interaction?.findInput(inputKey);
     if (!interaction || !input?.getIsEligible(value)) return;
-    if (typeof value === "string" && (input.descriptor.domain.type === "cardTarget" || input.descriptor.domain.type === "boardTarget")) {
+    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(
         {
@@ -891,61 +1108,67 @@ var Controller = class {
     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, explicit) {
-    const card = this.store.get().cards.get(id);
-    if (!card) return;
-    let routes = card.routes.filter(
-      (route2) => route2.getIsAvailable() && route2.currentLifetime() && !this.sourceState.request && this.sourceState.connection === "ready" && route2.getInputs().some(
-        (input2) => input2.descriptor.domain.type === "cardTarget" && input2.getIsEligible(id)
-      )
-    );
-    if (explicit) routes = routes.filter((route2) => route2.key === explicit);
-    if (routes.length > 1) throw new AmbiguousTargetError(id);
-    const route = routes[0];
-    const input = route?.getInputs().find(
-      (input2) => input2.descriptor.domain.type === "cardTarget" && input2.getIsEligible(id)
-    );
-    if (route && input) this.select(route.key, input.key, id, route);
+      this.handle(() => this.submit(key, false));
   }
-  handle(promise) {
-    void promise.then(
+  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 (!result.accepted)
+        if (active() && !result.accepted)
           this.options.onError?.(
             new Error(result.message ?? result.errorCode, { cause: result })
           );
       },
-      (error) => this.options.onError?.(error)
+      (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) {
+  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() || !interaction.getIsReady())
+    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,
-      draft: this.drafts()[key] ?? EMPTY,
-      revision: this.revisions.get(key) ?? 0,
-      version: this.sourceState.snapshot.version,
-      epoch: this.epoch,
-      accepted: false,
-      cancel
+      draftRevision: params === void 0 ? this.revisions.get(key) ?? 0 : void 0
     };
     this.pending = operation;
     try {
       const result = await (cancel ? commandSource.cancel(interaction.id) : commandSource.submit(
         interaction.id,
-        interaction.readiness().values
+        interaction.readiness(params).values
       ));
       if (this.pending !== operation) return result;
       if (!result.accepted) {
@@ -953,8 +1176,10 @@ var Controller = class {
         this.refresh();
         return result;
       }
-      operation.accepted = true;
-      this.finishBarrier();
+      this.pending = null;
+      if (operation.draftRevision !== void 0 && (this.revisions.get(operation.key) ?? 0) === operation.draftRevision)
+        this.reset(operation.key);
+      else this.refresh();
       return result;
     } catch (error) {
       if (this.pending === operation) {
@@ -964,21 +1189,12 @@ var Controller = class {
       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.pending = null;
-      this.refresh();
-      return;
-    }
-    if (this.sourceState.connection !== "ready" || (this.sourceState.snapshot?.version ?? -1) <= operation.version)
+  reportSourceFailure() {
+    const failure = this.sourceState.failure;
+    if (!failure || !this.options.onError || this.reportedFailures.get(this.options.source) === failure)
       return;
-    this.pending = null;
-    if ((this.revisions.get(operation.key) ?? 0) === operation.revision)
-      this.reset(operation.key);
-    else this.refresh();
+    this.reportedFailures.set(this.options.source, failure);
+    this.options.onError?.(failure);
   }
   subscribeSource() {
     const source = this.options.source;
@@ -998,7 +1214,7 @@ var Controller = class {
       }
       this.reconcile();
       this.refresh();
-      this.finishBarrier();
+      this.reportSourceFailure();
     });
   }
   setOptions(next) {
@@ -1022,6 +1238,7 @@ var Controller = class {
     }
     this.reconcile();
     this.refresh();
+    this.reportSourceFailure();
   }
   reconcile() {
     const snapshot = this.sourceState.snapshot;
@@ -1047,11 +1264,12 @@ var Controller = class {
       for (const [name, value] of Object.entries(values)) {
         const input = descriptor.inputs.find((input2) => input2.key === name);
         if (!input && this.pending?.key === key) continue;
-        if (input?.domain.selection?.mode === "many" && Array.isArray(value)) {
+        const selection = input && inputSelection(input);
+        if (input && selection?.mode === "many" && Array.isArray(value)) {
           const eligible = value.filter(
-            (item) => inputValueInDomain(input.domain, item)
+            (item) => inputTargetInDomain(input.domain, item)
           );
-          const max = input.domain.selection.max;
+          const max = selection.max;
           const retained = max === void 0 ? eligible : eligible.slice(0, max);
           if (retained.length !== value.length) {
             kept[name] = retained;
@@ -1068,7 +1286,13 @@ var Controller = class {
       }
       if (fieldChanged) next[key] = immutableValues(kept);
     }
-    if (changed) this.writeDrafts(Object.freeze(next));
+    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
@@ -1082,11 +1306,7 @@ var Controller = class {
     this.subscription?.unsubscribe();
     this.pending = null;
     this.options.source.dispose();
-    this.sourceState = {
-      ...this.sourceState,
-      connection: "closed",
-      request: null
-    };
+    this.sourceState = this.options.source.store.get();
     this.refresh();
   }
   assertCoverage() {
@@ -1096,63 +1316,98 @@ var Controller = class {
     if (missing.length)
       throw new Error(`Interactions not read: ${missing.join(", ")}`);
   }
-  routeTarget(kind, id, explicit, boardId) {
-    if (kind === "card") {
-      this.selectCard(id, explicit);
+  routeTarget(target, options) {
+    if (target.kind === "card") {
+      this.selectCard(target.value, options);
       return;
     }
     const candidates = this.lastInteractions.flatMap(
       (interaction) => interaction.getInputs().filter(
-        (input) => input.descriptor.domain.type === "boardTarget" && (input.descriptor.domain.targetKind === kind || kind === "space" && input.descriptor.domain.targetKind === "tile") && (!boardId || input.descriptor.domain.boardId === boardId) && input.getIsEligible(id) && interaction.getIsAvailable() && (!explicit || interaction.key === explicit)
+        (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(id);
+    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, id);
+    if (match)
+      this.select(match.interaction.key, match.input.key, target.value);
   }
-  routeCardDrop(cardId, target) {
+  prepareCardDrop(cards, target) {
     if (this.disposed || this.sourceState.request || this.pending || this.sourceState.connection !== "ready")
       return;
-    const card = this.store.get().cards.get(cardId);
-    if (!card) return;
-    const candidates = card.routes.flatMap((interaction2) => {
-      if (!interaction2.getIsAvailable() || target.interaction && interaction2.key !== target.interaction)
-        return [];
-      const cardInput2 = interaction2.getInputs().find(
-        (input2) => input2.descriptor.domain.type === "cardTarget" && input2.getIsEligible(cardId)
-      );
-      if (!cardInput2) return [];
-      return interaction2.getInputs().filter(
-        (input2) => input2.descriptor.domain.type === "boardTarget" && (input2.descriptor.domain.targetKind === target.kind || target.kind === "space" && input2.descriptor.domain.targetKind === "tile") && (!target.boardId || input2.descriptor.domain.boardId === target.boardId) && input2.getIsEligible(target.id)
-      ).map((input2) => ({ interaction: interaction2, cardInput: cardInput2, input: input2 }));
-    });
-    if (candidates.length > 1) throw new AmbiguousTargetError(target.id);
-    const candidate = candidates[0];
-    if (!candidate) return;
-    const { interaction, cardInput, input } = candidate;
-    let next = { ...this.drafts()[interaction.key] };
-    routeCardInputIntent(
-      {
-        getDraft: () => next,
-        setInput: (_key, key, value) => {
-          next = { ...next, [key]: value };
+    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];
+          }
         },
-        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
         }
-      },
-      interaction.descriptor,
-      {
-        cardId,
-        cardInputKey: cardInput.key,
-        dropTarget: { inputKey: input.key, value: target.id }
-      }
-    );
-    this.writeDraft(interaction.key, next);
+      );
+    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 (current && shouldAutoSubmitInteraction(current.descriptor) && current.getIsReady())
-      this.handle(current.submit());
+    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";
@@ -1170,7 +1425,7 @@ var Controller = class {
   }
   build(previous) {
     this.trackDrafts();
-    const { snapshot, connection, request } = this.sourceState;
+    const { snapshot, connection, request, failure } = this.sourceState;
     const old = previous?.snapshot;
     const drafts = this.drafts();
     const active = this.active();
@@ -1193,11 +1448,20 @@ var Controller = class {
     );
     const players = sameActors && previous ? previous.players : {
       order: Object.freeze(playerObjects.map((p) => p.id)),
-      get: (id) => playerObjects.find((p) => p.id === 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 index < 0 ? void 0 : playerObjects[(index + 1) % playerObjects.length];
+        return requireLookup(
+          index < 0 ? void 0 : playerObjects[(index + 1) % playerObjects.length],
+          "Next player after",
+          id
+        );
       }
     };
     const me = sameActors && previous ? previous.me : snapshot ? {
@@ -1212,7 +1476,7 @@ var Controller = class {
       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 status = request || this.pending ? "submitting" : "open";
       const oldObject = this.lastInteractions.find(
         (value) => value.key === key
       );
@@ -1233,6 +1497,14 @@ var Controller = class {
     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);
       },
@@ -1249,37 +1521,65 @@ var Controller = class {
       }
     };
     const inputs = interactionsSame && previous ? previous.inputs : {
-      get: (key, name) => interactions.get(key)?.getInput(name)
+      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 ?? {}).map(
-        ([id, zone]) => this.object(
-          "zone",
-          new ZoneObject(
-            this,
-            id,
-            Object.freeze(
-              zone.cardIds.map(
-                (cardId, index) => this.object(
-                  "card",
-                  new CardObject(
+      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,
-                    cardId,
+                    tile,
                     id,
+                    hostId,
                     index,
-                    zone.cardViewsById[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"
-                          )
+                      interactionObjects.filter(
+                        (interaction) => interaction.getInputs().some(
+                          (input) => input.descriptor.domain.type === "tileTarget" && input.getIsEligible(tile.ref)
                         )
                       )
                     )
@@ -1290,13 +1590,20 @@ var Controller = class {
           )
         )
       );
+      const find = (id, hostId) => objects.find((zone) => zone.id === id && zone.hostId === hostId);
       return {
-        get: (id) => objects.find((zone) => zone.id === id),
+        get: (id, hostId) => requireLookup(find(id, hostId), "Zone", id),
+        find,
         getAll: () => Object.freeze(objects)
       };
     })();
     const cards = zonesSame ? previous.cards : {
-      get: (id) => zones.getAll().map((zone) => zone.getCard(id)).find((card) => card !== void 0)
+      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;
@@ -1308,6 +1615,7 @@ var Controller = class {
       version: snapshot?.version ?? null,
       connection,
       request,
+      failure,
       state: capturedState,
       phase: sameSnapshot && previous ? previous.phase : Object.freeze(
         new PhaseObject(snapshot?.frame.flow.currentPhase ?? null)
@@ -1356,8 +1664,109 @@ function createGameInstance() {
   };
 }
 
+// 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 vertical 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 steep = (from, to) => Math.abs(to.y - from.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 (!steep(pull, at) || Math.abs(at.y - pull.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" || steep(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
+  createGameInstance,
+  isSameDropTarget,
+  GESTURE_THRESHOLDS,
+  createGestureRecognizer,
+  magneticDropPoint
 };
-//# sourceMappingURL=chunk-SP234IY4.js.map
+//# sourceMappingURL=chunk-BVWJS3AB.js.map