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

package/dist/chunk-SP234IY4.js

@@ -0,0 +1,1363 @@
+import {
+  immutableCopy
+} from "./chunk-DMFVAZI2.js";
+import {
+  inputValueInDomain
+} from "./chunk-VUWNJXLJ.js";
+
+// src/headless/instance.ts
+import { createStore } from "@tanstack/store";
+
+// src/headless/interaction-inputs.ts
+function interactionInputKeys(descriptor) {
+  return descriptor.inputs.map((input) => input.key);
+}
+function applyInteractionInputDefaults(descriptor, params) {
+  const next = descriptor.step ? Object.fromEntries(
+    Object.entries(params).filter(
+      ([key]) => descriptor.inputs.some((input) => input.key === key)
+    )
+  ) : { ...params };
+  for (const input of descriptor.inputs) {
+    if (next[input.key] !== void 0) continue;
+    if (!("defaultValue" in input)) continue;
+    next[input.key] = input.defaultValue;
+  }
+  return next;
+}
+function validateInteractionInputDomains(descriptor, params) {
+  const fieldErrors = {};
+  for (const rawInput of descriptor.inputs) {
+    const input = rawInput;
+    const value = params[input.key];
+    if (value === void 0 || value === null) continue;
+    const selectionErrors = validateInputSelection(input, value);
+    for (const error of selectionErrors) {
+      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;
+}
+function isInputValueReady(input, value) {
+  if (value === void 0) return false;
+  if (value === null)
+    return input.domain.type === "choice" && (input.domain.choices ?? []).some(
+      (choice) => choice.value === null && !choice.disabled
+    );
+  const selection = inputSelection(input);
+  if (selection?.mode !== "many") return true;
+  return Array.isArray(value) && value.length >= selection.min;
+}
+function isManyInput(input) {
+  return inputSelection(input)?.mode === "many";
+}
+function toggleManyValue(current, value, selection) {
+  if (selection.mode !== "many") return [value];
+  const previous = Array.isArray(current) ? current.map((item) => String(item)) : [];
+  const existing = previous.indexOf(value);
+  if (existing >= 0) {
+    return previous.filter((item) => item !== value);
+  }
+  if (selection.max !== void 0 && previous.length >= selection.max) {
+    return previous;
+  }
+  return [...previous, value];
+}
+function isManyTargetSelectable(input, current, targetId) {
+  const selection = inputSelection(input);
+  if (selection?.mode !== "many") return true;
+  const currentValues = Array.isArray(current) ? current.map((item) => String(item)) : [];
+  if (currentValues.includes(targetId)) return true;
+  if (selection.distinct && currentValues.includes(targetId)) return false;
+  return selection.max === void 0 || currentValues.length < selection.max;
+}
+function hasInteractionFieldErrors(fieldErrors) {
+  return Object.values(fieldErrors).some(
+    (messages) => (messages?.length ?? 0) > 0
+  );
+}
+function inputByKey(descriptor, key) {
+  return descriptor.inputs.find((input) => input.key === key);
+}
+function 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;
+}
+function pushFieldError(fieldErrors, key, message) {
+  fieldErrors[key] = [...fieldErrors[key] ?? [], message];
+}
+function pluralize(word, count) {
+  return count === 1 ? word : `${word}s`;
+}
+
+// src/headless/interaction-router.ts
+function applyInteractionDraftMutation(store, descriptor, mutations) {
+  const originalDraft = {
+    ...store.getDraft(descriptor.interactionKey)
+  };
+  const nextDraft = {
+    ...originalDraft
+  };
+  const currentKeys = new Set(interactionInputKeys(descriptor));
+  for (const { key, value } of mutations) {
+    if (!descriptor.step || currentKeys.has(key)) nextDraft[key] = value;
+  }
+  if (descriptor.step) {
+    for (const key of Object.keys(nextDraft))
+      if (!currentKeys.has(key)) delete nextDraft[key];
+  }
+  const allKeys = /* @__PURE__ */ new Set([
+    ...Object.keys(originalDraft),
+    ...Object.keys(nextDraft)
+  ]);
+  for (const key of allKeys) {
+    if (!(key in nextDraft)) {
+      store.clearInput(descriptor.interactionKey, key);
+      continue;
+    }
+    if (originalDraft[key] !== nextDraft[key]) {
+      store.setInput(descriptor.interactionKey, key, nextDraft[key]);
+    }
+  }
+  return nextDraft;
+}
+function getInteractionDraftReadiness(descriptor, draft) {
+  const values = applyInteractionInputDefaults(
+    descriptor,
+    draft
+  );
+  const missingInputs = interactionInputKeys(descriptor).filter((key) => {
+    const input = inputByKey(descriptor, key);
+    const value = values[key];
+    return input ? !isInputValueReady(input, value) : value === null || value === void 0;
+  });
+  const fieldErrors = validateInteractionInputDomains(descriptor, values);
+  return {
+    values,
+    missingInputs,
+    fieldErrors,
+    ready: missingInputs.length === 0 && !hasInteractionFieldErrors(fieldErrors)
+  };
+}
+function routeInteractionTarget(store, descriptor, target) {
+  const input = inputByKey(descriptor, target.inputKey);
+  const currentDraft = store.getDraft(descriptor.interactionKey);
+  const selection = isTargetDomain(input?.domain) ? input.domain.selection : void 0;
+  const targetValue = selection?.mode === "many" ? toggleManyValue(currentDraft[target.inputKey], target.value, selection) : target.value;
+  const params = applyInteractionDraftMutation(store, descriptor, [
+    ...Object.entries(target.extraInputs ?? {}).map(([key, value]) => ({
+      key,
+      value
+    })),
+    { key: target.inputKey, value: targetValue }
+  ]);
+  return {
+    params,
+    readiness: getInteractionDraftReadiness(descriptor, params)
+  };
+}
+function routeCardInputIntent(store, descriptor, intent) {
+  return routeInteractionTarget(store, descriptor, {
+    inputKey: intent.cardInputKey,
+    value: intent.cardId,
+    extraInputs: intent.dropTarget ? { [intent.dropTarget.inputKey]: intent.dropTarget.value } : void 0
+  });
+}
+function shouldAutoSubmitInteraction(descriptor) {
+  return descriptor.commit.mode === "autoWhenReady" && !descriptor.inputs.some((input) => isManyInput(input));
+}
+
+// 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);
+function inDomain(input, value, partial = false) {
+  return inputValueInDomain(input.domain, value, input.domain.selection, {
+    ignoreMinimum: partial
+  });
+}
+function immutableValues(value) {
+  return immutableCopy(value);
+}
+function data(action, interaction, input, value) {
+  return {
+    "data-action": action,
+    "data-interaction": interaction,
+    ...input ? { "data-input": input } : {},
+    ...value === void 0 ? {} : {
+      "data-value": typeof value === "string" ? value : JSON.stringify(value)
+    }
+  };
+}
+var AmbiguousTargetError = class extends Error {
+  constructor(id) {
+    super(
+      `Target '${id}' belongs to more than one interaction. Choose an interaction explicitly.`
+    );
+    this.name = "AmbiguousTargetError";
+  }
+};
+var InteractionObject = class {
+  constructor(owner, descriptor, draft, status, connected) {
+    this.owner = owner;
+    this.descriptor = descriptor;
+    this.status = status;
+    this.connected = connected;
+    this.seat = descriptor.actorSeat ?? owner.sourceState.snapshot?.players.findIndex(
+      (player) => player.playerId === owner.sourceState.snapshot?.me
+    ) ?? -1;
+    this.draftIdentity = draft;
+    this.draft = immutableValues(draft);
+    this.source = owner.options.source;
+    this.epoch = owner.epoch;
+    this.key = descriptor.interactionKey;
+    this.id = descriptor.interactionId;
+    this.phase = descriptor.phaseName;
+    this.label = descriptor.label;
+    this.help = descriptor.help;
+    this.kind = descriptor.step ? "steps" : "inputs";
+    this.inputObjects = Object.freeze(
+      descriptor.inputs.map(
+        (input) => owner.object("input", new InputObject(this, input))
+      )
+    );
+  }
+  owner;
+  descriptor;
+  status;
+  connected;
+  key;
+  id;
+  phase;
+  label;
+  help;
+  kind;
+  inputObjects;
+  seat;
+  draft;
+  draftIdentity;
+  source;
+  epoch;
+  get game() {
+    return this.owner.instance;
+  }
+  getAvailability() {
+    return this.descriptor.availability;
+  }
+  getIsAvailable() {
+    return this.descriptor.availability.status === "available";
+  }
+  getUnavailableReason() {
+    return this.descriptor.availability.status === "available" ? null : this.descriptor.availability.reason;
+  }
+  getStep() {
+    return this.descriptor.step ?? null;
+  }
+  getStepIndex() {
+    return this.descriptor.step?.index ?? null;
+  }
+  getInput(key) {
+    return 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])
+      )
+    };
+  }
+  getIsReady() {
+    return this.readiness().ready;
+  }
+  getMissingInputs() {
+    return this.readiness().missingInputs;
+  }
+  getStatus() {
+    return this.status;
+  }
+  currentLifetime() {
+    return this.source === this.owner.options.source && this.epoch === this.owner.epoch && !this.owner.disposed;
+  }
+  submit() {
+    return this.currentLifetime() ? this.owner.submit(this.key, false) : Promise.resolve({ accepted: false, errorCode: "CLOSED" });
+  }
+  cancel() {
+    return this.currentLifetime() ? this.owner.submit(this.key, true) : Promise.resolve({ accepted: false, errorCode: "CLOSED" });
+  }
+  reset() {
+    if (this.currentLifetime()) this.owner.reset(this.key);
+  }
+  activate() {
+    if (this.currentLifetime()) this.owner.activate(this.key);
+  }
+  getSubmitHandler() {
+    return (event) => {
+      event?.preventDefault();
+      this.owner.handle(this.submit());
+    };
+  }
+  getSubmitProps() {
+    const disabled = !this.getIsAvailable() || !this.getIsReady() || this.status !== "open" || !this.connected;
+    return {
+      ...data("submit", this.key),
+      "data-seat": this.seat,
+      type: "button",
+      disabled,
+      "data-ready": this.getIsReady(),
+      "data-disabled": disabled,
+      onClick: this.getSubmitHandler()
+    };
+  }
+};
+var InputObject = class {
+  constructor(interaction, descriptor) {
+    this.interaction = interaction;
+    this.descriptor = descriptor;
+    this.key = descriptor.key;
+    this.kind = descriptor.kind;
+  }
+  interaction;
+  descriptor;
+  key;
+  kind;
+  get game() {
+    return this.interaction.game;
+  }
+  getDomain() {
+    return this.descriptor.domain;
+  }
+  getValue() {
+    return this.interaction.draft[this.key] ?? (Object.hasOwn(this.interaction.draft, this.key) ? null : this.descriptor.defaultValue);
+  }
+  setValue(value) {
+    if (!this.interaction.currentLifetime()) return;
+    this.interaction.owner.setInput(this.interaction.key, this.key, value);
+  }
+  clear() {
+    if (!this.interaction.currentLifetime()) return;
+    this.interaction.owner.clearInput(this.interaction.key, this.key);
+  }
+  getIsReady() {
+    const descriptor = {
+      ...this.interaction.descriptor,
+      inputs: [this.descriptor]
+    };
+    return getInteractionDraftReadiness(descriptor, {
+      [this.key]: this.getValue()
+    }).ready && inDomain(this.descriptor, this.getValue());
+  }
+  getEligibleTargets() {
+    const domain = this.descriptor.domain;
+    if (domain.type === "cardTarget" || domain.type === "boardTarget")
+      return domain.eligibleTargets;
+    if (domain.type === "choice" || domain.type === "choiceList")
+      return domain.choices.filter((choice) => !choice.disabled).map((choice) => choice.value);
+    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)));
+  }
+  getIsSelected(value) {
+    const current = this.getValue();
+    return isManyInput(this.descriptor) && Array.isArray(current) ? current.some((item) => equalValue(item, value)) : equalValue(current, value);
+  }
+  getSelectHandler(value) {
+    return () => {
+      if (this.interaction.currentLifetime())
+        this.interaction.owner.select(this.interaction.key, this.key, value);
+    };
+  }
+  getTargetProps(value) {
+    const eligible = this.getIsEligible(value);
+    const disabled = !eligible || !this.interaction.getIsAvailable() || this.interaction.status !== "open" || !this.interaction.connected;
+    return {
+      ...data("select", this.interaction.key, this.key, value),
+      "data-seat": this.interaction.seat,
+      type: "button",
+      disabled,
+      "data-eligible": eligible,
+      "data-selected": this.getIsSelected(value),
+      "data-disabled": disabled,
+      onClick: () => this.getSelectHandler(value)()
+    };
+  }
+  getFieldProps() {
+    const disabled = !this.interaction.getIsAvailable() || this.interaction.status !== "open" || !this.interaction.connected;
+    return {
+      ...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
+        );
+      }
+    };
+  }
+};
+var CardObject = class {
+  constructor(owner, id, zone, index, encoded, routes) {
+    this.owner = owner;
+    this.id = id;
+    this.zone = zone;
+    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.hidden = this.view === null;
+  }
+  owner;
+  id;
+  zone;
+  index;
+  routes;
+  epoch;
+  seat;
+  view;
+  hidden;
+  get game() {
+    return this.owner.instance;
+  }
+  getInteractions() {
+    return this.routes;
+  }
+  getIsEligible() {
+    return this.routes.some((route) => route.getIsAvailable());
+  }
+  getIsSelected() {
+    return this.routes.some(
+      (route) => route.getInputs().some(
+        (input) => input.descriptor.domain.type === "cardTarget" && input.getIsSelected(this.id)
+      )
+    );
+  }
+  getCanSelect() {
+    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)
+      )
+    );
+  }
+  select(options) {
+    if (this.epoch !== this.owner.epoch || this.owner.disposed) return;
+    this.owner.selectCard(this.id, options?.interaction);
+  }
+  getSelectHandler(options) {
+    return () => this.select(options);
+  }
+  getProps(options) {
+    return {
+      type: "button",
+      disabled: !this.getCanSelect(),
+      "data-action": "select",
+      "data-value": this.id,
+      "data-interaction": options?.interaction,
+      "data-eligible": this.getIsEligible(),
+      "data-selected": this.getIsSelected(),
+      "data-disabled": !this.getCanSelect(),
+      "data-hidden": this.hidden,
+      "data-seat": this.seat,
+      onClick: this.getSelectHandler(options)
+    };
+  }
+};
+var ZoneObject = class {
+  constructor(owner, id, cards) {
+    this.owner = owner;
+    this.id = id;
+    this.cards = cards;
+  }
+  owner;
+  id;
+  cards;
+  get game() {
+    return this.owner.instance;
+  }
+  get count() {
+    return this.cards.length;
+  }
+  getIsEmpty() {
+    return this.count === 0;
+  }
+  getCard(id) {
+    return this.cards.find((card) => card.id === id);
+  }
+  getCards(options) {
+    return options?.sort ? [...this.cards].sort(options.sort) : this.cards;
+  }
+};
+var PlayerObject = class {
+  constructor(owner, summary, index, isMe, active) {
+    this.owner = owner;
+    this.index = index;
+    this.isMe = isMe;
+    this.active = active;
+    this.id = summary.playerId;
+    this.name = summary.displayName;
+    this.color = summary.color;
+  }
+  owner;
+  index;
+  isMe;
+  active;
+  id;
+  name;
+  color;
+  get game() {
+    return this.owner.instance;
+  }
+};
+var PhaseObject = class {
+  constructor(current) {
+    this.current = current;
+  }
+  current;
+  is(name) {
+    return this.current === name;
+  }
+  switch(routes) {
+    return this.current === null ? null : routes[this.current]();
+  }
+};
+var Controller = class {
+  epoch = 0;
+  options;
+  localDrafts;
+  localActive;
+  disposed = false;
+  instance;
+  store;
+  prototypes = {
+    interaction: Object.create(InteractionObject.prototype),
+    input: Object.create(InputObject.prototype),
+    card: Object.create(CardObject.prototype),
+    zone: Object.create(ZoneObject.prototype),
+    board: {}
+  };
+  subscription;
+  sourceState;
+  pending = null;
+  building;
+  rootProperties = /* @__PURE__ */ new Map();
+  featureDisposals = [];
+  warned = /* @__PURE__ */ new Set();
+  invalidControlledState;
+  observed = /* @__PURE__ */ new Set();
+  revisions = /* @__PURE__ */ new Map();
+  lastDrafts = EMPTY_DRAFTS;
+  lastInteractions = [];
+  lastSnapshotDrafts;
+  trackDrafts() {
+    const drafts = this.drafts();
+    for (const key of /* @__PURE__ */ new Set([
+      ...Object.keys(this.lastDrafts),
+      ...Object.keys(drafts)
+    ]))
+      if (this.lastDrafts[key] !== drafts[key])
+        this.revisions.set(key, (this.revisions.get(key) ?? 0) + 1);
+    this.lastDrafts = drafts;
+  }
+  constructor(options, features) {
+    this.options = options;
+    this.localDrafts = options.initialState?.drafts ?? EMPTY_DRAFTS;
+    this.localActive = options.initialState?.activeInteraction ?? null;
+    this.sourceState = options.source.store.get();
+    const root = {
+      getSnapshot: () => this.building ?? this.store.get(),
+      getOptions: () => this.options,
+      setOptions: (next) => this.setOptions(next),
+      subscribe: (listener) => {
+        const sub = this.store.subscribe(listener);
+        return () => sub.unsubscribe();
+      },
+      dispose: () => this.dispose(),
+      assertCoverage: () => this.assertCoverage(),
+      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)
+      }
+    });
+    if ("apply" in options.source)
+      Object.defineProperty(root, "apply", {
+        value: (action) => this.options.source.apply(action)
+      });
+    if ("explore" in options.source)
+      Object.defineProperty(root, "explore", {
+        value: (...args) => this.options.source.explore(...args)
+      });
+    const context = {
+      createBoard: (id, data2) => this.object("board", {
+        id,
+        data: immutableCopy(data2),
+        game: this.instance
+      }),
+      routeTarget: (kind, id, options2) => this.routeTarget(kind, id, options2?.interaction, options2?.boardId),
+      routeCardDrop: (cardId, target) => this.routeCardDrop(cardId, target),
+      invalidate: () => {
+        if (!this.disposed) this.refresh();
+      }
+    };
+    for (const feature of Object.values(
+      features?.(this.instance, context) ?? {}
+    )) {
+      if (feature.root)
+        for (const key of Reflect.ownKeys(feature.root)) {
+          if (key in root || this.rootProperties.has(key))
+            throw new Error(`Overlapping feature property '${String(key)}'.`);
+          this.rootProperties.set(
+            key,
+            Object.getOwnPropertyDescriptor(feature.root, key)
+          );
+          Object.defineProperty(root, key, {
+            get: () => Reflect.get(this.building ?? this.store.get(), key)
+          });
+        }
+      for (const hook of [
+        "interaction",
+        "input",
+        "zone",
+        "card",
+        "board"
+      ])
+        this.install(this.prototypes[hook], feature[hook]);
+      if (feature.dispose) this.featureDisposals.push(feature.dispose);
+    }
+    this.refresh();
+    this.subscribeSource();
+  }
+  install(target, extension) {
+    if (!extension) return;
+    for (const key of Reflect.ownKeys(extension)) {
+      if (key in target || [
+        "game",
+        "owner",
+        "descriptor",
+        "draft",
+        "inputObjects",
+        "status",
+        "connected",
+        "key",
+        "id",
+        "phase",
+        "label",
+        "help",
+        "kind",
+        "interaction",
+        "view",
+        "hidden",
+        "zone",
+        "index",
+        "routes",
+        "cards"
+      ].includes(String(key)))
+        throw new Error(`Overlapping feature property '${String(key)}'.`);
+    }
+    Object.defineProperties(
+      target,
+      Object.getOwnPropertyDescriptors(extension)
+    );
+  }
+  object(hook, value) {
+    return Object.freeze(Object.setPrototypeOf(value, this.prototypes[hook]));
+  }
+  drafts() {
+    if (this.options.state && this.options.state === this.invalidControlledState)
+      return EMPTY_DRAFTS;
+    return this.options.state?.drafts ?? this.localDrafts;
+  }
+  active() {
+    if (this.options.state && this.options.state === this.invalidControlledState)
+      return null;
+    return this.options.state?.activeInteraction !== void 0 ? this.options.state.activeInteraction : this.localActive;
+  }
+  writeDrafts(next) {
+    if (this.options.state?.drafts === void 0) this.localDrafts = next;
+    this.options.onDraftsChange?.(next);
+    this.refresh();
+  }
+  writeDraft(key, value) {
+    const drafts = this.drafts();
+    const next = { ...drafts };
+    if (value === void 0) delete next[key];
+    else next[key] = immutableValues(value);
+    this.writeDrafts(Object.freeze(next));
+  }
+  activate(key) {
+    if (this.disposed || key !== null && !this.current(key)) return;
+    if (this.options.state?.activeInteraction === void 0)
+      this.localActive = key;
+    this.options.onActiveInteractionChange?.(key);
+    this.refresh();
+  }
+  descriptorFor(base, draft) {
+    const zones = this.sourceState.snapshot?.frame.zones ?? {};
+    for (const input of base.inputs) {
+      const card = draft[input.key];
+      if (input.domain.type !== "cardTarget" || typeof card !== "string")
+        continue;
+      for (const zone of Object.values(zones)) {
+        const route = zone.playableByCardId[card]?.find(
+          (value) => value.interactionKey === base.interactionKey
+        );
+        if (route) return route;
+      }
+    }
+    return base;
+  }
+  current(key) {
+    return this.store.get().interactions.get(key);
+  }
+  editable(key) {
+    const interaction = this.current(key);
+    return !this.disposed && this.sourceState.connection === "ready" && !this.sourceState.request && interaction?.getIsAvailable() ? interaction : void 0;
+  }
+  setInput(key, inputKey, value) {
+    const interaction = this.editable(key);
+    if (!interaction?.getInput(inputKey)) return;
+    this.writeDraft(key, { ...this.drafts()[key], [inputKey]: value });
+  }
+  clearInput(key, inputKey) {
+    if (!this.editable(key)?.getInput(inputKey)) return;
+    const value = { ...this.drafts()[key] };
+    delete value[inputKey];
+    this.writeDraft(key, value);
+  }
+  reset(key) {
+    if (this.disposed) return;
+    this.writeDraft(key, void 0);
+    if (this.active() === key) this.activate(null);
+  }
+  select(key, inputKey, value, route) {
+    const interaction = route ?? this.editable(key);
+    if (route && (!route.currentLifetime() || !route.getIsAvailable() || this.sourceState.connection !== "ready" || this.sourceState.request || this.pending))
+      return;
+    const input = interaction?.getInput(inputKey);
+    if (!interaction || !input?.getIsEligible(value)) return;
+    if (typeof value === "string" && (input.descriptor.domain.type === "cardTarget" || input.descriptor.domain.type === "boardTarget")) {
+      let next = { ...this.drafts()[key] };
+      routeInteractionTarget(
+        {
+          getDraft: () => next,
+          setInput: (_key, k, v) => {
+            next = { ...next, [k]: v };
+          },
+          clearInput: (_key, k) => {
+            if (k) delete next[k];
+          }
+        },
+        interaction.descriptor,
+        { inputKey, value }
+      );
+      this.writeDraft(key, next);
+    } else this.setInput(key, inputKey, value);
+    this.activate(key);
+    const current = this.current(key);
+    if (current && Object.hasOwn(this.drafts()[key] ?? EMPTY, inputKey) && shouldAutoSubmitInteraction(current.descriptor) && current.getIsReady())
+      this.handle(this.submit(key, false));
+  }
+  selectCard(id, 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);
+  }
+  handle(promise) {
+    void promise.then(
+      (result) => {
+        if (!result.accepted)
+          this.options.onError?.(
+            new Error(result.message ?? result.errorCode, { cause: result })
+          );
+      },
+      (error) => this.options.onError?.(error)
+    );
+  }
+  async submit(key, cancel) {
+    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())
+      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
+    };
+    this.pending = operation;
+    try {
+      const result = await (cancel ? commandSource.cancel(interaction.id) : commandSource.submit(
+        interaction.id,
+        interaction.readiness().values
+      ));
+      if (this.pending !== operation) return result;
+      if (!result.accepted) {
+        this.pending = null;
+        this.refresh();
+        return result;
+      }
+      operation.accepted = true;
+      this.finishBarrier();
+      return result;
+    } catch (error) {
+      if (this.pending === operation) {
+        this.pending = null;
+        this.refresh();
+      }
+      throw error;
+    }
+  }
+  finishBarrier() {
+    const operation = this.pending;
+    if (!operation?.accepted || this.sourceState.request || operation.source !== this.options.source || operation.epoch !== this.epoch)
+      return;
+    if (this.sourceState.connection === "closed") {
+      this.pending = null;
+      this.refresh();
+      return;
+    }
+    if (this.sourceState.connection !== "ready" || (this.sourceState.snapshot?.version ?? -1) <= operation.version)
+      return;
+    this.pending = null;
+    if ((this.revisions.get(operation.key) ?? 0) === operation.revision)
+      this.reset(operation.key);
+    else this.refresh();
+  }
+  subscribeSource() {
+    const source = this.options.source;
+    this.subscription = source.store.subscribe(() => {
+      if (this.disposed || this.options.source !== source) return;
+      const next = source.store.get();
+      const previousSnapshot = this.sourceState.snapshot;
+      this.sourceState = next;
+      if (previousSnapshot && next.snapshot && previousSnapshot.me !== next.snapshot.me) {
+        this.epoch++;
+        this.invalidControlledState = this.options.state;
+        this.pending = null;
+        this.localDrafts = EMPTY_DRAFTS;
+        this.localActive = null;
+        this.options.onDraftsChange?.({});
+        this.options.onActiveInteractionChange?.(null);
+      }
+      this.reconcile();
+      this.refresh();
+      this.finishBarrier();
+    });
+  }
+  setOptions(next) {
+    if (this.disposed) throw new Error("Game instance is disposed.");
+    const changed = next.source !== this.options.source;
+    if (changed) {
+      this.epoch++;
+      this.subscription?.unsubscribe();
+      this.options.source.dispose();
+      this.pending = null;
+    }
+    this.options = next;
+    if (changed) {
+      this.invalidControlledState = next.state;
+      this.localDrafts = EMPTY_DRAFTS;
+      this.localActive = null;
+      this.sourceState = next.source.store.get();
+      this.options.onDraftsChange?.({});
+      this.options.onActiveInteractionChange?.(null);
+      this.subscribeSource();
+    }
+    this.reconcile();
+    this.refresh();
+  }
+  reconcile() {
+    const snapshot = this.sourceState.snapshot;
+    if (!snapshot) return;
+    const drafts = this.drafts();
+    let changed = false;
+    const next = { ...drafts };
+    for (const [key, values] of Object.entries(drafts)) {
+      if (!values) continue;
+      const base = snapshot.frame.availableInteractions.find(
+        (value) => value.interactionKey === key
+      );
+      if (!base) {
+        if (this.pending?.key !== key) {
+          delete next[key];
+          changed = true;
+        }
+        continue;
+      }
+      const descriptor = this.descriptorFor(base, values);
+      const kept = { ...values };
+      let fieldChanged = false;
+      for (const [name, value] of Object.entries(values)) {
+        const input = descriptor.inputs.find((input2) => input2.key === name);
+        if (!input && this.pending?.key === key) continue;
+        if (input?.domain.selection?.mode === "many" && Array.isArray(value)) {
+          const eligible = value.filter(
+            (item) => inputValueInDomain(input.domain, item)
+          );
+          const max = input.domain.selection.max;
+          const retained = max === void 0 ? eligible : eligible.slice(0, max);
+          if (retained.length !== value.length) {
+            kept[name] = retained;
+            changed = true;
+            fieldChanged = true;
+          }
+          continue;
+        }
+        if (!input || !inDomain(input, value, true)) {
+          delete kept[name];
+          changed = true;
+          fieldChanged = true;
+        }
+      }
+      if (fieldChanged) next[key] = immutableValues(kept);
+    }
+    if (changed) this.writeDrafts(Object.freeze(next));
+    const active = this.active();
+    if (active && !snapshot.frame.availableInteractions.some(
+      (value) => value.interactionKey === active
+    ))
+      this.activate(null);
+  }
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.featureDisposals.forEach((dispose) => dispose());
+    this.subscription?.unsubscribe();
+    this.pending = null;
+    this.options.source.dispose();
+    this.sourceState = {
+      ...this.sourceState,
+      connection: "closed",
+      request: null
+    };
+    this.refresh();
+  }
+  assertCoverage() {
+    const missing = this.sourceState.snapshot?.frame.availableInteractions.filter(
+      (d) => d.availability.status === "available" && !this.observed.has(d.interactionKey)
+    ).map((d) => d.interactionKey) ?? [];
+    if (missing.length)
+      throw new Error(`Interactions not read: ${missing.join(", ")}`);
+  }
+  routeTarget(kind, id, explicit, boardId) {
+    if (kind === "card") {
+      this.selectCard(id, explicit);
+      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)
+      ).map((input) => ({ interaction, input }))
+    );
+    if (candidates.length > 1) throw new AmbiguousTargetError(id);
+    const match = candidates[0];
+    if (match) this.select(match.interaction.key, match.input.key, id);
+  }
+  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;
+    let next = { ...this.drafts()[interaction.key] };
+    routeCardInputIntent(
+      {
+        getDraft: () => next,
+        setInput: (_key, key, value) => {
+          next = { ...next, [key]: value };
+        },
+        clearInput: (_key, key) => {
+          if (key) delete next[key];
+        }
+      },
+      interaction.descriptor,
+      {
+        cardId,
+        cardInputKey: cardInput.key,
+        dropTarget: { inputKey: input.key, value: target.id }
+      }
+    );
+    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());
+  }
+  warnUnread() {
+    const environment = import.meta.env?.DEV ?? globalThis.process?.env?.NODE_ENV === "development";
+    if (!(this.options.debug ?? environment)) return;
+    queueMicrotask(() => {
+      if (this.disposed) return;
+      for (const descriptor of this.sourceState.snapshot?.frame.availableInteractions ?? []) {
+        const key = descriptor.interactionKey;
+        if (descriptor.availability.status === "available" && !this.observed.has(key) && !this.warned.has(key)) {
+          this.warned.add(key);
+          console.warn(`Available interaction '${key}' has not been read.`);
+        }
+      }
+    });
+  }
+  build(previous) {
+    this.trackDrafts();
+    const { snapshot, connection, request } = this.sourceState;
+    const old = previous?.snapshot;
+    const drafts = this.drafts();
+    const active = this.active();
+    const sameSnapshot = snapshot === old;
+    const sameActors = sameSnapshot;
+    const summaries = snapshot?.players ?? [];
+    const activeIds = snapshot?.frame.flow.activePlayers ?? [];
+    const playerObjects = sameActors && previous ? previous.players.getAll() : Object.freeze(
+      summaries.map(
+        (player, index) => Object.freeze(
+          new PlayerObject(
+            this,
+            player,
+            index,
+            player.playerId === snapshot?.me,
+            activeIds.includes(player.playerId)
+          )
+        )
+      )
+    );
+    const players = sameActors && previous ? previous.players : {
+      order: Object.freeze(playerObjects.map((p) => p.id)),
+      get: (id) => 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];
+      }
+    };
+    const me = sameActors && previous ? previous.me : snapshot ? {
+      id: snapshot.me,
+      player: players.get(snapshot.me),
+      getCanAct: () => snapshot.frame.availableInteractions.some(
+        (value) => value.availability.status === "available"
+      )
+    } : null;
+    const descriptors = snapshot?.frame.availableInteractions ?? [];
+    const interactionObjects = descriptors.map((base) => {
+      const key = base.interactionKey;
+      const draft = drafts[key] ?? EMPTY;
+      const descriptor = this.descriptorFor(base, draft);
+      const status = request || this.pending ? request?.interactionId === descriptor.interactionId && request.phase === "awaiting-frame" ? "submitted" : "submitting" : "open";
+      const oldObject = this.lastInteractions.find(
+        (value) => value.key === key
+      );
+      return oldObject?.descriptor === descriptor && oldObject.epoch === this.epoch && oldObject.source === this.options.source && oldObject.draftIdentity === draft && oldObject.status === status && oldObject.connected === (connection === "ready") ? oldObject : this.object(
+        "interaction",
+        new InteractionObject(
+          this,
+          descriptor,
+          draft,
+          status,
+          connection === "ready"
+        )
+      );
+    });
+    const interactionsSame = previous && interactionObjects.length === this.lastInteractions.length && interactionObjects.every(
+      (value, index) => value === this.lastInteractions[index]
+    );
+    this.lastInteractions = Object.freeze(interactionObjects);
+    const interactions = interactionsSame ? previous.interactions : {
+      get: (key) => {
+        this.observed.add(key);
+        return interactionObjects.find((value) => value.key === key);
+      },
+      list: () => {
+        interactionObjects.forEach((value) => this.observed.add(value.key));
+        return Object.freeze(interactionObjects);
+      },
+      listAvailable: () => {
+        const available = interactionObjects.filter(
+          (value) => value.getIsAvailable()
+        );
+        available.forEach((value) => this.observed.add(value.key));
+        return Object.freeze(available);
+      }
+    };
+    const inputs = interactionsSame && previous ? previous.inputs : {
+      get: (key, name) => interactions.get(key)?.getInput(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(
+                    this,
+                    cardId,
+                    id,
+                    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"
+                          )
+                        )
+                      )
+                    )
+                  )
+                )
+              )
+            )
+          )
+        )
+      );
+      return {
+        get: (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)
+    };
+    const capturedState = this.lastSnapshotDrafts === drafts && previous?.state.activeInteraction === active ? previous.state : immutableCopy({ drafts, activeInteraction: active });
+    this.lastSnapshotDrafts = drafts;
+    for (const value of [players, me, interactions, inputs, zones, cards])
+      if (value) Object.freeze(value);
+    const model = {
+      snapshot,
+      view: snapshot?.frame.view ?? null,
+      version: snapshot?.version ?? null,
+      connection,
+      request,
+      state: capturedState,
+      phase: sameSnapshot && previous ? previous.phase : Object.freeze(
+        new PhaseObject(snapshot?.frame.flow.currentPhase ?? null)
+      ),
+      turn: sameSnapshot && previous ? previous.turn : Object.freeze({
+        activePlayerIds: activeIds,
+        currentPlayerId: activeIds.length === 1 ? activeIds[0] : null,
+        order: players.order,
+        isMine: snapshot ? activeIds.includes(snapshot.me) : false
+      }),
+      me,
+      players,
+      interactions,
+      inputs,
+      zones,
+      cards,
+      events: sameSnapshot && previous ? previous.events : Object.freeze({
+        recent: snapshot?.frame.events ?? Object.freeze([])
+      })
+    };
+    this.building = model;
+    try {
+      for (const [key, descriptor] of this.rootProperties)
+        Object.defineProperty(model, key, {
+          value: descriptor.get ? descriptor.get.call(this.instance) : descriptor.value,
+          enumerable: true
+        });
+    } finally {
+      this.building = void 0;
+    }
+    return model;
+  }
+  refresh() {
+    if (!this.store) return;
+    this.store.setState((previous) => Object.freeze(this.build(previous)));
+    this.warnUnread();
+  }
+};
+function createGameInstance() {
+  return function(options) {
+    const controller = new Controller(
+      options,
+      options.features
+    );
+    return controller.instance;
+  };
+}
+
+export {
+  AmbiguousTargetError,
+  createGameInstance
+};
+//# sourceMappingURL=chunk-SP234IY4.js.map