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

package/dist/{chunk-SP234IY4.js → chunk-7RGMPJQG.js}

@@ -2,8 +2,72 @@ import {
   immutableCopy
 } from "./chunk-DMFVAZI2.js";
 import {
-  inputValueInDomain
-} from "./chunk-VUWNJXLJ.js";
+  inputDomainErrors,
+  inputTargetInDomain,
+  inputValueInDomain,
+  inputValueKey,
+  requireLookup
+} from "./chunk-3JXUL4VN.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,22 @@ 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 || target.kind === "space" && domain.targetKind === "tile") && domain.boardId === (target.valueKind === "board-id" ? target.boardId : target.value.boardId);
+}
 function immutableValues(value) {
   return immutableCopy(value);
 }
@@ -286,7 +271,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";
   }
@@ -351,19 +336,20 @@ 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])
-      )
-    };
+    return getInteractionDraftReadiness(this.descriptor, this.draft);
   }
   getIsReady() {
     return this.readiness().ready;
@@ -392,7 +378,7 @@ var InteractionObject = class {
   getSubmitHandler() {
     return (event) => {
       event?.preventDefault();
-      this.owner.handle(this.submit());
+      this.owner.handle(() => this.submit());
     };
   }
   getSubmitProps() {
@@ -422,6 +408,21 @@ var InputObject = class {
   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: (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;
   }
@@ -443,7 +444,7 @@ var InputObject = class {
     };
     return getInteractionDraftReadiness(descriptor, {
       [this.key]: this.getValue()
-    }).ready && inDomain(this.descriptor, this.getValue());
+    }).ready;
   }
   getEligibleTargets() {
     const domain = this.descriptor.domain;
@@ -455,11 +456,7 @@ var InputObject = class {
   }
   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();
@@ -485,28 +482,18 @@ 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, index, encoded, backImage, routes) {
     this.owner = owner;
     this.id = id;
     this.zone = zone;
@@ -518,6 +505,7 @@ var CardObject = class {
     ) ?? -1;
     this.view = encoded ? immutableCopy(JSON.parse(encoded)) : null;
     this.hidden = this.view === null;
+    this.backImage = backImage ?? null;
   }
   owner;
   id;
@@ -528,6 +516,7 @@ var CardObject = class {
   seat;
   view;
   hidden;
+  backImage;
   get game() {
     return this.owner.instance;
   }
@@ -544,16 +533,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,13 +550,14 @@ 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)
@@ -593,6 +583,9 @@ var ZoneObject = class {
     return this.count === 0;
   }
   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) {
@@ -649,6 +642,7 @@ var Controller = class {
   };
   subscription;
   sourceState;
+  reportedFailures = /* @__PURE__ */ new WeakMap();
   pending = null;
   building;
   rootProperties = /* @__PURE__ */ new Map();
@@ -675,7 +669,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),
@@ -687,34 +734,23 @@ var Controller = class {
       assertCoverage: () => this.assertCoverage(),
       inspect: () => this.store.get()
     };
-    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 +759,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: () => {
+        const view = this.instance.view;
+        return view?.boards?.byId ?? {};
+      },
+      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),
       routeCardDrop: (cardId, target) => this.routeCardDrop(cardId, target),
       invalidate: () => {
         if (!this.disposed) this.refresh();
       }
     };
+    const context = { ...runtime, [runtimeFeatures]: runtime };
     for (const feature of Object.values(
       features?.(this.instance, context) ?? {}
     )) {
@@ -762,6 +804,7 @@ var Controller = class {
     }
     this.refresh();
     this.subscribeSource();
+    this.reportSourceFailure();
   }
   install(target, extension) {
     if (!extension) return;
@@ -796,7 +839,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)
@@ -843,7 +887,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 +895,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 +913,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")) {
       let next = { ...this.drafts()[key] };
       routeInteractionTarget(
         {
@@ -891,33 +935,45 @@ 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));
+  }
+  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(promise) {
-    void promise.then(
+  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) {
@@ -968,7 +1024,7 @@ var Controller = class {
     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") {
+    if (this.sourceState.connection === "closed" || this.sourceState.connection === "failed") {
       this.pending = null;
       this.refresh();
       return;
@@ -980,6 +1036,13 @@ var Controller = class {
       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(() => {
@@ -999,6 +1062,7 @@ var Controller = class {
       this.reconcile();
       this.refresh();
       this.finishBarrier();
+      this.reportSourceFailure();
     });
   }
   setOptions(next) {
@@ -1022,6 +1086,7 @@ var Controller = class {
     }
     this.reconcile();
     this.refresh();
+    this.reportSourceFailure();
   }
   reconcile() {
     const snapshot = this.sourceState.snapshot;
@@ -1047,11 +1112,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;
@@ -1082,11 +1148,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,40 +1158,35 @@ 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) => 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) {
     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;
+    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);
+    const input = interaction.findInput(target.inputKey);
+    if (!cardInput || cardInput.descriptor.domain.type !== "cardTarget" || !cardInput.getIsEligible(cardId) || !input || !matchesBoardTarget(input.descriptor, target) || !input.getIsEligible(target.value))
+      return;
     let next = { ...this.drafts()[interaction.key] };
     routeCardInputIntent(
       {
@@ -1145,14 +1202,14 @@ var Controller = class {
       {
         cardId,
         cardInputKey: cardInput.key,
-        dropTarget: { inputKey: input.key, value: target.id }
+        dropTarget: { inputKey: input.key, value: target.value }
       }
     );
     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());
+      this.handle(() => current.submit());
   }
   warnUnread() {
     const environment = import.meta.env?.DEV ?? globalThis.process?.env?.NODE_ENV === "development";
@@ -1170,7 +1227,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 +1250,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 ? {
@@ -1233,6 +1299,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,7 +1323,12 @@ 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 : (() => {
@@ -1269,6 +1348,7 @@ var Controller = class {
                     id,
                     index,
                     zone.cardViewsById[cardId],
+                    zone.cardBacksById[cardId],
                     Object.freeze(
                       (zone.playableByCardId[cardId] ?? []).map(
                         (descriptor) => this.object(
@@ -1291,12 +1371,22 @@ var Controller = class {
         )
       );
       return {
-        get: (id) => objects.find((zone) => zone.id === id),
+        get: (id) => requireLookup(
+          objects.find((zone) => zone.id === id),
+          "Zone",
+          id
+        ),
+        find: (id) => objects.find((zone) => zone.id === id),
         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 +1398,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)
@@ -1357,7 +1448,8 @@ function createGameInstance() {
 }
 
 export {
+  runtimeFeatures,
   AmbiguousTargetError,
   createGameInstance
 };
-//# sourceMappingURL=chunk-SP234IY4.js.map
+//# sourceMappingURL=chunk-7RGMPJQG.js.map