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

package/index.d.ts

@@ -0,0 +1,3650 @@
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/achievement.d.ts
+/**
+ * The largest value progress will carry.
+ *
+ * Spelled here *and* in `@hopple/manifest`, on purpose and with a test to keep
+ * them equal — the server checks the same rule and is not allowed to depend on
+ * this package.
+ *
+ * @group Achievements
+ */
+declare const ACHIEVEMENT_VALUE_MAX = 9007199254740991;
+/**
+ * What the host says came of a report.
+ *
+ * `earned` is the transition and the only thing worth drawing a banner on: a
+ * game that unlocks the same achievement on every level-up gets it once. A host
+ * that took the report answers both fields from this player's own history, so
+ * unlike a score's rank there is nothing here a host might not know.
+ *
+ * @group Achievements
+ */
+type AchievementResult = {
+  /** Whether it is theirs, after this call. */
+  unlocked: boolean;
+  /** Whether *this call* is what unlocked it. False for one already held. */
+  earned: boolean;
+  /** The best value, after this call. Absent for a flagged achievement. */
+  progress?: number;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/analytics.d.ts
+/**
+ * What a game says happened.
+ *
+ * The bridge carries only this. Everything the host can see for itself — phases,
+ * placements, deadlines, the end — it records where the messages already are, so
+ * a game cannot skew it and a game written before any of this existed still
+ * leaves a full trace.
+ *
+ * **One event, one message, as it happens.** No buffer and no batch: a pipe
+ * sized for a handful of events a session gains nothing by holding them, and
+ * holding them would cost a flush on every way a game can end. Whoever delivers
+ * these to a server will batch there, where delivery is, and where the batching
+ * can be as clever as the delivery needs.
+ *
+ * **Nothing here is a limit.** How many events a run may carry, how long a name
+ * may be, how much a prop may hold: those are the host's, and every host will
+ * answer differently — a dev shell keeps everything, an app in the field keeps
+ * what its warehouse can take. What this file settles is the *shape*, which both
+ * ends must agree on, and the two rules the manifest is written under: what a
+ * name looks like, and the namespace a game may not use.
+ */
+/**
+ * What a prop may hold. Flat scalars, because a column is flat.
+ *
+ * @group Analytics
+ */
+type AnalyticsValue = string | number | boolean;
+/** @group Analytics */
+type AnalyticsProps = Record<string, AnalyticsValue>;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/audio.d.ts
+/**
+ * How loud the game is allowed to be, which is the host's to decide and the
+ * game's to obey.
+ *
+ * **This is the one namespace where the host is not offering a service.** A
+ * save, a score, a link and an achievement are all things a game asks for and a
+ * host may refuse; audio runs the other way. The host states the volumes, and a
+ * game that ignores them is a game that plays music over a phone call, under an
+ * advertisement, and in a library. So there is no `unsupported` here and no way
+ * to decline: the only thing a game does with this is apply it.
+ *
+ * **Nothing about sound crosses the bridge.** The samples, the mixing and the
+ * decoding all happen in the frame, exactly as presses do — what travels is the
+ * three numbers the frame cannot know, because they belong to a player using a
+ * host rather than to a game.
+ *
+ * **The channels are named by the manifest and not described here.** What
+ * `music` means is the game's, and the host learned the id and its title from
+ * the file it was published with. So the wire carries volumes keyed by id and
+ * nothing else, and a host newer than a game — or a game whose next version
+ * renamed a channel — produces an id the other side simply has no fader for.
+ */
+/**
+ * The loudest anything gets, and the quietest.
+ *
+ * A fraction rather than decibels, because it is what a fader hands over and
+ * what a gain node takes, and neither end of this wire is the place to decide
+ * on a curve. A host that wants one applies it before it says a number; a game
+ * that wants one applies it after. Both are right, and the wire stays a
+ * fraction either way.
+ *
+ * @group Audio
+ */
+declare const AUDIO_VOLUME_MAX = 1;
+/**
+ * The channel every host has and no game declares. See `AUDIO_MASTER` in
+ * `@hopple/manifest`, which is the same word said where a manifest can be
+ * checked against it.
+ *
+ * @group Audio
+ */
+declare const AUDIO_MASTER = "master";
+/**
+ * How loud the game may be, as the host has it set right now.
+ *
+ * **Mute and the master fader are separate facts and stay separate.** A player
+ * who mutes a game and then unmutes it expects the volume they had, not the
+ * one they would have to find again — so mute is not `master: 0`, and a game
+ * that stored it as one would hand the player back silence.
+ *
+ * The whole state travels every time rather than a delta, for the reason
+ * `layout.change` carries the whole layout: these are small, they arrive
+ * rarely, and a game that missed one — because it was loading, because a host
+ * coalesced two — must not end up mixing from halves.
+ *
+ * @group Audio
+ */
+type AudioState = {
+  /**
+   * Everything off, whatever the faders say.
+   *
+   * The one control a host can count on a player reaching for in a hurry, and
+   * the reason it is a boolean of its own: silence now, and the mix they had
+   * when they come back.
+   */
+  muted: boolean;
+  /** The fader over all of it, `0`–`1`. */
+  master: number;
+  /**
+   * Each declared channel's own fader, `0`–`1`, by the id its manifest gave it.
+   *
+   * A channel missing from here is `1` — a host that has never been asked about
+   * `music` is not a host that wants it silent. That is what lets a game's next
+   * version add a channel and have it audible for every player who already had
+   * settings stored.
+   */
+  channels: Record<string, number>;
+};
+/**
+ * What every game gets where nobody has said otherwise: audible, and mixed the
+ * way the game meant it.
+ *
+ * The reading that claims the least, which for audio is the *loud* one — a game
+ * that started silent against a host too old to have this API would be a game
+ * that appeared broken to everybody, and a player who wants quiet has a control
+ * for it on every host that has one.
+ *
+ * @group Audio
+ */
+declare const AUDIO_FULL: AudioState;
+/**
+ * How loud one channel actually comes out, which is the only number a game
+ * needs and the one both sides must agree on.
+ *
+ * Here rather than in the game's SDK because the dev shell draws it too — a
+ * developer reading *music: 0.35* off a panel and hearing something else has no
+ * way to tell which half is wrong. Multiplication and not the smaller of the
+ * two: a master fader is a fader over the mix, so halving it halves everything
+ * under it rather than capping the loudest.
+ *
+ * @group Audio
+ */
+declare function audioVolumeOf(state: AudioState, channel?: string): number;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/errors.d.ts
+/**
+ * How a call fails.
+ *
+ * Requests reject; nothing throws synchronously once a peer exists. The codes
+ * are the stable part — a game built against a newer SDK than the host it lands
+ * on must be able to tell why it was refused and degrade, rather than take an
+ * unhandled rejection into the player's face.
+ *
+ * Codes are added as something starts producing them, never in advance: a code
+ * nothing can emit tells a game to handle a case that cannot happen. Adding one
+ * is additive and safe.
+ */
+/** @group Bridge */
+type ErrorCode =
+/** No handler on the other side. Usually means the host predates the method. */
+'unknown_method' |
+/** The handler rejected the shape of `params`. */
+'bad_params' |
+/** No reply inside the peer's timeout. Says nothing about whether it ran. */
+'timeout' |
+/** The peer was torn down with the call still in flight — a recycled slot. */
+'disposed' |
+/**
+ * The call belonged to a session that has ended: the game started over inside
+ * a frame the host still holds. Distinct from `disposed` because the bridge is
+ * alive and the next call will work — it is this one that has nobody left to
+ * answer it.
+ */
+'stale' |
+/** The handshake asked for a protocol version this side cannot speak. */
+'unsupported_version' |
+/**
+ * This host does not do that at all — a site with no store answering
+ * `save.write`.
+ *
+ * A different fact from `unknown_method`, which says the host is *older* than
+ * the method, and a game acts on the difference: one is a host that will
+ * never save and one is a host that would if it were newer. Neither is worth
+ * retrying, and both are worth saying honestly.
+ */
+'unsupported' |
+/** Over this host's cap. Says trim, rather than go looking for a bug. */
+'too_large' |
+/**
+ * Faster than this host will take. The counterpart of the analytics refusal.
+ *
+ * Never what a host that *coalesced* two writes says: a write superseded by
+ * newer state from the same game has not been lost, and both promises
+ * resolve. This is for a host actually dropping writes, which usually means a
+ * game is saving from a render loop by mistake.
+ */
+'rate_limited' |
+/** The handler threw. The message is ours, never the thrown value's. */
+'internal';
+/** @group Bridge */
+type ProtocolError = {
+  code: ErrorCode;
+  message: string;
+};
+/**
+ * What a rejected call rejects with.
+ *
+ * @group Bridge
+ */
+declare class BridgeError extends Error {
+  code: ErrorCode;
+  constructor(error: ProtocolError);
+}
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/envelope.d.ts
+/**
+ * `p` is the protocol version, carried on every message rather than only at the
+ * handshake, because a message that arrives without context still has to be
+ * classifiable.
+ *
+ * There is deliberately no addressing. A bridge joins exactly one host to
+ * exactly one game: the game lives alone in its frame and has no way to name
+ * another game, and the host holds one frame and needs no way to name another.
+ * A host that runs several games at once — the app, the production site — runs
+ * several bridges, each with its own transport, and keeping their inboxes apart
+ * is that host's problem with its own frames. Putting a channel in the envelope
+ * would make every transport pay for a problem only one kind of host has.
+ *
+ * @group Bridge
+ */
+type Envelope = {
+  p: 1;
+  kind: 'req';
+  id: string;
+  method: string;
+  params: unknown;
+} | {
+  p: 1;
+  kind: 'res';
+  id: string;
+  ok: true;
+  value: unknown;
+} | {
+  p: 1;
+  kind: 'res';
+  id: string;
+  ok: false;
+  error: ProtocolError;
+} | {
+  p: 1;
+  kind: 'evt';
+  topic: string;
+  data: unknown;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/input.d.ts
+/**
+ * What the host says about how this game is being played.
+ *
+ * **Nothing about input is asked for over this bridge.** A key is pressed
+ * inside the frame and read inside the frame; a thumbstick under a thumb is
+ * sampled a metre from the game that wants it. Putting either on the wire would
+ * spend a message and a frame of latency on something already in the room.
+ *
+ * So what travels here is what the frame has no copy of. The game's own
+ * declaration — its actions and its layouts of on-screen controls — comes from
+ * the manifest, and the manifest is the host's: the frame holds none. With it
+ * comes the *mapping* — the declared bindings with whatever a player has
+ * remapped folded over them — the scheme they are using, and whether on-screen
+ * controls apply on this host at all. All of it is wanted before the first
+ * frame, and the last three can change under a running game without the game
+ * being able to notice.
+ *
+ * **The bindings are carried as strings and not parsed here.** Their vocabulary
+ * lives in `@hopple/manifest`, where a binding is first written down, and
+ * whoever resolves one imports it from there. A host newer than the game it is
+ * talking to will send bindings this game has never heard of, and the right
+ * thing to do with those is to keep them on the wire and drop them at the point
+ * of use — which is what a resolver that only matches what it knows does for
+ * free.
+ */
+/**
+ * Which kind of input the player is using right now.
+ *
+ * The last one they actually used, not everything attached: a laptop with a
+ * controller plugged in is a keyboard until somebody moves a stick. What a game
+ * does with it is choose its prompts — *Press Z* against a glyph — and decide
+ * whether to draw touch hints of its own.
+ *
+ * @group Input
+ */
+type InputScheme = 'keyboard' | 'mouse' | 'touch' | 'gamepad';
+/** @group Input */
+declare const INPUT_SCHEMES: readonly InputScheme[];
+/**
+ * What presses one action, and what to call it in front of a player.
+ *
+ * `bind` is the effective list — the manifest's, with a remap folded over it —
+ * in the order a game should prefer them when it draws only one.
+ *
+ * **`label` is the host's, and it is why this is on the wire at all.** The same
+ * action is *Z* on a keyboard, *A* on one controller and *B* on another, and
+ * only the host knows which the player is holding. A game writes
+ * `Press ${mapping.shoot.label}` and is right everywhere without ever learning
+ * what a controller is. Absent means the host had nothing better to say than the
+ * game's own declaration.
+ *
+ * @group Input
+ */
+type InputBinding = {
+  bind: string[];
+  /** What to call the action itself. From the manifest unless the host knows better. */
+  title?: string;
+  /** What to show for the binding a player would actually use. See above. */
+  label?: string;
+};
+/**
+ * How a group of on-screen buttons is arranged. See `ControlShape` in
+ * `@hopple/manifest`, which a test keeps this in step with.
+ *
+ * @group Input
+ */
+type InputLayoutShape = 'row' | 'column' | 'diamond' | 'cluster';
+/**
+ * Where on the screen a group of on-screen controls sits. See `ControlZone` in
+ * `@hopple/manifest`.
+ *
+ * @group Input
+ */
+type InputLayoutZone = 'left' | 'right' | 'full';
+/**
+ * The one direction an on-screen thumbstick moves in. See `ControlAxis` in
+ * `@hopple/manifest`.
+ *
+ * @group Input
+ */
+type InputLayoutAxis = 'x' | 'y';
+/**
+ * How an on-screen thumbstick meets a thumb: a player's setting, the same in
+ * every game they open.
+ *
+ * `floating` is drawn where the layout puts it, as a sign that there is a
+ * stick, and comes to wherever a thumb lands on its side of the screen — so a
+ * player never has to find it, and the place they first touch is always the
+ * centre. `fixed` stays where it is drawn and is moved only from there.
+ *
+ * @group Input
+ */
+type InputSticks = 'floating' | 'fixed';
+/**
+ * Why the mapping or the scheme is different from what the game was told before.
+ *
+ * @group Input
+ */
+type InputChangeCause =
+/** A player changed a binding. */
+'remap' |
+/** They picked up a controller, or put one down. */
+'scheme' |
+/** The host revised it for its own reasons. */
+'host' |
+/** A player changed how the on-screen controls behave. */
+'setting';
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/panel.d.ts
+/**
+ * The pages of the panel this version of the protocol has a name for.
+ *
+ * **A vocabulary, not a capability.** Every one of these is a subject both ends
+ * already have words for elsewhere — a game's own description, its boards, its
+ * achievements, its bindings — so the names are the ones the hosts already use
+ * for the pages they draw, and a game author who reads "About" in the panel
+ * finds `about` here.
+ *
+ * It grows, and it only ever grows: a name means the same thing for ever,
+ * because a game ships and is never updated. A host older than a name answers
+ * `unsupported`, which is the same thing it says about a page it simply does
+ * not draw — and the right answer to both, because from the game's side they
+ * are one fact: that page is not going to open here.
+ *
+ * @group Panels
+ */
+type PageId =
+/** What this game is: its title, its author, its description. */
+'about' |
+/** Who has scored what, on this game's boards. */
+'scores' |
+/** What has been unlocked, and how far along the rest is. */
+'achievements' |
+/** What this game is played with, and where a player rebinds it. */
+'input';
+/** @group Panels */
+declare const PAGES: readonly PageId[];
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/pause.d.ts
+/**
+ * Whether the game is holding still, which the host may ask for and only the
+ * game can answer.
+ *
+ * **This is the third shape a namespace on this bridge takes, and it is worth
+ * naming.** A save, a score and a panel are services: the game asks and the
+ * host may refuse. Audio runs the other way: the host states and the game
+ * obeys, with no refusal to model. Pausing is neither. The host asks, and the
+ * game is the only side that knows whether there is anything to stop — so the
+ * answer is not an acknowledgement but a *state*, and one of the three it may
+ * be is "you cannot ask me that just now".
+ *
+ * **Pausing is not an order, and the two must not be folded together.** The
+ * orders in `Allowed` are what the *host* lets the game run — a loop stopped
+ * because the game is being swiped past is the host's fact, declared rather
+ * than negotiated. This is the player's fact: they pressed a button, and the
+ * game stopped its clock and put a menu up. A host asks for a pause as it takes
+ * a game in play away from the player, and leaves resuming to the player: one
+ * that muddled the two would un-pause a player's game by scrolling back to it.
+ *
+ * **Whether a game can be paused at all is nothing more than what it says.** A
+ * game that never announces a state is `unpausable` for ever and is never
+ * asked, which is what every game published before this existed gets. There is
+ * no separate capability to declare: "cannot be paused" and "nothing to stop
+ * just now" are one fact to a player, and one state here.
+ *
+ * **`unpausable` is a real state and not an error.** A game between rounds, on
+ * its title screen, or — in the demo — with nothing on the field to stop, has
+ * nothing to pause; saying so is more useful than refusing a call, because it
+ * is a fact the host draws rather than one it recovers from. It also moves on
+ * its own, which is why the game announces the state as well as answering
+ * about it.
+ */
+/**
+ * Where the game stands, as one word.
+ *
+ * Three values rather than a boolean and a capability flag, because the third
+ * one is what a host actually draws around: a control that is *absent* is a
+ * different thing from one that is showing "Pause", and a host holding two
+ * booleans has to work out which of their four combinations mean nothing.
+ *
+ * @group Pause
+ */
+type PauseState =
+/** Playing. A host draws Pause. */
+'running' |
+/** Held, at the player's asking. A host draws Resume. */
+'paused' |
+/**
+ * There is nothing here to stop right now.
+ *
+ * A title screen, the gap between rounds, a cut scene that has to finish.
+ * A host draws nothing at all — not a disabled button, which is a promise
+ * that pressing it would do something.
+ */
+'unpausable';
+/** @group Pause */
+declare const PAUSE_STATES: readonly PauseState[];
+/**
+ * The cautious reading, and the one every silence falls back to: a game that
+ * has said nothing cannot be paused.
+ *
+ * The opposite of the reading `AUDIO_FULL` takes, and for the same reason —
+ * both are the answer that claims the least. Guessing loud is safe for volume
+ * because a game that started silent would look broken; guessing `unpausable`
+ * is safe here because a host that drew Pause on a game with no pause would
+ * have promised a button that does nothing.
+ *
+ * @group Pause
+ */
+declare const PAUSE_NONE: PauseState;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/save.d.ts
+/**
+ * The one thing a game may keep.
+ *
+ * A game reads its state while it loads and writes it as it plays. Where that
+ * lands is the host's — `localStorage` in the dev shell today, a row behind an
+ * account later — and what is in it is the game's, which the host never parses.
+ *
+ * **The shape of this is not the shape of analytics**, and every difference is
+ * deliberate. Analytics is one-way and unacknowledged because nothing waits for
+ * it; a read's answer is the whole point, a write has to be known to have
+ * landed, and a save that quietly went missing is something a player feels. So
+ * these are requests, they have error codes, and the game is told when one
+ * failed.
+ *
+ * **Nothing here is a limit either.** How big a save a host will take, how often
+ * it will take one, whether it debounces and how long its window is: all the
+ * host's, all revisable on the host's own deploy cadence. What this file settles
+ * is the *shape* both ends must agree on, and one floor — `SAVE_BYTES` — that a
+ * game may assume anywhere, forever, because a game ships and is never updated.
+ */
+/**
+ * What a game may write anywhere, in bytes of `state` as UTF-8.
+ *
+ * The floor rather than the cap: a host that will take more says so in the
+ * welcome, and a game that never asks still knows this much is safe. 64 KiB is
+ * far more than a save of positions and counters needs and far less than any
+ * store would notice.
+ *
+ * @group Save
+ */
+declare const SAVE_BYTES = 65536;
+/**
+ * What is waiting, without fetching it.
+ *
+ * Small, fixed-size, and already known to any host that has a store, so it
+ * rides in the `Welcome` where the blob deliberately does not. It is what tells
+ * a game whether the round trip is worth making: a game draws *Continue* or
+ * *New game* before it has asked for anything, and a game now on schema 3 that
+ * will not migrate a 1 never fetches it at all.
+ *
+ * @group Save
+ */
+type SaveStored = {
+  /** The host's clock, when the record was written. */
+  at: number;
+  version: number;
+  /** How big `state` is, so a game knows what it is about to be handed. */
+  bytes: number;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/score.d.ts
+/**
+ * What a player did, as one number.
+ *
+ * A game submits a score when a run ends; the host makes it durable and, if it
+ * has anywhere to send it, sends it. What comes back is what the player is
+ * shown: their own best, and where it stands.
+ *
+ * **The shape of this is not the shape of a save, and not the shape of
+ * analytics.** A save is one document rewritten in place, and losing one costs
+ * a player their progress. A score is an append — every run is its own fact, a
+ * later worse run does not erase a better one, and the collapsing into "your
+ * best" happens where the rows are rather than on the way in. Analytics is
+ * one-way because nothing waits for it; a score is a request because a game
+ * draws the answer.
+ *
+ * **The submission carries no player.** The game says which board and what
+ * number, and the host attaches who — which is the host being authoritative
+ * about the one fact a game must not be able to assert. It also means a game
+ * literally cannot submit on somebody else's behalf, which is free here and
+ * would be expensive to retrofit.
+ *
+ * **There is no anti-cheat and this file does not pretend otherwise.** A score
+ * is whatever the machine running the game says it is. What is checked is that
+ * the number is a number: finite, and inside the range where an integer still
+ * round-trips. The realistic thing that catches is an uninitialised variable.
+ */
+/**
+ * The largest score the wire will carry, and the smallest.
+ *
+ * Spelled here *and* in `@hopple/manifest`, on purpose and with a test to keep
+ * them equal. The server checks the same rule and is not allowed to depend on
+ * this package — "the server never talks to a game", made mechanical — so the
+ * rule is written down in the one package both sides may import and enforced on
+ * the wire here.
+ *
+ * @group Score
+ */
+declare const SCORE_VALUE_MAX = 9007199254740991;
+/**
+ * What the host says came of it.
+ *
+ * `improved` and `best` are answerable by any host that took the submission,
+ * because they are about this player's own history and nothing else. `rank` and
+ * `of` are not: under a host that acknowledges when the score is *durable*
+ * rather than when a server has seen it, there may be no server answer yet. So
+ * they are optional, and a host that does not know leaves them out rather than
+ * guessing — a rank a game drew from a guess is a rank a player will screenshot.
+ *
+ * @group Score
+ */
+type ScoreResult = {
+  /** Whether this run beat the player's previous best. Ties are not improvements. */
+  improved: boolean;
+  /** The player's best on this board, after this submission. */
+  best: number;
+  /** Where that best stands, when the host knows. */
+  rank?: number;
+  /** Out of how many players, when the host knows. */
+  of?: number;
+};
+/**
+ * Where one player stands on one board.
+ *
+ * @group Score
+ */
+type ScoreStanding = {
+  best: number;
+  /** The host's clock, when the best was set. */
+  at: number;
+  /** How many runs this player has submitted to this board. */
+  runs: number;
+  rank?: number;
+  of?: number;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/share.d.ts
+/**
+ * A link to this game, offered to the player by the host.
+ *
+ * A game cannot share itself. It sits in a sandboxed frame on an opaque origin
+ * with no top-level navigation, no popups and no clipboard the player has
+ * gestured at — and it does not know its own address in the first place, because
+ * where this game lives is the host's fact and differs per host: a row in a feed
+ * on the site, a deep link into the app, a path on somebody else's page. So the
+ * game asks, and the host does the offering.
+ *
+ * **The game names no URL and is told none.** It says only what it would like
+ * carried along, and the host mints the link, decides how to put it in front of
+ * the player — a share sheet, the clipboard, a dialogue — and tells the player
+ * what became of it. A game that could read its own link would be a game that
+ * could fabricate one, and a host that took a URL from a game would be
+ * publishing whatever the game handed it.
+ *
+ * **The game is not told what the player did with it.** The host is the one
+ * that opened the sheet or wrote the clipboard, so the host is the one that
+ * says "link copied", and a game that forgot to would leave a player with a
+ * copy nobody mentioned. A game with an outcome in hand would also be a game
+ * that could pay for shares, which is a thing no player should be asked for.
+ *
+ * **`data` is the game's, and opaque to everyone else.** The host keeps it with
+ * the link and gives it back to whoever opens that link, without ever parsing
+ * it: a level seed, a board, a score to beat. What it means is settled between
+ * the game that wrote it and the same game reading it back, which is the only
+ * pair that can agree about it.
+ *
+ * **`meta` is the game's too, and it goes the other way: to the platform, never
+ * back to a game.** Why the link was made — the level, the score that was
+ * beaten, which of the game's own buttons was pressed — kept beside the host's
+ * own record of who made it and how, so the people running a game can learn
+ * which of its shares bring players in. The game reading a link back is never
+ * told it, so nothing a game plays on can depend on it.
+ *
+ * **A game asks; only the host refuses.** Nothing is negotiated at the
+ * handshake and there is nothing for a game to check first: whether there is a
+ * link to give, how often one may be asked for, how much data one will carry
+ * are all the host's, all revisable on the host's own deploy cadence, and all
+ * answered when a player actually presses the button. What this file settles is
+ * the shape both ends must agree on, and `SHARE_BYTES` — the amount of `data`
+ * every host takes, forever, because a game ships and is never updated.
+ *
+ * **Both directions, and they are not symmetrical.** Going out is a request
+ * the game does not wait on: the host answers as soon as it has taken the offer
+ * and before it opens anything, because a sheet stays up for as long as the
+ * player likes and no reply timeout can be long enough for that. Coming back —
+ * the data a link carried into this run — is a fact of the run and rides in the
+ * welcome beside `info`, because a game opened from a link has to know before
+ * its first frame. See `ShareWelcome`.
+ */
+/**
+ * What every host carries, in bytes of `data` as UTF-8.
+ *
+ * The floor rather than the cap: a host may take more and none may take less,
+ * so a game that stays under this is never refused for its size anywhere. It is
+ * the one number about sharing a game can rely on without asking, which is why
+ * it is a constant rather than something the wire carries.
+ *
+ * Small on purpose. 512 bytes is a seed, a board, a score; a save belongs in
+ * `save`, which is where a host keeps things that are big. It is the number
+ * every game already published was promised, so it stays the floor whether a
+ * host carries the data in the link itself or keeps it on a server and puts
+ * only a reference in the link.
+ *
+ * @group Share
+ */
+declare const SHARE_BYTES = 512;
+/**
+ * What every host takes of `meta`, in bytes of its JSON as UTF-8.
+ *
+ * A floor like `SHARE_BYTES`, and for the same reason: a game that stays under
+ * it is never refused anywhere. Enough for a handful of facts about why a link
+ * was made; a game that wants to say more is describing its state, which is
+ * what `data` is for.
+ *
+ * @group Share
+ */
+declare const SHARE_META_BYTES = 1024;
+/**
+ * Something a game can say about a share: what JSON can say, and nothing else.
+ *
+ * @group Share
+ */
+type ShareMetaValue = string | number | boolean | null | ShareMetaValue[] | {
+  [key: string]: ShareMetaValue;
+};
+/**
+ * Why a game made a link, in its own words — kept by the platform beside who
+ * made it and how, and never handed back to a game.
+ *
+ * @group Share
+ */
+type ShareMeta = {
+  [key: string]: ShareMetaValue;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/methods.d.ts
+/**
+ * How far a game has got with its own preparation.
+ *
+ * Only ever forwards, and only ever about the game itself — not about what is
+ * being done with it. `disposed` ends it.
+ *
+ *     booting → loading → ready → disposed
+ *
+ * @group Lifecycle
+ */
+type Phase =
+/**
+ * The frame exists and nothing has spoken yet: the bundle is still starting
+ * up. A game never observes this — there is no game running to observe it —
+ * but a host needs a word for the gap, because a bundle that never runs looks
+ * exactly like one that has not run *yet*, and only a deadline tells them
+ * apart.
+ */
+'booting' |
+/** Up and talking, getting its own things together: assets, save, first frame. */
+'loading' |
+/** The game says it can be shown. The one phase it declares rather than obeys. */
+'ready' |
+/** Going away. The last thing a game is told, and its chance to flush. */
+'disposed';
+/**
+ * A box in the frame's own coordinates: `0,0` is the frame's top-left corner.
+ *
+ * @group Layout
+ */
+type Rect = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+/**
+ * How big something is, in CSS pixels.
+ *
+ * @group Layout
+ */
+type Size = {
+  width: number;
+  height: number;
+};
+/**
+ * What is over the game, and why.
+ *
+ * A game avoids all of these the same way, so they arrive in one list rather
+ * than several a game would have to concatenate before it could use them.
+ *
+ * @group Layout
+ */
+type ObstructionKind =
+/** Host interface: a rail, a corner control. It takes the input there too. */
+'chrome' |
+/** The device itself: a notch, a camera hole, a rounded corner. */
+'cutout' |
+/** Something the host has put over the game for now: a sheet, a dialogue. */
+'overlay' |
+/**
+ * The SDK's own on-screen controls, drawn inside the frame.
+ *
+ * The one kind a host never sends: it is synthesised where the controls are
+ * drawn, and joins the same list so that a game keeping clear of reserved
+ * rectangles keeps clear of a thumbstick without being told twice.
+ */
+'controls';
+/** @group Layout */
+type Obstruction = {
+  rect: Rect;
+  kind: ObstructionKind;
+  /**
+   * Whether this is part of the game's usable area or merely on top of it.
+   *
+   * `true` means stay out: the region is not yours, and pointer events there
+   * will never reach you. `false` means something is covering you for now and
+   * what to do about it is entirely your decision — the SDK leaves it out of
+   * the insets, so a game that ignores this keeps the layout it had.
+   *
+   * A separate field rather than something to be read off `kind`, because a
+   * game ships and is never updated: one written today will one day meet a kind
+   * nobody has invented yet, and this is what lets it be right about it anyway.
+   */
+  reserved: boolean;
+};
+/**
+ * Which kind of host this is.
+ *
+ * @group Info
+ */
+type AppSurface =
+/** The Hopple app, in a WebView. */
+'app' |
+/** A browser: the production site, or a game embedded on someone else's page. */
+'web' |
+/** A developer's own machine, under `hopple dev`. Never a player. */
+'dev';
+/**
+ * How much machine there is, as one word.
+ *
+ * A budget the host worked out when it started the game, not a live reading —
+ * which is what makes it safe to say once. Anything that changes while a game
+ * runs is a different kind of fact and would need somewhere to change.
+ *
+ * @group Info
+ */
+type DeviceTier = 'low' | 'mid' | 'high';
+/**
+ * Which host is running this game.
+ *
+ * @group Info
+ */
+type AppInfo = {
+  /** Who it is, as a stable name: `hopple`, or whoever embedded the game. */
+  id: string;
+  /** Their version. For a game's own diagnostics; the protocol version is what capability is settled by. */
+  version: string;
+  /**
+   * `dev` is the one worth acting on, and the one to be careful with: it is how
+   * a game shows its own frame counter to its author and to nobody else. A game
+   * that *plays* differently in dev is a game whose dev testing proves less than
+   * it looks.
+   */
+  surface: AppSurface;
+};
+/**
+ * Which game the host believes it is running.
+ *
+ * From the manifest that arrived with the verified bundle, not from anything the
+ * bundle says about itself. A game that inlined its own version at build time
+ * and finds it disagreeing with this one has been shipped wrong, and from inside
+ * the frame there is nowhere else that is visible.
+ *
+ * @group Info
+ */
+type GameInfo = {
+  id: string;
+  version: string;
+};
+/**
+ * Who is playing, as far as a game is allowed to know.
+ *
+ * @group Info
+ */
+type PlayerInfo = {
+  /**
+   * An opaque name for this player *in this game*, stable while they keep
+   * playing it, and `null` where the host has no notion of a player at all —
+   * a site running one game has none, and a game keying anything to a player
+   * has to survive that.
+   *
+   * **Per game, not per person.** A host derives this from the player and the
+   * game together, so two games by the same author cannot recognise the same
+   * person between them. Nothing here can enforce that — this package only
+   * carries what a host hands over — so it is a rule every host we write obeys.
+   */
+  id: string | null;
+  /** Whether this player has played *this* game before. */
+  returning: boolean;
+  /**
+   * The language to speak, as a BCP 47 tag.
+   *
+   * The player's, not the device's, which is why it is here rather than under
+   * `device`: `navigator.language` is already readable inside the frame and
+   * answers what the operating system is set to, while this is what they chose
+   * in the app.
+   */
+  locale: string;
+};
+/**
+ * What the host is running the game on.
+ *
+ * @group Info
+ */
+type DeviceInfo = {
+  tier: DeviceTier;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/listeners.d.ts
+/**
+ * The one way anything here is listened to: `on(listener)` hands back the
+ * function that stops it.
+ *
+ * Every `on()` a game or a host is offered behaves the same, because they are
+ * all this:
+ *
+ * - **Each `on()` is its own.** The same function added twice is called twice,
+ *   and each returned function takes back only the registration it came from —
+ *   so two parts of a game that happen to share a handler cannot unsubscribe
+ *   each other.
+ * - **Stopping is final and safe to repeat.** A listener taken back while
+ *   others are being told is not called after that point, and calling the
+ *   returned function again does nothing.
+ * - **A listener added while others are being told hears the next change**,
+ *   not the one under way: it was not there when it happened.
+ * - **One that throws is reported and stops nobody.** The others are still
+ *   told, and whoever made the change still gets on with it.
+ *
+ * @module listeners
+ */
+/**
+ * Stops the listener an `on()` added. Calling it again does nothing.
+ *
+ * @group Bridge
+ */
+type Unsubscribe = () => void;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/protocol/src/transport.d.ts
+/** @group Bridge */
+type Transport = {
+  send(message: Envelope): void;
+  /** Returns the unsubscribe. Calling `receive` twice is not defined behaviour. */
+  receive(handler: (message: Envelope) => void): () => void;
+  close(): void;
+};
+/**
+ * The name a platform leaves its shim under, and the name it calls if it is late.
+ *
+ * Declared here, in the package both ends import, so that a platform author and
+ * the SDK are reading the same two strings. Nothing in this package writes
+ * either of them: the shim is wholly the platform's, and this file is a target
+ * to hit rather than code we ship.
+ *
+ * @group Bridge
+ */
+declare const SHIM = "__HOPPLE_SHIM__";
+/** @group Bridge */
+declare const SET_SHIM = "__HOPPLE_SET_SHIM__";
+/**
+ * What a native shell leaves for a game to talk through.
+ *
+ * A game in a browser frame has `window.parent` and needs none of this. A game
+ * in a WebView is a top-level document — its `parent` is itself — so there is no
+ * window above it to post to, and the platform has to hand it a channel instead.
+ * This is that channel, reduced to the least a platform can be asked for.
+ *
+ * **The SDK writes none of it.** It agrees on a name and a shape and finds
+ * whatever was left; how the bytes actually cross is the platform's business,
+ * and is different on every one. That is what keeps this package free of hosts
+ * it has never heard of.
+ *
+ * A shim has exactly two duties:
+ *
+ *   - **Arrive.** Before the game's bundle runs is easiest, and is what our own
+ *     hosts do — a document-start hook, `injectedJavaScriptBeforeContentLoaded`,
+ *     a `WKUserScript` at `.atDocumentStart`. A platform that cannot manage that
+ *     is late rather than broken: see the rendezvous below.
+ *   - **Never throw.** A shim that throws breaks a game that did nothing wrong.
+ *
+ * And one duty it explicitly does *not* have: **it must not buffer.** Nothing
+ * arrives before the game is listening, because every host → game message is
+ * gated on the handshake and the game is the side that opens it. An array in
+ * every shim would be paying, on every platform, for a message that is never
+ * sent.
+ *
+ * **Two ways in, and a platform may use either**, because neither side may
+ * assume it is first:
+ *
+ * ```js
+ * // The whole of what a platform has to get right about ordering.
+ * if (w.__HOPPLE_SET_SHIM__) w.__HOPPLE_SET_SHIM__(shim);
+ * else w.__HOPPLE_SHIM__ = shim;
+ * ```
+ *
+ * A platform that installs early always takes the second branch; one that
+ * cannot takes the first, and the SDK — which has been waiting — connects. The
+ * setter only exists while the SDK is waiting, and is removed once it is used
+ * or the wait expires.
+ *
+ * **Strings, not envelopes.** Every native bridge carries strings, so that is
+ * the contract, and it means the SDK stays the trust boundary: `JSON.parse` and
+ * `isEnvelope` run in SDK code on both sides of the wire and never in a
+ * platform's. A shim cannot get validation wrong, because it does none.
+ *
+ * @group Bridge
+ */
+type HoppleShim = {
+  /**
+   * The contract version. `1` today.
+   *
+   * A shim whose version the SDK does not know is ignored rather than guessed
+   * at — which falls through to the frame branch, and then to the wait.
+   */
+  v: 1;
+  /** Send one already-serialised envelope to the host. Game → host. */
+  send(message: string): void;
+  /**
+   * Take the SDK's inbound handler, and hand back the unsubscribe.
+   *
+   * Called once, by the SDK, and it is a subscription rather than a delivery:
+   * how the platform later reaches the handler it was given — an eval into a
+   * global, a real message channel — is the platform's problem and is not
+   * described here.
+   */
+  receive(handler: (message: string) => void): () => void;
+};
+/**
+ * The two globals, so a platform's own TypeScript sees the same shape the SDK
+ * reads. Neither is ever written by this package.
+ */
+declare global {
+  var __HOPPLE_SHIM__: HoppleShim | undefined;
+  var __HOPPLE_SET_SHIM__: ((shim: HoppleShim) => void) | undefined;
+}
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/manifest/src/manifest.d.ts
+/**
+ * What a game says about itself.
+ *
+ * Written in the project's hopple config and uploaded beside the game's page
+ * as `game.manifest.json`. It is the first thing the host learns: it is
+ * published with the game, so a host holds it before it has anything to run —
+ * from the server in the app, from the project in the dev server. It never
+ * travels over the bridge. Not to be confused with `FeedEntry`, which is
+ * what the *catalogue* says about a game.
+ *
+ * The core is deliberately tiny: identity, a name, and how the game wants to
+ * be held. Everything a later API needs declared ahead of time
+ * gets its own optional top-level key named after that API — `save`,
+ * `achievements`, and so on — whose contents are designed by the milestone that
+ * builds it. Most namespaces will never need one.
+ *
+ * **The types below are the only place a rule is written.** Their shapes and
+ * the constraint tags in their comments — `@maxLength`, `@pattern` and the rest
+ * — are compiled into `game.manifest.schema.json`, and `validateManifest` checks
+ * a manifest by walking that schema. Change a type and the schema, the
+ * validator and every editor that reads the schema follow. The only rules
+ * written in code are the few no schema can state, and they are at the bottom
+ * of this file.
+ *
+ * Validation lives here rather than in the host so that the publish CLI, the
+ * dev server and the host all reach the same verdict about the same file.
+ *
+ * @module manifest
+ */
+/**
+ * The name a manifest is uploaded under, beside the game's page.
+ *
+ * @group Manifest
+ * @category Useful
+ */
+declare const MANIFEST_FILE = "game.manifest.json";
+/**
+ * The manifest's own version, separate from the protocol's.
+ *
+ * Bumped only if the *core* changes meaning, which is a thing we intend never
+ * to do — new keys are additive and need no bump. A host refuses a schema it
+ * does not know, because a manifest it half-understands is worse than none.
+ *
+ * @group Manifest
+ * @category Useful
+ */
+declare const MANIFEST_SCHEMA = 1;
+/**
+ * How the game wants to be held. The host decides what to do about it.
+ *
+ * @group Layout
+ */
+type Orientation = 'portrait' | 'landscape' | 'any';
+/**
+ * Whether the host may put its own furniture over the game's frame.
+ *
+ * The one layout question that has to be answered before the bundle runs, which
+ * is why it is declared here rather than asked at runtime: the host sizes the
+ * frame before there is a game to ask. A game that says nothing gets `reserve`,
+ * so a rail never lands on the buttons of something written before rails
+ * existed.
+ *
+ * @group Layout
+ */
+type InsetMode =
+/** The frame is the whole surface; read `sdk.layout` and keep out of the way. */
+'draw-under' |
+/** The host shrinks the frame clear of its own furniture. Nothing to avoid. */
+'reserve';
+/**
+ * What a game declares about layout. Absent means every default.
+ *
+ * @group Layout
+ * @category Useful
+ */
+type LayoutDeclaration = {
+  insets: InsetMode;
+  [key: string]: unknown;
+};
+/**
+ * What a prop may hold, as one word. The three the wire carries, and no more.
+ *
+ * @group Analytics
+ */
+type AnalyticsType = 'string' | 'number' | 'boolean';
+/**
+ * One event's props. Every one optional: see `AnalyticsDeclaration`.
+ *
+ * Prop names follow the grammar event names do, which `@hopple/protocol`
+ * enforces on the wire too; a test keeps the two in step.
+ *
+ * @group Analytics
+ * @maxProperties 8
+ * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 24, errorMessage: 'must be a prop name of lowercase letters, digits, dots, hyphens and underscores' }
+ */
+type AnalyticsShape = Record<string, AnalyticsType>;
+/**
+ * The custom events a game sends, and what each one carries.
+ *
+ * **The first key here whose reader is not the host.** `layout.insets` is
+ * declared because a frame has to be sized before there is a game to ask;
+ * nothing about analytics has to be answered before the bundle runs. What earns
+ * this its place is cardinality: names and columns invented at runtime make a
+ * pipe nobody can build a table for, and the party that has to build that table
+ * — the publish CLI, the server, a creator dashboard — is exactly the party that
+ * already reads the manifest and never talks to a game.
+ *
+ * **Every prop is optional and nothing is required**, which is what keeps the
+ * declaration cheap enough to be worth asking for: forgetting one costs a column
+ * rather than the event. The additive rule carries over unchanged — add events,
+ * add props, never retype one — and that is the whole of what a per-event table
+ * needs to survive the game's next version.
+ *
+ * @group Analytics
+ * @category Useful
+ */
+type AnalyticsDeclaration = {
+  /**
+   * Every event the game may send, by name.
+   *
+   * Names starting `hopple.` are the host's own records and not a game's to
+   * use. The grammar is the wire's too: `@hopple/protocol` enforces the same
+   * one, and a test keeps the two in step. At most 64 events: the wire never
+   * sees a declaration, so nothing enforces this at runtime and nothing has to.
+   *
+   * @maxProperties 64
+   * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 48, not: { pattern: '^hopple\\.' }, errorMessage: 'must be lowercase letters, digits, dots, hyphens and underscores, and must not start with "hopple.", which the host uses' }
+   */
+  events: Record<string, AnalyticsShape>;
+  [key: string]: unknown;
+};
+/**
+ * What a game expects to keep, in bytes.
+ *
+ * **The manifest's own test is whether the host must know before the bundle
+ * runs**, and here it must: a host that prefetches a save from a server has to
+ * know which games have one before there is a game to ask, and a publish
+ * pipeline that provisions storage has to know before a player exists.
+ *
+ * The budget the game expects, not a grant. A host answers with its own cap at
+ * the handshake, and a game with no key here may still call the API — it just
+ * gets nothing prefetched, which is the honest reading of not having said so.
+ *
+ * @group Save
+ * @category Useful
+ */
+type SaveDeclaration = {
+  /**
+   * At most 1 MiB. Not the same question as what a host will take — that is
+   * the host's and is settled at the handshake. This is only what is worth
+   * writing down: a declaration in the megabytes is a game that has
+   * misunderstood what this is for, and finding that out at publish time is
+   * cheaper than at a player's.
+   *
+   * @asType integer
+   * @exclusiveMinimum 0
+   * @maximum 1048576
+   */
+  bytes: number;
+  [key: string]: unknown;
+};
+/**
+ * One thing a game makes noise with, as the player is offered it.
+ *
+ * The title is the whole of it, and required: this exists to be a label on a
+ * fader in a host's own panel, and a fader labelled `sfx2` is a control nobody
+ * can use. What a channel *is* — a bus, a set of samples, one oscillator — is
+ * the game's business and is never described here.
+ *
+ * @group Audio
+ */
+type AudioChannel = {
+  /**
+   * What to call it in front of a player.
+   *
+   * @category Important
+   * @pattern \S
+   * @maxLength 40
+   * @errorMessage must not be blank
+   */
+  title: string;
+  [key: string]: unknown;
+};
+/**
+ * What this game makes noise with, so a host can offer a fader for each.
+ *
+ * **A map from the first version, even for a game with one channel.** The
+ * channel id travels in `audio.set`, which is frozen game-side code, and a
+ * single-channel key would have to *change meaning* to grow a second one — the
+ * one move the additive rule forbids.
+ *
+ * **The manifest's test is whether the host must know before the bundle runs**,
+ * and here it must twice over. The panel is drawn where the game's title is,
+ * which a host draws for games in a feed that nobody has opened; and the
+ * opening volumes ride in the handshake, so the host has to know which channels
+ * it is stating a volume for before there is a game to ask.
+ *
+ * **The key is required, and `null` is how a silent game says so.** Leaving it
+ * out would read the same as forgetting it, and a game that makes noise but
+ * never said so is one whose player cannot turn it down. An object with no
+ * channels is a game with sound and no tracks worth a fader of their own: it
+ * gets a master fader and a mute button and no more. What is never optional is
+ * obeying what the host then says: see `AudioState`.
+ *
+ * @group Audio
+ * @category Useful
+ */
+type AudioDeclaration = {
+  /**
+   * The channels, by id. Optional, and may be empty: either way there is only
+   * the master. At most 8: a panel of faders nobody can read is not a feature.
+   *
+   * `master` is refused rather than quietly shadowed. A master fader exists
+   * whether or not a game has said anything, and an author who wrote it meant
+   * something by it; a fader that turned out to be the host's own would be a
+   * control that ignored half of what they wired it to. The id grammar is the
+   * wire's too, and a test keeps the two in step.
+   *
+   * @maxProperties 8
+   * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 48, not: { const: 'master' }, errorMessage: 'must be lowercase letters, digits, dots, hyphens and underscores, and must not be "master", which every host adds itself' }
+   */
+  channels?: Record<string, AudioChannel>;
+  [key: string]: unknown;
+};
+/**
+ * Which way a board sorts — the one thing about a score that cannot be guessed.
+ *
+ * `desc` is the ordinary leaderboard, where more is better. `asc` is a time, a
+ * stroke count, a number of moves. Nothing downstream can infer this from the
+ * values it holds, and a client that guessed would render a time board upside
+ * down, so it is required rather than defaulted.
+ *
+ * @group Score
+ */
+type ScoreDirection = 'asc' | 'desc';
+/**
+ * How to draw the number.
+ *
+ * A client renders a board for a game it has never run, so it cannot ask the
+ * game what `224310` means. `integer` is a count, `decimal` a measurement,
+ * `duration-ms` a time to be written as minutes and seconds. Absent is
+ * `integer`, which is what most boards are.
+ *
+ * @group Score
+ */
+type ScoreFormat = 'integer' | 'decimal' | 'duration-ms';
+/** @group Score */
+type ScoreBoard = {
+  /**
+   * What to call it in front of a player.
+   *
+   * @category Important
+   * @pattern \S
+   * @maxLength 40
+   * @errorMessage must not be blank
+   */
+  title: string;
+  direction: ScoreDirection;
+  /** See `ScoreFormat`. Absent means `integer`. */
+  format?: ScoreFormat;
+  [key: string]: unknown;
+};
+/**
+ * The boards this game keeps a score on.
+ *
+ * **A map from the first version, even for a game that wants one board.** The
+ * board id travels in `score.submit`, which is frozen game-side code, and a
+ * single-board key would have to *change meaning* to grow a second one — the
+ * one thing the additive rule forbids. A map costs a game with one board the
+ * few characters of naming it, and costs a game with four nothing at all.
+ *
+ * **Read by the host and by the server**, which is what earns it a key rather
+ * than a runtime call: a client draws a game's board in a sheet over a feed
+ * without ever having run that game, and the server has to know how a board
+ * sorts before it can answer a query about one.
+ *
+ * @group Score
+ * @category Useful
+ */
+type ScoreDeclaration = {
+  /**
+   * The boards, by id. At least one: a `score` key with no boards is a game
+   * that meant to declare one and did not, and reading it as "no boards" would
+   * hand it a scoreboard tab with nothing behind it. The id grammar is the
+   * wire's too, and a test keeps the two in step.
+   *
+   * @minProperties 1
+   * @maxProperties 16
+   * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 48, errorMessage: 'must be lowercase letters, digits, dots, hyphens and underscores' }
+   */
+  boards: Record<string, ScoreBoard>;
+  [key: string]: unknown;
+};
+/**
+ * One named step on the way to a measured achievement's target.
+ *
+ * **A tier is a label, never a second achievement.** The achievement is
+ * unlocked at its `target` and nowhere else; a tier is what a panel calls the
+ * player between here and there — *Silver, 50 of 100*. Modelling each tier as
+ * its own id would be three rows in every board that draws them and three
+ * unlocks a game has to remember to send, where this is one number reported
+ * once and read three ways.
+ *
+ * @group Achievements
+ */
+type AchievementTier = {
+  /**
+   * The reported value this tier is reached at, on the near side of the target.
+   *
+   * @minimum -9007199254740991
+   * @maximum 9007199254740991
+   */
+  at: number;
+  /**
+   * What to call the player who has reached it.
+   *
+   * @category Important
+   * @pattern \S
+   * @maxLength 40
+   * @errorMessage must not be blank
+   */
+  title: string;
+  /**
+   * A glyph for this tier, where it wants its own.
+   *
+   * @pattern \S
+   * @maxLength 8
+   * @errorMessage must not be blank
+   */
+  icon?: string;
+  [key: string]: unknown;
+};
+/**
+ * What makes an achievement measured rather than flagged.
+ *
+ * **`direction` is the one thing that cannot be guessed**, exactly as it cannot
+ * be guessed for a board. `desc` — the default, and what most achievements are
+ * — counts up to the target: *break 100 blocks*. `asc` counts down to it:
+ * *finish under two minutes*, where the value kept is the player's best time
+ * and a smaller one beats a larger. A panel that assumed bigger-is-better would
+ * draw a stopwatch achievement as though every slow run were progress.
+ *
+ * **`format` is how to draw the number**, for the reason a board needs one:
+ * whoever renders this has never run the game and cannot ask it what `112400`
+ * means.
+ *
+ * Both are `ScoreDirection` and `ScoreFormat` rather than types of their own.
+ * "Which way is better" and "how is this number written" are the same two
+ * questions wherever they are asked, and a second spelling of each is two
+ * vocabularies to keep in step and one bug when they drift.
+ *
+ * @group Achievements
+ */
+type AchievementProgress = {
+  /**
+   * The value that unlocks it. Reaching it is the whole of being unlocked.
+   *
+   * Bounded by `Number.MAX_SAFE_INTEGER`, for the reason `SCORE_VALUE_MAX` is:
+   * past there a whole number stops round-tripping through JSON and through a
+   * 64-bit column, and progress toward a target nobody can reproduce is
+   * progress nobody can draw.
+   *
+   * @minimum -9007199254740991
+   * @maximum 9007199254740991
+   */
+  target: number;
+  /** Which way is better. Absent is `desc`: more is better. */
+  direction?: ScoreDirection;
+  /** How to draw the value. Absent is `integer`. */
+  format?: ScoreFormat;
+  /**
+   * Named milestones on the way, ordered toward the target.
+   *
+   * @maxItems 8
+   */
+  tiers?: AchievementTier[];
+  [key: string]: unknown;
+};
+/**
+ * One thing a player can be shown to have done.
+ *
+ * **Two kinds, told apart by one key.** Without `progress` this is a flag: it
+ * happens once, and saying so twice is the same fact twice. With `progress` it
+ * is measured — a count, a distance, a best time — reported as the game goes
+ * and unlocked when the value reaches the target.
+ *
+ * **`secret` withholds the words, never the row.** A secret achievement is
+ * listed while it is locked, so a player can see there is one left, with its
+ * title and detail held back until it is theirs. Hiding the row itself would
+ * make the list's length change under the player, which reads as a bug rather
+ * than as a surprise. It is a courtesy of the panel and not a secret kept from
+ * the machine: the manifest ships beside the bundle and is public, so anybody
+ * who wants the words already has them.
+ *
+ * @group Achievements
+ */
+type Achievement = {
+  /**
+   * What to call it in front of a player.
+   *
+   * @category Important
+   * @pattern \S
+   * @maxLength 40
+   * @errorMessage must not be blank
+   */
+  title: string;
+  /**
+   * One line under the title, saying what it takes.
+   *
+   * @pattern \S
+   * @maxLength 120
+   * @errorMessage must not be blank
+   */
+  detail?: string;
+  /**
+   * A short glyph to draw beside it — an emoji, usually. Eight characters is
+   * enough for an emoji with a modifier on it.
+   *
+   * @pattern \S
+   * @maxLength 8
+   * @errorMessage must not be blank
+   */
+  icon?: string;
+  /** Whether the words are withheld until it is unlocked. See above. */
+  secret?: boolean;
+  /** Present makes this measured rather than flagged. See `AchievementProgress`. */
+  progress?: AchievementProgress;
+  [key: string]: unknown;
+};
+/**
+ * The achievements this game keeps for a player.
+ *
+ * **A map, for the reason `score.boards` is one**: the id travels in
+ * `achievement.unlock`, which is frozen game-side code, so the shape has to
+ * hold a second entry without anything changing meaning.
+ *
+ * **Read by the host, by the client and by the server, and by none of them from
+ * the game.** The site draws this panel for a game sitting in the feed that has
+ * never been run; the server refuses an id no publisher declared. That is what
+ * earns a manifest key rather than a runtime call — the same test `score`
+ * passed.
+ *
+ * @group Achievements
+ * @category Useful
+ */
+type AchievementDeclaration = {
+  /**
+   * The achievements, by id. At least one: an `achievements` key with nothing
+   * in it is a game that meant to declare one and did not. The id grammar is
+   * the wire's too, and a test keeps the two in step.
+   *
+   * @minProperties 1
+   * @maxProperties 128
+   * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 48, errorMessage: 'must be lowercase letters, digits, dots, hyphens and underscores' }
+   */
+  list: Record<string, Achievement>;
+  [key: string]: unknown;
+};
+/**
+ * A device a game can be played with, as one word.
+ *
+ * Hardware rather than API surface: `mouse` and `touch` are separate words even
+ * though a game reads both through one pointer, because what a *client* does
+ * with this is decide whether to put a game in front of somebody who has no way
+ * to play it.
+ *
+ * @group Input
+ */
+type InputDevice = 'keyboard' | 'mouse' | 'touch' | 'gamepad';
+/**
+ * One set of devices that together are enough to play.
+ *
+ * @group Input
+ * @minItems 1
+ * @maxItems 8
+ */
+type InputDeviceSet = InputDevice[];
+/**
+ * A name for something that can *press* an action.
+ *
+ * `key.<code>` names a physical key by `KeyboardEvent.code` — **the code and
+ * never the character**. `KeyA` is the key where A sits on a US keyboard and
+ * stays that key on AZERTY, where it types Q, so a game that binds movement to
+ * codes has WASD under the same four fingers everywhere. `Escape` is the host's:
+ * it leaves fullscreen and pointer lock, which are invisible from inside the
+ * frame, and a game that bound it would lose that fight quietly on every press.
+ *
+ * `pad.south` is the south of either cluster: the face button on one pad and the
+ * d-pad's down on another, which is what makes one binding cover both. Compass
+ * words for both clusters, with no `pad.dpad.down` alias beside
+ * `pad.left.south` — a vocabulary that can never shrink should not start out
+ * doubled. A thumbstick is not one of these; see `InputStick`.
+ *
+ * @group Input
+ * @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)
+ */
+type InputBinding$1 = string;
+/**
+ * A name for a thumbstick — something a game reads, never binds.
+ *
+ * @group Input
+ * @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
+ */
+type InputStick = string;
+/**
+ * What presses an action: at least one binding, and at most 8.
+ *
+ * @group Input
+ * @minItems 1
+ * @maxItems 8
+ */
+type InputBindings = InputBinding$1[];
+/**
+ * One thing a player does, named by the game and bound to whatever produces it.
+ *
+ * **An action is a button and never an axis.** A key, a face button on a pad, a
+ * pointer button and an on-screen button all press the same action, because
+ * from the game's side they are the same event. A thumbstick is not one of
+ * those and is read through its own API — folding the two together would put a
+ * range on every binding that mostly does not have one, and would leave a game
+ * unable to say whether it meant the press or the lean.
+ *
+ * **An object rather than a bare list of bindings**, from the first version,
+ * because two strings are wanted the moment anybody draws this: a `title` for
+ * the remapping screen, which shows actions to a player and cannot show
+ * `move.left`, and a `label` for the face of an on-screen button. Growing a
+ * list into an object later would change what an action's value *is*, which is
+ * the one move the additive rule forbids. Only the object is accepted, even for
+ * an action that needs neither string: one way to write an action is one way to
+ * read it.
+ *
+ * @group Input
+ */
+type InputAction = {
+  /** What presses it. See `InputBinding` for the vocabulary. */
+  bind: InputBindings;
+  /**
+   * What to call it in front of a player, in a remapping screen.
+   *
+   * @pattern \S
+   * @maxLength 40
+   * @errorMessage must not be blank
+   */
+  title?: string;
+  /**
+   * What to draw on an on-screen button: a glyph, or a letter.
+   *
+   * @pattern \S
+   * @maxLength 8
+   * @errorMessage must not be blank
+   */
+  label?: string;
+  [key: string]: unknown;
+};
+/**
+ * Where on the screen a group of on-screen controls sits.
+ *
+ * @group Input
+ */
+type ControlZone = 'left' | 'right' | 'full';
+/**
+ * How a group of on-screen buttons is arranged.
+ *
+ * Arrangement only, with the count doing the rest, so three across and five
+ * down need no words of their own. **A shape nobody recognises is drawn as a
+ * `column`** — the same escape `Obstruction.reserved` is. Whoever renders these
+ * may be older than the game that declared them, and a control that fails to
+ * appear is a game that cannot be played at all. It is still refused at
+ * publish, where saying so is cheap.
+ *
+ * @group Input
+ */
+type ControlShape = 'row' | 'column' | 'diamond' | 'cluster';
+/**
+ * One on-screen control: a group of buttons, or a thumbstick.
+ *
+ * **A button slot names an action; a stick slot names a stick.** The asymmetry
+ * is the hardware's. On-screen buttons have no fixed count or position — three
+ * across, five down, four in a diamond — so there is no standard control to
+ * unify them with, and the action is the only stable name they have. Thumbsticks
+ * come in twos and everybody agrees which is which, so a virtual one says which
+ * it stands for and a game reads the physical stick and this one through one id.
+ *
+ * There is no d-pad here. A d-pad is four buttons wherever it exists — four
+ * entries on the wire from a real pad, four keys on a keyboard — so a layout
+ * that wants one declares four buttons and binds them like anything else.
+ *
+ * @group Input
+ * @if { properties: { type: { const: 'buttons' } }, required: ['type'] }
+ * @then { required: ['buttons'], properties: { as: { type: 'object', additionalProperties: { $ref: '#/definitions/InputBinding' } }, axis: { not: {}, errorMessage: 'is only for a thumbstick' } } }
+ * @else { properties: { as: { $ref: '#/definitions/InputStick' } } }
+ */
+type ControlSlot = {
+  type: 'buttons' | 'thumbstick';
+  /**
+   * `buttons` only: the actions this control presses, in drawing order.
+   *
+   * @minItems 1
+   * @maxItems 8
+   */
+  buttons?: string[];
+  /** `buttons` only. See `ControlShape`. Absent is `column`. */
+  shape?: ControlShape;
+  /**
+   * What this control stands in for on a standard pad.
+   *
+   * On a thumbstick it is the stick id a game reads — `pad.left.stick` — so one
+   * `onStick` sees the physical stick and this one alike. Left out, the stick is
+   * only itself, which a game reads as `controls.<id>`. On a group of buttons it
+   * is a map from action to standard button, optional and rarely wanted: a game
+   * whose bindings already name `pad.south` needs nothing here, and this is for
+   * one that also wants the low-level path to see the press.
+   */
+  as?: InputStick | Record<string, InputBinding$1>;
+  /** `thumbstick` only. See `ControlAxis`. Absent, the stick moves both ways. */
+  axis?: ControlAxis;
+  [key: string]: unknown;
+};
+/**
+ * The one direction an on-screen thumbstick moves in: `x` across, `y` up and
+ * down.
+ *
+ * For a game that steers along one line — a runner sliding left and right, a
+ * paddle — where a stick that also leans up and down is a thumb wandering off
+ * the line it means. The drawn stick becomes a track along that axis and always
+ * reports the other one as 0. **Only the drawn stick:** a real pad's stick still
+ * reports both, so a game reads the axis it wants from either.
+ *
+ * Whoever draws the controls may be older than the game, and draw a stick that
+ * moves both ways. The SDK zeroes the other axis whatever the renderer reports,
+ * so the game hears one axis either way.
+ *
+ * @group Input
+ */
+type ControlAxis = 'x' | 'y';
+/**
+ * The controls in one zone of a layout, by id.
+ *
+ * @group Input
+ * @maxProperties 8
+ * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 48, errorMessage: 'must be a control id of lowercase letters, digits, dots, hyphens and underscores' }
+ */
+type ControlZoneSlots = Record<string, ControlSlot>;
+/**
+ * One named arrangement of on-screen controls.
+ *
+ * A game may declare several and switch between them — a menu wants different
+ * controls from play, and a driving section different ones again — which is why
+ * they are named rather than there being one. A zone nobody knows is a layout
+ * from a newer SDK, which the additive rule says must still load, so whoever
+ * draws it simply has nowhere to put it.
+ *
+ * @group Input
+ */
+type ControlLayout = {
+  left?: ControlZoneSlots;
+  right?: ControlZoneSlots;
+  full?: ControlZoneSlots;
+  [key: string]: unknown;
+};
+/**
+ * What a game says about how it is played.
+ *
+ * **It passes the manifest's test twice.** The host must know before the bundle
+ * runs — whether on-screen controls apply at all, and what a remapping screen
+ * offers, are settled before there is a game to ask — and it is read by parties
+ * that never run the game: a feed deciding whether to show a keyboard-only game
+ * to somebody holding a phone, and a remapping screen opened from outside a run.
+ *
+ * Action, control and layout ids follow the grammar the wire does, and a test
+ * keeps the two in step.
+ *
+ * @group Input
+ * @category Useful
+ */
+type InputDeclaration = {
+  /**
+   * The sets of hardware this game can be played with: any one set, every
+   * member of which must be present.
+   *
+   * A flat list of alternatives rather than a tree of `any` and `all`. Every
+   * real answer is a handful of alternatives, and this one renders straight into
+   * *needs a keyboard and a mouse* without anybody having written a solver.
+   *
+   * **The publisher's claim, taken at its word**, exactly as `orientation` is:
+   * nothing here checks it against the bindings. It cannot be checked. A game is
+   * free to read the platform directly — raw key events, an accelerometer, a
+   * microphone — and that is a stated allowance rather than an oversight, so
+   * what a game *binds* never implies what it can be played with.
+   *
+   * @minItems 1
+   * @maxItems 8
+   */
+  supported?: InputDeviceSet[];
+  /**
+   * The actions, by id.
+   *
+   * @maxProperties 64
+   * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 48, errorMessage: 'must be lowercase letters, digits, dots, hyphens and underscores' }
+   */
+  actions?: Record<string, InputAction>;
+  /**
+   * Named arrangements of on-screen controls. See `ControlLayout`.
+   *
+   * @maxProperties 8
+   * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 48, errorMessage: 'must be a layout name of lowercase letters, digits, dots, hyphens and underscores' }
+   */
+  controls?: Record<string, ControlLayout>;
+  [key: string]: unknown;
+};
+/**
+ * The index signature is the additive-only rule applied to this file: a game
+ * built against a newer SDK declares keys an older host has never heard of, and
+ * must still run there. It costs a typo in a manifest literal going unnoticed
+ * by the compiler, which the validator catches instead.
+ *
+ * @group Manifest
+ * @category Important
+ */
+type GameManifest = {
+  /** @category Important */
+  schema: typeof MANIFEST_SCHEMA;
+  /**
+   * Stable across versions, and unique among its publisher's games: it is the
+   * second half of the address the game is published at, `owner/id`, and the
+   * name every new version is filed under. Lowercase, url-safe, and no two
+   * hyphens in a row, because it ends up in urls and storage keys.
+   *
+   * @category Important
+   * @pattern ^[a-z0-9]+(?:-[a-z0-9]+)*$
+   * @maxLength 64
+   * @errorMessage must be lowercase letters, digits and hyphens
+   */
+  id: string;
+  /**
+   * The game's own version, `MAJOR.MINOR.PATCH`. Ours to read, never to parse for meaning.
+   *
+   * @category Important
+   * @pattern ^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$
+   * @errorMessage must look like 1.0.0
+   */
+  version: string;
+  /**
+   * @category Important
+   * @pattern \S
+   * @maxLength 60
+   * @errorMessage must not be blank
+   */
+  title: string;
+  /**
+   * A sentence or two about the game, shown beside its title.
+   *
+   * @category Useful
+   * @pattern \S
+   * @maxLength 500
+   * @errorMessage must not be blank
+   */
+  description?: string;
+  /**
+   * A picture of the game, shown wherever a link to it is pasted — a chat, a
+   * post, a message.
+   *
+   * The path of a PNG, JPEG or WebP file, relative to the config the manifest
+   * is in, and at most `COVER_MAX_BYTES`. `hopple publish` uploads it beside
+   * the game. 1200 × 630 is the shape every platform shows whole; without one,
+   * a link shows Hopple's own card.
+   *
+   * @category Useful
+   * @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"
+   */
+  cover?: string;
+  /** @category Important */
+  orientation: Orientation;
+  /**
+   * The `@hopple/sdk` version the game was built against, optionally prefixed
+   * with `^` or `~`.
+   *
+   * Recorded rather than enforced: what the host and the game actually have to
+   * agree on is the protocol version, which the handshake settles. This is for
+   * diagnostics — "every game that broke was built against 2.3" is a question
+   * worth being able to ask. Deliberately far narrower than everything npm
+   * accepts: a grammar we can read in one line is a grammar three packages can
+   * agree on.
+   *
+   * @category Important
+   * @pattern ^[\^~]?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$
+   * @errorMessage must be a version like 1.0.0, ^1.0.0 or ~1.0.0
+   */
+  sdk: string;
+  /**
+   * How the game wants the host's furniture handled. See `InsetMode`.
+   *
+   * @category Useful
+   */
+  layout?: LayoutDeclaration;
+  /**
+   * The custom events this game sends. See `AnalyticsDeclaration`.
+   *
+   * @category Useful
+   */
+  analytics?: AnalyticsDeclaration;
+  /**
+   * That this game keeps state, and roughly how much. See `SaveDeclaration`.
+   *
+   * @category Useful
+   */
+  save?: SaveDeclaration;
+  /**
+   * The boards this game keeps a score on. See `ScoreDeclaration`.
+   *
+   * @category Useful
+   */
+  score?: ScoreDeclaration;
+  /**
+   * What a player can be shown to have done. See `AchievementDeclaration`.
+   *
+   * @category Useful
+   */
+  achievements?: AchievementDeclaration;
+  /**
+   * How this game is played, and what it draws to be played with. See `InputDeclaration`.
+   *
+   * @category Useful
+   */
+  input?: InputDeclaration;
+  /**
+   * What this game makes noise with, one channel at a time, or `null` for a
+   * game that makes none. See `AudioDeclaration`.
+   *
+   * @category Important
+   */
+  audio: AudioDeclaration | null;
+  [key: string]: unknown;
+};
+/**
+ * A game project's hopple config: `hopple.config.ts`, `hopple.config.js` or
+ * `hopple.config.json`, beside the project's `package.json`.
+ *
+ * Everything the `hopple` command line needs to know about a project, in one
+ * place: how to build the game, which built file is the game, and the manifest
+ * that says what the game is. Only the manifest leaves the machine, uploaded
+ * beside the page as `game.manifest.json`. A TypeScript or JavaScript config
+ * default-exports one of these; a JSON config is one.
+ *
+ * ```ts
+ * import type { HoppleConfig } from '@hopple/sdk';
+ *
+ * export default {
+ *   build: 'npm run build',
+ *   page: 'dist/index.html',
+ *   manifest: { schema: 1, id: 'my-game', version: '0.1.0', title: 'My Game', orientation: 'portrait', sdk: '^0.1.0', audio: null },
+ * } satisfies HoppleConfig;
+ * ```
+ *
+ * @group Manifest
+ * @category Important
+ */
+type HoppleConfig = {
+  /** Where an editor finds this file's schema, in a JSON config. Read by nothing else. */
+  $schema?: string;
+  /**
+   * The command that builds the game, run in the config's directory before
+   * `hopple dev`, `check` and `publish` use it, so none of them sees a stale
+   * build. Leave it out for a game with nothing to build.
+   *
+   * @pattern \S
+   * @errorMessage must be the command that builds the game, like "npm run build"
+   */
+  build?: string;
+  /**
+   * The built page, relative to the config: the one file that is published,
+   * so it has to hold the whole game.
+   *
+   * @pattern \.[Hh][Tt][Mm][Ll]?$
+   * @errorMessage must be the built .html file, like "dist/index.html"
+   */
+  page: string;
+  /** What the game is. Uploaded beside the page, and read by every host before the game runs. */
+  manifest: GameManifest;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/achievements.d.ts
+/**
+ * Where this player stands on one achievement.
+ *
+ * @group Achievements
+ */
+type AchievementStatus<Id extends string = string> = {
+  readonly id: Id;
+  /** Whether it is theirs. */
+  readonly unlocked: boolean;
+  /** The host's clock, when it became theirs. Absent while it is not. */
+  readonly at?: number;
+  /**
+   * The best value reported so far, on a measured achievement. Absent for one
+   * nothing has been reported against, which is not the same as zero.
+   */
+  readonly progress?: number;
+};
+/**
+ * Every achievement this host takes, in the order the manifest declares them,
+ * and whether the host knows where this player stands on them.
+ *
+ * `known: false` is the host not having an answer — a store still replying, a
+ * client that cannot reach its server — and its items carry an id and nothing
+ * else, so there is no `unlocked` to read until `known` has been checked. A
+ * game that drew "locked" there would be telling somebody they had lost
+ * everything because a network was slow.
+ *
+ * @group Achievements
+ */
+type AchievementStanding<Id extends string = string> = {
+  readonly known: true;
+  readonly items: readonly AchievementStatus<Id>[];
+} | {
+  readonly known: false;
+  readonly items: readonly {
+    readonly id: Id;
+  }[];
+};
+/** @group Achievements */
+type AchievementListener<Id extends string = string> = (now: AchievementStanding<Id>, previous: AchievementStanding<Id>) => void;
+/**
+ * @group Achievements
+ * @category Important
+ */
+type Achievements<Id extends string = string, Measured extends string = Id> = {
+  /**
+   * Whether this host keeps achievements at all. Known at the handshake: a
+   * game with none leaves out its achievements screen. Reporting to a host
+   * without them does nothing, so a game need not check before it reports.
+   */
+  readonly available: boolean;
+  /**
+   * Where this player stands on every achievement, read without asking.
+   *
+   * The same object until something changes, and frozen, so a game can hold
+   * on to it and compare it with `===`.
+   */
+  readonly standing: AchievementStanding<Id>;
+  /**
+   * Runs when `standing` changes: the host's answer arriving after the welcome,
+   * or a report moving something.
+   *
+   * Not called for the opening standing: that arrived with the welcome, before
+   * there was anything to listen with. Read `standing` once and subscribe.
+   */
+  on(listener: AchievementListener<Id>): Unsubscribe;
+  /**
+   * This achievement is theirs, whatever its progress says. The host announces
+   * it the first time, so a game that calls this on every level-up shows one
+   * banner.
+   *
+   * Legitimate on a measured achievement too, and it finishes it: the progress
+   * goes to the target rather than leaving something unlocked at 40 of 100.
+   *
+   * An id this game's manifest never declared is reported to `onError`, as an
+   * author's mistake and not a player's.
+   */
+  unlock(id: Id): void;
+  /**
+   * How far along a measured achievement this player is, as an absolute value.
+   *
+   * *At 40*, not *add one*. The host keeps whichever value the manifest calls
+   * better — the larger on an ordinary count, the smaller on a best time — so
+   * reporting the same number twice does nothing, and reporting a worse one is
+   * not a regression. Reaching the target unlocks it.
+   *
+   * Against an achievement declared as a flag, the host refuses it and the
+   * refusal is reported to `onError`: there is no target to move toward, and a
+   * host that quietly unlocked it would be hiding the mistake.
+   */
+  progress(id: Measured, value: number): void;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/analytics.d.ts
+/**
+ * @group Analytics
+ * @category Important
+ */
+type Analytics<Events extends object = Record<string, AnalyticsProps>> = {
+  /**
+   * Say that something happened.
+   *
+   * The name must be one the game declared in its manifest, or the host will
+   * refuse it. A name or a prop that cannot travel goes to `onError` — the game
+   * author's own channel, so a mistake is loud where it is cheap and harmless
+   * where it is not — and a refused prop costs its column rather than the event.
+   */
+  track<Event extends keyof Events & string>(name: Event, props?: Events[Event]): void;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/audio.d.ts
+/**
+ * Something about the game's sound changed: the host's order, the player's
+ * mute, a fader. Read what you need — `volume(channel)`, `allowed` — and apply
+ * it at once.
+ *
+ * @group Audio
+ */
+type AudioListener = () => void;
+/**
+ * @group Audio
+ * @category Important
+ */
+type Audio<Channel extends string = string> = {
+  /**
+   * Whether the host lets the game make sound now. Known as soon as `init`
+   * resolves.
+   *
+   * `volume()` is already 0 while this is `false`, so a game that mixes from
+   * `volume()` obeys it without reading it. Read it to pause an engine's own
+   * sound rather than leave it playing silently.
+   */
+  readonly allowed: boolean;
+  /**
+   * Everything off, whatever the faders say.
+   *
+   * Not the same fact as `master === 0`, and a game must not fold the two
+   * together: a player who mutes and unmutes expects the mix they had back.
+   */
+  readonly muted: boolean;
+  /** The fader over the whole game, `0`–`1`, ignoring mute. */
+  readonly master: number;
+  /** The whole of what the host last said. Frozen; a new object on every change. */
+  readonly state: AudioState;
+  /**
+   * How loud one of this game's channels should actually come out, `0`–`1`.
+   *
+   * **The number to multiply a sound by, and the only one worth reading.** It
+   * is the host's order, mute, the master fader and the channel's own, already
+   * folded — so a game
+   * that writes `gain.value = sdk.audio.volume('music')` is correct, and one
+   * that reads the three separately is one refactor away from forgetting mute.
+   *
+   * A channel this game never declared reads as its master, which is what a
+   * game asking about a channel its manifest does not carry deserves: audible,
+   * and governed by the one fader that certainly exists. Called with nothing,
+   * or with `master`, it is the master fader itself.
+   */
+  volume(channel?: Channel): number;
+  /**
+   * The channel's own fader, unmixed and ignoring mute.
+   *
+   * For a game drawing its own volume screen. What a sound is multiplied by is
+   * `volume()`, and mixing with this one instead is how a mute button stops
+   * working.
+   */
+  channel(id: Channel): number;
+  /**
+   * Told whenever any of it changes: the host's order, and the moment the
+   * player mutes or moves a fader.
+   *
+   * **Apply it at once.** The host is answered as soon as every listener has
+   * been called, and nothing returned is waited for — a mute that fades out
+   * over half a second is half a second of sound the player asked not to hear.
+   * A ramp of a few milliseconds, to keep a gain jump from clicking, is fine;
+   * it just is not something to wait on.
+   *
+   * Not called for the opening state: that arrived with the welcome, before
+   * there was anything to listen with. Apply it once and subscribe.
+   */
+  on(listener: AudioListener): Unsubscribe;
+  /**
+   * A gain node for one channel of a Web Audio context, kept at that channel's
+   * volume: connect every sound on the channel to it instead of to
+   * `context.destination`.
+   *
+   * The context is looked after too: suspended whenever sound is not
+   * `allowed` (and the host told only once it has gone quiet), resumed when it
+   * is, and resumed by the player's first press in the frame where the browser
+   * started it suspended. The same context and channel always give the same
+   * node.
+   */
+  output(context: AudioContext, channel?: Channel): GainNode;
+  /**
+   * Keep an `<audio>` or `<video>` element at one channel's volume, and paused
+   * whenever sound is not `allowed` — playing again when it is, if it was
+   * playing when it stopped.
+   *
+   * Returns a function that lets the element go again.
+   */
+  media(element: HTMLMediaElement, channel?: Channel): Unsubscribe;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/info.d.ts
+/**
+ * What the host said, frozen.
+ *
+ * Frozen because it is a record of what a game was told, and a game that could
+ * edit it would be writing a bug that only surfaces somewhere else entirely,
+ * when something reads the field back and believes it.
+ *
+ * @group Info
+ * @category Important
+ */
+type Info = Readonly<{
+  app: Readonly<AppInfo>;
+  game: Readonly<GameInfo>;
+  player: Readonly<PlayerInfo>;
+  device: Readonly<DeviceInfo>;
+}>;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/layout.d.ts
+/**
+ * How much of each edge belongs to the host. CSS pixels.
+ *
+ * @group Layout
+ * @category Useful
+ */
+type Insets = {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+};
+/**
+ * What is over the game. Facts only — no projection, because which projection
+ * is the right one is the game's to decide.
+ *
+ * @group Layout
+ */
+type LayoutState = {
+  /**
+   * The frame the rectangles are measured against, as the host last set it:
+   * the page's own window, so `innerWidth` and `innerHeight` agree with it from
+   * the moment `init` resolves.
+   */
+  readonly frame: Size;
+  /**
+   * Everything over the frame, whoever put it there: the host's rail and the
+   * device's notch, and the SDK's own on-screen controls where a game is
+   * showing some. One list, because a game avoids all of them the same way.
+   */
+  readonly obstructions: readonly Obstruction[];
+  /**
+   * The default projection of everything reserved onto the four edges, for the
+   * majority of games that want exactly that.
+   *
+   * It is a convenience, not the truth: a game that wants to ignore cutouts, or
+   * to keep clear of overlays as well, calls `insetsFrom` over whatever subset
+   * of `obstructions` it means. A game that scrolls wants a second reading
+   * beside this one — see `InsetPolicy`.
+   */
+  readonly insets: Insets;
+};
+/** @group Layout */
+type LayoutListener = (now: LayoutState, previous: LayoutState) => void;
+/**
+ * @group Layout
+ * @category Important
+ */
+type Layout = LayoutState & {
+  /** Runs whenever the frame or the rectangles change. */
+  on(listener: LayoutListener): Unsubscribe;
+};
+/**
+ * Which rectangles an inset is being asked about.
+ *
+ * `all` is the ordinary reading and the default. `strips` is for the one thing
+ * insets cannot express: see `only` below.
+ *
+ * @group Layout
+ * @category Useful
+ */
+type InsetPolicy = {
+  /**
+   * `all` — every reserved rectangle. `strips` — only those that run the whole
+   * length of an edge, which on a real host means the rail and nothing else.
+   *
+   * The distinction exists because of scrollbars, and it is worth spelling out
+   * since nothing else in this file has to care. A scrollbar is painted on the
+   * border edge of whatever scrolls, and padding lives inside that edge — so a
+   * game that scrolls cannot move its scrollbar off the host's rail by paying
+   * `insets`, however honestly it pays them. The only thing that moves it is
+   * making the scrolling element itself stop short, which means insets that say
+   * *the host has taken this whole edge* rather than *the host is somewhere over
+   * here*.
+   *
+   * A corner control is the case the two answers differ on, and `strips` drops
+   * it deliberately: it costs the least area on a side edge, so `all` turns a
+   * 56-pixel square into a 56-pixel column down the entire height — most of a
+   * sidebar's worth of scrolling content for one button. What a game loses by
+   * dropping it is the far end of its scrollbar, under a corner the host's
+   * control was always going to sit on.
+   *
+   * Content is the other half and is not this function's problem: keeping text
+   * and buttons off a corner control is what `all` and a padding are for, and
+   * a game doing both reads this twice. The demo does.
+   */
+  only?: 'all' | 'strips';
+};
+/**
+ * The cheapest set of edge insets that covers every reserved rectangle.
+ *
+ * Each rectangle is pushed onto one of the four edges — the one where it costs
+ * the least area, which for a corner is the shorter way out. That is what makes
+ * the same corner control a top inset on a phone and a right inset on a desktop
+ * window without anybody deciding it twice.
+ *
+ * A rectangle touching no edge at all still has to be covered by something,
+ * since an inset is all this can say; it gets pushed to its nearest edge and
+ * takes the gap with it. Hosts are expected not to do that, and a game that
+ * wants the truth about one should read the rectangles.
+ *
+ * Exported because it is the whole policy in one pure function: a game that
+ * wants to project differently, or against a size of its own choosing, can.
+ *
+ * @group Layout
+ * @category Useful
+ */
+declare function insetsFrom(obstructions: readonly Obstruction[], frame: Size, policy?: InsetPolicy): Insets;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/names.d.ts
+/**
+ * The keys of a declared map, or `string` where the map is not a literal one —
+ * which is what a manifest typed as the wide `GameManifest` gives — and
+ * `never` where nothing is declared.
+ *
+ * @group Names
+ */
+type DeclaredNames<T> = T extends object ? string extends keyof T ? string : Extract<keyof T, string> : never;
+/**
+ * An action the manifest declares under `input.actions`.
+ *
+ * @group Names
+ */
+type ActionName<M> = M extends {
+  input?: {
+    actions?: infer A;
+  };
+} ? DeclaredNames<NonNullable<A>> : never;
+/**
+ * An on-screen control layout the manifest declares under `input.controls`.
+ *
+ * @group Names
+ */
+type LayoutName<M> = M extends {
+  input?: {
+    controls?: infer C;
+  };
+} ? DeclaredNames<NonNullable<C>> : never;
+/**
+ * A score board the manifest declares under `score.boards`.
+ *
+ * @group Names
+ */
+type BoardName<M> = M extends {
+  score?: {
+    boards?: infer B;
+  };
+} ? DeclaredNames<NonNullable<B>> : never;
+/**
+ * An achievement the manifest declares under `achievements.list`.
+ *
+ * @group Names
+ */
+type AchievementName<M> = M extends {
+  achievements?: {
+    list?: infer L;
+  };
+} ? DeclaredNames<NonNullable<L>> : never;
+/**
+ * An achievement declared with `progress`: the only kind `progress()` takes.
+ *
+ * @group Names
+ */
+type MeasuredName<M> = M extends {
+  achievements?: {
+    list?: infer L;
+  };
+} ? string extends keyof NonNullable<L> ? string : { [K in keyof NonNullable<L>]: NonNullable<L>[K] extends {
+  progress: object;
+} ? K : never; }[keyof NonNullable<L>] & string : never;
+/**
+ * An audio channel the manifest declares under `audio.channels`.
+ *
+ * @group Names
+ */
+type ChannelName<M> = M extends {
+  audio?: {
+    channels?: infer C;
+  } | null;
+} ? DeclaredNames<NonNullable<C>> : never;
+/**
+ * An analytics event the manifest declares under `analytics.events`.
+ *
+ * @group Names
+ */
+type EventName<M> = M extends {
+  analytics?: {
+    events?: infer E;
+  };
+} ? DeclaredNames<NonNullable<E>> : never;
+/**
+ * What a property declared as `string`, `number` or `boolean` holds.
+ *
+ * @group Names
+ */
+type DeclaredValue<T> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : AnalyticsValue;
+/**
+ * Every declared event with the properties it was declared with, each
+ * optional and typed as declared.
+ *
+ * @group Names
+ */
+type EventProps<M> = M extends {
+  analytics?: {
+    events?: infer E;
+  };
+} ? string extends keyof NonNullable<E> ? Record<string, AnalyticsProps> : { [K in keyof NonNullable<E> & string]: { [P in keyof NonNullable<E>[K]]?: DeclaredValue<NonNullable<E>[K][P]>; }; } : Record<never, never>;
+/**
+ * One of the sticks a game reads: a gamepad's, or an on-screen thumbstick
+ * acting as one, or an on-screen thumbstick of its own (`controls.<name>`).
+ * `pad.stick` is whichever of a pad's two the player is using.
+ *
+ * @group Names
+ */
+type StickName = 'pad.left.stick' | 'pad.right.stick' | 'pad.stick' | `controls.${string}`;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/input/state.d.ts
+/**
+ * Where the pointer is, in the frame's own coordinates.
+ *
+ * @group Input
+ */
+type PointerState = {
+  x: number;
+  y: number;
+  /** Whether its primary button — or the finger — is down. */
+  down: boolean;
+};
+/**
+ * How far a stick is pushed, each axis in −1..1.
+ *
+ * @group Input
+ */
+type StickState = {
+  x: number;
+  y: number;
+};
+/**
+ * @group Input
+ */
+type ActionListener<Action extends string = string> = (down: boolean, action: Action) => void;
+/**
+ * @group Input
+ */
+type StickListener = (value: StickState, stick: string) => void;
+/**
+ * @group Input
+ */
+type PointerListener = (pointer: PointerState | null) => void;
+/**
+ * What was true at one moment, and what has happened since the last one.
+ *
+ * Frozen and detached: reading a snapshot twice in a frame gives the same
+ * answers, and holding one past the frame it was taken in tells the truth about
+ * a moment that has passed rather than lying about the present.
+ *
+ * @group Input
+ */
+type InputSnapshot<Action extends string = string> = {
+  /** Whether the action is down right now. */
+  pressed(action: Action): boolean;
+  /**
+   * Whether it went down since the last read.
+   *
+   * True even when it has already come back up — a tap shorter than one frame
+   * is a real press that pure level polling would miss entirely, and the
+   * commonest thing a player does on a touchscreen.
+   */
+  started(action: Action): boolean;
+  /** Whether it came up since the last read. */
+  ended(action: Action): boolean;
+  /** How far a stick is pushed. `pad.stick` reads whichever one is off centre. */
+  stick(stick: StickName): StickState;
+  /** Where the pointer is, or `null` for a pointer that is nowhere. */
+  pointer: PointerState | null;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/input/controls.d.ts
+/**
+ * The name a host leaves its input shim under.
+ *
+ * Beside `SHIM` in spirit and separate from it in fact: that one is a channel a
+ * platform must provide for a game to speak at all, and this one is an opinion
+ * about drawing that most hosts will not have. A game with no shim draws the
+ * default controls and is completely playable — which is what an embed on
+ * somebody else's page gets, since there is nowhere for anyone to inject one.
+ *
+ * @group Input
+ */
+declare const INPUT_SHIM = "__HOPPLE_INPUT__";
+/**
+ * One control, as a renderer is given it. Resolved: no ids left to look up.
+ *
+ * @group Input
+ */
+type ControlModelSlot = {
+  id: string;
+  type: 'buttons' | 'thumbstick';
+  /** Always a shape this SDK knows. An unfamiliar one has already become `column`. */
+  shape: InputLayoutShape;
+  /**
+   * For `buttons`: what each one presses, what to draw on it, and the standard
+   * control it stands in for where the layout said one.
+   */
+  buttons: readonly {
+    action: string;
+    label: string;
+    as?: string;
+  }[];
+  /** For `thumbstick`: the stick id it drives. */
+  stick: string;
+  /**
+   * For `thumbstick`: the one axis it moves along, where the layout held it to
+   * one. Absent, it moves both ways. A renderer that draws it freely anyway is
+   * still correct: the SDK zeroes the other axis of whatever is reported.
+   */
+  axis?: InputLayoutAxis;
+};
+/**
+ * @group Input
+ */
+type ControlModelZone = {
+  zone: InputLayoutZone;
+  controls: readonly ControlModelSlot[];
+};
+/**
+ * A whole layout, resolved against the manifest's actions.
+ *
+ * @group Input
+ */
+type ControlModel = {
+  /** Which named layout this is. */
+  layout: string;
+  zones: readonly ControlModelZone[];
+  /** The frame the controls are being drawn on, when it is known. */
+  frame: Size;
+  /**
+   * How much of that frame the host has taken along each edge.
+   *
+   * The host's furniture only — its rail, its corner control, the device's
+   * notch. Emphatically *not* the pad's own rectangles, which reach a game as
+   * obstructions of kind `controls` and would, if they were projected in here,
+   * inset the pad by the pad on every pass until it walked off the frame.
+   * Whoever fills this in owes that filter; `index.ts` pays it.
+   *
+   * Zero is the ordinary answer and always a safe one: a host that reserved the
+   * frame instead of drawing over it has already shrunk `frame` clear of its
+   * own furniture, and a host too old to say anything has said nothing. Both
+   * land here as four zeroes and the pad sits where it always sat.
+   */
+  insets: Insets;
+  /**
+   * How a thumbstick meets a thumb, as the player set it on their host.
+   *
+   * `floating`: drawn where the layout puts it, so a player can see there is a
+   * stick, and brought to wherever a thumb lands on its side of the screen, so
+   * the place they first touch is the centre. `fixed`: moved only from where
+   * it is drawn. A renderer that ignores this draws `fixed`, which is still a
+   * stick a game can be played with.
+   */
+  sticks: InputSticks;
+};
+/**
+ * How a renderer says something happened.
+ *
+ * The only way out of a renderer, replaced or not. A shim reports and the SDK
+ * decides: that is what keeps a replaced renderer from being able to leave an
+ * action held forever.
+ *
+ * @group Input
+ */
+type ControlReport = {
+  /** `index` is into the control's own `buttons`. */
+  press(control: string, index: number, down: boolean): void;
+  /** A stick's position, each axis in −1..1 and already inside the unit circle. */
+  move(control: string, x: number, y: number): void;
+};
+/**
+ * What a host may install to change how controls are drawn.
+ *
+ * **Every hook is optional and every one is wrapped.** A shim that throws is
+ * dropped back to the default for that hook and reported to `onError`, because
+ * a replaceable renderer is otherwise a way for one host to ship a broken pad to
+ * every game it runs at once.
+ *
+ * **The SDK declares the version and the shim adapts.** This file is frozen
+ * inside bundles that shipped months before any given shim was written, so the
+ * dangerous direction is a new shim meeting an old SDK — and it is safe by
+ * construction if the shim is the side doing the adapting. A shim reads
+ * `request.contract` and answers with what that version can carry.
+ *
+ * @group Input
+ */
+type InputShim = {
+  /** The contract version this shim was written against. `1` today. */
+  v: 1;
+  /**
+   * Whether to draw controls for this layout at all.
+   *
+   * The host's half of the answer; the game's half is having asked. Returning
+   * nothing leaves the decision alone, which is what a shim that only wanted to
+   * restyle should do.
+   */
+  decide?(request: {
+    layout: string;
+    frame: Size;
+    /** What the host has taken along each edge — see `ControlModel.insets`. */
+    insets: Insets;
+    contract: number;
+  }): boolean | undefined;
+  /**
+   * How far a stick must move before it counts, 0 to 1.
+   *
+   * The host's rather than the game's, because it is an accessibility setting
+   * before it is a taste: a player whose hands shake needs a wider dead region
+   * in every game they open, not in the ones that happened to think of it.
+   */
+  deadzone?: number;
+  /** A tick when a control is pressed. Absent where the platform has none. */
+  haptic?(kind: 'press' | 'release'): void;
+  /** Called with the root once, to set custom properties or add a stylesheet. */
+  style?(root: ShadowRoot, request: {
+    layout: string;
+    frame: Size;
+  }): void;
+  /**
+   * Draw the controls instead of the SDK.
+   *
+   * Given the root, the resolved model and the one way back. Returns a teardown,
+   * which is called before the next render and when the controls are hidden.
+   */
+  render?(root: ShadowRoot, model: ControlModel, report: ControlReport): (() => void) | void;
+};
+/**
+ * @group Input
+ */
+declare function isInputShim(value: unknown): value is InputShim;
+/**
+ * The contract version this SDK speaks. Told to a shim so it can answer in kind.
+ *
+ * `2` added `insets` — to the model a renderer is given, to what `decide` is
+ * asked, and as four custom properties the default sheet spends. Purely
+ * additive: a `v: 1` shim that reads none of them behaves exactly as it did.
+ *
+ * `3` added `axis` to a thumbstick in the model. Additive again: a shim that
+ * draws the stick moving both ways still gives the game one axis, because the
+ * other is dropped from what it reports.
+ *
+ * `4` added `sticks` to the model: whether the player wants a thumbstick that
+ * comes to their thumb. Additive: a shim that reads nothing of it draws the
+ * stick where it always did.
+ *
+ * @group Input
+ */
+declare const INPUT_CONTRACT = 4;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/input/bindings.d.ts
+/**
+ * The standard mapping's buttons, by index, as the names this SDK uses.
+ *
+ * `Gamepad.mapping === 'standard'` is what makes these indices mean anything;
+ * a pad that reports anything else is read for its axes and ignored for its
+ * buttons, because an unmapped index is a number with no meaning attached.
+ *
+ * **The left cluster is the d-pad and the right is the faces**, which is what
+ * makes `pad.south` cover both *A* and *down* with one word. Compass positions
+ * rather than letters throughout: A and B are swapped between the two
+ * best-selling controllers, so a name built on them is wrong for half the
+ * players who read it.
+ *
+ * @group Input
+ */
+declare const PAD_BUTTONS: readonly (string | null)[];
+/**
+ * The binding a player would actually use, given what they are holding.
+ *
+ * A game that draws one prompt for an action with four bindings has to be told
+ * which one, and the answer is the one their hands are on. Falls back to the
+ * first declared binding, which is the game author's own idea of the primary
+ * one.
+ *
+ * @group Input
+ * @category Useful
+ */
+declare function preferredBinding(bind: readonly string[], scheme: InputScheme): string | undefined;
+/**
+ * Whether a binding is one the player could press with what they are using.
+ *
+ * @group Input
+ * @category Useful
+ */
+declare function servesScheme(binding: string, scheme: InputScheme): boolean;
+/**
+ * What to write on the screen for one binding.
+ *
+ * **Best effort, and the host is allowed to do better.** Whether the south face
+ * button says *A* or *B* depends on whose controller it is, and
+ * `Gamepad.id` is free text that varies by browser and by operating system — so
+ * a host that genuinely knows, because it is a native app, sends its own label
+ * and this is what fills in when nobody did. Getting it slightly wrong is a
+ * prompt a player can still follow; refusing to draw one is a game that never
+ * says which button to press.
+ *
+ * @group Input
+ * @category Useful
+ */
+declare function labelFor(binding: string, scheme: InputScheme): string;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/input/index.d.ts
+/**
+ * How far a stick moves before it counts, where no shim has an opinion.
+ *
+ * @group Input
+ * @category Useful
+ */
+declare const DEADZONE = 0.15;
+/**
+ * What presses each action, and what the player is pressing with: the part of
+ * input that is state rather than a stream of presses.
+ *
+ * @group Input
+ */
+type InputState<Action extends string = string> = {
+  /**
+   * What presses each action, and what to call it in front of a player.
+   *
+   * `mapping.shoot.label` is the whole reason this is readable: it is *Z* on a
+   * keyboard, a glyph on whatever pad the player picked up, and the label the
+   * manifest gave the on-screen button on a touch screen — the name written on
+   * whatever the player would press. So a game writes one prompt and is right
+   * on all of them. An action can be missing, so keep a fallback.
+   */
+  readonly mapping: Readonly<Partial<Record<Action, InputBinding>>>;
+  /** What the player is using right now. */
+  readonly scheme: InputScheme;
+};
+/**
+ * A player rebound something, or picked up another device. `previous` says
+ * which: a different `scheme` is a new device, a different `mapping` under the
+ * same one is a rebinding.
+ *
+ * @group Input
+ */
+type InputListener<Action extends string = string> = (now: InputState<Action>, previous: InputState<Action>) => void;
+/**
+ * What the player is doing, as the frame sees it: `sdk.input`.
+ *
+ * @group Input
+ * @category Important
+ */
+type Input<Action extends string = string, Layout extends string = string> = InputState<Action> & {
+  /**
+   * Run this whenever an action goes down or comes up.
+   *
+   * One press however many things are bound to it: an action held by a key and
+   * a pad button at once goes down with the first and up with the last, rather
+   * than flickering as a player moves between them.
+   *
+   * An action the manifest never declared is reported to `onError`: it would
+   * never fire.
+   */
+  onAction(action: Action, listener: ActionListener<Action>): Unsubscribe;
+  /** Run this when a stick moves. `pad.stick` hears from either of them. */
+  onStick(stick: StickName, listener: StickListener): Unsubscribe;
+  /** Run this when the pointer moves or its button changes. `null` is *nowhere*. */
+  onPointer(listener: PointerListener): Unsubscribe;
+  /**
+   * Run this when `mapping` or `scheme` changes: a player rebinds something, or
+   * picks up a controller. Frozen and replaced rather than mutated, so a value
+   * read in a frame loop cannot change under it.
+   */
+  on(listener: InputListener<Action>): Unsubscribe;
+  readonly controls: Controls<Layout>;
+  /**
+   * Whether to keep enough state for `read()` to answer about movement.
+   *
+   * Presses are always tracked, so a key already held when this is switched on
+   * is reported honestly by the first read, and a pad's buttons and sticks are
+   * tracked from the moment the player presses something on it. What this gates
+   * is the pointer's position, which costs a listener on every move.
+   */
+  poll: boolean;
+  /**
+   * What is true now, and what has happened since the last read.
+   *
+   * Call it once at the top of a frame: taking a snapshot consumes the edges, so
+   * a second reader in the same frame sees none of the presses the first did.
+   * The pointer's position needs `poll` set; presses and sticks do not.
+   */
+  read(): InputSnapshot<Action>;
+  /**
+   * Stop reading input and let go of everything held.
+   *
+   * For a text field a game drew itself, where the action layer would otherwise
+   * eat the keystrokes. Ordinary inputs and `contenteditable` are stepped around
+   * without being asked; this is for the one case that cannot be seen from
+   * outside — a field drawn on a canvas.
+   */
+  suspend(): void;
+  resume(): void;
+  readonly suspended: boolean;
+};
+/**
+ * The on-screen controls: shown when the game says so *and* the host says they
+ * apply.
+ *
+ * Two halves, and a game needs both answers. Asking is the game's — a pad drawn
+ * over a title screen is worse than one that arrives a moment late — and whether
+ * there is any point is the host's, because a desktop with a keyboard has none.
+ *
+ * @group Input
+ * @category Useful
+ */
+type Controls<Layout extends string = string> = {
+  /**
+   * Draw a layout, if this host will have one.
+   *
+   * The name may be left out by a game that declared exactly one layout. Showing
+   * a different layout while a button is held releases that button, because a
+   * control that has gone away cannot be the thing that ends its own press. A
+   * layout the manifest never declared is reported to `onError`.
+   */
+  show(layout?: Layout): void;
+  /**
+   * Take them down, releasing anything they were holding.
+   *
+   * Hiding is about drawing and nothing else: the keys and pad buttons bound to
+   * the same actions go on working.
+   */
+  hide(): void;
+  /**
+   * Whether controls are on the screen right now.
+   *
+   * The effective answer, not the request: the game asked, *and* the host allows
+   * it, *and* the layout fitted on this frame. A game draws its own touch hints
+   * off this rather than off having called `show`.
+   */
+  readonly showing: boolean;
+  /** The layout the game last asked for, or `null`. */
+  readonly asked: Layout | null;
+  /** Whether this host has any use for on-screen controls at all. */
+  readonly available: boolean;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/lifecycle.d.ts
+/** @group Lifecycle */
+type LifecycleListener = (phase: Phase, previous: Phase) => void | Promise<void>;
+/**
+ * @group Lifecycle
+ * @category Important
+ */
+type Lifecycle = {
+  /** How far this game has got. `loading` until it says otherwise. */
+  readonly phase: Phase;
+  /**
+   * Tell the host the game can be shown. Nothing to wait for: `phase` becomes
+   * `ready` once the host has heard, and a failure is reported to `onError`.
+   */
+  ready(): void;
+  /** Runs on every change of phase. Return a promise to hold the reply. */
+  on(listener: LifecycleListener): Unsubscribe;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/loop.d.ts
+/**
+ * The host has let the game run its loop, or stopped it. Return a promise to
+ * make the host wait.
+ *
+ * @group Loop
+ */
+type LoopListener = (allowed: boolean) => void | Promise<void>;
+/**
+ * One frame of the game's loop: `dt` is the seconds since the last frame,
+ * capped at `MAX_STEP` so a hitch never becomes one enormous step, and 0 on the
+ * first frame after the loop starts or comes back. `now` is the frame's own
+ * timestamp, in milliseconds.
+ *
+ * @group Loop
+ */
+type FrameCallback = (dt: number, now: number) => void;
+/**
+ * The longest step `tick` hands a frame, in seconds.
+ *
+ * @group Loop
+ */
+declare const MAX_STEP = 0.1;
+/**
+ * @group Loop
+ * @category Important
+ */
+type Loop = {
+  /**
+   * Whether the game may ask for frames now. Known as soon as `init` resolves.
+   *
+   * `false` means no `requestAnimationFrame`, no timers driving the game: what
+   * was drawn last stays on screen.
+   */
+  readonly allowed: boolean;
+  /**
+   * Told whenever `allowed` changes. Return a promise to hold the host's reply.
+   *
+   * For a game whose engine runs its own loop: sleep it when this says `false`
+   * and wake it when it says `true`.
+   */
+  on(listener: LoopListener): Unsubscribe;
+  /**
+   * Run `frame` once per display frame while the loop is `allowed`, and not at
+   * all otherwise. What it drew last stays on screen meanwhile.
+   *
+   * A player's own pause is the game's: the loop keeps running so the game can
+   * draw its pause screen, and the game stops advancing its own clock.
+   *
+   * Returns a function that stops this frame callback for good.
+   */
+  tick(frame: FrameCallback): Unsubscribe;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/panel.d.ts
+/**
+ * Where the host's panel stands over the game.
+ *
+ * @group Panels
+ */
+type PanelState = {
+  /**
+   * Whether the panel is over the game, on any page: the game's own, or one of
+   * the host's, such as the player's own tab. Either way the player is reading
+   * the panel rather than playing.
+   */
+  readonly isOpen: boolean;
+  /**
+   * Which of the game's pages it is open on, or `null`: closed, or open on a
+   * page of the host's own that a game has no name for.
+   */
+  readonly page: PageId | null;
+};
+/**
+ * The panel opened, closed or moved to another page.
+ *
+ * `previous` is where it stood before, so a listener can tell *closed* from
+ * *moved* without keeping its own copy — a player going from Scores to Input
+ * never passes through a closed panel, and a game that resumed on every change
+ * would resume mid-read.
+ *
+ * @group Panels
+ */
+type PanelListener = (now: PanelState, previous: PanelState) => void;
+/**
+ * @group Panels
+ * @category Important
+ */
+type Panel = {
+  /**
+   * Whether this host will open its panel for this game at all: `pages` is not
+   * empty.
+   */
+  readonly available: boolean;
+  /**
+   * The pages this host will open for this game, in the order it would show
+   * them.
+   *
+   * Empty is a host with no panel and a host older than panels alike, which
+   * are one fact from here: draw it yourself. It is per game as well as per
+   * host — a game with no boards is not offered `scores`, because there is no
+   * board for the host to draw. A page a host names that this SDK has no word
+   * for is left out: a game cannot open what it cannot name.
+   */
+  readonly pages: readonly PageId[];
+  /**
+   * Whether the panel is over the game right now, on any page.
+   *
+   * Right from the first frame: a host does not close its own furniture to
+   * start a game — the site's panel follows the focused game rather than
+   * shutting on travel — so this is answered at the handshake rather than after
+   * the first change.
+   *
+   * Reading it in a loop is free; it changes only when the host says so.
+   */
+  readonly isOpen: boolean;
+  /**
+   * Which of the game's pages the panel is open on, or `null`: closed, or open
+   * on a page of the host's own.
+   *
+   * **Not restricted to `pages`.** A host may show a page of the game's that no
+   * game was ever invited to open, and a game that ignored it because the name
+   * was unfamiliar would keep playing under it.
+   */
+  readonly page: PageId | null;
+  /**
+   * Run this whenever the panel opens, closes or moves to another page.
+   *
+   * Returns a function that removes the listener. Whatever a listener throws
+   * goes to `init`'s `onError` and the rest still run: one game's broken
+   * handler must not stop the others hearing that the panel closed.
+   *
+   * **This is the callback, and `layout` is the mechanism.** A game that only
+   * needs to move its buttons out of the way should keep using `layout` — the
+   * rectangle is the answer to that question. This is for the decisions a
+   * rectangle cannot support: ducking the music while they read, holding a run
+   * rather than counting it against them.
+   *
+   * It is not a pause signal: the panel opens over a game that is still
+   * `active`. A game that says it is `running` is asked to pause through
+   * `pause` when the panel opens over it; for anything else, what to do about
+   * it is the game's.
+   */
+  on(listener: PanelListener): Unsubscribe;
+  /**
+   * Ask the host to open its panel on one of its pages, in front of the player.
+   *
+   * Nothing to wait for: when the player closes it is not something to wait
+   * on either, because a host is free to keep its panel docked beside the game
+   * and never close it. What happens arrives through `on`.
+   *
+   * A page this host does not draw does nothing — a game checking `pages` first
+   * never asks for one. Anything else that goes wrong is reported to `onError`:
+   * `rate_limited` is a host that will not open it right now, asked too often
+   * or asked to cover a player mid-run.
+   *
+   * **Call it from a press, and only from a press.** This puts something over
+   * the game, and a host is within its rights to refuse one no player asked
+   * for — the same rule a share is under, and for the same reason.
+   */
+  open(page: PageId): void;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/pause.d.ts
+/**
+ * The host has asked for a pause, or for the game to carry on.
+ *
+ * **Return a promise and the host waits for it**, the way it waits on an
+ * order: a game that has to finish an animation before it
+ * can honestly say it has stopped holds the reply until it has. The leash is
+ * short — half a second at most hosts — so slow is fine and hung is not.
+ *
+ * **Say where you ended up with `set`.** The reply the host receives is
+ * whatever the state is once every listener has settled, so a listener that
+ * pauses the game calls `set('paused')` and one that finds there is nothing to
+ * pause does nothing at all: the state is already `unpausable`, and that is the
+ * honest answer.
+ *
+ * @group Pause
+ */
+type PauseListener = (paused: boolean) => void | Promise<void>;
+/**
+ * @group Pause
+ * @category Important
+ */
+type Pause = {
+  /**
+   * Where this game currently stands, as the host has last been told.
+   *
+   * `unpausable` until the game says otherwise, which is what a game that never
+   * mentions pausing means.
+   */
+  readonly state: PauseState;
+  /**
+   * Say where the game now stands.
+   *
+   * **The one way to change it, whoever's idea it was.** A player pressing the
+   * game's own pause control, a run ending onto a title screen with nothing
+   * left to stop, and a listener applying what the host just asked for all end
+   * up here — so there is one place a game's pause state is written and one
+   * message shape it reaches the host in.
+   *
+   * Told to the host immediately, unless it is what the host already believes:
+   * saying the same word twice is not a change, and a host that redrew its
+   * control on every frame of a game that calls this in its loop would be a
+   * host flickering for nothing.
+   *
+   * Nothing is stopped by calling this. Freezing the clock, holding the
+   * animation and quieting the sound are the game's own work, and this is how
+   * the game says it has done it.
+   */
+  set(state: PauseState): void;
+  /**
+   * Told whenever the host asks for a pause or a resume: its own pause button,
+   * its panel opening, or the game being taken away from the player mid-play.
+   *
+   * It hears the host asking, not the state moving — the state is whatever
+   * the game says with `set` — so it is not called for a change the game made
+   * itself: a listener that fired on the game's own `set` would be a game
+   * hearing its own decision back, and one that answered it would be a loop.
+   */
+  on(listener: PauseListener): Unsubscribe;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/resources.d.ts
+/**
+ * The host has let the game hold its resources again, or asked for them back.
+ * Return a promise to make the host wait until they have gone, or come back.
+ *
+ * @group Resources
+ */
+type ResourcesListener = (allowed: boolean) => void | Promise<void>;
+/**
+ * @group Resources
+ * @category Important
+ */
+type Resources = {
+  /**
+   * Whether the game may hold what it could load again. Known as soon as
+   * `init` resolves.
+   *
+   * `false` means let go of whatever is large and can be rebuilt — textures,
+   * decoded sound, the level's geometry — and keep what cannot, such as the
+   * state of play.
+   */
+  readonly allowed: boolean;
+  /**
+   * Told whenever `allowed` changes. Return a promise to hold the host's
+   * reply: the host waits, briefly, for the memory to have gone before it
+   * warms the next game.
+   */
+  on(listener: ResourcesListener): Unsubscribe;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/save.d.ts
+/**
+ * What a game gets back from a read: its own schema number, and its state.
+ *
+ * @group Save
+ * @category Useful
+ */
+type SaveState = {
+  /** Whatever the game passed to `write`, or 1 where it never named one. */
+  version: number;
+  /** Parsed where it was written as a value, verbatim where it was a string. */
+  state: unknown;
+};
+/**
+ * What is stored, as far as anybody has said.
+ *
+ * `known: false` is nobody having said yet — a host whose store had not
+ * answered by the handshake — and the only way to find out is to `read()`.
+ * `known: true` carries the answer: a header (how big, how old, what schema),
+ * or `null` for a player with nothing stored. The two are kept apart by a
+ * field a game has to look at, rather than by `null` against `undefined`.
+ *
+ * @group Save
+ * @category Useful
+ */
+type SaveStatus = {
+  readonly known: false;
+} | {
+  readonly known: true;
+  readonly stored: SaveStored | null;
+};
+/**
+ * Told when what is stored changes: a read answered what was unknown, or the
+ * game wrote or cleared its save.
+ *
+ * @group Save
+ * @category Useful
+ */
+type SaveListener = (now: SaveStatus, previous: SaveStatus) => void;
+/**
+ * @group Save
+ * @category Important
+ */
+type Save = {
+  /**
+   * Whether this host keeps saves at all. Known at the handshake: a game with
+   * none leaves out *Continue* rather than learning on the press.
+   */
+  readonly available: boolean;
+  /**
+   * What is stored, before anything has been fetched.
+   *
+   * Enough to draw *Continue* or *New game* before asking for anything, and
+   * enough for a game now on schema 3 that will not migrate a 1 to never fetch
+   * it at all. It follows the game's own reads, writes and clears.
+   */
+  readonly status: SaveStatus;
+  /** Told whenever `status` changes. */
+  on(listener: SaveListener): Unsubscribe;
+  /**
+   * Fetch the state.
+   *
+   * `null` for a player with nothing stored. Rejects with a `BridgeError` where
+   * the host refused — `unsupported` from a host with no store — which is a
+   * game's cue to carry on without one rather than to fail to load.
+   */
+  read(): Promise<SaveState | null>;
+  /**
+   * Keep this. Resolves when the host says the record is durable.
+   *
+   * A string is stored as it stands and comes back a string; anything else is
+   * `JSON.stringify`d and comes back parsed. A value that cannot survive that
+   * at all — a cycle, a `BigInt` — rejects with `bad_params` before anything
+   * reaches the bridge.
+   *
+   * `version` is the game's own schema number and means whatever the game says
+   * it means. There is no migration hook: a hook would be frozen game-side code
+   * that is sugar over an `if`, and a game that got it wrong could never be
+   * fixed.
+   */
+  write(state: unknown, options?: {
+    version?: number;
+  }): Promise<void>;
+  /** Throw the save away — a game resetting its own progress, at a player's asking. */
+  clear(): Promise<void>;
+  /** The largest save this host will take, in bytes. `SAVE_BYTES` where it said nothing. */
+  readonly maxBytes: number;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/score.d.ts
+/**
+ * Where this player stands on every board, as far as anybody has said.
+ *
+ * `known: false` is this host not having an answer yet — a store still
+ * replying, a client that cannot reach its server — and a game that drew "no
+ * best yet" for it would be telling somebody their record was gone because a
+ * network was slow. `known: true` carries every board this host takes, each
+ * with the player's standing on it or `null` for a board they have never
+ * scored on.
+ *
+ * @group Score
+ * @category Useful
+ */
+type ScoreStandings<Board extends string = string> = {
+  readonly known: false;
+} | {
+  readonly known: true;
+  readonly boards: Readonly<Record<Board, ScoreStanding | null>>;
+};
+/**
+ * Told when the standing changes: the host's answer arrived after the
+ * handshake, or a submission moved it.
+ *
+ * @group Score
+ * @category Useful
+ */
+type ScoreListener<Board extends string = string> = (now: ScoreStandings<Board>, previous: ScoreStandings<Board>) => void;
+/**
+ * @group Score
+ * @category Important
+ */
+type Score<Board extends string = string> = {
+  /**
+   * Whether this host keeps scores at all. Known at the handshake: a game with
+   * none leaves out its score screen rather than learning on the first
+   * submission.
+   */
+  readonly available: boolean;
+  /**
+   * The boards this host will take a score on, from the manifest it holds.
+   * Empty where it keeps none.
+   */
+  readonly boards: readonly Board[];
+  /** Where this player stands on each board. */
+  readonly standing: ScoreStandings<Board>;
+  /** Told whenever `standing` changes. */
+  on(listener: ScoreListener<Board>): Unsubscribe;
+  /**
+   * Keep this number, and tell me what it did.
+   *
+   * Resolves with `improved` — whether this run beat the player's own best,
+   * where a tie is not an improvement — and `best`, what that best now is.
+   * `rank` and `of` come too when the host happens to know them, and a game
+   * that draws a position must handle their being absent: a host that
+   * acknowledges a score as soon as it is *durable* has not necessarily heard
+   * back from anywhere yet.
+   *
+   * `board` may be left out by a game with one board, which is what a game with
+   * one board should do. A game with several that leaves it out is refused
+   * rather than guessed at.
+   *
+   * Rejects with `unsupported` from a host that keeps no scores. `bad_params`
+   * is a board this game's manifest never declared, which is an author's
+   * mistake and not a player's. `rate_limited` means this is being called far
+   * more often than runs actually end.
+   *
+   * **Every run is its own submission.** A worse run than last time is not an
+   * error and is not to be withheld — the host keeps it, `improved` comes back
+   * `false`, and the best stands. A game that only submits its personal bests
+   * is a game whose weekly board has one number in it.
+   */
+  submit(value: number, options?: {
+    board?: Board;
+  }): Promise<ScoreResult>;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/share.d.ts
+/**
+ * @group Share
+ * @category Important
+ */
+type Share = {
+  /**
+   * Whether this host can put a link in front of the player. Known at the
+   * handshake: draw a Share button only where it is `true`, rather than
+   * learning on the press that there was nothing behind it.
+   */
+  readonly available: boolean;
+  /**
+   * What the link that opened this game carried, or `null` for a player who
+   * arrived the ordinary way.
+   *
+   * Exactly the string some run of this game passed to `offer` — the board that
+   * was sent, the seed that was beaten — and it is here at startup rather than
+   * fetched, so a game opened from a link draws what the link says in its first
+   * frame instead of drawing the ordinary game and jumping.
+   *
+   * **Read it the way you would read a stranger's input, because it is one.** A
+   * URL is written by anybody: it can be truncated by a chat client, edited by
+   * a curious player, or made up. This game wrote the format and this game must
+   * check it — the same care `save.read` deserves, for a stronger reason.
+   *
+   * **`null` says nothing about whether a link can be offered.** It means
+   * nobody arrived by one; `available` is what says whether one can be made.
+   */
+  readonly data: string | null;
+  /**
+   * Ask the host to put a link to this game in front of the player.
+   *
+   * Nothing to wait for. The host puts the link in front of the player — a
+   * share sheet, the clipboard — and tells them what became of it, "link
+   * copied" included; the game is not told, and has nothing to draw. A player
+   * may keep a sheet open as long as they like, and pressing Share again while
+   * one is up does not open a second.
+   *
+   * `data` is the game's own and travels in the link, opaque to the host, back
+   * to whoever opens it. A string, because it has to survive being a URL and
+   * because the game reading it back is the game that wrote it: anything
+   * structured is the game's to encode and the game's to parse. `SHARE_BYTES`
+   * is what every host carries; more than that is a host's own decision, and a
+   * host that will not carry it refuses with `too_large`.
+   *
+   * `meta` is for the platform rather than for the game: why this link was made
+   * — the level, the score, which of the game's buttons — kept beside the
+   * host's own record of who made it and how, so a game's makers can learn
+   * which of its shares bring people in. Anything JSON can say, and
+   * `SHARE_META_BYTES` of it is what every host takes. Nobody who opens the link
+   * is handed it.
+   *
+   * What goes wrong is reported to `onError` and sends nothing: `bad_params`
+   * for a `data` that is not a string or a `meta` JSON cannot carry, which are
+   * bugs in the game; `too_large` from a host for more than it carries;
+   * `rate_limited` from one that will not offer a link right now. A host with
+   * no link to give does nothing, which a game checking `available` never asks
+   * of it. Every one of them is a game that carries on: nothing about a share
+   * belongs to the state of play.
+   *
+   * **Call it from a press, and only from a press.** This opens something over
+   * the game, and a host will be within its rights to refuse an offer no player
+   * asked for — some cannot even honour one, because the permission to put a
+   * sheet on screen comes from the player's own gesture.
+   */
+  offer(options?: {
+    data?: string;
+    meta?: ShareMeta;
+  }): void;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/init.d.ts
+/**
+ * What `init` hands back: every namespace a game has, on one object.
+ *
+ * `M` is the game's manifest type, `typeof config.manifest`: every name the
+ * game passes in — an action, a board, an achievement, an event, a channel —
+ * is then one its manifest declares. Without it, every name is a `string`.
+ *
+ * `Useful` rather than `Important` because of how it is reached. A reader comes
+ * looking for `init` — it is the only way in — and arrives here by following
+ * what it returns, which is the same path the code takes.
+ *
+ * @group Bridge
+ * @category Useful
+ */
+type GameSdk<M extends object = GameManifest> = {
+  /**
+   * How far the game has got: `loading`, `ready`, `disposed`. The one thing
+   * here a game must actually call is `lifecycle.ready()`.
+   *
+   * @category Important
+   */
+  lifecycle: Lifecycle;
+  /**
+   * The game's frame loop, and the host's order about it: ask for frames only
+   * while `loop.allowed`. `loop.tick()` runs a frame callback that obeys it on
+   * the game's behalf.
+   *
+   * @category Important
+   */
+  loop: Loop;
+  /**
+   * The host's order about memory: hold what can be loaded again only while
+   * `resources.allowed`, and let it go when told.
+   *
+   * @category Important
+   */
+  resources: Resources;
+  /**
+   * What the host has put over the frame, how big that frame is, and what the
+   * two leave the game. Numbers only: what to do about them is the game's, and
+   * so is whatever it draws with.
+   *
+   * @category Useful
+   */
+  layout: Layout;
+  /**
+   * Who this run is for and what it is running on: the host, the game as the
+   * host loaded it, the player, the machine.
+   *
+   * Settled at the handshake and frozen. There is nothing to listen to because
+   * there is nothing that changes — which is also why reading it in a loop is
+   * free, and why a game can branch on the device tier before it fetches its
+   * first asset.
+   *
+   * @category Useful
+   */
+  info: Info;
+  /**
+   * Say what happened, for the host to keep.
+   *
+   * One way and unacknowledged: nothing here can be waited on, and nothing here
+   * can fail. What the host does with an event — store it, show it in a log,
+   * throw it away — is no business of the game's.
+   *
+   * @category Useful
+   */
+  analytics: Analytics<EventProps<M>>;
+  /**
+   * The one thing a game may keep: one document, this player's, this game's.
+   *
+   * Read it while you load and write it as you play. `save.status` says what
+   * is waiting before anything is fetched, so a game can draw *Continue*
+   * without a round trip; `read()` fetches it, `write()` resolves when the host
+   * says the record is durable, and there is nothing to flush because nothing
+   * is held here.
+   *
+   * `save.available` is `false` on a host with no store, whose calls answer
+   * `unsupported`: a game with no save rather than one that fails to load.
+   *
+   * @category Useful
+   */
+  save: Save;
+  /**
+   * Keep a number against this player, and be told what it did.
+   *
+   * `score.standing` says where they already are before anything is asked
+   * for, so a game draws a target in its first frame; `submit()` resolves with
+   * whether the run beat it. What a game never gets is anybody else's number —
+   * a board is drawn by the client over the game, not inside it.
+   *
+   * `score.available` is `false` on a host with no scoring, whose calls answer
+   * `unsupported`: a game that carries on without a target.
+   *
+   * @category Useful
+   */
+  score: Score<BoardName<M>>;
+  /**
+   * What this player has been shown to have done, and how to say they have
+   * done more.
+   *
+   * `achievements.standing` answers before anything is asked for, so a game
+   * draws *3 of 12* in its first frame; `unlock()` says something is theirs
+   * and `progress()` says how far along they are — as an absolute value, so
+   * reporting it twice does nothing. What a game never gets is anybody else's:
+   * the panel that lists them is drawn by the client over the game, not inside
+   * it.
+   *
+   * `achievements.available` is `false` on a host with none, and reporting to
+   * it does nothing: a game that carries on without a banner.
+   *
+   * @category Useful
+   */
+  achievements: Achievements<AchievementName<M>, MeasuredName<M>>;
+  /**
+   * What the player presses, how far they are pushing a stick, where the
+   * pointer is — and the on-screen controls to draw where there is no keyboard.
+   *
+   * Read in the frame and answered in the frame: nothing about a press crosses
+   * the bridge, and the controls are drawn here so a thumb on a stick reaches
+   * the game in the frame it moved. What the host contributes is what the frame
+   * cannot see — what this player remapped, what they are holding, and whether
+   * on-screen controls mean anything on this device.
+   *
+   * The actions and the on-screen layouts are the ones the host read from the
+   * published manifest, sent at the handshake: a game declares them in its
+   * manifest and nowhere else. A host older than input sends none, and a game
+   * there has nothing to bind.
+   *
+   * @category Useful
+   */
+  input: Input<ActionName<M>, LayoutName<M>>;
+  /**
+   * How loud this game may be, which the host decides and the game obeys.
+   *
+   * **The one namespace here that is not a service and cannot be refused.**
+   * Everything else is a game asking a host for something; this is a host
+   * telling a game something, and respecting it is the condition of being on
+   * the platform rather than a courtesy. `output()` and `media()` obey it on
+   * the game's behalf — the volume, mute, and silence whenever sound is not
+   * `allowed`. `volume(channel)` is the number to multiply a sound by, for a
+   * game whose engine mixes for itself.
+   *
+   * A host older than audio, or one with no volume controls, leaves this at
+   * full and never pushes: the game plays the mix it meant, which is the only
+   * sensible reading of silence here.
+   *
+   * @category Useful
+   */
+  audio: Audio<ChannelName<M>>;
+  /**
+   * Ask the host to offer the player a link to this game, carrying whatever the
+   * game wants carried.
+   *
+   * The game names no URL and is told none: where this game lives is the host's
+   * fact, and putting a link in front of a player — a sheet, the clipboard — is
+   * something only the host can do from outside the frame. `share.available`
+   * says at the handshake whether this host has a link to give.
+   *
+   * `share.data` is the way back in: what the link this run was opened with
+   * carried, known at the handshake so a game can draw it in its first frame.
+   *
+   * @category Useful
+   */
+  share: Share;
+  /**
+   * Ask the host to open its panel on one of its pages: what this game is,
+   * the board, the list of what has been unlocked, the page where a key is
+   * rebound.
+   *
+   * The host draws all of it and the game supplies the moment — a pause screen,
+   * the end of a run, the fourth wrong key. Nothing here says where the panel
+   * goes or what it looks like: a page is a subject, and the shape of one is
+   * the host's.
+   *
+   * `panel.pages` is what a game draws its own furniture from, known at the
+   * handshake: a game that shows *Press ⚙ to rebind* when `input` is there
+   * draws its own rebinding screen when it is not, and it decides that before
+   * its first frame rather than when the player presses.
+   *
+   * `panel.isOpen`, `panel.page` and `panel.on` are the other direction — the
+   * panel is over the game now, whoever opened it, and on which page. Higher
+   * level than the `overlay` rectangle in `layout`, which is still the right
+   * answer for moving buttons out of the way: this one says it is the panel,
+   * and which page, so a game can duck its music while a player rebinds a key
+   * rather than guessing from a box.
+   *
+   * Pausing is `pause` below, and the two are worth keeping apart: a game that
+   * says it is `running` is asked to pause when the panel opens over it, and
+   * that request arrives there rather than here.
+   *
+   * @category Useful
+   */
+  panel: Panel;
+  /**
+   * Whether the game is holding still, which the host may ask for and only the
+   * game can answer.
+   *
+   * **The one namespace where a host's request may honestly come back saying
+   * something else.** A game with nothing on the field to stop — a title
+   * screen, the gap between rounds — answers `unpausable`, and that is a state
+   * the host draws rather than a failure it recovers from: it shows no control
+   * at all, because a disabled button is a promise that pressing it would do
+   * something.
+   *
+   * `on()` is where the stopping goes, and the host waits for it the way it
+   * waits for a fade-out. The host asks when its pause button is pressed, when
+   * its panel opens, and when it takes a game in play away from the player. `set()` is how the game says where it ended up —
+   * including when nobody asked, which is a player pressing the game's own
+   * pause key.
+   *
+   * Nothing here stops anything by itself: what freezes and what carries on is
+   * a thousand decisions this SDK has no business making. A game that never
+   * calls `set` stays `unpausable`, which is what a host is told about every
+   * game published before pausing existed.
+   *
+   * @category Useful
+   */
+  pause: Pause;
+  /**
+   * Ask the host to answer, and time how long it takes.
+   *
+   * Resolves with the round trip in milliseconds, rejecting with a `BridgeError`
+   * whose code is `timeout` if the host never answers. This is the liveness
+   * check the demo is built on, and it stays useful afterwards.
+   */
+  ping(): Promise<number>;
+  /** Tear the bridge down. Calls in flight reject with `disposed`. */
+  dispose(): void;
+};
+/**
+ * @group Bridge
+ * @category Useful
+ */
+type InitOptions = {
+  /** The window the game is running in. Defaults to the global one. */
+  scope?: Window | undefined;
+  /**
+   * How long a call waits before rejecting with `timeout`.
+   *
+   * Never shorter for the handshake than ten seconds, whatever this says. A
+   * game that gives up on a hello the host has heard is one the host goes on to
+   * show anyway, once it tires of waiting for `ready` — with nothing running
+   * in it.
+   */
+  timeoutMs?: number | undefined;
+  /**
+   * The channel to talk over. Defaults to whatever the game turns out to be
+   * running in — a shim a native shell left, or the frame that embedded us —
+   * which is what every real game wants; a test, or a host that embeds a game
+   * some other way, can hand over its own.
+   */
+  transport?: Transport | undefined;
+  /**
+   * How long to wait for a host to turn up when there is neither a shim nor a
+   * parent frame, before rejecting. Defaults to `SHIM_WAIT_MS`.
+   *
+   * Here from day one rather than when a platform first needs it: this is
+   * game-side code, bundled into a game at build time, so it can never be added
+   * later for games already published.
+   */
+  shimWaitMs?: number | undefined;
+  /**
+   * Where a failure that belongs to nobody's promise goes — a lifecycle
+   * listener that threw, an event the SDK refused. Defaults to `console.error`.
+   *
+   * The host is told about each of these as well, whatever this does with
+   * them, as it is about any error the game throws and nothing catches.
+   */
+  onError?: ((error: unknown) => void) | undefined;
+};
+/**
+ * Introduce the game to its host, and hand back the SDK once it has answered.
+ *
+ * The handshake is not optional and `init` does not resolve without it. It
+ * settles the protocol version both sides will speak, and gets this game a
+ * name to stamp its requests with — without which a host cannot tell what a
+ * reloaded game says from what the game before it said.
+ *
+ * **Let a rejection through rather than catching it.** Every way this fails
+ * leaves the game with no host to talk to — none there, one that never
+ * answered, one too old or too new to speak to it — and a host does not show a
+ * game that never got through the handshake. Nobody is left to read a message
+ * drawn into the page; a developer reads the console, which is where an
+ * uncaught rejection goes, with its stack. Nor is there a way to carry on
+ * without a host: that is every namespace written twice, and the half no host
+ * ever runs is the half that breaks.
+ *
+ * Calling it twice in one game is a bug: the host only ever talks to the most
+ * recent one, and the abandoned peer's calls start failing with `stale`.
+ *
+ * **The window is sized by the time it resolves.** `innerWidth` and
+ * `innerHeight` agree with `layout.frame` from then on, so a game sizes itself
+ * the way any page does.
+ *
+ * Pass the manifest's type to have every declared name checked:
+ *
+ *     import type config from '../hopple.config.ts';
+ *     const hopple = await init<typeof config.manifest>();
+ *
+ * @group Bridge
+ * @category Important
+ */
+declare function init<M extends object = GameManifest>(options?: InitOptions): Promise<GameSdk<M>>;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/transport.d.ts
+/**
+ * How long a game with no shim and no parent waits for one to turn up.
+ *
+ * Generous on purpose: a shim two seconds late is not coming, and the only game
+ * made to wait is one that was never going to run.
+ *
+ * @group Bridge
+ */
+declare const SHIM_WAIT_MS = 2000;
+/** @group Bridge */
+type HostTransportOptions = {
+  /** The window the game is running in. Defaults to the global one. */
+  scope?: Window | undefined;
+  /** How long to wait for a late shim before giving up. */
+  shimWaitMs?: number | undefined;
+  /** Where a shim that arrived wrongly, or twice, is reported. */
+  onError?: ((error: unknown) => void) | undefined;
+};
+/**
+ * Find something to talk over, waiting briefly if there is nothing yet.
+ *
+ * Asynchronous because of that last case alone. The two ordinary ones — a shim
+ * already installed, a parent frame — resolve without yielding a turn.
+ *
+ * @group Bridge
+ * @category Useful
+ */
+declare function hostTransport(options?: HostTransportOptions): Promise<Transport>;
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-1wJl1B/game/src/shim.d.ts
+/**
+ * Whether an arbitrary value is a shim this SDK knows how to speak to.
+ *
+ * A version we do not know is a shim we must not guess at — a `v: 2` that moved
+ * `send` to a different signature would be a channel we corrupt rather than one
+ * we fail on. Refusing it falls through to the frame branch, and then to the
+ * wait, which either connects or says clearly that nothing did.
+ *
+ * @group Bridge
+ */
+declare function isShim(value: unknown): value is HoppleShim;
+/**
+ * What a platform left for us, or nothing — in which case we are in a frame.
+ *
+ * @group Bridge
+ */
+declare function findShim(scope: Window): HoppleShim | null;
+/**
+ * A shim, seen by the peer as an ordinary channel.
+ *
+ * The trust boundary is in here, in SDK code, and never in the platform's: a
+ * shim that cannot validate is a shim that cannot validate wrongly.
+ *
+ * @group Bridge
+ */
+declare function shimTransport(shim: HoppleShim): Transport;
+//#endregion
+export { ACHIEVEMENT_VALUE_MAX, AUDIO_FULL, AUDIO_MASTER, AUDIO_VOLUME_MAX, type Achievement, type AchievementDeclaration, type AchievementListener, type AchievementName, type AchievementProgress, type AchievementResult, type AchievementStanding, type AchievementStatus, type AchievementTier, type Achievements, type ActionListener, type ActionName, type Analytics, type AnalyticsDeclaration, type AnalyticsProps, type AnalyticsShape, type AnalyticsType, type AnalyticsValue, type AppInfo, type AppSurface, type Audio, type AudioChannel, type AudioDeclaration, type AudioListener, type AudioState, type BoardName, BridgeError, type ChannelName, type ControlLayout, type ControlModel, type ControlModelSlot, type ControlModelZone, type ControlReport, type ControlShape, type ControlSlot, type ControlZone, type Controls, DEADZONE, type DeclaredNames, type DeclaredValue, type DeviceInfo, type DeviceTier, type ErrorCode, type EventName, type EventProps, type FrameCallback, type GameInfo, type GameManifest, type GameSdk, type HoppleConfig, type HoppleShim, type HostTransportOptions, INPUT_CONTRACT, INPUT_SCHEMES, INPUT_SHIM, type Info, type InitOptions, type Input, type InputAction, type InputBinding, type InputChangeCause, type InputDeclaration, type InputDevice, type InputListener, type InputScheme, type InputShim, type InputSnapshot, type InputState, type InsetMode, type InsetPolicy, type Insets, type Layout, type LayoutDeclaration, type LayoutListener, type LayoutName, type LayoutState, type Lifecycle, type LifecycleListener, type Loop, type LoopListener, MANIFEST_FILE, MANIFEST_SCHEMA, MAX_STEP, type MeasuredName, type Obstruction, type ObstructionKind, type Orientation, PAD_BUTTONS, PAGES, PAUSE_NONE, PAUSE_STATES, type PageId, type Panel, type PanelListener, type PanelState, type Pause, type PauseListener, type PauseState, type Phase, type PlayerInfo, type PointerListener, type PointerState, type Rect, type Resources, type ResourcesListener, SAVE_BYTES, SCORE_VALUE_MAX, SET_SHIM, SHARE_BYTES, SHARE_META_BYTES, SHIM, SHIM_WAIT_MS, type Save, type SaveDeclaration, type SaveListener, type SaveState, type SaveStatus, type SaveStored, type Score, type ScoreBoard, type ScoreDeclaration, type ScoreDirection, type ScoreFormat, type ScoreListener, type ScoreResult, type ScoreStanding, type ScoreStandings, type Share, type ShareMeta, type ShareMetaValue, type Size, type StickListener, type StickName, type StickState, type Unsubscribe, audioVolumeOf, findShim, hostTransport, init, insetsFrom, isInputShim, isShim, labelFor, preferredBinding, servesScheme, shimTransport };