@hopple/sdk 0.0.0-stage → 0.1.0-rc.1

package/index.js

@@ -0,0 +1,3548 @@
+// ../protocol/src/achievement.ts
+var ACHIEVEMENT_ID = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+var ACHIEVEMENT_ID_MAX = 48;
+var ACHIEVEMENT_VALUE_MAX = 9007199254740991;
+function isAchievementId(value) {
+  return typeof value === "string" && value.length <= ACHIEVEMENT_ID_MAX && ACHIEVEMENT_ID.test(value);
+}
+function isAchievementValue(value) {
+  return typeof value === "number" && Number.isFinite(value) && Math.abs(value) <= ACHIEVEMENT_VALUE_MAX;
+}
+function readAchievementState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  if (typeof raw.unlocked !== "boolean") return null;
+  const state = { unlocked: raw.unlocked };
+  if (typeof raw.at === "number" && Number.isFinite(raw.at)) state.at = raw.at;
+  if (isAchievementValue(raw.progress)) state.progress = raw.progress;
+  return state;
+}
+function readAchievementResult(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  if (typeof raw.unlocked !== "boolean" || typeof raw.earned !== "boolean") return null;
+  const result = { unlocked: raw.unlocked, earned: raw.earned };
+  if (isAchievementValue(raw.progress)) result.progress = raw.progress;
+  return result;
+}
+function readAchievementWelcome(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  const ids = Array.isArray(raw.ids) ? raw.ids.filter(isAchievementId) : [];
+  const welcome = { ids };
+  const state = readStates(raw.state);
+  if (state !== void 0) welcome.state = state;
+  return welcome;
+}
+function readAchievementChange(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const state = readStates(value.state);
+  return state === void 0 ? null : { state };
+}
+function readStates(value) {
+  if (value === null) return null;
+  if (typeof value !== "object" || value === void 0 || Array.isArray(value)) return void 0;
+  const states = {};
+  for (const [id, entry] of Object.entries(value)) {
+    if (!isAchievementId(id)) continue;
+    const read = readAchievementState(entry);
+    if (read !== null) states[id] = read;
+  }
+  return states;
+}
+
+// ../protocol/src/analytics.ts
+var ANALYTICS_RESERVED_PREFIX = "hopple.";
+var ANALYTICS_NAME = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+function isAnalyticsName(value) {
+  return typeof value === "string" && !value.startsWith(ANALYTICS_RESERVED_PREFIX) && ANALYTICS_NAME.test(value);
+}
+function readAnalyticsEvent(name, props, declared) {
+  const label = typeof name === "string" ? name : "";
+  if (!isAnalyticsName(name)) return { ok: false, reason: "name", name: label };
+  const shape = declared?.[name];
+  if (declared !== void 0 && shape === void 0) {
+    return { ok: false, reason: "undeclared", name };
+  }
+  if (props !== void 0 && !isProps(props)) return { ok: false, reason: "props", name };
+  const kept = {};
+  const dropped = [];
+  for (const [key, value] of Object.entries(isProps(props) ? props : {})) {
+    const type = shape?.[key];
+    const undeclared = shape !== void 0 && type === void 0;
+    if (undeclared || !ANALYTICS_NAME.test(key) || !fits(value, type)) {
+      dropped.push(key);
+      continue;
+    }
+    kept[key] = value;
+  }
+  return { ok: true, name, props: kept, dropped };
+}
+function isProps(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fits(value, type) {
+  if (typeof value === "string") return type === void 0 || type === "string";
+  if (typeof value === "number") {
+    return Number.isFinite(value) && (type === void 0 || type === "number");
+  }
+  if (typeof value === "boolean") return type === void 0 || type === "boolean";
+  return false;
+}
+
+// ../protocol/src/audio.ts
+var AUDIO_VOLUME_MAX = 1;
+var AUDIO_MASTER = "master";
+var AUDIO_ID_MAX = 48;
+var AUDIO_ID = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+function isAudioChannelId(value) {
+  return typeof value === "string" && value.length <= AUDIO_ID_MAX && AUDIO_ID.test(value);
+}
+var AUDIO_FULL = Object.freeze({
+  muted: false,
+  master: AUDIO_VOLUME_MAX,
+  // Frozen, because this is the fallback every reader reaches for and a shared
+  // object somebody wrote one channel into would quietly become the default
+  // mix for every game that ever meets a host with nothing to say.
+  channels: Object.freeze({})
+});
+function readAudioVolume(value, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.min(AUDIO_VOLUME_MAX, Math.max(0, value));
+}
+function readAudioState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  const channels = {};
+  if (typeof raw.channels === "object" && raw.channels !== null && !Array.isArray(raw.channels)) {
+    for (const [id, level] of Object.entries(raw.channels)) {
+      if (!isAudioChannelId(id) || id === AUDIO_MASTER) continue;
+      if (typeof level !== "number" || !Number.isFinite(level)) continue;
+      channels[id] = Math.min(AUDIO_VOLUME_MAX, Math.max(0, level));
+    }
+  }
+  return {
+    muted: raw.muted === true,
+    master: readAudioVolume(raw.master, AUDIO_FULL.master),
+    channels
+  };
+}
+function sameAudioState(a, b) {
+  if (a.muted !== b.muted || a.master !== b.master) return false;
+  const keys = Object.keys(a.channels);
+  if (keys.length !== Object.keys(b.channels).length) return false;
+  return keys.every((key) => a.channels[key] === b.channels[key]);
+}
+function audioVolumeOf(state, channel) {
+  if (state.muted) return 0;
+  if (channel === void 0 || channel === AUDIO_MASTER) return state.master;
+  return state.master * (state.channels[channel] ?? AUDIO_VOLUME_MAX);
+}
+
+// ../protocol/src/allow.ts
+var ALLOW_ALL = Object.freeze({ audio: true, loop: true, resources: true });
+function readAllowed(value) {
+  const raw = typeof value === "object" && value !== null ? value : {};
+  return {
+    audio: raw.audio !== false,
+    loop: raw.loop !== false,
+    resources: raw.resources !== false
+  };
+}
+
+// ../protocol/src/envelope.ts
+var PROTOCOL_VERSION = 1;
+function isEnvelope(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const message = value;
+  if (message.p !== PROTOCOL_VERSION) return false;
+  switch (message.kind) {
+    case "req":
+      return typeof message.id === "string" && typeof message.method === "string";
+    case "res":
+      if (typeof message.id !== "string") return false;
+      if (message.ok === true) return true;
+      if (message.ok === false) return isProtocolError(message.error);
+      return false;
+    case "evt":
+      return typeof message.topic === "string";
+    default:
+      return false;
+  }
+}
+function isProtocolError(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const error = value;
+  return typeof error.code === "string" && typeof error.message === "string";
+}
+
+// ../protocol/src/errors.ts
+var BridgeError = class extends Error {
+  code;
+  constructor(error) {
+    super(error.message);
+    this.name = "BridgeError";
+    this.code = error.code;
+  }
+};
+function toProtocolError(thrown) {
+  if (thrown instanceof BridgeError) {
+    return { code: thrown.code, message: thrown.message };
+  }
+  return { code: "internal", message: "The handler failed." };
+}
+
+// ../protocol/src/error.ts
+var GAME_ERROR_MESSAGE_MAX = 1e3;
+var GAME_ERROR_STACK_MAX = 8e3;
+function describeThrown(kind, thrown) {
+  let message;
+  let stack;
+  try {
+    if (isError(thrown)) {
+      message = thrown.message === "" ? String(thrown.name) : `${String(thrown.name)}: ${thrown.message}`;
+      stack = typeof thrown.stack === "string" ? thrown.stack : void 0;
+    } else if (typeof thrown === "string") {
+      message = thrown;
+    } else if (typeof thrown === "object" && thrown !== null) {
+      message = JSON.stringify(thrown) ?? String(thrown);
+    } else {
+      message = String(thrown);
+    }
+  } catch {
+    message = "An error that could not be described.";
+  }
+  const error = { kind, message: clip(message, GAME_ERROR_MESSAGE_MAX) };
+  if (stack !== void 0 && stack !== "") error.stack = clip(stack, GAME_ERROR_STACK_MAX);
+  return error;
+}
+function isError(value) {
+  if (value instanceof Error) return true;
+  const tag = Object.prototype.toString.call(value);
+  return (tag === "[object Error]" || tag === "[object DOMException]") && typeof value.message === "string";
+}
+function clip(text2, max) {
+  return text2.length > max ? `${text2.slice(0, max - 1)}\u2026` : text2;
+}
+
+// ../protocol/src/input.ts
+var INPUT_SCHEMES = ["keyboard", "mouse", "touch", "gamepad"];
+var INPUT_ID_MAX = 48;
+var INPUT_ID = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+var INPUT_BINDING_MAX = 96;
+function isInputActionId(value) {
+  return typeof value === "string" && value.length <= INPUT_ID_MAX && INPUT_ID.test(value);
+}
+var INPUT_LAYOUT_SHAPES = ["row", "column", "diamond", "cluster"];
+var INPUT_LAYOUT_ZONES = ["left", "right", "full"];
+var INPUT_CHANGE_CAUSES = ["remap", "scheme", "host", "setting"];
+function readInputBinding(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  if (!Array.isArray(raw.bind)) return null;
+  const bind = raw.bind.filter(
+    (one) => typeof one === "string" && one.length <= INPUT_BINDING_MAX
+  );
+  const binding = { bind };
+  if (typeof raw.title === "string") binding.title = raw.title;
+  if (typeof raw.label === "string") binding.label = raw.label;
+  return binding;
+}
+function readInputWelcome(value) {
+  const state = readInputState(value);
+  if (state === null) return null;
+  const raw = value;
+  const actions = {};
+  for (const [id, entry] of entries(raw.actions)) {
+    if (!isInputActionId(id)) continue;
+    const read = readInputBinding(entry);
+    if (read !== null) actions[id] = read;
+  }
+  const layouts = {};
+  for (const [name, entry] of entries(raw.layouts)) {
+    if (!isInputActionId(name)) continue;
+    const read = readInputLayout(entry);
+    if (read !== null) layouts[name] = read;
+  }
+  return { ...state, actions, layouts };
+}
+function readInputLayout(value) {
+  if (!isRecord(value)) return null;
+  const layout = {};
+  for (const zone of INPUT_LAYOUT_ZONES) {
+    const slots = value[zone];
+    if (!isRecord(slots)) continue;
+    const controls = {};
+    for (const [id, slot] of Object.entries(slots)) {
+      if (!isInputActionId(id)) continue;
+      const read = readInputLayoutControl(slot);
+      if (read !== null) controls[id] = read;
+    }
+    layout[zone] = controls;
+  }
+  return layout;
+}
+function readInputLayoutControl(value) {
+  if (!isRecord(value)) return null;
+  const type = value["type"];
+  if (type !== "buttons" && type !== "thumbstick") return null;
+  const control = { type };
+  const buttons2 = value["buttons"];
+  if (Array.isArray(buttons2)) control.buttons = buttons2.filter(isInputActionId);
+  const shape = value["shape"];
+  if (INPUT_LAYOUT_SHAPES.includes(shape)) {
+    control.shape = shape;
+  }
+  const as = value["as"];
+  if (isBindingString(as)) control.as = as;
+  else if (isRecord(as)) {
+    const stands = {};
+    for (const [action, binding] of Object.entries(as)) {
+      if (isInputActionId(action) && isBindingString(binding)) stands[action] = binding;
+    }
+    control.as = stands;
+  }
+  const axis = value["axis"];
+  if (type === "thumbstick" && (axis === "x" || axis === "y")) control.axis = axis;
+  return control;
+}
+function readInputChange(value) {
+  const state = readInputState(value);
+  if (state === null) return null;
+  const cause = value.cause;
+  return {
+    ...state,
+    cause: INPUT_CHANGE_CAUSES.includes(cause) ? cause : "host"
+  };
+}
+function readInputState(value) {
+  if (!isRecord(value)) return null;
+  const raw = value;
+  const mapping = {};
+  for (const [id, entry] of entries(raw.mapping)) {
+    if (!isInputActionId(id)) continue;
+    const read = readInputBinding(entry);
+    if (read !== null) mapping[id] = read;
+  }
+  return {
+    mapping,
+    // An unknown scheme is a host newer than this game. `keyboard` is the
+    // cautious reading: it draws written prompts, which are wrong-looking at
+    // worst, where guessing `gamepad` would draw glyphs for a pad nobody holds.
+    scheme: INPUT_SCHEMES.includes(raw.scheme) ? raw.scheme : "keyboard",
+    controls: raw.controls === true,
+    // Absent is a host older than the setting, and its players get the stick
+    // that needs no finding. One nobody here knows is a newer host's, and the
+    // same answer is the safe one.
+    sticks: raw.sticks === "fixed" ? "fixed" : "floating"
+  };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function entries(value) {
+  return isRecord(value) ? Object.entries(value) : [];
+}
+function isBindingString(value) {
+  return typeof value === "string" && value.length <= INPUT_BINDING_MAX;
+}
+
+// ../protocol/src/methods.ts
+var APP_SURFACES = ["app", "web", "dev"];
+var DEVICE_TIERS = ["low", "mid", "high"];
+var NO_INFO = {
+  app: { id: "", version: "", surface: "web" },
+  game: { id: "", version: "" },
+  player: { id: null, returning: false, locale: "en" },
+  device: { tier: "mid" }
+};
+
+// ../protocol/src/listeners.ts
+function createListeners(report) {
+  const added = /* @__PURE__ */ new Set();
+  function call(entry, args) {
+    try {
+      return entry.listener(...args);
+    } catch (thrown) {
+      report(thrown);
+      return void 0;
+    }
+  }
+  return {
+    on(listener) {
+      const entry = { listener };
+      added.add(entry);
+      return () => {
+        added.delete(entry);
+      };
+    },
+    emit(...args) {
+      for (const entry of [...added]) {
+        if (!added.has(entry)) continue;
+        const result = call(entry, args);
+        if (result instanceof Promise) result.catch(report);
+      }
+    },
+    async settle(...args) {
+      await Promise.all(
+        [...added].map(async (entry) => {
+          if (!added.has(entry)) return;
+          try {
+            await call(entry, args);
+          } catch (thrown) {
+            report(thrown);
+          }
+        })
+      );
+    },
+    get size() {
+      return added.size;
+    },
+    clear() {
+      added.clear();
+    }
+  };
+}
+
+// ../protocol/src/panel.ts
+var PAGE_ID = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+var PAGE_ID_MAX = 32;
+var PAGES = ["about", "scores", "achievements", "input"];
+function isPageId(value) {
+  return typeof value === "string" && value.length <= PAGE_ID_MAX && PAGE_ID.test(value);
+}
+function readPanelWelcome(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  const welcome = { ids: Array.isArray(raw.ids) ? raw.ids.filter(isPageId) : [] };
+  if (raw.isOpen === true || isPageId(raw.page)) welcome.isOpen = true;
+  if (isPageId(raw.page)) welcome.page = raw.page;
+  return welcome;
+}
+function readPanelChange(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  const page = isPageId(raw.page) ? raw.page : null;
+  const isOpen = raw.isOpen === true || page !== null;
+  return { isOpen, page: isOpen ? page : null };
+}
+
+// ../protocol/src/pause.ts
+var PAUSE_STATES = ["running", "paused", "unpausable"];
+var PAUSE_NONE = "unpausable";
+function readPauseRequest(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  return typeof raw.paused === "boolean" ? { paused: raw.paused } : null;
+}
+
+// ../protocol/src/save.ts
+var SAVE_BYTES = 65536;
+function readSaveRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  if (typeof raw.state !== "string") return null;
+  if (typeof raw.version !== "number" || !Number.isFinite(raw.version)) return null;
+  if (raw.encoding !== "json" && raw.encoding !== "text") return null;
+  const record = { version: raw.version, encoding: raw.encoding, state: raw.state };
+  if (typeof raw.rev === "string") record.rev = raw.rev;
+  return record;
+}
+function saveBytes(state) {
+  return new TextEncoder().encode(state).length;
+}
+function readSaveStored(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const raw = value;
+  if (!number(raw.at) || !number(raw.version) || !number(raw.bytes)) return null;
+  return { at: raw.at, version: raw.version, bytes: raw.bytes };
+}
+function number(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// ../protocol/src/score.ts
+var SCORE_VALUE_MAX = 9007199254740991;
+var SCORE_BOARD_ID = /^[a-z0-9]+(?:[._-][a-z0-9]+)*$/;
+var SCORE_BOARD_ID_MAX = 48;
+function isScoreBoardId(value) {
+  return typeof value === "string" && value.length <= SCORE_BOARD_ID_MAX && SCORE_BOARD_ID.test(value);
+}
+function isScoreValue(value) {
+  return typeof value === "number" && Number.isFinite(value) && Math.abs(value) <= SCORE_VALUE_MAX;
+}
+function readScoreStanding(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  if (!isScoreValue(raw.best) || !number2(raw.at) || !number2(raw.runs)) return null;
+  const standing = { best: raw.best, at: raw.at, runs: raw.runs };
+  if (number2(raw.rank)) standing.rank = raw.rank;
+  if (number2(raw.of)) standing.of = raw.of;
+  return standing;
+}
+function readScoreWelcome(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  const boards = Array.isArray(raw.boards) ? raw.boards.filter(isScoreBoardId) : [];
+  const welcome = { boards };
+  if (raw.standing === null) {
+    welcome.standing = null;
+  } else if (typeof raw.standing === "object" && raw.standing !== void 0) {
+    const standing = {};
+    for (const [board, entry] of Object.entries(raw.standing)) {
+      if (!isScoreBoardId(board)) continue;
+      const read = readScoreStanding(entry);
+      if (read !== null) standing[board] = read;
+    }
+    welcome.standing = standing;
+  }
+  return welcome;
+}
+function readScoreChange(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  if (raw.standing === null) return { standing: null };
+  const read = readScoreWelcome({ boards: [], standing: raw.standing });
+  return read?.standing === void 0 ? null : { standing: read.standing };
+}
+function readScoreResult(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const raw = value;
+  if (typeof raw.improved !== "boolean" || !isScoreValue(raw.best)) return null;
+  const result = { improved: raw.improved, best: raw.best };
+  if (number2(raw.rank)) result.rank = raw.rank;
+  if (number2(raw.of)) result.of = raw.of;
+  return result;
+}
+function number2(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// ../protocol/src/share.ts
+var SHARE_BYTES = 512;
+var SHARE_META_BYTES = 1024;
+function readShareWelcome(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const raw = value;
+  const welcome = {};
+  if (typeof raw.data === "string" && raw.data !== "") welcome.data = raw.data;
+  if (typeof raw.offers === "boolean") welcome.offers = raw.offers;
+  return welcome;
+}
+function readShareMeta(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  try {
+    const carried = JSON.parse(JSON.stringify(value));
+    return typeof carried === "object" && carried !== null && !Array.isArray(carried) ? carried : null;
+  } catch {
+    return null;
+  }
+}
+
+// ../protocol/src/peer.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+function createPeer(options) {
+  const { transport } = options;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const report = options.onError ?? ((error) => console.error(error));
+  const handlers = options.handlers;
+  const pending = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Map();
+  let nextId = 0;
+  let mine = null;
+  let theirs = null;
+  let disposed = false;
+  const unsubscribe = transport.receive(receive);
+  function receive(message) {
+    if (disposed) return;
+    if (message.kind === "req") {
+      void answer(message);
+    } else if (message.kind === "res") {
+      settle(message);
+    } else {
+      deliver(message);
+    }
+  }
+  async function answer(request) {
+    if (fromEndedSession(request.id)) {
+      post({
+        p: PROTOCOL_VERSION,
+        kind: "res",
+        id: request.id,
+        ok: false,
+        error: { code: "stale", message: "That conversation has ended; introduce yourself again." }
+      });
+      return;
+    }
+    const handler = handlers[request.method];
+    if (!handler) {
+      post({
+        p: PROTOCOL_VERSION,
+        kind: "res",
+        id: request.id,
+        ok: false,
+        error: { code: "unknown_method", message: `No handler for "${request.method}".` }
+      });
+      return;
+    }
+    try {
+      const value = await handler(request.params);
+      if (disposed) return;
+      post({ p: PROTOCOL_VERSION, kind: "res", id: request.id, ok: true, value });
+    } catch (thrown) {
+      if (disposed) return;
+      post({
+        p: PROTOCOL_VERSION,
+        kind: "res",
+        id: request.id,
+        ok: false,
+        error: toProtocolError(thrown)
+      });
+    }
+  }
+  function settle(response) {
+    const call2 = pending.get(response.id);
+    if (!call2) return;
+    pending.delete(response.id);
+    clearTimeout(call2.timer);
+    if (response.ok) call2.resolve(response.value);
+    else call2.reject(new BridgeError(response.error));
+  }
+  function deliver(event) {
+    listeners.get(event.topic)?.emit(event.data);
+  }
+  function post(message) {
+    try {
+      transport.send(message);
+    } catch (thrown) {
+      report(thrown);
+    }
+  }
+  function call(method, params, options2) {
+    if (disposed) {
+      return Promise.reject(
+        new BridgeError({ code: "disposed", message: `"${method}" was not sent: peer disposed.` })
+      );
+    }
+    nextId += 1;
+    const id = mine === null ? String(nextId) : `${mine}-${nextId}`;
+    const wait = options2?.timeoutMs ?? timeoutMs;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pending.delete(id);
+        reject(
+          new BridgeError({
+            code: "timeout",
+            message: `"${method}" got no reply within ${wait}ms.`
+          })
+        );
+      }, wait);
+      pending.set(id, { resolve, reject, timer });
+      post({ p: PROTOCOL_VERSION, kind: "req", id, method, params });
+    });
+  }
+  function emit(topic, data) {
+    if (disposed) return;
+    post({ p: PROTOCOL_VERSION, kind: "evt", topic, data });
+  }
+  function on(topic, listener) {
+    let subscribers = listeners.get(topic);
+    if (subscribers === void 0) {
+      subscribers = createListeners(report);
+      listeners.set(topic, subscribers);
+    }
+    const stop = subscribers.on(listener);
+    const held = subscribers;
+    return () => {
+      stop();
+      if (held.size === 0 && listeners.get(topic) === held) listeners.delete(topic);
+    };
+  }
+  function abort(error) {
+    for (const call2 of pending.values()) {
+      clearTimeout(call2.timer);
+      call2.reject(error);
+    }
+    pending.clear();
+  }
+  function useSession(id) {
+    mine = id;
+  }
+  function expectSession(id) {
+    if (disposed) return;
+    theirs = id;
+    abort(
+      new BridgeError({
+        code: "stale",
+        message: "The other side started over; this call belonged to the conversation before it."
+      })
+    );
+  }
+  function fromEndedSession(id) {
+    if (theirs === null) return false;
+    const stamp = id.indexOf("-");
+    if (stamp === -1) return false;
+    return id.slice(0, stamp) !== theirs;
+  }
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    unsubscribe();
+    abort(new BridgeError({ code: "disposed", message: "The peer was disposed mid-call." }));
+    listeners.clear();
+    transport.close();
+  }
+  return { call, emit, on, useSession, expectSession, dispose };
+}
+
+// ../protocol/src/transport.ts
+var SHIM = "__HOPPLE_SHIM__";
+var SET_SHIM = "__HOPPLE_SET_SHIM__";
+
+// package.json
+var package_default = { version: "0.1.0-rc.1" };
+
+// src/calls.ts
+function answering(peer) {
+  const call = (method, params, options) => peer.call(method, params, options).catch((thrown) => {
+    throw notHere(thrown);
+  });
+  return { ...peer, call };
+}
+function forget(work, onError, then) {
+  let sent;
+  try {
+    sent = work();
+  } catch (thrown) {
+    sent = Promise.reject(thrown);
+  }
+  sent.then(then, (thrown) => {
+    if (thrown instanceof BridgeError && (thrown.code === "unsupported" || thrown.code === "disposed")) {
+      return;
+    }
+    onError(thrown);
+  });
+}
+function notHere(thrown) {
+  if (!(thrown instanceof BridgeError) || thrown.code !== "unknown_method") return thrown;
+  return new BridgeError({ code: "unsupported", message: thrown.message });
+}
+
+// src/achievements.ts
+function createAchievements(options) {
+  let available = false;
+  let ids = [];
+  let state;
+  let standing = standingOf(ids, state);
+  const listeners = createListeners(options.onError);
+  function settle(next) {
+    state = next;
+    const previous = standing;
+    standing = standingOf(ids, state);
+    if (!sameStanding(previous, standing)) listeners.emit(standing, previous);
+  }
+  function keep(id, result) {
+    if (state === void 0) return;
+    const before = state ?? {};
+    const previous = before[id];
+    const now = {
+      unlocked: result.unlocked,
+      // Set once and never moved: the moment something was earned does not
+      // change because it was reported again.
+      ...result.unlocked ? { at: previous?.at ?? Date.now() } : {},
+      ...result.progress === void 0 ? {} : { progress: result.progress }
+    };
+    settle({ ...before, [id]: now });
+  }
+  const achievements = {
+    get available() {
+      return available;
+    },
+    get standing() {
+      return standing;
+    },
+    on: listeners.on,
+    unlock(id) {
+      if (!available) return;
+      forget(
+        () => options.peer().call("achievement.unlock", { id }),
+        options.onError,
+        (answer) => {
+          keep(id, readAchievementResult(answer) ?? { unlocked: true, earned: true });
+        }
+      );
+    },
+    progress(id, value) {
+      if (!isAchievementValue(value)) {
+        options.onError(
+          new Error(`achievements: progress on "${id}" must be a finite number an achievement can hold.`)
+        );
+        return;
+      }
+      if (!available) return;
+      forget(
+        () => options.peer().call("achievement.progress", { id, progress: value }),
+        options.onError,
+        (answer) => {
+          keep(id, readAchievementResult(answer) ?? { unlocked: false, earned: false, progress: value });
+        }
+      );
+    }
+  };
+  return {
+    achievements,
+    adopt(value) {
+      const welcome = readAchievementWelcome(value);
+      available = welcome !== null;
+      ids = welcome?.ids ?? [];
+      state = welcome?.state;
+      standing = standingOf(ids, state);
+    },
+    onChange(value) {
+      const change = readAchievementChange(value);
+      if (change !== null) settle(change.state);
+    }
+  };
+}
+function standingOf(ids, state) {
+  if (state === void 0) {
+    return Object.freeze({ known: false, items: Object.freeze(ids.map((id) => Object.freeze({ id }))) });
+  }
+  const held = state ?? {};
+  const items = ids.map((id) => Object.freeze({ id, ...held[id] ?? { unlocked: false } }));
+  return Object.freeze({ known: true, items: Object.freeze(items) });
+}
+function sameStanding(a, b) {
+  if (a.known !== b.known || a.items.length !== b.items.length) return false;
+  if (!a.known || !b.known) return true;
+  return a.items.every((one, i) => {
+    const other = b.items[i];
+    return other !== void 0 && one.id === other.id && one.unlocked === other.unlocked && one.at === other.at && one.progress === other.progress;
+  });
+}
+
+// src/analytics.ts
+function createAnalytics(options) {
+  return {
+    refused(data) {
+      const raw = data;
+      const said = typeof raw === "object" && raw !== null ? raw : null;
+      (options.onRefused ?? options.onError)(
+        new Error(`analytics: the host refused "${String(said?.name)}" (${String(said?.reason)}).`)
+      );
+    },
+    analytics: {
+      track(name, props) {
+        const intake = readAnalyticsEvent(name, props);
+        if (!intake.ok) {
+          options.onError(new Error(`analytics: "${intake.name}" was not sent (${intake.reason}).`));
+          return;
+        }
+        if (intake.dropped.length > 0) {
+          options.onError(
+            new Error(`analytics: "${intake.name}" dropped ${intake.dropped.join(", ")}.`)
+          );
+        }
+        const event = { name: intake.name };
+        if (Object.keys(intake.props).length > 0) event.props = intake.props;
+        options.peer().emit("analytics.event", event);
+      }
+    }
+  };
+}
+
+// src/audio.ts
+var UNLOCKING = ["pointerdown", "pointerup", "touchend", "keydown"];
+function createAudio(options) {
+  let state = frozen(AUDIO_FULL);
+  let allowed = true;
+  let ordered = false;
+  const listeners = createListeners(options.onError);
+  const outputs = /* @__PURE__ */ new Map();
+  const held = /* @__PURE__ */ new Map();
+  let listening = false;
+  function level(channel) {
+    return allowed ? audioVolumeOf(state, channel) : 0;
+  }
+  function apply() {
+    for (const gains of outputs.values()) {
+      for (const [channel, gain] of gains) gain.gain.value = level(channel);
+    }
+    for (const [element, one] of held) element.volume = level(one.channel);
+  }
+  function wake() {
+    if (!allowed) return;
+    for (const context of outputs.keys()) {
+      if (context.state === "suspended") context.resume().catch(() => {
+      });
+    }
+    for (const [element, one] of held) {
+      if (!one.stopped) continue;
+      element.play().then(
+        () => {
+          one.stopped = false;
+        },
+        () => {
+        }
+      );
+    }
+  }
+  async function hush() {
+    for (const [element, one] of held) {
+      if (element.paused) continue;
+      element.pause();
+      one.stopped = true;
+    }
+    await Promise.all(
+      [...outputs.keys()].map(
+        (context) => context.state === "running" ? context.suspend().catch(() => {
+        }) : void 0
+      )
+    );
+  }
+  function listen() {
+    if (listening || options.scope === null) return;
+    listening = true;
+    for (const type of UNLOCKING) options.scope.addEventListener(type, wake, { capture: true });
+  }
+  const audio = {
+    get allowed() {
+      return allowed;
+    },
+    get muted() {
+      return state.muted;
+    },
+    get master() {
+      return state.master;
+    },
+    get state() {
+      return state;
+    },
+    volume(channel) {
+      return level(channel);
+    },
+    channel(id) {
+      if (id === AUDIO_MASTER) return state.master;
+      return state.channels[id] ?? AUDIO_VOLUME_MAX;
+    },
+    on: listeners.on,
+    output(context, channel) {
+      let gains = outputs.get(context);
+      if (gains === void 0) {
+        gains = /* @__PURE__ */ new Map();
+        outputs.set(context, gains);
+        if (!allowed && context.state === "running") {
+          context.suspend().catch(() => {
+          });
+        }
+      }
+      let gain = gains.get(channel);
+      if (gain === void 0) {
+        gain = context.createGain();
+        gain.gain.value = level(channel);
+        gain.connect(context.destination);
+        gains.set(channel, gain);
+      }
+      listen();
+      wake();
+      return gain;
+    },
+    media(element, channel) {
+      held.set(element, { channel, stopped: false });
+      element.volume = level(channel);
+      if (!allowed && !element.paused) {
+        element.pause();
+        const one = held.get(element);
+        if (one !== void 0) one.stopped = true;
+      }
+      listen();
+      return () => {
+        held.delete(element);
+      };
+    }
+  };
+  return {
+    audio,
+    async onAllow(params) {
+      ordered = true;
+      if (params.allowed !== allowed) {
+        allowed = params.allowed;
+        apply();
+        listeners.emit();
+        if (allowed) wake();
+        else await hush();
+      }
+      return { allowed };
+    },
+    dispose() {
+      if (listening && options.scope !== null) {
+        for (const type of UNLOCKING) options.scope.removeEventListener(type, wake, { capture: true });
+      }
+      listening = false;
+      outputs.clear();
+      held.clear();
+    },
+    adopt(value, initial) {
+      if (!ordered) allowed = initial;
+      state = frozen(readAudioState(value) ?? AUDIO_FULL);
+      apply();
+    },
+    onSet(params) {
+      const next = frozen(readAudioState(params) ?? state);
+      if (!sameAudioState(state, next)) {
+        state = next;
+        apply();
+        listeners.emit();
+      }
+      return state;
+    }
+  };
+}
+function frozen(state) {
+  return Object.freeze({
+    muted: state.muted,
+    master: state.master,
+    channels: Object.freeze({ ...state.channels })
+  });
+}
+
+// src/errors.ts
+var HELD_MAX = 20;
+var FOLD_MS = 1e3;
+var FOLDING_MAX = 32;
+function createErrorReporter(scope) {
+  let peer = null;
+  let held = [];
+  const folding = /* @__PURE__ */ new Map();
+  function deliver(error) {
+    if (peer !== null) {
+      peer.emit("error.report", error);
+      return;
+    }
+    if (held.length < HELD_MAX) held.push(error);
+  }
+  function fold(key, error) {
+    const entry = {
+      error,
+      again: 0,
+      timer: setTimeout(() => {
+        folding.delete(key);
+        if (entry.again === 0) return;
+        deliver({ ...error, count: entry.again });
+        fold(key, error);
+      }, FOLD_MS)
+    };
+    folding.set(key, entry);
+  }
+  function send(error) {
+    const key = `${error.kind}
+${error.message}
+${error.stack ?? ""}`;
+    const seen = folding.get(key);
+    if (seen !== void 0) {
+      seen.again += 1;
+      return;
+    }
+    deliver(error);
+    if (folding.size < FOLDING_MAX) fold(key, error);
+  }
+  function report(kind, thrown) {
+    send(describeThrown(kind, thrown));
+  }
+  const onError = (event) => {
+    const caught = event;
+    if (caught.error !== void 0 && caught.error !== null) {
+      report("uncaught", caught.error);
+      return;
+    }
+    if (typeof caught.message !== "string" || caught.message === "") return;
+    const error = describeThrown("uncaught", caught.message);
+    if (typeof caught.filename === "string" && caught.filename !== "") {
+      error.stack = `at ${caught.filename}:${caught.lineno}:${caught.colno}`;
+    }
+    send(error);
+  };
+  const onRejection = (event) => {
+    report("rejection", event.reason);
+  };
+  scope?.addEventListener("error", onError);
+  scope?.addEventListener("unhandledrejection", onRejection);
+  return {
+    report,
+    connect(next) {
+      peer = next;
+      const waiting = held;
+      held = [];
+      for (const error of waiting) next.emit("error.report", error);
+    },
+    dispose() {
+      scope?.removeEventListener("error", onError);
+      scope?.removeEventListener("unhandledrejection", onRejection);
+      for (const { error, again, timer } of folding.values()) {
+        clearTimeout(timer);
+        if (again > 0) deliver({ ...error, count: again });
+      }
+      folding.clear();
+      held = [];
+    }
+  };
+}
+
+// src/info.ts
+function readInfo(value) {
+  const message = group(value);
+  const app = group(message.app);
+  const game = group(message.game);
+  const player = group(message.player);
+  const device = group(message.device);
+  return Object.freeze({
+    app: Object.freeze({
+      id: text(app.id, NO_INFO.app.id),
+      version: text(app.version, NO_INFO.app.version),
+      surface: oneOf(app.surface, APP_SURFACES, NO_INFO.app.surface)
+    }),
+    game: Object.freeze({
+      id: text(game.id, NO_INFO.game.id),
+      version: text(game.version, NO_INFO.game.version)
+    }),
+    player: Object.freeze({
+      // Anything that is not a name is nobody. A host that means "there is a
+      // player here" says so with their name for this game, and an empty string
+      // is not one — believing it would hand every anonymous player the same id.
+      id: typeof player.id === "string" && player.id !== "" ? player.id : null,
+      returning: player.returning === true,
+      locale: text(player.locale, NO_INFO.player.locale)
+    }),
+    device: Object.freeze({
+      tier: oneOf(device.tier, DEVICE_TIERS, NO_INFO.device.tier)
+    })
+  });
+}
+function group(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function text(value, fallback) {
+  return typeof value === "string" ? value : fallback;
+}
+function oneOf(value, allowed, fallback) {
+  return allowed.includes(value) ? value : fallback;
+}
+
+// src/input/bindings.ts
+var PAD_BUTTONS = [
+  "pad.right.south",
+  "pad.right.east",
+  "pad.right.west",
+  "pad.right.north",
+  "pad.left.bumper",
+  "pad.right.bumper",
+  "pad.left.trigger",
+  "pad.right.trigger",
+  "pad.select",
+  "pad.start",
+  // The stick presses. No name yet: nothing has asked for one, and a name added
+  // when something does is additive, where a name invented now is forever.
+  null,
+  null,
+  "pad.left.north",
+  "pad.left.south",
+  "pad.left.west",
+  "pad.left.east"
+];
+var PAD_STICKS = ["pad.left.stick", "pad.right.stick"];
+var EITHER_STICK = ["pad.left.stick", "pad.right.stick"];
+function matchesBinding(declared, concrete) {
+  if (declared === concrete) return true;
+  if (declared.startsWith("pad.") && concrete.startsWith("pad.")) {
+    const want = declared.slice(4);
+    const parts = concrete.slice(4).split(".");
+    return parts.length === 2 && parts[1] === want;
+  }
+  if (declared === "pointer.primary") return concrete === "mouse.left" || concrete === "touch.tap";
+  if (declared === "pointer.secondary") return concrete === "mouse.right";
+  return false;
+}
+function matchesStick(listening, concrete) {
+  if (listening === concrete) return true;
+  return listening === "pad.stick" && EITHER_STICK.includes(concrete);
+}
+function preferredBinding(bind, scheme) {
+  return bind.find((one) => servesScheme(one, scheme)) ?? bind[0];
+}
+function servesScheme(binding, scheme) {
+  if (binding.startsWith("pointer.")) return scheme === "mouse" || scheme === "touch";
+  if (binding.startsWith("controls.")) return scheme === "touch";
+  switch (scheme) {
+    case "keyboard":
+      return binding.startsWith("key.");
+    case "gamepad":
+      return binding.startsWith("pad.");
+    case "mouse":
+      return binding.startsWith("mouse.");
+    case "touch":
+      return binding.startsWith("touch.");
+    default:
+      return false;
+  }
+}
+function labelFor(binding, scheme) {
+  if (binding.startsWith("key.")) return keyLabel(binding.slice(4));
+  if (binding === "mouse.left") return "Click";
+  if (binding === "mouse.right") return "Right click";
+  if (binding === "mouse.middle") return "Middle click";
+  if (binding === "touch.tap") return "Tap";
+  if (binding === "pointer.primary") return scheme === "touch" ? "Tap" : "Click";
+  if (binding === "pointer.secondary") return "Right click";
+  if (!binding.startsWith("pad.")) return "";
+  const parts = binding.slice(4).split(".");
+  const [head, tail] = parts;
+  if (parts.length === 1) {
+    if (head === "start") return "Start";
+    if (head === "select") return "Select";
+    return FACES[head] ?? "";
+  }
+  if (head === "left" && tail !== void 0) {
+    const arrow = ARROWS[tail];
+    if (arrow !== void 0) return arrow;
+    return tail === "bumper" ? "LB" : tail === "trigger" ? "LT" : "";
+  }
+  if (head === "right" && tail !== void 0) {
+    const face = FACES[tail];
+    if (face !== void 0) return face;
+    return tail === "bumper" ? "RB" : tail === "trigger" ? "RT" : "";
+  }
+  return "";
+}
+var FACES = { south: "A", east: "B", west: "X", north: "Y" };
+var ARROWS = { north: "\u2191", south: "\u2193", west: "\u2190", east: "\u2192" };
+function keyLabel(code) {
+  if (code.startsWith("Key") && code.length === 4) return code.slice(3);
+  if (code.startsWith("Digit") && code.length === 6) return code.slice(5);
+  if (code.startsWith("Numpad")) return `Num ${code.slice(6)}`;
+  const named = {
+    ArrowUp: "\u2191",
+    ArrowDown: "\u2193",
+    ArrowLeft: "\u2190",
+    ArrowRight: "\u2192",
+    Space: "Space",
+    Enter: "Enter",
+    Tab: "Tab",
+    Backspace: "Backspace",
+    ShiftLeft: "Shift",
+    ShiftRight: "Shift",
+    ControlLeft: "Ctrl",
+    ControlRight: "Ctrl",
+    AltLeft: "Alt",
+    AltRight: "Alt"
+  };
+  return named[code] ?? code;
+}
+
+// src/input/controls.ts
+var INPUT_SHIM = "__HOPPLE_INPUT__";
+function isInputShim(value) {
+  if (typeof value !== "object" || value === null) return false;
+  return value.v === 1;
+}
+var INPUT_CONTRACT = 4;
+var SIDES = ["top", "right", "bottom", "left"];
+var KNOWN_SHAPES = ["row", "column", "diamond", "cluster"];
+var ZONES = ["left", "right", "full"];
+function resolveLayout(name, layout, actions, frame, insets, sticks) {
+  const zones = [];
+  for (const zone of ZONES) {
+    const slots = layout[zone];
+    if (slots === void 0) continue;
+    const controls = [];
+    for (const [id, slot] of Object.entries(slots)) {
+      controls.push(resolveSlot(id, slot, actions));
+    }
+    if (controls.length > 0) zones.push({ zone, controls });
+  }
+  return { layout: name, zones, frame, insets, sticks };
+}
+function resolveSlot(id, slot, actions) {
+  const shape = KNOWN_SHAPES.includes(slot.shape) ? slot.shape : "column";
+  if (slot.type === "thumbstick") {
+    const stick2 = typeof slot.as === "string" ? slot.as : `controls.${id}`;
+    const resolved = { id, type: "thumbstick", shape, buttons: [], stick: stick2 };
+    if (slot.axis !== void 0) resolved.axis = slot.axis;
+    return resolved;
+  }
+  const stands = typeof slot.as === "object" && slot.as !== null ? slot.as : {};
+  const buttons2 = (slot.buttons ?? []).map((action) => {
+    const button = {
+      action,
+      label: labelOf(actions[action]) ?? action
+    };
+    const stood = stands[action];
+    if (typeof stood === "string") button.as = stood;
+    return button;
+  });
+  return { id, type: "buttons", shape, buttons: buttons2, stick: "" };
+}
+function labelOf(action) {
+  const label = action?.label;
+  return typeof label === "string" && label !== "" ? label : void 0;
+}
+function createControlsHost(options) {
+  const { scope } = options;
+  const doc = scope.document;
+  let host = null;
+  let root = null;
+  let teardown = null;
+  let styled = false;
+  function mount() {
+    if (root !== null) return root;
+    host = doc.createElement("div");
+    host.setAttribute("data-hopple-controls", "");
+    host.style.cssText = "position:fixed;inset:0;pointer-events:none;z-index:2147483000;touch-action:none;";
+    root = host.attachShadow({ mode: "open" });
+    (doc.body ?? doc.documentElement).append(host);
+    return root;
+  }
+  return {
+    render(model) {
+      this.clear();
+      const root2 = mount();
+      for (const side of SIDES) {
+        host?.style.setProperty(`--hopple-pad-${side}`, `${model.insets[side]}px`);
+      }
+      const shim = options.shim();
+      if (shim !== null && !styled && typeof shim.style === "function") {
+        try {
+          shim.style(root2, { layout: model.layout, frame: model.frame });
+          styled = true;
+        } catch (thrown) {
+          options.onError(thrown);
+        }
+      }
+      if (shim !== null && typeof shim.render === "function") {
+        try {
+          const undo = shim.render(root2, model, options.report);
+          teardown = typeof undo === "function" ? undo : null;
+          return;
+        } catch (thrown) {
+          options.onError(thrown);
+          root2.replaceChildren();
+          teardown = null;
+        }
+      }
+      teardown = draw(root2, model, options.report, doc, options.onError);
+    },
+    clear() {
+      if (teardown !== null) {
+        try {
+          teardown();
+        } catch (thrown) {
+          options.onError(thrown);
+        }
+        teardown = null;
+      }
+      root?.replaceChildren();
+    },
+    rects() {
+      const found = [];
+      if (root === null) return found;
+      for (const element of root.querySelectorAll("[data-control]")) {
+        const box = element.getBoundingClientRect();
+        if (box.width <= 0 || box.height <= 0) continue;
+        found.push({ x: box.x, y: box.y, width: box.width, height: box.height });
+      }
+      return found;
+    },
+    fits(frame, insets) {
+      if (frame.width <= 0 || frame.height <= 0) return true;
+      const right = frame.width - insets.right;
+      const bottom = frame.height - insets.bottom;
+      for (const rect of this.rects()) {
+        if (rect.x < insets.left || rect.y < insets.top) return false;
+        if (rect.x + rect.width > right || rect.y + rect.height > bottom) return false;
+      }
+      return true;
+    },
+    owns(event) {
+      if (host === null) return false;
+      const path = typeof event.composedPath === "function" ? event.composedPath() : [];
+      if (path.includes(host)) return true;
+      return event.target === host;
+    },
+    dispose() {
+      this.clear();
+      host?.remove();
+      host = null;
+      root = null;
+    }
+  };
+}
+function draw(root, model, report, doc, onError) {
+  const style = doc.createElement("style");
+  style.textContent = SHEET;
+  root.append(style);
+  const undo = [];
+  const floating = model.sticks === "floating";
+  for (const { zone, controls } of model.zones) {
+    const element = doc.createElement("div");
+    element.className = `zone zone-${zone}`;
+    for (const control of controls) {
+      if (control.type === "buttons") {
+        element.append(buttons(control, report, doc, undo, onError));
+        continue;
+      }
+      const drawn = stick(control, floating ? zone : null, report, doc, undo, onError);
+      element.append(drawn.well);
+      if (drawn.reach !== null) style.after(drawn.reach);
+    }
+    root.append(element);
+  }
+  return () => {
+    for (const off of undo) off();
+  };
+}
+function buttons(control, report, doc, undo, onError) {
+  const group2 = doc.createElement("div");
+  group2.className = `control buttons shape-${control.shape}`;
+  group2.setAttribute("data-control", control.id);
+  for (const [index, button] of control.buttons.entries()) {
+    const element = doc.createElement("button");
+    element.className = "btn";
+    element.type = "button";
+    element.textContent = button.label;
+    element.setAttribute("aria-label", button.action);
+    element.setAttribute("data-action", button.action);
+    const set = (down2) => (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      element.classList.toggle("down", down2);
+      try {
+        report.press(control.id, index, down2);
+      } catch (thrown) {
+        onError(thrown);
+      }
+    };
+    const down = set(true);
+    const up = set(false);
+    element.addEventListener("pointerdown", down);
+    element.addEventListener("pointerup", up);
+    element.addEventListener("pointercancel", up);
+    element.addEventListener("pointerleave", up);
+    undo.push(() => {
+      element.removeEventListener("pointerdown", down);
+      element.removeEventListener("pointerup", up);
+      element.removeEventListener("pointercancel", up);
+      element.removeEventListener("pointerleave", up);
+    });
+    group2.append(element);
+  }
+  return group2;
+}
+function stick(control, zone, report, doc, undo, onError) {
+  const { axis } = control;
+  const well = doc.createElement("div");
+  well.className = axis === void 0 ? "control stick" : `control stick track track-${axis}`;
+  if (zone !== null) well.classList.add("floating");
+  well.setAttribute("data-control", control.id);
+  well.setAttribute("aria-label", control.stick);
+  if (axis !== void 0) {
+    for (const end2 of ["start", "end"]) {
+      const chevron = doc.createElement("span");
+      chevron.className = `chevron chevron-${end2}`;
+      well.append(chevron);
+    }
+  }
+  const knob = doc.createElement("div");
+  knob.className = "knob";
+  well.append(knob);
+  let reach = null;
+  if (zone !== null) {
+    reach = doc.createElement("div");
+    reach.className = `reach reach-${zone}`;
+    reach.setAttribute("data-reach", control.id);
+  }
+  let holding = null;
+  let rest = null;
+  let origin = null;
+  function send(x, y) {
+    knob.style.setProperty("--x", String(x));
+    knob.style.setProperty("--y", String(y));
+    try {
+      report.move(control.id, x, y);
+    } catch (thrown) {
+      onError(thrown);
+    }
+  }
+  function bring(to) {
+    origin = to;
+    const from = rest ?? to;
+    well.classList.toggle("held", to !== null);
+    well.style.setProperty("--dx", `${to === null || from === null ? 0 : to.x - from.x}px`);
+    well.style.setProperty("--dy", `${to === null || from === null ? 0 : to.y - from.y}px`);
+  }
+  const begin = (event) => {
+    const pointer = event;
+    event.preventDefault();
+    event.stopPropagation();
+    if (zone !== null && rest === null) {
+      const box = well.getBoundingClientRect();
+      rest = { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+    }
+    holding = pointer.pointerId;
+    try {
+      event.currentTarget?.setPointerCapture?.(pointer.pointerId);
+    } catch {
+    }
+    if (zone !== null) bring({ x: pointer.clientX, y: pointer.clientY });
+    lean(pointer);
+  };
+  const lean = (pointer) => {
+    const box = well.getBoundingClientRect();
+    const centre = origin ?? { x: box.x + box.width / 2, y: box.y + box.height / 2 };
+    if (axis !== void 0) {
+      const long = axis === "x" ? box.width : box.height;
+      const short = axis === "x" ? box.height : box.width;
+      const travel = long > short ? (long - short) / 2 : long / 2;
+      if (travel <= 0) return;
+      const offset = axis === "x" ? pointer.clientX - centre.x : pointer.clientY - centre.y;
+      const along = Math.max(-1, Math.min(1, offset / travel));
+      send(axis === "x" ? along : 0, axis === "y" ? along : 0);
+      return;
+    }
+    const radius = Math.min(box.width, box.height) / 2;
+    if (radius <= 0) return;
+    let x = (pointer.clientX - centre.x) / radius;
+    let y = (pointer.clientY - centre.y) / radius;
+    const magnitude = Math.hypot(x, y);
+    if (magnitude > 1) {
+      x /= magnitude;
+      y /= magnitude;
+    }
+    send(x, y);
+  };
+  const move = (event) => {
+    const pointer = event;
+    if (holding !== pointer.pointerId) return;
+    event.preventDefault();
+    event.stopPropagation();
+    lean(pointer);
+  };
+  const end = (event) => {
+    const pointer = event;
+    if (holding !== pointer.pointerId) return;
+    event.stopPropagation();
+    holding = null;
+    if (zone !== null) bring(null);
+    send(0, 0);
+  };
+  for (const target of reach === null ? [well] : [well, reach]) {
+    target.addEventListener("pointerdown", begin);
+    target.addEventListener("pointermove", move);
+    target.addEventListener("pointerup", end);
+    target.addEventListener("pointercancel", end);
+    undo.push(() => {
+      target.removeEventListener("pointerdown", begin);
+      target.removeEventListener("pointermove", move);
+      target.removeEventListener("pointerup", end);
+      target.removeEventListener("pointercancel", end);
+    });
+  }
+  return { well, reach };
+}
+var SHEET = `
+:host, * { box-sizing: border-box; }
+:host {
+  --hopple-pad-size: 56px;
+  --hopple-pad-stick: 116px;
+  /* The length of a stick held to one axis; its thickness is a button's. */
+  --hopple-pad-track: 148px;
+  --hopple-pad-gap: 12px;
+  --hopple-pad-inset: 20px;
+  /* What the host has taken, written onto the element by render(). Kept apart
+     from --hopple-pad-inset deliberately: that one is the gap the pad likes to
+     keep off an edge and is a shim's to set, these are a fact about the frame
+     and are not. The zones spend the sum, so a shim restyling the gap does not
+     have to know the rail exists. */
+  --hopple-pad-top: 0px;
+  --hopple-pad-right: 0px;
+  --hopple-pad-bottom: 0px;
+  --hopple-pad-left: 0px;
+  --hopple-pad-tint: rgba(255, 255, 255, 0.14);
+  --hopple-pad-edge: rgba(255, 255, 255, 0.55);
+  --hopple-pad-ink: #fff;
+  --hopple-pad-opacity: 0.85;
+  --hopple-pad-radius: 999px;
+  /* How high a floating stick's side of the screen reaches, from the bottom. */
+  --hopple-pad-reach: 60%;
+  /* A floating stick at rest is a sign that there is one, drawn quieter than
+     the stick under a thumb. */
+  --hopple-pad-idle: 0.6;
+}
+.zone {
+  position: fixed;
+  bottom: calc(var(--hopple-pad-inset) + var(--hopple-pad-bottom));
+  display: flex; align-items: flex-end; gap: var(--hopple-pad-gap);
+  opacity: var(--hopple-pad-opacity); pointer-events: none;
+}
+.zone-left { left: calc(var(--hopple-pad-inset) + var(--hopple-pad-left)); }
+.zone-right {
+  right: calc(var(--hopple-pad-inset) + var(--hopple-pad-right));
+  flex-direction: row-reverse;
+}
+.zone-full {
+  left: calc(var(--hopple-pad-inset) + var(--hopple-pad-left));
+  right: calc(var(--hopple-pad-inset) + var(--hopple-pad-right));
+  justify-content: center;
+}
+.control { pointer-events: auto; touch-action: none; }
+.buttons { display: grid; gap: var(--hopple-pad-gap); }
+.shape-column { grid-auto-flow: row; }
+.shape-row { grid-auto-flow: column; }
+.shape-cluster { grid-template-columns: repeat(2, auto); }
+.shape-diamond {
+  grid-template-columns: repeat(3, auto); grid-template-rows: repeat(3, auto);
+}
+/* North, west, east, south \u2014 the order a diamond is declared in. */
+.shape-diamond .btn:nth-child(1) { grid-area: 1 / 2; }
+.shape-diamond .btn:nth-child(2) { grid-area: 2 / 1; }
+.shape-diamond .btn:nth-child(3) { grid-area: 2 / 3; }
+.shape-diamond .btn:nth-child(4) { grid-area: 3 / 2; }
+.btn {
+  width: var(--hopple-pad-size); height: var(--hopple-pad-size);
+  border-radius: var(--hopple-pad-radius);
+  border: 1.5px solid var(--hopple-pad-edge);
+  background: var(--hopple-pad-tint); color: var(--hopple-pad-ink);
+  font: 600 15px/1 system-ui, sans-serif;
+  display: grid; place-items: center; padding: 0;
+  touch-action: none; user-select: none; -webkit-user-select: none;
+  -webkit-tap-highlight-color: transparent; cursor: pointer;
+}
+.btn.down { background: var(--hopple-pad-edge); }
+.stick {
+  width: var(--hopple-pad-stick); height: var(--hopple-pad-stick);
+  border-radius: 50%; border: 1.5px solid var(--hopple-pad-edge);
+  background: var(--hopple-pad-tint);
+  display: grid; place-items: center;
+  touch-action: none; user-select: none; -webkit-user-select: none;
+  -webkit-tap-highlight-color: transparent;
+}
+.knob {
+  width: 44%; height: 44%; border-radius: 50%;
+  background: var(--hopple-pad-edge);
+  transform: translate(calc(var(--x, 0) * 40%), calc(var(--y, 0) * 40%));
+  will-change: transform;
+}
+.track {
+  position: relative;
+  --hopple-pad-travel: calc((var(--hopple-pad-track) - var(--hopple-pad-size)) / 2);
+}
+.track-x { width: var(--hopple-pad-track); height: var(--hopple-pad-size); border-radius: var(--hopple-pad-radius); }
+.track-y { width: var(--hopple-pad-size); height: var(--hopple-pad-track); border-radius: var(--hopple-pad-radius); }
+.track .knob {
+  position: relative; z-index: 1;
+  width: calc(var(--hopple-pad-size) - 14px); height: calc(var(--hopple-pad-size) - 14px);
+  transform: translate(
+    calc(var(--x, 0) * var(--hopple-pad-travel)),
+    calc(var(--y, 0) * var(--hopple-pad-travel))
+  );
+}
+/* A groove along the track for the knob to ride in. */
+.track::before {
+  content: ''; position: absolute; border-radius: 2px;
+  background: var(--hopple-pad-edge); opacity: 0.35;
+}
+.track-x::before { left: 30%; right: 30%; top: calc(50% - 1px); height: 2px; }
+.track-y::before { top: 30%; bottom: 30%; left: calc(50% - 1px); width: 2px; }
+/* An open arrow at each end: which way the track goes, before a thumb is on it. */
+.chevron {
+  position: absolute; width: 9px; height: 9px;
+  border: solid var(--hopple-pad-edge); border-width: 0 0 2px 2px;
+}
+.track-x .chevron { top: calc(50% - 4.5px); }
+.track-x .chevron-start { left: 14px; transform: rotate(45deg); }
+.track-x .chevron-end { right: 14px; transform: rotate(-135deg); }
+.track-y .chevron { left: calc(50% - 4.5px); }
+.track-y .chevron-start { top: 14px; transform: rotate(135deg); }
+.track-y .chevron-end { bottom: 14px; transform: rotate(-45deg); }
+/* Where a floating stick listens. The host's furniture is left alone; the
+   pad's own gap off the edge is not kept, since a thumb is not a drawing. */
+.reach {
+  position: fixed; pointer-events: auto; touch-action: none;
+  bottom: var(--hopple-pad-bottom);
+  height: calc(var(--hopple-pad-reach) - var(--hopple-pad-bottom));
+  -webkit-tap-highlight-color: transparent;
+}
+.reach-left { left: var(--hopple-pad-left); right: 50%; }
+.reach-right { left: 50%; right: var(--hopple-pad-right); }
+.reach-full { left: var(--hopple-pad-left); right: var(--hopple-pad-right); }
+.floating { translate: var(--dx, 0px) var(--dy, 0px); }
+.floating:not(.held) { opacity: var(--hopple-pad-idle); }
+@media (prefers-reduced-motion: no-preference) {
+  .knob { transition: transform 60ms linear; }
+  /* Back to rest gently; to a thumb at once, since it is already there. */
+  .floating { transition: translate 140ms ease-out, opacity 140ms ease-out; }
+  .floating.held { transition: none; }
+}
+`;
+
+// src/input/sources.ts
+function typing(scope) {
+  const active = scope.document.activeElement;
+  if (active === null) return false;
+  if (active.isContentEditable) return true;
+  const tag = active.tagName;
+  return tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT";
+}
+function createSources(options) {
+  const { scope, store } = options;
+  const doc = scope.document;
+  const always = [];
+  const moving = [];
+  let watching = false;
+  let frame = null;
+  const padButtons = /* @__PURE__ */ new Map();
+  const pads = /* @__PURE__ */ new Set();
+  let focused = true;
+  function listen(target, type, handler, into, capture = false) {
+    const wrapped = (event) => {
+      try {
+        handler(event);
+      } catch (thrown) {
+        options.onError(thrown);
+      }
+    };
+    target.addEventListener(type, wrapped, capture);
+    into.push(() => target.removeEventListener(type, wrapped, capture));
+  }
+  function key(event, down) {
+    const press = event;
+    if (down && press.repeat) return;
+    if (options.suspended() || typing(scope)) return;
+    const concrete = `key.${press.code}`;
+    if (!options.isBound(concrete)) return;
+    press.preventDefault();
+    options.onScheme("keyboard");
+    store.press(concrete, down);
+  }
+  function buttonOf(event) {
+    if (event.pointerType !== "mouse") return "touch.tap";
+    if (event.button === 0) return "mouse.left";
+    if (event.button === 1) return "mouse.middle";
+    if (event.button === 2) return "mouse.right";
+    return null;
+  }
+  function pointer(event, phase) {
+    const move = event;
+    if (options.fromControls(event)) return;
+    options.onScheme(move.pointerType === "mouse" ? "mouse" : "touch");
+    if (phase === "move") {
+      store.movePointer({ x: move.clientX, y: move.clientY, down: store.pointer?.down ?? false });
+      return;
+    }
+    const down = phase === "down";
+    store.movePointer({ x: move.clientX, y: move.clientY, down });
+    if (options.suspended()) return;
+    const concrete = buttonOf(move);
+    if (concrete !== null) store.press(concrete, down);
+    if (concrete === "touch.tap" || concrete === "mouse.left") store.press("pointer.primary", down);
+  }
+  function applyDeadzone(x, y) {
+    const dead = options.deadzone();
+    const magnitude = Math.hypot(x, y);
+    if (magnitude <= dead) return { x: 0, y: 0 };
+    if (dead <= 0 || magnitude === 0) return { x, y };
+    const scaled = (magnitude - dead) / (1 - dead) / magnitude;
+    return { x: x * scaled, y: y * scaled };
+  }
+  function samplePads() {
+    for (const pad of scope.navigator.getGamepads?.() ?? []) {
+      if (pad === null) continue;
+      if (pad.mapping === "standard") {
+        const previous = padButtons.get(pad.index) ?? [];
+        const now = [];
+        for (const [index, button] of pad.buttons.entries()) {
+          const down = button.pressed;
+          now[index] = down;
+          if (down === (previous[index] ?? false)) continue;
+          if (!focused) continue;
+          const concrete = PAD_BUTTONS[index];
+          if (concrete === null || concrete === void 0) continue;
+          options.onScheme("gamepad");
+          if (!options.suspended()) store.press(concrete, down);
+        }
+        padButtons.set(pad.index, now);
+      }
+      for (const [pair, stick2] of PAD_STICKS.entries()) {
+        const raw = focused ? applyDeadzone(pad.axes[pair * 2] ?? 0, pad.axes[pair * 2 + 1] ?? 0) : { x: 0, y: 0 };
+        if (raw.x !== 0 || raw.y !== 0) options.onScheme("gamepad");
+        store.moveStick(stick2, raw.x, raw.y);
+      }
+    }
+  }
+  function loop() {
+    const tick = () => {
+      frame = null;
+      try {
+        samplePads();
+      } catch (thrown) {
+        options.onError(thrown);
+      }
+      if (pads.size > 0 && frame === null) loop();
+    };
+    frame = typeof scope.requestAnimationFrame === "function" ? scope.requestAnimationFrame(tick) : setTimeout(tick, 16);
+  }
+  function stopLoop() {
+    if (frame === null) return;
+    if (typeof scope.cancelAnimationFrame === "function") scope.cancelAnimationFrame(frame);
+    else clearTimeout(frame);
+    frame = null;
+  }
+  function connect(index) {
+    pads.add(index);
+    if (frame === null) loop();
+  }
+  function disconnect(index) {
+    pads.delete(index);
+    const held = padButtons.get(index) ?? [];
+    padButtons.delete(index);
+    for (const [button, down] of held.entries()) {
+      const concrete = PAD_BUTTONS[button];
+      if (down && concrete !== null && concrete !== void 0) store.press(concrete, false);
+    }
+    for (const stick2 of PAD_STICKS) store.moveStick(stick2, 0, 0);
+    if (pads.size === 0) stopLoop();
+  }
+  return {
+    attach() {
+      listen(scope, "keydown", (event) => key(event, true), always);
+      listen(scope, "keyup", (event) => key(event, false), always);
+      listen(scope, "pointerdown", (event) => pointer(event, "down"), always);
+      listen(scope, "pointerup", (event) => pointer(event, "up"), always);
+      listen(scope, "pointercancel", (event) => pointer(event, "up"), always);
+      listen(scope, "blur", () => {
+        focused = false;
+        store.releaseAll();
+      }, always);
+      listen(scope, "focus", () => {
+        focused = true;
+      }, always);
+      listen(doc, "visibilitychange", () => {
+        if (doc.visibilityState === "hidden") store.releaseAll();
+      }, always);
+      listen(scope, "contextmenu", (event) => {
+        if (options.isBound("mouse.right")) event.preventDefault();
+      }, always);
+      listen(scope, "gamepadconnected", (event) => {
+        connect(event.gamepad.index);
+      }, always);
+      listen(scope, "gamepaddisconnected", (event) => {
+        disconnect(event.gamepad.index);
+      }, always);
+      for (const pad of scope.navigator.getGamepads?.() ?? []) {
+        if (pad !== null) connect(pad.index);
+      }
+    },
+    watchPointer(on) {
+      if (on === watching) return;
+      watching = on;
+      if (on) {
+        listen(scope, "pointermove", (event) => pointer(event, "move"), moving);
+        listen(doc, "pointerleave", () => store.movePointer(null), moving);
+        return;
+      }
+      for (const off of moving.splice(0)) off();
+    },
+    detach() {
+      this.watchPointer(false);
+      for (const off of always.splice(0)) off();
+      stopLoop();
+      pads.clear();
+      padButtons.clear();
+    }
+  };
+}
+
+// src/input/state.ts
+var CENTRED = { x: 0, y: 0 };
+function createInputStore(options) {
+  let mapping = {};
+  const held = /* @__PURE__ */ new Map();
+  let started = /* @__PURE__ */ new Set();
+  let ended = /* @__PURE__ */ new Set();
+  const sticks = /* @__PURE__ */ new Map();
+  let pointer = null;
+  const actionListeners = /* @__PURE__ */ new Map();
+  const stickListeners = /* @__PURE__ */ new Map();
+  const pointerListeners = createListeners(options.onError);
+  function under(keyed, key) {
+    let listeners = keyed.get(key);
+    if (listeners === void 0) {
+      listeners = createListeners(options.onError);
+      keyed.set(key, listeners);
+    }
+    return listeners;
+  }
+  function settle(action, down) {
+    (down ? started : ended).add(action);
+    const listeners = actionListeners.get(action);
+    listeners?.emit(down, action);
+  }
+  function hold(action, source, down) {
+    let sources = held.get(action);
+    if (sources === void 0) {
+      sources = /* @__PURE__ */ new Set();
+      held.set(action, sources);
+    }
+    const was = sources.size > 0;
+    if (down) sources.add(source);
+    else sources.delete(source);
+    const now = sources.size > 0;
+    if (was !== now) settle(action, now);
+  }
+  return {
+    /**
+     * The mapping in force. Replacing it releases everything held.
+     *
+     * A binding that disappeared under a finger is a press with nothing to end
+     * it, and a game left holding `shoot` forever because a player opened the
+     * remapping screen mid-shot is the exact bug this API exists to prevent.
+     *
+     * `release: false` is for the caller that has already established the
+     * bindings did not actually move — a label rebuilt because somebody picked
+     * up a controller. Releasing there would stop a player mid-jump for a
+     * change that was only ever cosmetic.
+     */
+    setMapping(next, options2) {
+      mapping = next;
+      if (options2?.release !== false) this.releaseAll();
+    },
+    get mapping() {
+      return mapping;
+    },
+    /**
+     * Something concrete happened: resolve it against the mapping.
+     *
+     * `source` names *who* is holding the action, where that is not the same as
+     * what was pressed. An on-screen button standing in for `pad.south` matches
+     * the same bindings a real pad does and must still be releasable on its own
+     * — otherwise hiding the controls under a held finger would either leave the
+     * action held forever, or let go of the real pad button beside it.
+     */
+    press(concrete, down, source) {
+      for (const [action, binding] of Object.entries(mapping)) {
+        if (!binding.bind.some((declared) => matchesBinding(declared, concrete))) continue;
+        hold(action, source ?? concrete, down);
+      }
+    },
+    /**
+     * An action pressed by name, without going through the mapping.
+     *
+     * How an on-screen control works: its slot names the action, so there is no
+     * binding in between and nothing for a remap to change. That is deliberate —
+     * a player rearranges the buttons a game drew for them by not using them,
+     * not by rebinding something that is already the action itself.
+     */
+    pressAction(action, source, down) {
+      hold(action, source, down);
+    },
+    moveStick(stick2, x, y) {
+      const previous = sticks.get(stick2);
+      if (previous !== void 0 && previous.x === x && previous.y === y) return;
+      const value = { x, y };
+      sticks.set(stick2, value);
+      for (const [listening, listeners] of stickListeners) {
+        if (!matchesStick(listening, stick2)) continue;
+        listeners.emit(value, stick2);
+      }
+    },
+    movePointer(next) {
+      const same = next === null && pointer === null || next !== null && pointer !== null && next.x === pointer.x && next.y === pointer.y && next.down === pointer.down;
+      if (same) return;
+      pointer = next;
+      pointerListeners.emit(next);
+    },
+    /**
+     * Everything up, at once.
+     *
+     * The single answer to every way the ground can move under a held button:
+     * the frame lost focus, the tab was hidden, the host paused the game, the
+     * player switched layouts, a text field opened. In each of those the release
+     * that would have ended the press is going to land somewhere else, and a
+     * game that never hears it holds the button forever.
+     */
+    releaseAll() {
+      for (const [action, sources] of held) {
+        if (sources.size === 0) continue;
+        sources.clear();
+        settle(action, false);
+      }
+      for (const stick2 of [...sticks.keys()]) this.moveStick(stick2, 0, 0);
+      this.movePointer(null);
+    },
+    /**
+     * Let go of whatever these sources were holding, and nothing else.
+     *
+     * What hiding the on-screen controls does. Releasing everything would be
+     * safe and would also drop the keys a player has under their other hand,
+     * which on a device with both is a game that stops moving because a pad
+     * went away.
+     */
+    releaseFrom(owns) {
+      for (const [action, sources] of held) {
+        if (sources.size === 0) continue;
+        for (const source of [...sources]) if (owns(source)) sources.delete(source);
+        if (sources.size === 0) settle(action, false);
+      }
+    },
+    pressed(action) {
+      return (held.get(action)?.size ?? 0) > 0;
+    },
+    stick(stick2) {
+      const exact = sticks.get(stick2);
+      if (exact !== void 0) return exact;
+      for (const [id, value] of sticks) {
+        if (matchesStick(stick2, id) && (value.x !== 0 || value.y !== 0)) return value;
+      }
+      return CENTRED;
+    },
+    get pointer() {
+      return pointer;
+    },
+    /**
+     * What is true now, and what has happened since this was last asked.
+     *
+     * Taking one consumes the edges, which is why it is called once a frame:
+     * two readers in one frame means the second sees none of the presses the
+     * first did.
+     */
+    read() {
+      const startedNow = started;
+      const endedNow = ended;
+      started = /* @__PURE__ */ new Set();
+      ended = /* @__PURE__ */ new Set();
+      const down = /* @__PURE__ */ new Set();
+      for (const [action, sources] of held) if (sources.size > 0) down.add(action);
+      const stickValues = new Map(sticks);
+      const where = pointer === null ? null : { ...pointer };
+      return Object.freeze({
+        pressed: (action) => down.has(action),
+        started: (action) => startedNow.has(action),
+        ended: (action) => endedNow.has(action),
+        stick(stick2) {
+          const exact = stickValues.get(stick2);
+          if (exact !== void 0) return exact;
+          for (const [id, value] of stickValues) {
+            if (matchesStick(stick2, id) && (value.x !== 0 || value.y !== 0)) return value;
+          }
+          return CENTRED;
+        },
+        pointer: where
+      });
+    },
+    onAction(action, listener) {
+      return under(actionListeners, action).on(listener);
+    },
+    onStick(stick2, listener) {
+      return under(stickListeners, stick2).on(listener);
+    },
+    onPointer(listener) {
+      return pointerListeners.on(listener);
+    },
+    /** Whether anything is listening for where the pointer is. */
+    get watchingPointer() {
+      return pointerListeners.size > 0;
+    },
+    dispose() {
+      actionListeners.clear();
+      stickListeners.clear();
+      pointerListeners.clear();
+      held.clear();
+      sticks.clear();
+      pointer = null;
+    }
+  };
+}
+
+// src/input/index.ts
+var DEADZONE = 0.15;
+function createInput(options) {
+  const scope = options.scope;
+  let declared = {};
+  let layouts = {};
+  const store = createInputStore({ onError: options.onError });
+  let mapping = Object.freeze({});
+  let fromHost = {};
+  let hostScheme = "keyboard";
+  let scheme = "keyboard";
+  let available = false;
+  let sticks = "floating";
+  let suspended = false;
+  let polling = false;
+  let announced = { scheme };
+  let asked = null;
+  let showing = false;
+  let model = null;
+  const listeners = createListeners(options.onError);
+  let declaring = false;
+  const reported = /* @__PURE__ */ new Set();
+  function undeclared(what, name) {
+    const known2 = what === "action" ? name in declared || name in fromHost : name in layouts;
+    if (!declaring || known2 || reported.has(`${what}:${name}`)) return;
+    reported.add(`${what}:${name}`);
+    options.onError(new Error(`input: the manifest declares no ${what} "${name}".`));
+  }
+  function shim() {
+    if (scope === null) return null;
+    const found = scope[INPUT_SHIM];
+    return isInputShim(found) ? found : null;
+  }
+  function ask(run, fallback) {
+    const installed = shim();
+    if (installed === null) return fallback;
+    try {
+      const answer = run(installed);
+      return answer === void 0 ? fallback : answer;
+    } catch (thrown) {
+      options.onError(thrown);
+      return fallback;
+    }
+  }
+  function deadzone() {
+    const asked2 = ask((one) => one.deadzone, DEADZONE);
+    return typeof asked2 === "number" && asked2 >= 0 && asked2 < 1 ? asked2 : DEADZONE;
+  }
+  function rebuild() {
+    const next = {};
+    let bindingsMoved = false;
+    for (const [id, action] of Object.entries(declared)) {
+      const host2 = fromHost[id];
+      const bind = host2?.bind ?? action.bind;
+      const entry = { bind };
+      const title = host2?.title ?? action.title;
+      if (typeof title === "string") entry.title = title;
+      const label = labelOf2(id, bind, host2);
+      if (label !== "") entry.label = label;
+      next[id] = entry;
+      if (!sameBind(mapping[id]?.bind, bind)) bindingsMoved = true;
+    }
+    for (const [id, host2] of Object.entries(fromHost)) {
+      if (next[id] !== void 0) continue;
+      next[id] = host2;
+      bindingsMoved = true;
+    }
+    for (const id of Object.keys(mapping)) {
+      if (next[id] === void 0) bindingsMoved = true;
+    }
+    const previous = mapping;
+    mapping = Object.freeze(next);
+    store.setMapping(next, { release: bindingsMoved });
+    const was = announced;
+    const moved = was.scheme !== scheme || !sameMapping(previous, mapping);
+    announced = { scheme };
+    if (moved) {
+      listeners.emit(Object.freeze({ mapping, scheme }), Object.freeze({ mapping: previous, scheme: was.scheme }));
+    }
+  }
+  function labelOf2(id, bind, host2) {
+    if (host2?.label !== void 0 && hostScheme === scheme) return host2.label;
+    const preferred = preferredBinding(bind, scheme);
+    const worked = preferred === void 0 ? "" : labelFor(preferred, scheme);
+    if (worked !== "") return worked;
+    const own = declared[id]?.label;
+    return typeof own === "string" ? own : "";
+  }
+  function setScheme(next) {
+    if (next === scheme) return;
+    scheme = next;
+    rebuild();
+  }
+  const report = {
+    press(control, index, down) {
+      const slot = model?.zones.flatMap((zone) => zone.controls).find((one) => one.id === control);
+      const button = slot?.buttons[index];
+      if (button === void 0) return;
+      setScheme("touch");
+      if (suspended) return;
+      const owner = `${INPUT_SOURCE}${control}.${index}`;
+      store.pressAction(button.action, owner, down);
+      if (button.as !== void 0) store.press(button.as, down, `${owner}.as`);
+      ask((one) => one.haptic?.(down ? "press" : "release"), void 0);
+    },
+    move(control, x, y) {
+      const slot = model?.zones.flatMap((zone) => zone.controls).find((one) => one.id === control);
+      if (slot === void 0) return;
+      setScheme("touch");
+      if (suspended) return;
+      if (slot.axis === "x") store.moveStick(slot.stick, x, 0);
+      else if (slot.axis === "y") store.moveStick(slot.stick, 0, y);
+      else store.moveStick(slot.stick, x, y);
+    }
+  };
+  const host = scope === null ? null : createControlsHost({ scope, report, shim, onError: options.onError });
+  const sources = scope === null ? null : createSources({
+    scope,
+    store,
+    onScheme: setScheme,
+    isBound,
+    suspended: () => suspended,
+    deadzone,
+    fromControls: (event) => host?.owns(event) ?? false,
+    onError: options.onError
+  });
+  function isBound(concrete) {
+    for (const binding of Object.values(mapping)) {
+      if (binding.bind.some((declaredOne) => matchesBinding(declaredOne, concrete))) return true;
+    }
+    return false;
+  }
+  function retune() {
+    sources?.watchPointer(polling || store.watchingPointer);
+  }
+  function only() {
+    const names = Object.keys(layouts);
+    return names.length === 1 ? names[0] : null;
+  }
+  function refresh() {
+    const frame = options.frame();
+    const insets = options.insets();
+    const name = asked;
+    const wanted = name === null ? void 0 : layouts[name];
+    const permitted = host !== null && name !== null && wanted !== void 0 && available && ask((one) => one.decide?.({ layout: name, frame, insets, contract: INPUT_CONTRACT }), true) !== false;
+    if (!permitted || host === null || name === null || wanted === void 0) {
+      withdraw();
+      return;
+    }
+    model = resolveLayout(name, wanted, declared, frame, insets, sticks);
+    host.render(model);
+    if (!host.fits(frame, insets)) {
+      withdraw();
+      return;
+    }
+    showing = true;
+    options.setDrawn(host.rects());
+  }
+  function withdraw() {
+    if (!showing && model === null) return;
+    host?.clear();
+    model = null;
+    showing = false;
+    options.setDrawn([]);
+  }
+  function releaseControls() {
+    store.releaseFrom((source) => source.startsWith(INPUT_SOURCE));
+    for (const zone of model?.zones ?? []) {
+      for (const slot of zone.controls) {
+        if (slot.type === "thumbstick") store.moveStick(slot.stick, 0, 0);
+      }
+    }
+  }
+  const controls = {
+    show(layout) {
+      const name = layout ?? only();
+      if (name === null) return;
+      undeclared("layout", name);
+      if (name !== asked) releaseControls();
+      asked = name;
+      refresh();
+    },
+    hide() {
+      if (asked === null) return;
+      releaseControls();
+      asked = null;
+      refresh();
+    },
+    get showing() {
+      return showing;
+    },
+    get asked() {
+      return asked;
+    },
+    get available() {
+      return available;
+    }
+  };
+  const input = {
+    onAction(action, listener) {
+      undeclared("action", action);
+      return store.onAction(action, listener);
+    },
+    onStick: (stick2, listener) => store.onStick(stick2, listener),
+    onPointer(listener) {
+      const off = store.onPointer(listener);
+      retune();
+      return () => {
+        off();
+        retune();
+      };
+    },
+    get mapping() {
+      return mapping;
+    },
+    on: listeners.on,
+    get scheme() {
+      return scheme;
+    },
+    controls,
+    get poll() {
+      return polling;
+    },
+    set poll(on) {
+      polling = on;
+      retune();
+    },
+    read() {
+      const now = store.read();
+      return Object.freeze({
+        pressed: (action) => (undeclared("action", action), now.pressed(action)),
+        started: (action) => (undeclared("action", action), now.started(action)),
+        ended: (action) => (undeclared("action", action), now.ended(action)),
+        stick: (stick2) => now.stick(stick2),
+        pointer: now.pointer
+      });
+    },
+    suspend() {
+      if (suspended) return;
+      suspended = true;
+      store.releaseAll();
+    },
+    resume() {
+      suspended = false;
+    },
+    get suspended() {
+      return suspended;
+    }
+  };
+  rebuild();
+  sources?.attach();
+  return {
+    input,
+    adopt(value) {
+      const welcome = readInputWelcome(value);
+      if (welcome === null) return;
+      declaring = true;
+      declared = welcome.actions;
+      layouts = welcome.layouts;
+      fromHost = welcome.mapping;
+      hostScheme = welcome.scheme;
+      scheme = welcome.scheme;
+      available = welcome.controls;
+      sticks = welcome.sticks;
+      rebuild();
+      refresh();
+    },
+    onChange(value) {
+      const change = readInputChange(value);
+      if (change === null) return;
+      fromHost = change.mapping;
+      hostScheme = change.scheme;
+      scheme = change.scheme;
+      const was = { available, sticks };
+      available = change.controls;
+      sticks = change.sticks;
+      rebuild();
+      if (was.sticks !== sticks) releaseControls();
+      if (was.available !== available || was.sticks !== sticks) refresh();
+    },
+    relayout() {
+      refresh();
+    },
+    release: () => store.releaseAll(),
+    dispose() {
+      sources?.detach();
+      host?.dispose();
+      store.dispose();
+      listeners.clear();
+    }
+  };
+}
+var INPUT_SOURCE = "controls.";
+function sameBind(a, b) {
+  if (a === void 0) return false;
+  return a.length === b.length && a.every((one, index) => one === b[index]);
+}
+function sameMapping(a, b) {
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((key) => {
+    const one = a[key];
+    const other = b[key];
+    if (one === void 0 || other === void 0) return false;
+    return one.title === other.title && one.label === other.label && sameBind(one.bind, other.bind);
+  });
+}
+
+// src/layout.ts
+var NONE = { top: 0, right: 0, bottom: 0, left: 0 };
+var SIDES2 = ["top", "right", "bottom", "left"];
+var NOWHERE = { width: 0, height: 0 };
+function createLayout(options) {
+  let frame = NOWHERE;
+  let hosted = [];
+  let drawn = [];
+  let obstructions = [];
+  let projected = null;
+  const listeners = createListeners(options.onError);
+  function insets() {
+    projected ??= insetsFrom(obstructions, frame);
+    return projected;
+  }
+  function snapshot() {
+    return { frame, obstructions, insets: insets() };
+  }
+  function publish() {
+    if (options.root === null) return;
+    const now = insets();
+    for (const side of SIDES2) {
+      options.root.style.setProperty(`--hopple-inset-${side}`, `${now[side]}px`);
+    }
+  }
+  function settle(value) {
+    const previous = snapshot();
+    const message = readLayout(value);
+    frame = message.frame;
+    hosted = message.obstructions;
+    recombine(previous);
+  }
+  function recombine(previous) {
+    obstructions = drawn.length === 0 ? hosted : [...hosted, ...drawn];
+    projected = null;
+    publish();
+    if (previous.frame.width === frame.width && previous.frame.height === frame.height && sameBoxes(previous.obstructions, obstructions)) {
+      return;
+    }
+    const now = snapshot();
+    listeners.emit(now, previous);
+  }
+  return {
+    adopt: settle,
+    onChange: settle,
+    /**
+     * What the frame has drawn over the game, as rectangles.
+     *
+     * Called by the SDK's own on-screen controls when they are shown, hidden or
+     * re-laid-out. Listeners fire exactly as they do for a host's message,
+     * because from the game's side there is no difference worth knowing: a
+     * rectangle it must keep its buttons out of has appeared.
+     */
+    setDrawn(rects) {
+      const previous = snapshot();
+      drawn = rects.map((rect) => ({ rect, kind: "controls", reserved: true }));
+      recombine(previous);
+    },
+    dispose() {
+      listeners.clear();
+    },
+    layout: {
+      get frame() {
+        return frame;
+      },
+      get insets() {
+        return insets();
+      },
+      get obstructions() {
+        return obstructions;
+      },
+      on: listeners.on
+    }
+  };
+}
+function insetsFrom(obstructions, frame, policy = {}) {
+  const result = { ...NONE };
+  if (frame.width <= 0 || frame.height <= 0) return result;
+  const strips = policy.only === "strips";
+  for (const obstruction of obstructions) {
+    if (!obstruction.reserved) continue;
+    const box = clip2(obstruction.rect, frame);
+    if (box === null) continue;
+    if (strips && !spans(box, frame)) continue;
+    const candidates = [
+      ["top", box.y + box.height, frame.width],
+      ["bottom", frame.height - box.y, frame.width],
+      ["left", box.x + box.width, frame.height],
+      ["right", frame.width - box.x, frame.height]
+    ];
+    let best = candidates[0];
+    for (const candidate of candidates) {
+      if (candidate[1] * candidate[2] < best[1] * best[2]) best = candidate;
+    }
+    result[best[0]] = Math.max(result[best[0]], best[1]);
+  }
+  return result;
+}
+var SLACK = 1;
+function spans(box, frame) {
+  return box.x <= SLACK && box.x + box.width >= frame.width - SLACK || box.y <= SLACK && box.y + box.height >= frame.height - SLACK;
+}
+function clip2(rect, frame) {
+  const x = Math.max(0, rect.x);
+  const y = Math.max(0, rect.y);
+  const right = Math.min(frame.width, rect.x + rect.width);
+  const bottom = Math.min(frame.height, rect.y + rect.height);
+  if (right <= x || bottom <= y) return null;
+  return { x, y, width: right - x, height: bottom - y };
+}
+function sameBoxes(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  return a.every((one, index) => {
+    const other = b[index];
+    return other !== void 0 && one.kind === other.kind && one.reserved === other.reserved && one.rect.x === other.rect.x && one.rect.y === other.rect.y && one.rect.width === other.rect.width && one.rect.height === other.rect.height;
+  });
+}
+function readLayout(value) {
+  const message = value;
+  if (typeof message !== "object" || message === null) return { frame: NOWHERE, obstructions: [] };
+  const frame = isSize(message.frame) ? message.frame : NOWHERE;
+  if (!Array.isArray(message.obstructions)) return { frame, obstructions: [] };
+  const obstructions = [];
+  for (const entry of message.obstructions) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const { rect, kind, reserved } = entry;
+    if (!isRect(rect) || typeof reserved !== "boolean") continue;
+    obstructions.push({ rect, reserved, kind: kind ?? "chrome" });
+  }
+  return { frame, obstructions };
+}
+function isRect(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const rect = value;
+  return number3(rect.x) && number3(rect.y) && number3(rect.width) && number3(rect.height);
+}
+function isSize(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const size = value;
+  return number3(size.width) && number3(size.height);
+}
+function number3(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+// src/lifecycle.ts
+function createLifecycle(options) {
+  let phase = "loading";
+  let asked = false;
+  const listeners = createListeners(options.onError);
+  async function announce(next) {
+    const previous = phase;
+    phase = next;
+    await listeners.settle(next, previous);
+  }
+  return {
+    async onDispose() {
+      if (phase !== "disposed") await announce("disposed");
+      return {};
+    },
+    lifecycle: {
+      get phase() {
+        return phase;
+      },
+      ready() {
+        if (phase !== "loading" || asked) return;
+        asked = true;
+        forget(
+          () => options.peer().call("lifecycle.ready", {}),
+          (thrown) => {
+            asked = false;
+            options.onError(thrown);
+          },
+          () => {
+            if (phase !== "loading") return;
+            void announce("ready");
+          }
+        );
+      },
+      on: listeners.on
+    }
+  };
+}
+
+// src/loop.ts
+var MAX_STEP = 0.1;
+function createLoop(options) {
+  let allowed = true;
+  let ordered = false;
+  let ended = false;
+  const listeners = createListeners(options.onError);
+  const ticks = /* @__PURE__ */ new Set();
+  function running() {
+    return allowed && !ended;
+  }
+  function start(ticker) {
+    if (ticker.stopped || ticker.handle !== 0 || !running()) return;
+    ticker.last = void 0;
+    ticker.handle = options.frames.request((now) => step(ticker, now));
+  }
+  function stop(ticker) {
+    if (ticker.handle === 0) return;
+    options.frames.cancel(ticker.handle);
+    ticker.handle = 0;
+  }
+  function step(ticker, now) {
+    ticker.handle = 0;
+    const dt = ticker.last === void 0 ? 0 : Math.min(Math.max(now - ticker.last, 0) / 1e3, MAX_STEP);
+    ticker.last = now;
+    try {
+      ticker.frame(dt, now);
+    } catch (thrown) {
+      options.onError(thrown);
+    }
+    if (ticker.handle === 0 && !ticker.stopped && running()) {
+      ticker.handle = options.frames.request((at) => step(ticker, at));
+    }
+  }
+  function reschedule() {
+    for (const ticker of ticks) {
+      if (running()) start(ticker);
+      else stop(ticker);
+    }
+  }
+  return {
+    adopt(initial) {
+      if (!ordered) allowed = initial;
+      reschedule();
+    },
+    async onAllow(params) {
+      ordered = true;
+      if (params.allowed !== allowed) {
+        allowed = params.allowed;
+        reschedule();
+        await listeners.settle(allowed);
+      }
+      return { allowed };
+    },
+    dispose() {
+      ended = true;
+      for (const ticker of ticks) {
+        ticker.stopped = true;
+        stop(ticker);
+      }
+      ticks.clear();
+    },
+    loop: {
+      get allowed() {
+        return allowed;
+      },
+      on: listeners.on,
+      tick(frame) {
+        const ticker = { frame, handle: 0, last: void 0, stopped: false };
+        ticks.add(ticker);
+        start(ticker);
+        return () => {
+          ticker.stopped = true;
+          stop(ticker);
+          ticks.delete(ticker);
+        };
+      }
+    }
+  };
+}
+
+// src/panel.ts
+var CLOSED = Object.freeze({ isOpen: false, page: null });
+function createPanel(options) {
+  let pages = [];
+  let state = CLOSED;
+  const listeners = createListeners(options.onError);
+  const panel = {
+    get available() {
+      return pages.length > 0;
+    },
+    get pages() {
+      return pages;
+    },
+    get isOpen() {
+      return state.isOpen;
+    },
+    get page() {
+      return state.page;
+    },
+    on: listeners.on,
+    open(page) {
+      forget(() => options.peer().call("panel.open", { id: page }), options.onError);
+    }
+  };
+  function settle(next) {
+    if (next.isOpen === state.isOpen && next.page === state.page) return;
+    const previous = state;
+    state = Object.freeze({ isOpen: next.isOpen, page: next.page });
+    listeners.emit(state, previous);
+  }
+  return {
+    panel,
+    adopt(value) {
+      const welcome = readPanelWelcome(value);
+      pages = (welcome?.ids ?? []).filter(known);
+      state = Object.freeze({ isOpen: welcome?.isOpen === true, page: pageOf(welcome?.page) });
+    },
+    onChange(value) {
+      const change = readPanelChange(value);
+      if (change !== null) settle({ isOpen: change.isOpen, page: pageOf(change.page) });
+    },
+    dispose() {
+      listeners.clear();
+    }
+  };
+}
+function known(page) {
+  return PAGES.includes(page);
+}
+function pageOf(page) {
+  return typeof page === "string" && known(page) ? page : null;
+}
+
+// src/pause.ts
+function createPause(options) {
+  let state = PAUSE_NONE;
+  const listeners = createListeners(options.onError);
+  async function announce(paused) {
+    await listeners.settle(paused);
+  }
+  const pause = {
+    get state() {
+      return state;
+    },
+    set(next) {
+      if (next === state) return;
+      state = next;
+      options.peer().emit("pause.change", { state });
+    },
+    on: listeners.on
+  };
+  return {
+    pause,
+    async onSet(params) {
+      const request = readPauseRequest(params);
+      if (request !== null) await announce(request.paused);
+      return { state };
+    }
+  };
+}
+
+// src/resources.ts
+function createResources(options) {
+  let allowed = true;
+  let ordered = false;
+  const listeners = createListeners(options.onError);
+  return {
+    adopt(initial) {
+      if (!ordered) allowed = initial;
+    },
+    async onAllow(params) {
+      ordered = true;
+      if (params.allowed !== allowed) {
+        allowed = params.allowed;
+        await listeners.settle(allowed);
+      }
+      return { allowed };
+    },
+    resources: {
+      get allowed() {
+        return allowed;
+      },
+      on: listeners.on
+    }
+  };
+}
+
+// src/save.ts
+var FIRST_VERSION = 1;
+var LOSSY = [
+  { what: "a Map", is: (v) => v instanceof Map, becomes: "{}" },
+  { what: "a Set", is: (v) => v instanceof Set, becomes: "{}" },
+  { what: "a Date", is: (v) => v instanceof Date, becomes: "a string" },
+  {
+    what: "a typed array",
+    is: (v) => ArrayBuffer.isView(v),
+    becomes: "an object keyed by index"
+  },
+  { what: "a function", is: (v) => typeof v === "function", becomes: "nothing at all" },
+  { what: "undefined", is: (v) => v === void 0, becomes: "nothing at all" }
+];
+var WALK_DEPTH = 6;
+function createSave(options) {
+  let cap = SAVE_BYTES;
+  let available = false;
+  let status = UNKNOWN;
+  let dev = false;
+  const listeners = createListeners(options.onError);
+  function settle(stored) {
+    const previous = status;
+    if (previous.known && sameStored(previous.stored, stored)) return;
+    status = Object.freeze({ known: true, stored: stored === null ? null : Object.freeze({ ...stored }) });
+    listeners.emit(status, previous);
+  }
+  let rev;
+  function adopt(value, surface) {
+    dev = surface === "dev";
+    if (typeof value !== "object" || value === null) return;
+    available = true;
+    const said = value;
+    if (typeof said.bytes === "number" && Number.isFinite(said.bytes)) {
+      cap = Math.max(SAVE_BYTES, said.bytes);
+    }
+    const stored = said.stored === null ? null : readSaveStored(said.stored);
+    if (said.stored === null || stored !== null) {
+      status = Object.freeze({ known: true, stored: stored === null ? null : Object.freeze(stored) });
+    }
+  }
+  function encode(state) {
+    if (typeof state === "string") return [state, "text"];
+    let text2;
+    try {
+      text2 = JSON.stringify(state);
+    } catch (thrown) {
+      throw new BridgeError({
+        code: "bad_params",
+        message: `That state cannot be saved: ${thrown instanceof Error ? thrown.message : String(thrown)}`
+      });
+    }
+    if (text2 === void 0) {
+      throw new BridgeError({
+        code: "bad_params",
+        message: "That state cannot be saved: it is not a JSON value."
+      });
+    }
+    return [text2, "json"];
+  }
+  function warn(state) {
+    for (const found of lossy(state, WALK_DEPTH, /* @__PURE__ */ new Set())) {
+      options.onError(
+        new Error(`save: ${found.at} is ${found.what}, which JSON turns into ${found.becomes}.`)
+      );
+    }
+  }
+  return {
+    adopt,
+    save: {
+      get available() {
+        return available;
+      },
+      get status() {
+        return status;
+      },
+      on: listeners.on,
+      get maxBytes() {
+        return cap;
+      },
+      async read() {
+        const answer = await options.peer().call("save.read", {});
+        const record = readSaveRecord(answer?.record);
+        if (record === null) {
+          settle(null);
+          return null;
+        }
+        rev = record.rev;
+        settle(
+          readSaveStored(answer?.stored) ?? {
+            at: status.known && status.stored !== null ? status.stored.at : Date.now(),
+            version: record.version,
+            bytes: saveBytes(record.state)
+          }
+        );
+        if (record.encoding === "text") return { version: record.version, state: record.state };
+        try {
+          return { version: record.version, state: JSON.parse(record.state) };
+        } catch (thrown) {
+          options.onError(
+            new Error(
+              `save: the stored state could not be parsed (${thrown instanceof Error ? thrown.message : String(thrown)}).`
+            )
+          );
+          return null;
+        }
+      },
+      async write(state, given) {
+        const [text2, encoding] = encode(state);
+        if (dev) warn(state);
+        const size = saveBytes(text2);
+        if (size > cap) {
+          throw new BridgeError({
+            code: "too_large",
+            message: `That save is ${size} bytes and this host takes ${cap}.`
+          });
+        }
+        const record = {
+          version: given?.version ?? FIRST_VERSION,
+          encoding,
+          state: text2
+        };
+        if (rev !== void 0) record.rev = rev;
+        const answer = await options.peer().call("save.write", record);
+        const minted = answer?.rev;
+        rev = typeof minted === "string" ? minted : void 0;
+        settle({ at: Date.now(), version: record.version, bytes: size });
+      },
+      async clear() {
+        await options.peer().call("save.clear", {});
+        rev = void 0;
+        settle(null);
+      }
+    }
+  };
+}
+var UNKNOWN = Object.freeze({ known: false });
+function sameStored(a, b) {
+  if (a === null || b === null) return a === b;
+  return a.at === b.at && a.version === b.version && a.bytes === b.bytes;
+}
+function lossy(value, depth, seen, at = "the state") {
+  for (const kind of LOSSY) {
+    if (kind.is(value)) return [{ at, what: kind.what, becomes: kind.becomes }];
+  }
+  if (depth <= 0 || typeof value !== "object" || value === null) return [];
+  if (seen.has(value)) return [];
+  seen.add(value);
+  const found = [];
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => {
+      found.push(...lossy(entry, depth - 1, seen, `${at}[${index}]`));
+    });
+    return found;
+  }
+  for (const [key, entry] of Object.entries(value)) {
+    found.push(...lossy(entry, depth - 1, seen, `${at}.${key}`));
+  }
+  return found;
+}
+
+// src/score.ts
+function createScore(options) {
+  let available = false;
+  let boards = [];
+  let held;
+  let standing = UNKNOWN2;
+  const listeners = createListeners(options.onError);
+  function settle(next) {
+    held = next;
+    const previous = standing;
+    standing = standingsOf(boards, held);
+    if (!sameStandings(previous, standing)) listeners.emit(standing, previous);
+  }
+  function only(given) {
+    if (given !== void 0) return given;
+    return boards.length === 1 ? boards[0] : "";
+  }
+  const score = {
+    get available() {
+      return available;
+    },
+    get boards() {
+      return boards;
+    },
+    get standing() {
+      return standing;
+    },
+    on: listeners.on,
+    async submit(value, given) {
+      if (!isScoreValue(value)) {
+        throw new BridgeError({
+          code: "bad_params",
+          message: "A score must be a finite number that a board can hold."
+        });
+      }
+      const board = given?.board;
+      const answer = await options.peer().call("score.submit", board === void 0 ? { value } : { board, value });
+      const result = readScoreResult(answer) ?? { improved: false, best: value };
+      const at = only(board);
+      if (at !== "" && held !== void 0) {
+        const before = held ?? {};
+        const previous = before[at];
+        settle({
+          ...before,
+          [at]: {
+            best: result.best,
+            at: result.improved || previous === void 0 ? Date.now() : previous.at,
+            runs: (previous?.runs ?? 0) + 1,
+            ...result.rank === void 0 ? {} : { rank: result.rank },
+            ...result.of === void 0 ? {} : { of: result.of }
+          }
+        });
+      }
+      return result;
+    }
+  };
+  return {
+    score,
+    adopt(value) {
+      const welcome = readScoreWelcome(value);
+      available = welcome !== null;
+      boards = welcome?.boards ?? [];
+      held = welcome?.standing;
+      standing = standingsOf(boards, held);
+    },
+    onChange(value) {
+      const change = readScoreChange(value);
+      if (change !== null) settle(change.standing);
+    }
+  };
+}
+var UNKNOWN2 = Object.freeze({ known: false });
+function standingsOf(boards, held) {
+  if (held === void 0) return UNKNOWN2;
+  const all = {};
+  for (const board of boards) all[board] = held?.[board] ?? null;
+  for (const [board, entry] of Object.entries(held ?? {})) all[board] = entry;
+  return Object.freeze({ known: true, boards: Object.freeze(all) });
+}
+function sameStandings(a, b) {
+  if (!a.known || !b.known) return a.known === b.known;
+  const keys = Object.keys(a.boards);
+  if (keys.length !== Object.keys(b.boards).length) return false;
+  return keys.every((key) => {
+    const one = a.boards[key];
+    const other = b.boards[key];
+    if (one === null || one === void 0 || other === null || other === void 0) return one === other;
+    return one.best === other.best && one.at === other.at && one.runs === other.runs && one.rank === other.rank && one.of === other.of;
+  });
+}
+
+// src/share.ts
+function createShare(options) {
+  let arrived = null;
+  let available = false;
+  const share = {
+    get available() {
+      return available;
+    },
+    get data() {
+      return arrived;
+    },
+    offer(given) {
+      const data = given?.data;
+      const meta = given?.meta;
+      if (data !== void 0 && typeof data !== "string") {
+        options.onError(
+          new BridgeError({
+            code: "bad_params",
+            message: "Share data must be a string: encode it however this game reads it back."
+          })
+        );
+        return;
+      }
+      if (meta !== void 0 && readShareMeta(meta) === null) {
+        options.onError(new BridgeError({ code: "bad_params", message: "Share meta must be an object JSON can carry." }));
+        return;
+      }
+      forget(
+        () => options.peer().call("share.offer", { ...data === void 0 ? {} : { data }, ...meta === void 0 ? {} : { meta } }),
+        options.onError
+      );
+    }
+  };
+  return {
+    share,
+    adopt(value) {
+      const welcome = readShareWelcome(value);
+      arrived = welcome?.data ?? null;
+      available = welcome?.offers === true;
+    }
+  };
+}
+
+// src/shim.ts
+function isShim(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const shim = value;
+  if (shim.v !== 1) return false;
+  return typeof shim.send === "function" && typeof shim.receive === "function";
+}
+function findShim(scope) {
+  const found = scope[SHIM];
+  return isShim(found) ? found : null;
+}
+function shimTransport(shim) {
+  let unsubscribe = null;
+  return {
+    send(message) {
+      shim.send(JSON.stringify(message));
+    },
+    receive(handler) {
+      unsubscribe = shim.receive((text2) => {
+        let parsed;
+        try {
+          parsed = JSON.parse(text2);
+        } catch {
+          return;
+        }
+        if (isEnvelope(parsed)) handler(parsed);
+      });
+      return () => {
+        unsubscribe?.();
+        unsubscribe = null;
+      };
+    },
+    close() {
+    }
+  };
+}
+
+// src/transport.ts
+var SHIM_WAIT_MS = 2e3;
+function hostTransport(options = {}) {
+  const scope = options.scope ?? window;
+  const globals = scope;
+  const onError = options.onError ?? ((error) => console.error(error));
+  const installed = findShim(scope);
+  if (installed) return Promise.resolve(shimTransport(installed));
+  if (scope.parent !== scope) return Promise.resolve(frameTransport(scope, scope.parent));
+  const waitMs = options.shimWaitMs ?? SHIM_WAIT_MS;
+  return new Promise((resolve, reject) => {
+    let claimed = false;
+    const door = (late) => {
+      if (!isShim(late)) {
+        onError(new Error(`${SET_SHIM} was called with something that is not a v1 shim.`));
+        return;
+      }
+      if (claimed) {
+        onError(new Error(`${SET_SHIM} was called twice; this game already has a channel.`));
+        return;
+      }
+      claimed = true;
+      clearTimeout(deadline);
+      release();
+      resolve(shimTransport(late));
+    };
+    const deadline = setTimeout(() => {
+      release();
+      reject(
+        new Error(
+          `No host: there is no ${SHIM} on the global and no parent frame to talk to. A Hopple game runs inside a Hopple host rather than on its own: while developing, run it with \`npx hopple dev\`. A native shell installs a shim before the game's bundle runs, or calls ${SET_SHIM} afterwards; neither happened within ${waitMs}ms.`
+        )
+      );
+    }, waitMs);
+    globals[SET_SHIM] = door;
+    function release() {
+      if (globals[SET_SHIM] === door) delete globals[SET_SHIM];
+    }
+  });
+}
+function frameTransport(scope, host) {
+  return {
+    send(message) {
+      host.postMessage(message, "*");
+    },
+    receive(handler) {
+      const listener = (event) => {
+        if (event.source !== host) return;
+        if (!isEnvelope(event.data)) return;
+        handler(event.data);
+      };
+      scope.addEventListener("message", listener);
+      return () => scope.removeEventListener("message", listener);
+    },
+    close() {
+    }
+  };
+}
+
+// src/init.ts
+async function init(options = {}) {
+  const onError = options.onError ?? ((error) => console.error(error));
+  const errors = createErrorReporter(listenable(options.scope));
+  const fail = (error) => {
+    errors.report("sdk", error);
+    onError(error);
+  };
+  let transport;
+  try {
+    transport = options.transport ?? await hostTransport({
+      scope: options.scope,
+      shimWaitMs: options.shimWaitMs,
+      onError: fail
+    });
+  } catch (thrown) {
+    errors.dispose();
+    throw thrown;
+  }
+  const page = readable(options.scope);
+  const calls = () => asked;
+  const { lifecycle, onDispose } = createLifecycle({ peer: calls, onError: fail });
+  const loop = createLoop({ frames: framesOf(page), onError: fail });
+  const resources = createResources({ onError: fail });
+  const layout = createLayout({ root: page?.document.documentElement ?? null, onError: fail });
+  const analytics = createAnalytics({ peer: calls, onError: fail, onRefused: onError });
+  const save = createSave({ peer: calls, onError: fail });
+  const score = createScore({ peer: calls, onError: fail });
+  const achievements = createAchievements({ peer: calls, onError: fail });
+  const share = createShare({ peer: calls, onError: fail });
+  const audio = createAudio({ scope: page, onError: fail });
+  const panel = createPanel({ peer: calls, onError: fail });
+  const pause = createPause({ peer: calls, onError: fail });
+  const hostInsets = () => insetsFrom(
+    layout.layout.obstructions.filter((one) => one.kind !== "controls"),
+    layout.layout.frame
+  );
+  const input = createInput({
+    scope: page,
+    frame: () => layout.layout.frame,
+    insets: hostInsets,
+    setDrawn: layout.setDrawn,
+    onError: fail
+  });
+  let ground = {
+    frame: layout.layout.frame,
+    insets: hostInsets()
+  };
+  layout.layout.on(() => {
+    const now = { frame: layout.layout.frame, insets: hostInsets() };
+    if (now.frame.width === ground.frame.width && now.frame.height === ground.frame.height && SIDES3.every((side) => now.insets[side] === ground.insets[side])) {
+      return;
+    }
+    ground = now;
+    input.relayout();
+  });
+  const peer = createPeer({
+    transport,
+    handlers: {
+      // The host pings us for the same reason we ping it, and for one more: a
+      // game whose main loop has wedged still has a live frame, and this is the
+      // only way to tell those apart from outside.
+      "system.ping": (params) => ({ nonce: params.nonce }),
+      // Each order is answered once it has been obeyed: the sound has gone
+      // quiet, the frames have stopped, the memory has been let go.
+      "audio.allow": audio.onAllow,
+      "loop.allow": loop.onAllow,
+      "resources.allow": resources.onAllow,
+      // No more frames once the game is going away, whatever the host has
+      // allowed: the last thing drawn stays while the game saves.
+      "lifecycle.dispose": () => {
+        loop.dispose();
+        return onDispose();
+      },
+      // Answered as soon as every listener has been told, with the mix the
+      // game now holds: a volume is applied, never negotiated or waited on.
+      "audio.set": audio.onSet,
+      // Answered once every listener has settled: the host asked the game to
+      // stop and waits — briefly — to be told what actually happened, which
+      // may be that there was nothing to stop.
+      "pause.set": pause.onSet
+    },
+    timeoutMs: options.timeoutMs,
+    onError: fail
+  });
+  const asked = answering(peer);
+  const helloMs = Math.max(options.timeoutMs ?? HELLO_MS, HELLO_MS);
+  let welcome;
+  try {
+    welcome = await peer.call(
+      "system.hello",
+      { protocol: PROTOCOL_VERSION, sdk: package_default.version },
+      { timeoutMs: helloMs }
+    );
+  } catch (thrown) {
+    peer.dispose();
+    errors.dispose();
+    throw unanswered(thrown, helloMs);
+  }
+  peer.useSession(welcome.peer);
+  errors.connect(peer);
+  const allowed = readAllowed(welcome.allowed);
+  loop.adopt(allowed.loop);
+  resources.adopt(allowed.resources);
+  layout.adopt(welcome.layout);
+  peer.on("layout.change", layout.onChange);
+  peer.on("analytics.refused", analytics.refused);
+  peer.on("input.change", input.onChange);
+  peer.on("panel.change", panel.onChange);
+  peer.on("achievement.change", achievements.onChange);
+  peer.on("score.change", score.onChange);
+  loop.loop.on((running) => {
+    if (!running) input.release();
+  });
+  const info = readInfo(welcome.info);
+  save.adopt(welcome.save, info.app.surface);
+  score.adopt(welcome.score);
+  achievements.adopt(welcome.achievements);
+  share.adopt(welcome.share);
+  audio.adopt(welcome.audio, allowed.audio);
+  panel.adopt(welcome.panel);
+  input.adopt(welcome.input);
+  await sized(page, () => layout.layout.frame, fail);
+  const sdk = {
+    lifecycle,
+    loop: loop.loop,
+    resources: resources.resources,
+    layout: layout.layout,
+    info,
+    analytics: analytics.analytics,
+    save: save.save,
+    score: score.score,
+    achievements: achievements.achievements,
+    share: share.share,
+    panel: panel.panel,
+    pause: pause.pause,
+    input: input.input,
+    audio: audio.audio,
+    ping: () => measurePing(peer),
+    dispose: () => {
+      loop.dispose();
+      panel.dispose();
+      input.dispose();
+      audio.dispose();
+      layout.dispose();
+      errors.dispose();
+      peer.dispose();
+    }
+  };
+  return sdk;
+}
+var SIZED_MS = 1e3;
+async function sized(page, frame, onError) {
+  if (page === null) return;
+  const agrees = () => {
+    const { width, height } = frame();
+    if (width <= 0 || height <= 0) return true;
+    return Math.abs(page.innerWidth - width) <= 1 && Math.abs(page.innerHeight - height) <= 1;
+  };
+  if (agrees()) return;
+  await new Promise((resolve) => {
+    const check = () => {
+      if (agrees()) done();
+    };
+    const timer = setTimeout(() => {
+      const { width, height } = frame();
+      onError(
+        new Error(
+          `layout: the host says the frame is ${width}\xD7${height} but the window is ${page.innerWidth}\xD7${page.innerHeight}.`
+        )
+      );
+      done();
+    }, SIZED_MS);
+    function done() {
+      clearTimeout(timer);
+      page?.removeEventListener("resize", check);
+      resolve();
+    }
+    page.addEventListener("resize", check);
+  });
+}
+function listenable(scope) {
+  const found = scope ?? (typeof window === "undefined" ? void 0 : window);
+  if (found === void 0) return null;
+  return typeof found.addEventListener === "function" ? found : null;
+}
+function framesOf(page) {
+  const scope = page ?? (typeof requestAnimationFrame === "function" ? globalThis : null);
+  if (scope !== null && typeof scope.requestAnimationFrame === "function") {
+    return {
+      request: (callback) => scope.requestAnimationFrame(callback),
+      cancel: (handle) => scope.cancelAnimationFrame(handle)
+    };
+  }
+  return {
+    request: (callback) => setTimeout(() => callback(performance.now()), 16),
+    cancel: (handle) => clearTimeout(handle)
+  };
+}
+var HELLO_MS = 1e4;
+function unanswered(thrown, ms) {
+  if (!(thrown instanceof BridgeError) || thrown.code !== "timeout") return thrown;
+  return new BridgeError({
+    code: "timeout",
+    message: `No host answered: nothing replied to this game's hello within ${ms}ms. A Hopple game runs inside a Hopple host, and whatever is holding this page is not one, or has stopped answering. While developing, run the game with \`npx hopple dev\`.`
+  });
+}
+var SIDES3 = ["top", "right", "bottom", "left"];
+function readable(scope) {
+  const found = scope ?? (typeof window === "undefined" ? void 0 : window);
+  if (found === void 0) return null;
+  const maybe = found;
+  return typeof maybe.addEventListener === "function" && maybe.document != null ? found : null;
+}
+async function measurePing(peer) {
+  const nonce = newNonce();
+  const start = performance.now();
+  const pong = await peer.call("system.ping", { nonce });
+  const elapsed = performance.now() - start;
+  if (pong.nonce !== nonce) {
+    throw new Error(`The host answered a different ping: sent ${nonce}, got ${pong.nonce}.`);
+  }
+  return elapsed;
+}
+function newNonce() {
+  return Math.random().toString(36).slice(2, 10);
+}
+
+// ../manifest/src/manifest.schema.ts
+var GameManifest = {
+  "type": "object",
+  "properties": {
+    "schema": {
+      "type": "number",
+      "const": 1
+    },
+    "id": {
+      "type": "string",
+      "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$",
+      "maxLength": 64,
+      "errorMessage": "must be lowercase letters, digits and hyphens"
+    },
+    "version": {
+      "type": "string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?$",
+      "errorMessage": "must look like 1.0.0"
+    },
+    "title": {
+      "type": "string",
+      "pattern": "\\S",
+      "maxLength": 60,
+      "errorMessage": "must not be blank"
+    },
+    "description": {
+      "type": "string",
+      "pattern": "\\S",
+      "maxLength": 500,
+      "errorMessage": "must not be blank"
+    },
+    "cover": {
+      "type": "string",
+      "pattern": "^(?!/)(?!.*\\.\\.)[A-Za-z0-9._/-]+\\.(?:png|jpe?g|webp)$",
+      "maxLength": 200,
+      "errorMessage": 'must be the path of a .png, .jpg or .webp file beside the config, like "cover.png"'
+    },
+    "orientation": {
+      "$ref": "#/definitions/Orientation"
+    },
+    "sdk": {
+      "type": "string",
+      "pattern": "^[\\^~]?\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z.-]+)?$",
+      "errorMessage": "must be a version like 1.0.0, ^1.0.0 or ~1.0.0"
+    },
+    "layout": {
+      "$ref": "#/definitions/LayoutDeclaration"
+    },
+    "analytics": {
+      "$ref": "#/definitions/AnalyticsDeclaration"
+    },
+    "save": {
+      "$ref": "#/definitions/SaveDeclaration"
+    },
+    "score": {
+      "$ref": "#/definitions/ScoreDeclaration"
+    },
+    "achievements": {
+      "$ref": "#/definitions/AchievementDeclaration"
+    },
+    "input": {
+      "$ref": "#/definitions/InputDeclaration"
+    },
+    "audio": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/AudioDeclaration"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    }
+  },
+  "required": [
+    "schema",
+    "id",
+    "version",
+    "title",
+    "orientation",
+    "sdk",
+    "audio"
+  ],
+  "additionalProperties": {}
+};
+var AchievementProgress = {
+  "type": "object",
+  "properties": {
+    "target": {
+      "type": "number",
+      "minimum": -9007199254740991,
+      "maximum": 9007199254740991
+    },
+    "direction": {
+      "$ref": "#/definitions/ScoreDirection"
+    },
+    "format": {
+      "$ref": "#/definitions/ScoreFormat"
+    },
+    "tiers": {
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/AchievementTier"
+      },
+      "maxItems": 8
+    }
+  },
+  "required": [
+    "target"
+  ],
+  "additionalProperties": {}
+};
+var InputBinding = {
+  "type": "string",
+  "pattern": "^(?:key\\.(?!Escape$)(?=.{1,48}$)[A-Za-z][A-Za-z0-9]*|pointer\\.(?:primary|secondary)|mouse\\.(?:left|middle|right)|touch\\.tap|controls\\.(?=.{1,48}$)[a-z0-9]+(?:[_-][a-z0-9]+)*|pad\\.(?:north|south|east|west|start|select)|pad\\.(?:left|right)\\.(?:north|south|east|west|bumper|trigger))$",
+  "errorMessage": "is not a binding this SDK knows (a thumbstick is read rather than bound, and Escape is the host's key)"
+};
+var ControlLayout = {
+  "type": "object",
+  "properties": {
+    "left": {
+      "$ref": "#/definitions/ControlZoneSlots"
+    },
+    "right": {
+      "$ref": "#/definitions/ControlZoneSlots"
+    },
+    "full": {
+      "$ref": "#/definitions/ControlZoneSlots"
+    }
+  },
+  "additionalProperties": {}
+};
+var InputStick = {
+  "type": "string",
+  "pattern": "^(?:controls\\.(?=.{1,48}$)[a-z0-9]+(?:[_-][a-z0-9]+)*|pad\\.stick|pad\\.(?:left|right)\\.stick)$",
+  "errorMessage": "must name a thumbstick, such as pad.left.stick"
+};
+
+// ../manifest/src/manifest.ts
+var MANIFEST_FILE = "game.manifest.json";
+var COVER_MAX_BYTES = 1024 * 1024;
+var MANIFEST_SCHEMA = 1;
+var SCORE_VALUE_MAX2 = Number.MAX_SAFE_INTEGER;
+var ACHIEVEMENT_VALUE_MAX2 = AchievementProgress.properties.target.maximum;
+var MANIFEST_CORE_KEYS = GameManifest.required;
+var CONTROL_ZONES = Object.keys(ControlLayout.properties);
+var INPUT_BINDING = new RegExp(InputBinding.pattern);
+var INPUT_STICK = new RegExp(InputStick.pattern);
+export {
+  ACHIEVEMENT_VALUE_MAX,
+  AUDIO_FULL,
+  AUDIO_MASTER,
+  AUDIO_VOLUME_MAX,
+  BridgeError,
+  DEADZONE,
+  INPUT_CONTRACT,
+  INPUT_SCHEMES,
+  INPUT_SHIM,
+  MANIFEST_FILE,
+  MANIFEST_SCHEMA,
+  MAX_STEP,
+  PAD_BUTTONS,
+  PAGES,
+  PAUSE_NONE,
+  PAUSE_STATES,
+  SAVE_BYTES,
+  SCORE_VALUE_MAX,
+  SET_SHIM,
+  SHARE_BYTES,
+  SHARE_META_BYTES,
+  SHIM,
+  SHIM_WAIT_MS,
+  audioVolumeOf,
+  findShim,
+  hostTransport,
+  init,
+  insetsFrom,
+  isInputShim,
+  isShim,
+  labelFor,
+  preferredBinding,
+  servesScheme,
+  shimTransport
+};
+/*! @hopple/sdk | Copyright (c) 2026 The Hopple authors | MIT License */