@hopple/sdk 0.1.0-rc.3 → 1.0.0-next.12

package/index.d.ts

@@ -1,34 +1,4 @@
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/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-DAYaix/protocol/src/analytics.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/protocol/src/analytics.d.ts
 /**
  * What a game says happened.
  *
@@ -59,166 +29,77 @@ type AnalyticsValue = string | number | boolean;
 /** @group Analytics */
 type AnalyticsProps = Record<string, AnalyticsValue>;
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/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.
- */
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/protocol/src/errors.d.ts
 /**
- * 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.
+ * How a call fails.
  *
- * @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.
+ * 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.
  *
- * @group Audio
+ * 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.
  */
-declare const AUDIO_MASTER = "master";
 /**
- * How loud the game may be, as the host has it set right now.
+ * The codes a call fails with, as the keys of this interface.
  *
- * **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.
+ * An interface rather than a union so that a preview can add the codes only
+ * its calls fail with, as it adds its own namespace to the SDK: a game is
+ * named the codes of what it uses.
  *
- * 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
+ * @group Bridge
  */
-type AudioState = {
+interface ErrorCodes {
+  /** No handler on the other side. Usually means the host predates the method. */
+  unknown_method: true;
+  /** The handler rejected the shape of `params`. */
+  bad_params: true;
+  /** No reply inside the peer's timeout. Says nothing about whether it ran. */
+  timeout: true;
+  /** The peer was torn down with the call still in flight — a recycled slot. */
+  disposed: true;
   /**
-   * Everything off, whatever the faders say.
+   * 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: true;
+  /** The handshake asked for a protocol version this side cannot speak. */
+  unsupported_version: true;
+  /**
+   * This host does not do that at all — a site with no store answering
+   * `save.write`.
    *
-   * 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.
+   * 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.
    */
-  muted: boolean;
-  /** The fader over all of it, `0`–`1`. */
-  master: number;
+  unsupported: true;
+  /** Over this host's cap. Says trim, rather than go looking for a bug. */
+  too_large: true;
   /**
-   * Each declared channel's own fader, `0`–`1`, by the id its manifest gave it.
+   * Faster than this host will take. The counterpart of the analytics refusal.
    *
-   * 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.
+   * 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.
    */
-  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-DAYaix/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.
- */
+  rate_limited: true;
+  /**
+   * Not now: what it needs can't be reached for the moment. Worth trying
+   * again shortly.
+   */
+  unavailable: true;
+  /** The handler threw. The message is ours, never the thrown value's. */
+  internal: true;
+}
 /** @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';
+type ErrorCode = keyof ErrorCodes;
 /** @group Bridge */
 type ProtocolError = {
   code: ErrorCode;
@@ -234,48 +115,7 @@ declare class BridgeError extends Error {
   constructor(error: ProtocolError);
 }
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/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-DAYaix/protocol/src/input.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/protocol/src/input.d.ts
 /**
  * What the host says about how this game is being played.
  *
@@ -312,8 +152,6 @@ type Envelope = {
  * @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.
  *
@@ -336,87 +174,8 @@ type InputBinding = {
   /** 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 marked 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. A thumb that goes past its rim pulls it along, so turning back is
- * never further than the stick is wide. `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-DAYaix/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-DAYaix/protocol/src/pause.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/protocol/src/pause.d.ts
 /**
  * Whether the game is holding still, which the host may ask for and only the
  * game can answer.
@@ -473,23 +232,8 @@ type PauseState =
  * 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-DAYaix/protocol/src/save.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/protocol/src/save.d.ts
 /**
  * The one thing a game may keep.
  *
@@ -511,7 +255,8 @@ declare const PAUSE_NONE: PauseState;
  * 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.
+ * What a game may write anywhere, in bytes: of `state` as UTF-8, or of the
+ * bytes a game handed over where it handed bytes.
  *
  * 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
@@ -540,45 +285,7 @@ type SaveStored = {
   bytes: number;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/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;
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/protocol/src/score.d.ts
 /**
  * What the host says came of it.
  *
@@ -616,7 +323,7 @@ type ScoreStanding = {
   of?: number;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/protocol/src/share.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/protocol/src/share.d.ts
 /**
  * A link to this game, offered to the player by the host.
  *
@@ -670,7 +377,8 @@ type ScoreStanding = {
  * its first frame. See `ShareWelcome`.
  */
 /**
- * What every host carries, in bytes of `data` as UTF-8.
+ * What every host carries, in bytes of `data`: as UTF-8, or the bytes a game
+ * handed over where it handed bytes.
  *
  * 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
@@ -715,7 +423,7 @@ type ShareMeta = {
   [key: string]: ShareMetaValue;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/protocol/src/methods.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/protocol/src/methods.d.ts
 /**
  * How far a game has got with its own preparation.
  *
@@ -895,7 +603,7 @@ type DeviceInfo = {
   tier: DeviceTier;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/protocol/src/listeners.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/protocol/src/listeners.d.ts
 /**
  * The one way anything here is listened to: `on(listener)` hands back the
  * function that stops it.
@@ -924,152 +632,17 @@ type DeviceInfo = {
  */
 type Unsubscribe = () => void;
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/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-DAYaix/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
- */
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/manifest/src/manifest.d.ts
 /**
- * The name a manifest is uploaded under, beside the game's page.
+ * The API a game is written against: `M.m`, a major and the least minor it
+ * needs, or `next`, the pre-releases of the next stable release.
  *
  * @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
+ * @category Important
+ * @pattern ^(?:(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)|next)$
+ * @errorMessage must be the API the game is written against, like "1.0", or "next"
  */
-declare const MANIFEST_SCHEMA = 1;
+type ApiVersion = string;
 /**
  * How the game wants to be held. The host decides what to do about it.
  *
@@ -1100,7 +673,6 @@ type InsetMode =
  */
 type LayoutDeclaration = {
   insets: InsetMode;
-  [key: string]: unknown;
 };
 /**
  * What a prop may hold, as one word. The three the wire carries, and no more.
@@ -1152,7 +724,6 @@ type AnalyticsDeclaration = {
    * @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.
@@ -1182,7 +753,6 @@ type SaveDeclaration = {
    * @maximum 1048576
    */
   bytes: number;
-  [key: string]: unknown;
 };
 /**
  * One thing a game makes noise with, as the player is offered it.
@@ -1204,7 +774,6 @@ type AudioChannel = {
    * @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.
@@ -1245,7 +814,6 @@ type AudioDeclaration = {
    * @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.
@@ -1283,7 +851,26 @@ type ScoreBoard = {
   direction: ScoreDirection;
   /** See `ScoreFormat`. Absent means `integer`. */
   format?: ScoreFormat;
-  [key: string]: unknown;
+  /**
+   * Which board, of the ones this id has named. Absent is `1`.
+   *
+   * **Raising it starts the board again from nobody.** The runs under the
+   * version before are kept and no longer counted, shown or ranked, so a board
+   * whose scores stopped being comparable — new levels, a new rule — begins
+   * again under the id the game already submits to.
+   *
+   * **Only a change to what a stored score means needs it.** The title changes
+   * freely, and so does the format between `integer` and `decimal`. Once the
+   * board holds scores, turning it around (`direction`) or writing it in
+   * another unit (to or from `duration-ms`) is refused at the same version.
+   * Going back to a version declared before brings its runs back, so it is
+   * held to what that version was.
+   *
+   * @asType integer
+   * @minimum 1
+   * @maximum 1000
+   */
+  version?: number;
 };
 /**
  * The boards this game keeps a score on.
@@ -1314,7 +901,6 @@ type ScoreDeclaration = {
    * @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.
@@ -1353,7 +939,6 @@ type AchievementTier = {
    * @errorMessage must not be blank
    */
   icon?: string;
-  [key: string]: unknown;
 };
 /**
  * What makes an achievement measured rather than flagged.
@@ -1399,7 +984,6 @@ type AchievementProgress = {
    * @maxItems 8
    */
   tiers?: AchievementTier[];
-  [key: string]: unknown;
 };
 /**
  * One thing a player can be shown to have done.
@@ -1450,7 +1034,28 @@ type Achievement = {
   secret?: boolean;
   /** Present makes this measured rather than flagged. See `AchievementProgress`. */
   progress?: AchievementProgress;
-  [key: string]: unknown;
+  /**
+   * Which achievement, of the ones this id has named. Absent is `1`.
+   *
+   * **Raising it starts the achievement again for everybody.** What players
+   * reported and unlocked under the version before is kept and no longer
+   * counted, so it is earned afresh under the id the game already reports to.
+   *
+   * **Only a change to what a stored value means needs it.** The words change
+   * freely — title, detail, icon, secret — and so does the target, and a tier
+   * added after the last one: progress is kept as the number reported, which
+   * stays true when the goal moves, and a player who unlocked it keeps it. At
+   * the same version, a published achievement may not turn from a flag into a
+   * measure or back, turn its direction around, write its value in another
+   * unit (to or from `duration-ms`), or move or drop a tier it already has.
+   * Going back to a version declared before brings back what was earned under
+   * it, so it is held to what that version was.
+   *
+   * @asType integer
+   * @minimum 1
+   * @maximum 1000
+   */
+  version?: number;
 };
 /**
  * The achievements this game keeps for a player.
@@ -1479,7 +1084,6 @@ type AchievementDeclaration = {
    * @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.
@@ -1517,7 +1121,7 @@ type InputDeviceSet = InputDevice[];
  * 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))$
+ * @pattern ^(?:key\.(?!Escape$)(?=.{1,48}$)[A-Za-z][A-Za-z0-9]*|pointer\.(?:primary|secondary)|mouse\.(?:left|middle|right|wheelup|wheeldown)|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;
@@ -1577,7 +1181,115 @@ type InputAction = {
    * @errorMessage must not be blank
    */
   label?: string;
-  [key: string]: unknown;
+};
+/**
+ * What presses a player's action on a pad or on the screen: a pad button, or
+ * an on-screen control. Keys and mouse buttons are a keyboard set's, in
+ * `PlayerInputDeclaration.keyboard`.
+ *
+ * @group Input
+ * @pattern ^(?: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 must be a pad button or an on-screen control: a player's keys and mouse buttons go in input.player.keyboard
+ */
+type PlayerBinding = string;
+/**
+ * What presses a player's action on their part of the keyboard: a key, or a
+ * mouse button.
+ *
+ * @group Input
+ * @pattern ^(?:key\.(?!Escape$)(?=.{1,48}$)[A-Za-z][A-Za-z0-9]*|mouse\.(?:left|middle|right|wheelup|wheeldown))$
+ * @errorMessage must be a key or a mouse button (and Escape is the host's key)
+ */
+type KeyboardBinding = string;
+/**
+ * One thing each player does: the same action for every local player, pressed
+ * by their own pad, their own part of the keyboard, or the on-screen controls.
+ *
+ * @group Input
+ */
+type PlayerInputAction = {
+  /**
+   * What presses it on a pad, the same for every pad, and on the screen.
+   * Leave it out for an action pressed only on the keyboard.
+   *
+   * @minItems 1
+   * @maxItems 8
+   */
+  bind?: PlayerBinding[];
+  /**
+   * 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;
+  /**
+   * Whether pressing it on a pad or a part of the keyboard nobody plays with
+   * makes a new player, while the game is taking players. Left out on every
+   * action, any of them does.
+   */
+  join?: boolean;
+};
+/**
+ * One part of the keyboard one player plays with: the keys and mouse buttons
+ * that press each of the player actions there.
+ *
+ * @group Input
+ */
+type KeyboardSet = {
+  /**
+   * What the players call it: *Left keys*, *Arrows*.
+   *
+   * @pattern \S
+   * @maxLength 40
+   * @errorMessage must not be blank
+   */
+  title?: string;
+  /**
+   * The keys and mouse buttons of each player action, by its id.
+   *
+   * @maxProperties 64
+   * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 48, errorMessage: 'must be a player action id' }
+   */
+  bind: Record<string, KeyboardBinding[]>;
+};
+/**
+ * What each local player does, and how they share the keyboard.
+ *
+ * **One set of actions for every player.** Each local player has their own
+ * copy, pressed by the pad they hold, the part of the keyboard they play with,
+ * or the on-screen controls. A pad's buttons are the same for every pad, so any
+ * number of pads just works; the keyboard is split into sets, one player each,
+ * so the number of sets is how many can share it.
+ *
+ * @group Input
+ */
+type PlayerInputDeclaration = {
+  /**
+   * The actions each player has, by id: never an id `actions` declares too.
+   *
+   * @maxProperties 32
+   * @propertyNames { pattern: '^[a-z0-9]+(?:[._-][a-z0-9]+)*$', maxLength: 48, errorMessage: 'must be lowercase letters, digits, dots, hyphens and underscores' }
+   */
+  actions: Record<string, PlayerInputAction>;
+  /**
+   * The parts of the keyboard players play with, one player each, in the
+   * order they are offered. A player alone hears every one of them. Left out,
+   * the keyboard presses no player's action.
+   *
+   * @minItems 1
+   * @maxItems 4
+   */
+  keyboard?: KeyboardSet[];
 };
 /**
  * Where on the screen a group of on-screen controls sits.
@@ -1641,7 +1353,20 @@ type ControlSlot = {
   as?: InputStick | Record<string, InputBinding$1>;
   /** `thumbstick` only. See `ControlAxis`. Absent, the stick moves both ways. */
   axis?: ControlAxis;
-  [key: string]: unknown;
+  /**
+   * How big this control is next to the layout's others: `1.25` for a jump
+   * button a thumb lands on without looking, `0.8` for one pressed now and then.
+   * Absent, 1.
+   *
+   * A size in the layout rather than in the game's stylesheet, because whether
+   * the layout fits on a small screen is worked out from it before the
+   * controls are drawn. A game's stylesheet changes how they look, never how
+   * much of the screen they answer in.
+   *
+   * @minimum 0.75
+   * @maximum 1.5
+   */
+  scale?: number;
 };
 /**
  * The one direction an on-screen thumbstick moves in: `x` across, `y` up and
@@ -1674,8 +1399,8 @@ type ControlZoneSlots = Record<string, ControlSlot>;
  * 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.
+ * from a newer minor, which a host reads leniently, so whoever draws it simply
+ * has nowhere to put it.
  *
  * @group Input
  */
@@ -1683,7 +1408,6 @@ type ControlLayout = {
   left?: ControlZoneSlots;
   right?: ControlZoneSlots;
   full?: ControlZoneSlots;
-  [key: string]: unknown;
 };
 /**
  * What a game says about how it is played.
@@ -1733,20 +1457,99 @@ type InputDeclaration = {
    * @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;
+  /**
+   * What each local player does, beside `actions`, which are everybody's. See
+   * `PlayerInputDeclaration`.
+   */
+  player?: PlayerInputDeclaration;
+};
+/**
+ * How many people play a game on one device.
+ *
+ * Read by hosts before the game runs: a listing says *1–4 on one device*, and
+ * the input panel offers a row for each player.
+ *
+ * @group Input
+ * @category Useful
+ */
+type PlayersDeclaration = {
+  /**
+   * The most players on one device, each with their own copy of
+   * `input.player`'s actions. 1 when left out.
+   *
+   * @minimum 1
+   * @maximum 8
+   * @asType integer
+   */
+  local?: number;
+};
+/**
+ * A preview's revision: a whole number from 1, the `R` of its package's
+ * `0.R.p`. A breaking change to the preview is a new revision.
+ *
+ * @group Manifest
+ * @category Useful
+ * @minimum 1
+ * @asType integer
+ */
+type PreviewRevision = number;
+/**
+ * The previews a game is written against, each at the revision it needs.
+ *
+ * A preview is a part of the SDK that is not stable yet: its own `0.x`
+ * package, versioned apart from `api`, and served only to the games that
+ * declare it, at the revision they declare. A change to a preview reaches the
+ * games written against it and nobody else.
+ *
+ * @group Manifest
+ * @category Useful
+ */
+type PreviewsDeclaration = {
+  /**
+   * That this game plays over the network, in matches, at this revision of
+   * `@hopple/sdk-preview-network`: `sdk.match`.
+   *
+   * The permission a reviewer grants, and what lets a host offer *Play with
+   * friends* before the game has loaded. Nothing else about networking is
+   * declared: the way a match is played, and its size, are chosen by the game
+   * when it makes one. Absent, a game is never told about a match, and never
+   * reaches one.
+   */
+  network?: PreviewRevision;
 };
 /**
- * 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.
+ * What kind of game this is, as one word from a list every game shares.
+ *
+ * A closed list, because a client files games under these and has to name each
+ * one in front of a player: left to free text, one kind of game becomes three
+ * spellings of it with a game each. The list only grows, since a published
+ * manifest has to stay valid. Whoever reads one may be older than the game, and
+ * ignores a word it does not know.
+ *
+ * `local-multiplayer` and `online-multiplayer` say how a game is played rather
+ * than what it is, and only count where the manifest bears them out: see
+ * `declaredGenres`.
+ *
+ * @group Manifest
+ * @category Useful
+ */
+type GameGenre = 'racing' | 'shooter' | 'platformer' | 'puzzle' | 'arcade' | 'physics' | 'roguelike' | 'strategy' | 'building' | 'idle' | 'sports' | 'horror' | 'stealth' | 'fighting' | 'casual' | 'simulation' | 'adventure' | 'rhythm' | 'rpg' | 'local-multiplayer' | 'online-multiplayer';
+/**
+ * Publishing refuses a key the manifest's API does not know; a host reading a
+ * published one ignores it (see `validateManifest`).
  *
  * @group Manifest
  * @category Important
  */
 type GameManifest = {
-  /** @category Important */
-  schema: typeof MANIFEST_SCHEMA;
+  /**
+   * The API the game is written against. The major picks what the game is
+   * served; the minor is the least it needs. The CLI fills it from the
+   * installed `@hopple/sdk` when the config leaves it out.
+   *
+   * @category Important
+   */
+  api: ApiVersion;
   /**
    * 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
@@ -1770,8 +1573,19 @@ type GameManifest = {
    * @errorMessage must be a handle: lowercase letters, digits and hyphens
    */
   owner?: string;
+  /**
+   * `false` for a game that is never to be uploaded: an example, a test, a
+   * game kept to one machine. `hopple dev` and `hopple check` still run it;
+   * `hopple upload` and `hopple publish` refuse it, and so does a server it
+   * is sent to another way. Absent, it may be published.
+   *
+   * @category Useful
+   */
+  publishable?: boolean;
   /**
    * The game's own version, `MAJOR.MINOR.PATCH`. Ours to read, never to parse for meaning.
+   * People see it beside the build the server numbers each upload with, and
+   * each published version needs one no other published version of the game has.
    *
    * @category Important
    * @pattern ^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$
@@ -1794,6 +1608,18 @@ type GameManifest = {
    * @errorMessage must not be blank
    */
   description?: string;
+  /**
+   * What kind of game it is, the main one first. Read by whoever files it in a
+   * catalogue, which never runs it. At most `GENRE_MAX`, not counting
+   * `local-multiplayer` and `online-multiplayer`: a game that is every kind
+   * tells a player nothing. The publisher's claim, taken at its word, except
+   * for those two. See `GameGenre`.
+   *
+   * @category Useful
+   * @minItems 1
+   * @maxItems 5
+   */
+  genres?: GameGenre[];
   /**
    * A picture of the game, shown wherever a link to it is pasted — a chat, a
    * post, a message.
@@ -1811,22 +1637,6 @@ type GameManifest = {
   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`.
    *
@@ -1864,62 +1674,38 @@ type GameManifest = {
    */
   input?: InputDeclaration;
   /**
-   * What this game makes noise with, one channel at a time, or `null` for a
-   * game that makes none. See `AudioDeclaration`.
+   * How many play on one device. See `PlayersDeclaration`.
    *
-   * @category Important
+   * @category Useful
    */
-  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;
+  players?: PlayersDeclaration;
   /**
-   * 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.
+   * What this game makes noise with, one channel at a time, or `null` for a
+   * game that makes none. See `AudioDeclaration`.
    *
-   * @pattern \S
-   * @errorMessage must be the command that builds the game, like "npm run build"
+   * @category Important
    */
-  build?: string;
+  audio: AudioDeclaration | null;
   /**
-   * The built page, relative to the config: the one file that is published,
-   * so it has to hold the whole game.
+   * The previews this game is written against, each at its revision. See
+   * `PreviewsDeclaration`.
    *
-   * @pattern \.[Hh][Tt][Mm][Ll]?$
-   * @errorMessage must be the built .html file, like "dist/index.html"
+   * @category Useful
    */
-  page: string;
-  /** What the game is. Uploaded beside the page, and read by every host before the game runs. */
-  manifest: GameManifest;
+  previews?: PreviewsDeclaration;
+};
+/**
+ * The manifest as a project's config holds it: `api` may be left out, for the
+ * CLI to fill from the installed `@hopple/sdk`.
+ *
+ * @group Manifest
+ * @category Useful
+ */
+type ProjectManifest = Omit<GameManifest, 'api'> & {
+  api?: ApiVersion;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/achievements.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/achievements.d.ts
 /**
  * Where this player stands on one achievement.
  *
@@ -2017,7 +1803,7 @@ type Achievements<Id extends string = string, Measured extends string = Id> = {
   progress(id: Measured, value: number): void;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/analytics.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/analytics.d.ts
 /**
  * @group Analytics
  * @category Important
@@ -2034,7 +1820,7 @@ type Analytics<Events extends object = Record<string, AnalyticsProps>> = {
   track<Event extends keyof Events & string>(name: Event, props?: Events[Event]): void;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/audio.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/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
@@ -2066,8 +1852,6 @@ type Audio<Channel extends string = string> = {
   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`.
    *
@@ -2127,7 +1911,7 @@ type Audio<Channel extends string = string> = {
   media(element: HTMLMediaElement, channel?: Channel): Unsubscribe;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/info.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/info.d.ts
 /**
  * What the host said, frozen.
  *
@@ -2145,7 +1929,7 @@ type Info = Readonly<{
   device: Readonly<DeviceInfo>;
 }>;
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/layout.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/layout.d.ts
 /**
  * How much of each edge belongs to the host. CSS pixels.
  *
@@ -2255,7 +2039,7 @@ type InsetPolicy = {
  */
 declare function insetsFrom(obstructions: readonly Obstruction[], frame: Size, policy?: InsetPolicy): Insets;
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/names.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/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
@@ -2274,6 +2058,19 @@ type ActionName<M> = M extends {
     actions?: infer A;
   };
 } ? DeclaredNames<NonNullable<A>> : never;
+/**
+ * An action each local player has, as the manifest declares it under
+ * `input.player.actions`.
+ *
+ * @group Names
+ */
+type PlayerActionName<M> = M extends {
+  input?: {
+    player?: {
+      actions?: infer A;
+    };
+  };
+} ? DeclaredNames<NonNullable<A>> : never;
 /**
  * An on-screen control layout the manifest declares under `input.controls`.
  *
@@ -2362,7 +2159,7 @@ type EventProps<M> = M extends {
  */
 type StickName = 'pad.left.stick' | 'pad.right.stick' | 'pad.stick' | `controls.${string}`;
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/input/state.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/input/state.d.ts
 /**
  * Where the pointer is, in the frame's own coordinates.
  *
@@ -2423,246 +2220,453 @@ type InputSnapshot<Action extends string = string> = {
   pointer: PointerState | null;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/input/controls.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/input/players.d.ts
+/**
+ * What one player holds: a pad, one part of the keyboard, or the on-screen
+ * controls.
+ *
+ * @group Input
+ */
+type Controller =
+/** One of the keyboard sets the game declared, from 0, with the title it gave it. */
+{
+  kind: 'keyboard';
+  set: number;
+  title: string;
+} |
+/** A pad, by `Gamepad.index`. */
+{
+  kind: 'gamepad';
+  pad: number;
+} | {
+  kind: 'touch';
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/input/pointers.d.ts
 /**
- * The name a host leaves its input shim under.
+ * Presses and groups of fingers on an element, recognised and meaning nothing:
+ * what a game's tools, or a camera, are built on.
  *
- * 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.
+ * What a press *is* is the same in every game, and every game that read
+ * pointer events itself got some of it wrong, in the same few ways: a touch
+ * the browser cancelled that counted as a tap, a drag that stuck when the mouse
+ * was let go outside the frame, a view that jumped when a third finger came or
+ * one of two went. What a press *means* is the game's, and differs per press:
+ * one finger paints in an editor and pans in a map, and paints again once the
+ * player picks the brush. So each layer of a game is asked, as a press goes
+ * down, whether it is theirs, and the SDK tells its owner what it does.
+ */
+/**
+ * A point on an element, in CSS pixels from its top left corner.
  *
  * @group Input
  */
-declare const INPUT_SHIM = "__HOPPLE_INPUT__";
+type Point = {
+  x: number;
+  y: number;
+};
 /**
- * One control, as a renderer is given it. Resolved: no ids left to look up.
+ * The modifier keys held.
  *
  * @group Input
  */
-type ControlModelSlot = {
-  id: string;
-  type: 'buttons' | 'thumbstick';
-  /** Always a shape this SDK knows. An unfamiliar one has already become `column`. */
-  shape: InputLayoutShape;
+type Modifiers = {
+  shift: boolean;
+  ctrl: boolean;
+  alt: boolean;
+  meta: boolean;
+};
+/**
+ * What a press is made with.
+ *
+ * @group Input
+ */
+type PointerDevice = 'mouse' | 'touch' | 'pen';
+/**
+ * A mouse button, by where it is. A pen's barrel button is `'right'`.
+ *
+ * @group Input
+ */
+type PointerButton = 'left' | 'middle' | 'right';
+/**
+ * One finger, pen or mouse button on an element, from going down to coming up.
+ * The same object throughout, kept up to date.
+ *
+ * @group Input
+ */
+type Press = {
+  readonly id: number;
+  readonly device: PointerDevice;
+  /** The mouse button; `null` for a finger or a pen's tip. */
+  readonly button: PointerButton | null;
+  /** The modifier keys held as it went down. */
+  readonly modifiers: Modifiers;
+  readonly start: Point;
+  readonly at: Point;
+  /** Whether it has gone further than the layer's `slop` from `start`. */
+  readonly moved: boolean;
+  /** Whether it stayed still for the layer's `holdMs`. */
+  readonly held: boolean;
+  /** Milliseconds since it went down. */
+  readonly age: number;
+};
+/**
+ * What a layer does with a press it took. Exactly one of `tap`, `end` and
+ * `cancel` finishes it.
+ *
+ * @group Input
+ */
+type PressHandler = {
   /**
-   * For `buttons`: what each one presses, what to draw on it, and the standard
-   * control it stands in for where the layout said one.
+   * It moved, by this many CSS pixels: once it has gone past `slop`, the first
+   * time from `start` so what was under it stays under it; from the first
+   * pixel with `immediate`.
    */
-  buttons: readonly {
-    action: string;
-    label: string;
-    as?: string;
-  }[];
-  /** For `thumbstick`: the stick id it drives. */
-  stick: string;
+  move?(press: Press, dx: number, dy: number): void;
+  /** Let go without having moved or held. */
+  tap?(press: Press): void;
+  /** Stayed still for `holdMs`. It never taps after that. */
+  hold?(press: Press): void;
+  /** Let go after moving or holding, at this velocity in CSS pixels a second. */
+  end?(press: Press, velocity: Point): void;
   /**
-   * 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.
+   * Taken away: by the browser (a scroll, a system gesture), by a second
+   * finger that another layer made a group, or by the layer going. Undo
+   * whatever it started.
    */
-  axis?: InputLayoutAxis;
+  cancel?(press: Press): void;
+  /** Hear moves from the first pixel rather than past `slop`: for drawing, or aiming. */
+  immediate?: boolean;
+};
+/**
+ * Two fingers or more on an element, from the second going down to the last
+ * coming up. The same object throughout, kept up to date.
+ *
+ * @group Input
+ */
+type Group = {
+  /** How many fingers are down now: one, once all but one have lifted. */
+  readonly fingers: number;
+  /** The most that were down at once: 2 for a two-finger tap. */
+  readonly most: number;
+  /** Midway between the first two fingers, or where the one left is; for a tap, where they were together. */
+  readonly centre: Point;
+  /** How far apart the first two fingers are, in CSS pixels; 0 with one. */
+  readonly spread: number;
+  /** The angle from the first finger to the second, in radians. */
+  readonly angle: number;
+  /** Whether any finger has gone further than `slop` from where it went down. */
+  readonly moved: boolean;
+  /** Milliseconds since the second finger went down. */
+  readonly age: number;
+};
+/**
+ * How a group moved since it last did: what a pinch, a two-finger drag and a
+ * twist do, at once. A finger coming or going moves nothing.
+ *
+ * @group Input
+ */
+type GroupChange = {
+  /** How far the centre moved, in CSS pixels. */
+  dx: number;
+  dy: number;
+  /** How much further apart the first two fingers are, as a factor: above 1 is apart. */
+  scale: number;
+  /** How far they turned, in radians, clockwise. */
+  rotate: number;
 };
 /**
+ * What a layer does with a group it took. Exactly one of `tap`, `end` and
+ * `cancel` finishes it.
+ *
  * @group Input
  */
-type ControlModelZone = {
-  zone: InputLayoutZone;
-  controls: readonly ControlModelSlot[];
+type GroupHandler = {
+  move?(group: Group, change: GroupChange): void;
+  /** Every finger lifted, none having moved, quicker than `holdMs`. */
+  tap?(group: Group): void;
+  /** Every finger lifted otherwise, the centre leaving at this velocity in CSS pixels a second. */
+  end?(group: Group, velocity: Point): void;
+  /** Taken away: the browser took the last finger, or the layer went. */
+  cancel?(group: Group): void;
 };
 /**
- * A whole layout, resolved against the manifest's actions.
+ * One layer of a game's on an element: `input.pointers`.
  *
  * @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;
+type PointerLayer = {
   /**
-   * 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.
+   * Whether a press going down is this layer's: a handler takes it, for good;
+   * `null` leaves it to the layers below. Asked of the newest layer first, and
+   * of a camera last.
    */
-  insets: Insets;
+  press?(press: Press): PressHandler | null;
   /**
-   * How a thumbstick meets a thumb, as the player set it on their host.
-   *
-   * `floating`: marked where the layout puts it, so a player can see there is
-   * a stick, brought to wherever a thumb lands on its side of the screen, so
-   * the place they first touch is the centre, and pulled along by a thumb that
-   * goes past its rim. `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.
+   * Whether fingers that make a group are this layer's, asked as the second
+   * goes down. A layer that takes them cancels the press of every finger in
+   * it. Taken by nobody, the new finger is a press of its own.
    */
-  sticks: InputSticks;
+  group?(group: Group): GroupHandler | null;
+  /** A mouse or a pen over the element with nothing pressed; `null` once it leaves. */
+  hover?(at: Point | null, device: PointerDevice): void;
+  /** How far a press may move, in CSS pixels, and still tap. 8 when left out. */
+  slop?: number;
+  /** How long a press stays still to hold, in milliseconds. 450 when left out. */
+  holdMs?: number;
 };
 /**
- * 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.
+ * A layer of pointers, being read: `input.pointers`.
  *
  * @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;
+type Pointers = {
+  /** Whether a press or a group this layer took is down now. */
+  readonly active: boolean;
+  /** Take the layer off; whatever it holds is cancelled. */
+  dispose(): void;
 };
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/input/wheel.d.ts
 /**
- * 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.
+ * One turn of a wheel, swipe of a trackpad, or pinch on one, the same in every
+ * browser: `input.wheel`.
  *
  * @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;
+type Wheel = {
+  /** A mouse wheel's notches, a trackpad's scroll, or a trackpad's pinch (Ctrl and a wheel are one too). */
+  kind: 'notch' | 'smooth' | 'pinch';
+  /** How far, in CSS pixels, positive right and down. A notch is 100 in every browser. 0 for a pinch. */
+  x: number;
+  y: number;
   /**
-   * 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.
+   * Whole steps down, negative up: one for each notch, and on a trackpad one
+   * as a swipe starts and another every 200 pixels after. What `mouse.wheelup`
+   * and `mouse.wheeldown` press. 0 for a pinch.
    */
-  render?(root: ShadowRoot, model: ControlModel, report: ControlReport): (() => void) | void;
+  steps: number;
+  /** A pinch's zoom, above 1 closer. 1 for anything else. */
+  scale: number;
+  /** A twist on Safari's trackpad, in radians, clockwise. 0 for anything else. */
+  rotate: number;
+  /** Where the pointer is, in CSS pixels from the element's top left corner. */
+  at: Point;
+  modifiers: Modifiers;
 };
 /**
+ * The wheel being taken over an element: `input.wheel`.
+ *
  * @group Input
  */
-declare function isInputShim(value: unknown): value is InputShim;
+type WheelTaker = {
+  /** What was taken since the last read, added up: for a game that reads once a frame. */
+  read(): {
+    x: number;
+    y: number;
+    steps: number;
+  };
+  /** Stop taking it. */
+  dispose(): void;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/input/camera.d.ts
 /**
- * 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.
+ * What the camera should do: one for each move of a finger, a pair of them,
+ * a wheel or a glide, whichever it was.
  *
  * @group Input
  */
-declare const INPUT_CONTRACT = 4;
-//#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/input/bindings.d.ts
+type CameraChange = {
+  /** Move what is shown by this, in CSS pixels: it follows the finger. */
+  dx: number;
+  dy: number;
+  /** Zoom by this factor around `x`, `y`, above 1 closer; 1 when not zooming. */
+  scale: number;
+  /** Turn by this, in radians clockwise around `x`, `y`: two fingers, or Safari's trackpad. */
+  rotate: number;
+  /** The point zoomed and turned around, in CSS pixels from the element's top left corner. */
+  x: number;
+  y: number;
+  /** What made it: so a game can treat a wheel differently from a finger. */
+  source: 'drag' | 'pinch' | 'wheel' | 'trackpad' | 'glide';
+};
 /**
- * The standard mapping's buttons, by index, as the names this SDK uses.
+ * A press or a group of fingers the camera had that never moved.
  *
- * `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.
+ * @group Input
+ */
+type Tap = {
+  at: Point;
+  device: PointerDevice;
+  /** The mouse button; `null` for fingers and a pen's tip. */
+  button: PointerButton | null;
+  /** How many fingers: 2 or 3 for a tap of that many. */
+  fingers: number;
+  modifiers: Modifiers;
+};
+/**
+ * What a wheel does to a camera.
  *
- * **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
+ */
+type WheelMode = 'zoom' | 'pan' | 'none';
+/**
+ * @group Input
+ */
+type CameraOptions = {
+  /** A view to move with every change. */
+  view?: View;
+  /** Hear every change, with or without a view: for a camera of the game's own. */
+  move?(change: CameraChange): void;
+  /** A drag or a pinch was let go, at this velocity in CSS pixels a second. */
+  end?(velocity: Point): void;
+  /** A press or a group of fingers the camera had, let go without moving. */
+  tap?(tap: Tap): void;
+  /** A press the camera had, held still. It never taps then. */
+  hold?(tap: Tap): void;
+  /** Which mouse buttons drag. A finger and a pen always do. `['left', 'middle']` when left out. */
+  buttons?: readonly PointerButton[];
+  /**
+   * What the wheel does. Left out, a wheel's notch zooms around the pointer and
+   * a trackpad pans, the way maps do; `'zoom'` or `'pan'` makes both do that,
+   * and `'none'` leaves the wheel alone. A function decides for each turn: a
+   * menu open, Shift held. A pinch on a trackpad zooms unless it says `'none'`.
+   */
+  wheel?: WheelMode | ((wheel: Wheel) => WheelMode);
+  /** Keep moving after a fling, slowing down, until the next press or wheel. */
+  inertia?: boolean;
+  /** How far a press may move, in CSS pixels, and still tap. 8 when left out. */
+  slop?: number;
+  /** How long a press stays still to hold, in milliseconds. 450 when left out. */
+  holdMs?: number;
+};
+/**
+ * A camera on an element: `input.camera`.
  *
  * @group Input
  */
-declare const PAD_BUTTONS: readonly (string | null)[];
+type Camera = {
+  /** Whether a press or fingers the camera has are down now. */
+  readonly active: boolean;
+  /** Stop: the element's presses and its wheel go back to whoever else wants them. */
+  dispose(): void;
+};
 /**
- * The binding a player would actually use, given what they are holding.
+ * A camera over a flat world: `input.view`.
  *
- * 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.
+ * The world is in a game's own units, with `y` down; `scale` is CSS pixels to
+ * one of them, and `x`, `y` the world point at the element's top left corner.
+ * A game draws with them, `screen = (world - x) * scale`, and may set any of
+ * them; each move keeps them inside `min`, `max` and `bounds`.
  *
  * @group Input
- * @category Useful
  */
-declare function preferredBinding(bind: readonly string[], scheme: InputScheme): string | undefined;
+type View = {
+  x: number;
+  y: number;
+  scale: number;
+  /** The one axis it moves along, for a strip; `null` for both. */
+  readonly axis: 'x' | 'y' | null;
+  /** Drag the view by this many CSS pixels, the world following the finger. */
+  pan(dx: number, dy: number): void;
+  /** Zoom by this factor, the world point at `x`, `y` staying where it is. */
+  zoom(factor: number, x: number, y: number): void;
+  /** Put the world point `x`, `y` in the middle of the element, at `scale` if given. */
+  look(x: number, y: number, scale?: number): void;
+  /** The world point at a point on the element. */
+  toWorld(x: number, y: number): Point;
+  /** The point on the element a world point is drawn at. */
+  toScreen(x: number, y: number): Point;
+  /**
+   * Say how big the element is, in CSS pixels: what `look` centres on and
+   * `bounds` keeps filled. Call it whenever the element changes size.
+   */
+  resize(width: number, height: number): void;
+};
 /**
- * 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;
+type ViewOptions = {
+  x?: number;
+  y?: number;
+  scale?: number;
+  /** The least `scale` it zooms out to. */
+  min?: number;
+  /** The most `scale` it zooms in to. */
+  max?: number;
+  /**
+   * Move along this axis only, for a strip: the other never pans nor shifts
+   * as it zooms, and a camera turns a vertical wheel into a pan along it.
+   */
+  axis?: 'x' | 'y';
+  /**
+   * The part of the world the view stays over, in world units: never scrolled
+   * past an edge, and centred on it once all of it fits.
+   */
+  bounds?: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+  /** The element's size in CSS pixels, as `resize` takes it. */
+  width?: number;
+  height?: number;
+};
+//#endregion
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/input/lock.d.ts
 /**
- * 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.
+ * The mouse held to the game: `input.pointerLock`.
  *
  * @group Input
- * @category Useful
  */
-declare function labelFor(binding: string, scheme: InputScheme): string;
+type PointerLock = {
+  /** Whether the mouse is locked to the game now. */
+  readonly locked: boolean;
+  /**
+   * Lock the mouse to an element, the whole page when left out, now if the
+   * browser allows it and on the player's next click or key if not.
+   *
+   * Asked again after the player has just left a lock, the browser makes them
+   * wait about a second; the SDK waits with them. Ask from a press of the
+   * player's where you can, a click on the game or the key that resumes it:
+   * from a frame loop, the browser may not take it until they press something.
+   */
+  request(element?: Element): void;
+  /** Let the mouse go, and stop waiting to take it. */
+  release(): void;
+  /**
+   * Run this when the lock is taken or lost. Lost without `release` is the
+   * player leaving it, with Escape or by switching away: the time to pause.
+   * The SDK does not take it back on its own; `request` again on resuming.
+   */
+  on(listener: (locked: boolean) => void): Unsubscribe;
+  /**
+   * Run this for each move of the mouse while it is locked, in CSS pixels,
+   * or in the mouse's own counts where the browser gives those
+   * (`unadjustedMovement`). The jumps a browser sends as a lock starts are
+   * left out.
+   */
+  onMove(listener: (dx: number, dy: number) => void): Unsubscribe;
+  /**
+   * How far the mouse moved while locked since the last read, added up the way
+   * `onMove` hears it: for a game that reads once a frame.
+   */
+  read(): {
+    x: number;
+    y: number;
+  };
+};
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/input/index.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/input/index.d.ts
 /**
- * How far a stick moves before it counts, where no shim has an opinion.
+ * A binding a game can name on its own, for a prompt about a button that is
+ * not one of its actions: `pad.start`, `key.Space`.
  *
  * @group Input
- * @category Useful
  */
-declare const DEADZONE = 0.15;
+type ButtonName = `key.${string}` | `pad.${string}` | `mouse.${string}` | `pointer.${string}` | `touch.${string}`;
 /**
  * What presses each action, and what the player is pressing with: the part of
  * input that is state rather than a stream of presses.
@@ -2673,11 +2677,12 @@ 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.
+   * `mapping.shoot.label` names one binding in text: *Z* on a keyboard, a
+   * letter for whatever pad the player picked up, and the label the manifest
+   * gave the on-screen button on a touch screen. A prompt is better drawn with
+   * `glyph`, which shows every binding, the same on every controller, and
+   * follows a rebinding without being redrawn. An action can be missing, so
+   * keep a fallback.
    */
   readonly mapping: Readonly<Partial<Record<Action, InputBinding>>>;
   /** What the player is using right now. */
@@ -2697,7 +2702,7 @@ type InputListener<Action extends string = string> = (now: InputState<Action>, p
  * @group Input
  * @category Important
  */
-type Input<Action extends string = string, Layout extends string = string> = InputState<Action> & {
+type Input<Action extends string = string, Layout extends string = string, PlayerAction extends string = Action> = InputState<Action> & {
   /**
    * Run this whenever an action goes down or comes up.
    *
@@ -2737,6 +2742,49 @@ type Input<Action extends string = string, Layout extends string = string> = Inp
    * The pointer's position needs `poll` set; presses and sticks do not.
    */
   read(): InputSnapshot<Action>;
+  /**
+   * A character that draws what presses an action now, in the font `font`
+   * names: every key or button bound to it, for the device in the player's
+   * hands, as a keycap or a pad button.
+   *
+   *     hint.textContent = `Press ${hopple.input.glyph('jump')} to jump`;
+   *     ctx.font = `20px 'My Font', sans-serif, ${hopple.input.font}`;
+   *
+   * The character is the same for the whole session; what changes is the font
+   * the SDK draws it with, which follows the player's bindings and their
+   * device. So text in the DOM is right without being touched again, and a
+   * canvas is right the next time it is painted. A binding works too —
+   * `glyph('pad.start')` — for a button that is no action of the game's.
+   *
+   * Only in a font stack that names `font`, and names it last: a box
+   * otherwise. Under `hopple dev` a glyph printed anywhere else is reported to
+   * `onError`.
+   */
+  glyph(name: Action | ButtonName): string;
+  /**
+   * What `glyph` draws, in words: `Z or Space`, `bottom face button`. For an
+   * `aria-label`, and for text drawn with no fonts at all. Empty for an action
+   * with nothing bound for this device.
+   */
+  describe(name: Action | ButtonName): string;
+  /** The font family `glyph` draws in: name it, last, wherever a glyph is printed. */
+  readonly font: string;
+  /**
+   * Draw an icon on an action's on-screen button instead of its label, or
+   * `null` to go back to the label.
+   *
+   *     hopple.input.icon('jump', 'M12 3 4 13h5v8h6v-8h5z');
+   *
+   * One SVG path, filled in the buttons' ink, in a 24 by 24 box: what icon
+   * sets draw filled icons in. The label stays the button's name for a screen
+   * reader. `glyph(action)` on a touch screen draws the same icon, so a prompt
+   * matches the button. A path that cannot be read, or that leaves the box, is
+   * reported to `onError` and the label is drawn instead.
+   *
+   * How the controls look otherwise is the game's stylesheet's: see the
+   * skill's input guide.
+   */
+  icon(action: Action, path: string | null): void;
   /**
    * Stop reading input and let go of everything held.
    *
@@ -2748,6 +2796,112 @@ type Input<Action extends string = string, Layout extends string = string> = Inp
   suspend(): void;
   resume(): void;
   readonly suspended: boolean;
+  /**
+   * Hear presses on an element, recognised and meaning nothing yet: a layer of
+   * the game's, for its tools, its aim, its brush.
+   *
+   *     hopple.input.pointers(canvas, {
+   *       press: (p) => tool === 'road' && p.button !== 'right' ? road(p) : null,
+   *     });
+   *
+   * Each press is offered to the layers on the element as it goes down, the
+   * newest first and a `camera` last; the first to return a handler has it,
+   * and hears it move, tap, hold, end or be cancelled. Two fingers or more are
+   * offered as a group first: a layer that takes them cancels their presses.
+   * A drag let go outside the frame still ends, a touch the browser took never
+   * taps, and a finger coming or going moves nothing. The element gets
+   * `touch-action: none` until its last layer is disposed.
+   */
+  pointers(element: Element, layer: PointerLayer): Pointers;
+  /**
+   * Take the wheel over an element: a mouse wheel, a trackpad's scroll and its
+   * pinch, the same in every browser, as an amount and as whole steps.
+   *
+   *     const wheel = hopple.input.wheel(list, (w) => void (scroll += w.y));
+   *
+   * The page does not scroll under it, and `mouse.wheelup` / `mouse.wheeldown`
+   * do not hear it, unless the listener returns `false` for that turn.
+   * `read()` adds up what was taken since it was last read.
+   */
+  wheel(element: Element, listener?: (wheel: Wheel) => boolean | void): WheelTaker;
+  /**
+   * A camera on an element, moved by whatever presses no other layer took:
+   * one finger or a mouse button drags, two fingers pinch, pan and turn, a
+   * mouse wheel zooms around the pointer and a trackpad pans and pinches, at
+   * one speed in every browser.
+   *
+   *     const view = hopple.input.view({ min: 0.5, max: 4, bounds: world });
+   *     hopple.input.camera(canvas, { view, tap: ({ at }) => select(view.toWorld(at.x, at.y)) });
+   *
+   * A `view` is moved for it; `move` hears every change, for a camera of the
+   * game's own.
+   */
+  camera(element: Element, options: CameraOptions): Camera;
+  /**
+   * A camera over a flat world that `camera` moves, kept between `min` and
+   * `max` and over `bounds`. Nothing in it is drawn: a game reads `x`, `y`
+   * and `scale` when it draws.
+   */
+  view(options?: ViewOptions): View;
+  /** The mouse held to the game, for a game that turns a camera with it. */
+  readonly pointerLock: PointerLock;
+  /**
+   * The players on this device, each with their own copy of the actions
+   * `input.player` declares, by `slot`. Empty for a game that declares none;
+   * otherwise the first player is always there.
+   *
+   * Frozen and replaced when somebody joins or leaves. `read()`, `onAction`
+   * and `glyph` on the input itself answer for a player action as if every
+   * player pressed it: what a menu anybody may work reads.
+   */
+  readonly players: readonly Player<PlayerAction>[];
+  /** Run this when a player joins or leaves, claims a controller, or picks up another. */
+  onPlayers(listener: (players: readonly Player<PlayerAction>[]) => void): Unsubscribe;
+  /**
+   * Whether a press of a join action on a controller nobody plays with seats
+   * a new player: set it on the screen where players join, and clear it
+   * before play.
+   *
+   * Setting it gives the first player the controller they last used, so the
+   * others' presses on the rest make them players. The first player's first
+   * press, if they have pressed nothing yet, is theirs.
+   */
+  joining: boolean;
+  /**
+   * The most players this device may have now: what the manifest declares, or
+   * fewer where the match being played has no room for more.
+   */
+  readonly mostPlayers: number;
+};
+/**
+ * One player on this device: their own actions, read from the controllers
+ * they hold.
+ *
+ * @group Input
+ * @category Important
+ */
+type Player<Action extends string = string> = {
+  /** Their place, from 0: the lowest free one when they joined, kept until they leave. */
+  readonly slot: number;
+  /**
+   * What they play with: the controller they claimed, or the one they last
+   * used. `null` once their pad has gone away, until a free one is pressed.
+   */
+  readonly controller: Controller | null;
+  /** What they are using now, for what to draw: never which device to read. */
+  readonly scheme: InputScheme;
+  /** What presses each action for them, on the controllers they hear. */
+  readonly mapping: Readonly<Partial<Record<Action, InputBinding>>>;
+  /** Their actions now, and what happened since their last read: once a frame, as `input.read()`. */
+  read(): InputSnapshot<Action>;
+  onAction(action: Action, listener: ActionListener<Action>): Unsubscribe;
+  /** Their sticks: their pad's, or the on-screen one when they hold the touch screen. */
+  onStick(stick: StickName, listener: StickListener): Unsubscribe;
+  /** A character drawing what presses an action for this player, as `input.glyph` draws it. */
+  glyph(action: Action | ButtonName): string;
+  describe(action: Action | ButtonName): string;
+  /** Take them out: what they held is free again. The only player stays. */
+  leave(): void;
 };
 /**
  * The on-screen controls: shown when the game says so *and* the host says they
@@ -2791,7 +2945,7 @@ type Controls<Layout extends string = string> = {
   readonly available: boolean;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/lifecycle.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/lifecycle.d.ts
 /** @group Lifecycle */
 type LifecycleListener = (phase: Phase, previous: Phase) => void | Promise<void>;
 /**
@@ -2810,7 +2964,7 @@ type Lifecycle = {
   on(listener: LifecycleListener): Unsubscribe;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/loop.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/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.
@@ -2864,7 +3018,36 @@ type Loop = {
   tick(frame: FrameCallback): Unsubscribe;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/panel.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/panel.d.ts
+/**
+ * The pages of the host's panel a game has a name for, as the keys of this
+ * interface.
+ *
+ * An interface rather than a union so that a preview can add its own pages to
+ * it, as it adds its own namespace to `GameSdk`: a page only a preview's games
+ * are offered is named only where that preview is installed.
+ *
+ * @group Panels
+ */
+interface PanelPages {
+  /** What this game is: its title, its author, its description. */
+  about: true;
+  /** Who has scored what, on this game's boards. */
+  scores: true;
+  /** What has been unlocked, and how far along the rest is. */
+  achievements: true;
+  /** What this game is played with, and where a player rebinds it. */
+  input: true;
+}
+/**
+ * A page of the host's panel: one of `PanelPages`.
+ *
+ * It grows, and it only ever grows: a name means the same thing for ever,
+ * because a game ships and is never updated.
+ *
+ * @group Panels
+ */
+type PageId = keyof PanelPages;
 /**
  * Where the host's panel stands over the game.
  *
@@ -2973,7 +3156,7 @@ type Panel = {
   open(page: PageId): void;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/pause.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/pause.d.ts
 /**
  * The host has asked for a pause, or for the game to carry on.
  *
@@ -3034,7 +3217,7 @@ type Pause = {
   on(listener: PauseListener): Unsubscribe;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/resources.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/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.
@@ -3064,7 +3247,7 @@ type Resources = {
   on(listener: ResourcesListener): Unsubscribe;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/save.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/save.d.ts
 /**
  * What a game gets back from a read: its own schema number, and its state.
  *
@@ -3074,7 +3257,10 @@ type Resources = {
 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. */
+  /**
+   * Parsed where it was written as a value, verbatim where it was a string, and
+   * a `Uint8Array` where it was one.
+   */
   state: unknown;
 };
 /**
@@ -3103,6 +3289,66 @@ type SaveStatus = {
  * @category Useful
  */
 type SaveListener = (now: SaveStatus, previous: SaveStatus) => void;
+/**
+ * Make one save of two that went their own ways.
+ *
+ * `mine` is this device's, `theirs` one another device made meanwhile, and
+ * neither was built on the other. Answer with the save to keep in place of
+ * both, on whatever schema `version` it is written in. Throw where the two
+ * cannot be merged — a schema this build does not know — and the host asks the
+ * player which to keep.
+ *
+ * Pure: it is called with two states and must not touch the game's own. Run
+ * while the game loads, its answer is what `read()` resolves with; run while
+ * the game plays, its answer goes to `onChange` as well.
+ *
+ * @group Save
+ * @category Useful
+ */
+type SaveMerger = (mine: SaveState, theirs: SaveState) => SaveState;
+/**
+ * Why the save a game plays on changed under it.
+ *
+ * - `arrived`: another device's save, built on what the game had — a server
+ *   that answered after the game read, or another device that played on. Run
+ *   through the game's `merge` with what it last saved, where it has one.
+ * - `merged`: the game's `merge` made one save of this device's and another
+ *   that went their own ways.
+ * - `gone`: thrown away on another device, with nothing made here since. The
+ *   save is `null`.
+ *
+ * @group Save
+ * @category Useful
+ */
+type SaveChangeReason = 'arrived' | 'merged' | 'gone';
+/**
+ * Told the save the game now plays on, once it changed under it while it
+ * played, and why: play on from this. `null` is a save thrown away on another
+ * device (`gone`): start again.
+ *
+ * The host now holds what the listener is handed, and the game's next write
+ * continues it. To keep the game's own instead — progress it has not saved
+ * yet, or a New game the player has just chosen over a save that arrived
+ * after — write it from the listener: it takes that save's place.
+ *
+ * @group Save
+ * @category Useful
+ */
+type SaveChangeListener = (save: SaveState | null, why: SaveChangeReason) => void;
+/**
+ * What a game says about its save at `init`, before the host has asked
+ * anything.
+ *
+ * @group Save
+ * @category Useful
+ */
+type SaveSetup = {
+  /**
+   * How to make one save of two. Left out, the host asks the player which of
+   * the two to keep. See `SaveMerger`.
+   */
+  merge?: SaveMerger | undefined;
+};
 /**
  * @group Save
  * @category Important
@@ -3134,10 +3380,12 @@ type Save = {
   /**
    * 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.
+   * A string is stored as it stands and comes back a string; a `Uint8Array` is
+   * stored as its bytes and comes back a `Uint8Array`, `maxBytes` counting the
+   * bytes themselves; 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, and bytes on a host
+   * older than keeping them reject with `unsupported`.
    *
    * `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
@@ -3149,11 +3397,32 @@ type Save = {
   }): Promise<void>;
   /** Throw the save away — a game resetting its own progress, at a player's asking. */
   clear(): Promise<void>;
+  /**
+   * Told when the save the game plays on changed under it, and why: play on
+   * from what the listener is handed.
+   *
+   * That is another device's save arriving after the game read — a server
+   * that answered late, a page left open while another device played on —
+   * (`arrived`), or the game's own `merge` run while it played (`merged`), or
+   * the save thrown away on another device with nothing made here since
+   * (`gone`, `null`). Without a merge, an arrival is handed over as it is: it
+   * is built on what the game had.
+   *
+   * Listening is what lets a game start before its save is in hand: draw from
+   * nothing at once, and take the player's save when it comes. Register it
+   * before `read()`. A game that is not listening is never written over —
+   * what it writes next is kept beside what arrived, for its merge or the
+   * player to settle.
+   *
+   * To keep the game's own over what it is handed, write it from the
+   * listener: that write takes the handed save's place.
+   */
+  onChange(listener: SaveChangeListener): Unsubscribe;
   /** The largest save this host will take, in bytes. `SAVE_BYTES` where it said nothing. */
   readonly maxBytes: number;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/score.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/score.d.ts
 /**
  * Where this player stands on every board, as far as anybody has said.
  *
@@ -3230,7 +3499,7 @@ type Score<Board extends string = string> = {
   }): Promise<ScoreResult>;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/share.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/share.d.ts
 /**
  * @group Share
  * @category Important
@@ -3257,9 +3526,18 @@ type Share = {
    * 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.
+   * nobody arrived by one, or that the link carried bytes, which are `bytes`;
+   * `available` is what says whether one can be made.
    */
   readonly data: string | null;
+  /**
+   * What the link that opened this game carried, where some run of this game
+   * passed `offer` a `Uint8Array`: those bytes. `null` otherwise — a player who
+   * arrived the ordinary way, or a link that carried a string, which is `data`.
+   *
+   * A stranger's input, exactly as `data` is.
+   */
+  readonly bytes: Uint8Array | null;
   /**
    * Ask the host to put a link to this game in front of the player.
    *
@@ -3269,23 +3547,26 @@ type Share = {
    * 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`.
+   * `data` is the game's own and travels with the link, opaque to the host,
+   * back to whoever opens it: a string, which arrives as `share.data`, or a
+   * `Uint8Array`, which arrives as `share.bytes`. The game reading it back is
+   * the game that wrote it, so anything structured is the game's to encode and
+   * the game's to parse — bytes pack a board far tighter than text does.
+   * `SHARE_BYTES` is what every host carries, counted in bytes either way; 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.
+   * is handed it; the game's team reads it, with `data`, by `hopple share`.
    *
    * 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;
+   * for a `data` that is neither a string nor a `Uint8Array`, or a `meta` JSON
+   * cannot carry, which are bugs in the game; `unsupported` for bytes on a host
+   * older than carrying them; `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
@@ -3297,12 +3578,12 @@ type Share = {
    * sheet on screen comes from the player's own gesture.
    */
   offer(options?: {
-    data?: string;
+    data?: string | Uint8Array;
     meta?: ShareMeta;
   }): void;
 };
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/game/src/init.d.ts
+//#region ../../../../../../../tmp/hopple-sdk-types-hbSZtA/game/src/init.d.ts
 /**
  * What `init` hands back: every namespace a game has, on one object.
  *
@@ -3317,7 +3598,7 @@ type Share = {
  * @group Bridge
  * @category Useful
  */
-type GameSdk<M extends object = GameManifest> = {
+interface 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()`.
@@ -3433,7 +3714,7 @@ type GameSdk<M extends object = GameManifest> = {
    *
    * @category Useful
    */
-  input: Input<ActionName<M>, LayoutName<M>>;
+  input: Input<ActionName<M> | PlayerActionName<M>, LayoutName<M>, PlayerActionName<M>>;
   /**
    * How loud this game may be, which the host decides and the game obeys.
    *
@@ -3526,19 +3807,17 @@ type GameSdk<M extends object = GameManifest> = {
    *
    * 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.
+   * check, and what a game can measure the bridge with.
    */
   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`.
    *
@@ -3548,22 +3827,6 @@ type InitOptions = {
    * 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`.
@@ -3572,6 +3835,15 @@ type InitOptions = {
    * them, as it is about any error the game throws and nothing catches.
    */
   onError?: ((error: unknown) => void) | undefined;
+  /**
+   * What the game says about its save before the host asks anything: how to
+   * merge two saves that went their own ways, on two devices. See `SaveSetup`.
+   *
+   * Here rather than on `sdk.save`, because the host may ask while the game is
+   * still reading its save — the merge is what that read resolves with — and a
+   * merge set after the read would be one the host never heard of.
+   */
+  save?: SaveSetup | undefined;
 };
 /**
  * Introduce the game to its host, and hand back the SDK once it has answered.
@@ -3607,62 +3879,4 @@ type InitOptions = {
  */
 declare function init<M extends object = GameManifest>(options?: InitOptions): Promise<GameSdk<M>>;
 //#endregion
-//#region ../../../../../../../tmp/hopple-sdk-types-DAYaix/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-DAYaix/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 };
+export { type Achievement, type AchievementDeclaration, type AchievementListener, type AchievementName, type AchievementProgress, 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 ApiVersion, type AppInfo, type AppSurface, type Audio, type AudioChannel, type AudioDeclaration, type AudioListener, type BoardName, BridgeError, type ButtonName, type Camera, type CameraChange, type CameraOptions, type ChannelName, type ControlLayout, type ControlShape, type ControlSlot, type ControlZone, type Controller, type Controls, type DeclaredNames, type DeclaredValue, type DeviceInfo, type DeviceTier, type ErrorCode, type ErrorCodes, type EventName, type EventProps, type FrameCallback, type GameInfo, type GameManifest, type GameSdk, type Group, type GroupChange, type GroupHandler, type Info, type InitOptions, type Input, type InputAction, type InputBinding, type InputDeclaration, type InputDevice, type InputListener, type InputScheme, 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, MAX_STEP, type MeasuredName, type Modifiers, type Obstruction, type ObstructionKind, type Orientation, type PageId, type Panel, type PanelListener, type PanelPages, type PanelState, type Pause, type PauseListener, type PauseState, type Phase, type Player, type PlayerActionName, type PlayerInfo, type Point, type PointerButton, type PointerDevice, type PointerLayer, type PointerListener, type PointerLock, type PointerState, type Pointers, type Press, type PressHandler, type ProjectManifest, type Rect, type Resources, type ResourcesListener, SAVE_BYTES, SHARE_BYTES, SHARE_META_BYTES, type Save, type SaveChangeListener, type SaveChangeReason, type SaveDeclaration, type SaveListener, type SaveMerger, type SaveSetup, 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 Tap, type Unsubscribe, type View, type ViewOptions, type Wheel, type WheelMode, type WheelTaker, init, insetsFrom };