@diffenderfer-games/hub 2.0.0-next.0 → 2.0.0-next.10

package/dist/shared/index.d.ts

@@ -1,11 +1,129 @@
-import { s as DailySystem } from "./daily.js";
-import { n as getUiStack, w as InputSystem } from "./input.js";
+import { S as avatar_d_exports } from "./avatar.js";
+import { M as SavedOpened, S as SavedEntry, s as DailySystem, w as SavedListOptions, y as GamePayload } from "./daily.js";
+import { O as InputSystem, n as getUiStack } from "./input.js";
 import { o as multiplayerForwarder } from "./mp.js";
 import { f as raceForwarder } from "./race.js";
 import { n as roomsForwarder } from "./rooms.js";
-import { Q as socialForwarder, X as notifyForwarder, Z as presenceForwarder } from "./social.js";
-import { Board, Board as Board$1, ErrorCode, GameInfo, GameLeaderboards, GameRecords, HubVersion, Inventory, Json, Json as Json$1, LeaderboardEntry, Metrics, Metrics as Metrics$1, PublicEndpoints, RejectReason, SessionUser, SortDir, SortDir as SortDir$1, Stats, Stats as Stats$1 } from "@diffenderfer-games/hub-contract";
+import { $ as AvatarRef, Q as AvatarChange, at as notifyForwarder, et as DesignerResult, ot as presenceForwarder, st as socialForwarder, tt as OpenDesignerOptions } from "./social.js";
+import { AvatarLook } from "@diffenderfer-games/hub-contract/avatar";
+import { Board, Board as Board$1, CreateTurnGame, ErrorCode, GameInfo, GameLeaderboards, GameRecords, HubVersion, Inventory, Inventory as Inventory$1, Json, Json as Json$1, LeaderboardEntry, Metrics, Metrics as Metrics$1, MyAvatar, OpenTurnGame, OpenTurnGame as OpenTurnGame$1, PublicEndpoints, RejectReason, ResumeSlot, ResumeSummary, SavedCounts, SessionUser, SortDir, SortDir as SortDir$1, Stats, Stats as Stats$1, TurnChatLine, TurnChatLine as TurnChatLine$1, TurnDeadline, TurnDeadline as TurnDeadline$1, TurnGameView, TurnGameView as TurnGameView$1, TurnSummary, TurnTournament } from "@diffenderfer-games/hub-contract";
 import { CallReturn, ClientData } from "@ayepi/core/client";
+//#region src/core/page-account.d.ts
+/** The signed-in player as the page heard it. */
+interface PageUser {
+  readonly id: number;
+  /** Their look code when the source carried it, else `null`. */
+  readonly look: string | null;
+}
+/** Where the news came from: an account event, or a socket hello (a time to catch up on what was missed). */
+type AccountSource = 'account' | 'session';
+/** Hears every report of who is signed in. */
+type AccountListener = (user: PageUser | null, source: AccountSource) => void;
+/** The page's account, as last heard. */
+declare class PageAccount {
+  /** `undefined` until something said; `null` when signed out. */
+  private heard;
+  private readonly listeners;
+  private isListening;
+  constructor();
+  /** The signed-in player, `null` when signed out, `undefined` before anything said. */
+  get user(): PageUser | null | undefined;
+  /** Record who is signed in (this client's own sign-in or sign-out) and tell the listeners. */
+  note(user: PageUser | null, source?: AccountSource): void;
+  /** Hear every report; returns the unsubscribe function. */
+  on(listener: AccountListener): () => void;
+  /** Listen to the window events (at once in a page; made before a window existed, on first use). */
+  private listen;
+  private onEvent;
+}
+//#endregion
+//#region src/core/avatar/avatar-ref.d.ts
+/** Anything that carries a player's look: a seat, a `PlayerLite`, a racer, a ticket user. */
+interface CarriesLook {
+  readonly look?: string;
+  readonly userId?: number;
+  readonly id?: number;
+  readonly uid?: number;
+}
+//#endregion
+//#region src/core/avatar/hub-avatar.d.ts
+/** What `hub.avatar` needs from its client. */
+interface AvatarHost {
+  /** The signed-in user's id, or `null` (`hub.userId()`). */
+  readonly currentUserId: () => number | null;
+  /** Hear every report of who is signed in (the page's account). */
+  readonly onAccount: (listener: AccountListener) => () => void;
+  /** `GET /avatar/me`; rejects when offline. */
+  readonly fetchMine: () => Promise<MyAvatar>;
+  /** `POST /avatar/batch`. */
+  readonly fetchCodes: (ids: readonly number[]) => Promise<Record<string, string>>;
+  /** Queue a save of your look (sent now when online, replayed later when not). */
+  readonly queueSave: (code: string, savedAt: number) => Promise<void>;
+}
+/** The renderer module `load()` resolves with. */
+type AvatarModule = typeof avatar_d_exports;
+type ChangeListener = (change: AvatarChange) => void;
+/** `hub.avatar`. */
+declare class HubAvatar {
+  private readonly host;
+  private readonly cache;
+  private readonly listeners;
+  private pending;
+  private flushQueued;
+  private detachRuntime;
+  /** The account the last report named. */
+  private lastUserId;
+  /** The code of your look the page was last given (`mine`, `mineSync`, `change`). */
+  private mineShown;
+  /** Players this page asked about or was handed (re-checked on each socket hello). */
+  private readonly seen;
+  constructor(host: AvatarHost);
+  /**
+   * Your look (your default if you never designed one). Works offline from
+   * the device cache. Before your account exists (a new guest's is made just
+   * after the game starts) it resolves at once with a default look, and
+   * `change` brings yours when the account is there.
+   */
+  mine(): Promise<AvatarRef>;
+  /** Your cached look, or your default; `null` only while nobody is signed in. */
+  mineSync(): AvatarRef | null;
+  /** Any player's look: from the cache, else batched with other requests in the same tick. */
+  of(userId: number): Promise<AvatarRef>;
+  /** Many players' looks at once. */
+  many(userIds: readonly number[]): Promise<Map<number, AvatarRef>>;
+  /** The look a payload already carries (a `RoomSeat`, `PlayerLite`, racer or ticket user). No request. */
+  from(carrier: CarriesLook): AvatarRef;
+  /** A seeded default for bots, previews and local pass-and-play seats: `bot('local:2')`. */
+  bot(seed: string | number): AvatarRef;
+  /** Save your look (designer code paths; queued offline, latest wins). */
+  save(look: AvatarLook): Promise<AvatarRef>;
+  /**
+   * Hear about look changes (yours, friends', your room's, and yours when
+   * your account appears). Returns the unsubscribe function. Wait for this
+   * rather than polling `mine()`.
+   */
+  on(_event: 'change', listener: ChangeListener): () => void;
+  /** Open "Make your avatar" over the game; resolves when it closes. */
+  openDesigner(options?: OpenDesignerOptions): Promise<DesignerResult>;
+  /** Loads the renderer and its art; resolves when rendering is synchronous. */
+  load(): Promise<AvatarModule>;
+  /** Remember the ref the page was given for your look. */
+  private showMine;
+  /** Cache your look; `change` fires when it differs from the one the page last had. */
+  private noteMine;
+  /** Someone said who is signed in: fetch your look when the account is new or its look isn't the cached one. */
+  private onAccount;
+  private refreshMine;
+  /** The socket (re)connected: a change sent while it was down never arrived, so ask again. */
+  private recheckSeen;
+  private emit;
+  private attachRuntime;
+  private scheduleFlush;
+  private flush;
+  /** Players' codes, in batches; offline or failing, the missing ones are left out (they get their default). */
+  private fetchCodes;
+}
+//#endregion
 //#region src/core/storage/key-value.d.ts
 /**
  * The string store behind the offline cache and queues: `localStorage` when
@@ -25,10 +143,6 @@ interface KeyValueStore {
   keys(): string[];
 }
 //#endregion
-//#region src/core/game-data.d.ts
-/** Anything a game may store as JSON: an object (interfaces included), an array, text, a number, a boolean or `null`. */
-type GamePayload = object | string | number | boolean | null;
-//#endregion
 //#region src/core/rest/endpoint-types.d.ts
 /** The name of a public REST endpoint (`getCurrentUser`, `writeSave`, ...). */
 type EndpointName = keyof PublicEndpoints;
@@ -234,7 +348,6 @@ type StatUpdateMode = 'set' | 'incr' | 'max';
 declare class LocalStore {
   private readonly prefix;
   private readonly store;
-  private sequence;
   /** The cache for game `slug` in `store` (default: `localStorage`, or memory without it). */
   constructor(slug: string, store?: KeyValueStore);
   private readStored;
@@ -257,6 +370,16 @@ declare class LocalStore {
   putSave(slot: string, saveData: Json, label: string | null): number;
   /** Forget a save. */
   deleteSave(slot: string): void;
+  /**
+   * The hub's `updatedAt` for `slot` as the current user last saw it (`null`:
+   * the slot was empty), or `undefined` when this device doesn't know.
+   */
+  cloudSave(slot: string): number | null | undefined;
+  /** Note the hub's copy of `slot` (just read or written) for the current user: its `updatedAt`, or `null` when empty. */
+  rememberCloudSave(slot: string, updatedAt: number | null): void;
+  /** Cache a slot as read from the hub (forgetting it when the hub has none), and note the hub's copy. */
+  cacheCloudSave(slot: string, save: Save | null): void;
+  private readCloudSaves;
   /** This game's cached stats. */
   getStats(): Stats;
   /** Apply one stat update and return the stat's new value. */
@@ -267,21 +390,24 @@ declare class LocalStore {
   getBoard(key: string): LocalBoard | null;
   /** Record a score locally, keeping the best one; returns the board and best. */
   submitScore(key: string, score: number, options: QueuedScoreOptions): LocalBoard;
-  /** The queued writes, oldest first. */
-  getQueue(): QueueOp[];
-  /** Replace the queue. */
-  setQueue(queue: readonly QueueOp[]): void;
-  /** How many writes are queued. */
-  queueLength(): number;
-  /** Queue a write, collapsing it with a compatible queued one. */
-  enqueue(input: QueueOpInput): void;
+  /** The v1 client's queued writes, removed from storage (the caller moves them into the outbox). */
+  takeLegacyQueue(): QueueOp[];
+  /** This game's cached inventory (empty when none is cached). */
+  getInventory(): Inventory;
+  /** Store this game's inventory and return it. */
+  setInventory(inventory: Inventory): Inventory;
   /** The buffered analytics events, oldest first. */
   getEvents(): BufferedEvent[];
   /** Replace the event buffer. */
   setEvents(events: readonly BufferedEvent[]): void;
   /** Buffer one event (capped; heartbeats are dropped first). */
   bufferEvent(type: string): void;
-  /** Fan a `/me/snapshot` reply out across every game's cache keys. */
+  /**
+   * Fan a `/me/snapshot` reply out across every game's cache keys. It lists
+   * every save slot of every game the player has played, so each game's
+   * slots on the hub become known (and this game's are all empty when it
+   * isn't listed).
+   */
   hydrate(snapshot: SnapshotResponse): void;
 }
 //#endregion
@@ -296,21 +422,348 @@ interface RestClient {
   readonly apiBase: string;
   /** Call an endpoint; resolves with its reply body, rejects with a {@link HubError}. */
   call<K extends EndpointName>(name: K, ...fieldsArgument: CallArguments<K>): Promise<EndpointReply<K>>;
+  /**
+   * Call an endpoint as part of an offline operation: an endpoint marked for
+   * offline replay gets `opKey` in the operation header, so the hub runs it
+   * once however often it is sent; any other endpoint is called as usual.
+   */
+  callOnce<K extends EndpointName>(opKey: string, name: K, ...fieldsArgument: CallArguments<K>): Promise<EndpointReply<K>>;
+}
+//#endregion
+//#region src/core/offline/outbox-entry.d.ts
+/** A queued operation. */
+interface OutboxEntry {
+  /** Unique and sortable by queue time: replay runs in `id` order. Also the base of its operation keys. */
+  readonly id: string;
+  /** Which handler performs it (`hub.save`, `hub.stat`, or a game's own kind). */
+  readonly kind: string;
+  /** The handler's input. */
+  readonly payload: Json;
+  /** When it was queued (epoch ms). */
+  readonly createdAt: number;
+  /** How many times replay has started it. A started entry never absorbs a later one. */
+  readonly attempts: number;
+  /** Not before this time (epoch ms); 0 means as soon as possible. */
+  readonly retryAt: number;
+  /** The last failure's message, when it has failed before. */
+  readonly lastError?: string;
+}
+//#endregion
+//#region src/core/offline/outbox-kinds.d.ts
+/** What a kind's handler gets besides its payload. */
+interface ReplayContext {
+  /** The operation's id (stable across retries). */
+  readonly opId: string;
+  /** Which try this is, from 1. */
+  readonly attempt: number;
+  /** `false` when the op runs at once (online, nothing waiting); `true` when it runs from the queue. */
+  readonly isReplay: boolean;
+  /**
+   * Call a hub endpoint. Calls to endpoints marked for offline replay carry
+   * an operation key made from the op id and the call's position in the
+   * handler, so a retried op whose earlier calls already landed gets their
+   * remembered replies instead of running them twice. Make the same calls in
+   * the same order on every try.
+   */
+  call<K extends EndpointName>(name: K, ...fieldsArgument: CallArguments<K>): Promise<EndpointReply<K>>;
+  /** A key for `step` of this op that is the same on every try: send it to a game server to deduplicate there. */
+  key(step: string): string;
+}
+/** Performs one operation of a kind. Throw to fail it (see the docs for which failures retry). */
+type OfflineHandler<Payload> = (payload: Payload, context: ReplayContext) => Promise<Json | undefined> | Json | undefined;
+/** A kind, with optional rules for folding new operations into waiting ones. */
+interface OfflineKindDefinition<Payload> {
+  /** Perform one operation. */
+  readonly run: OfflineHandler<Payload>;
+  /**
+   * Operations with the same merge key may fold together. Without one, every
+   * operation replays on its own.
+   */
+  readonly mergeKey?: (payload: Payload) => string;
+  /**
+   * Fold `incoming` into the newest waiting operation with the same merge key
+   * (in its place in the queue); `undefined` to queue it separately.
+   */
+  readonly merge?: (waiting: Payload, incoming: Payload) => Payload | undefined;
+  /** `true`: a new operation replaces every waiting one with the same merge key and goes last (a save slot's last write wins). */
+  readonly replaces?: boolean;
+}
+/** A kind as the outbox runs it: payloads are the stored JSON. */
+interface RegisteredKind {
+  /** Perform one operation (malformed payloads are refused before this). */
+  readonly run: (payload: Json, context: ReplayContext) => Promise<Json | undefined> | Json | undefined;
+  /** Whether a stored payload is well formed for this kind. */
+  readonly accepts: (payload: Json) => boolean;
+  readonly mergeKey?: (payload: Json) => string;
+  readonly merge?: (waiting: Json, incoming: Json) => Json | undefined;
+  readonly replaces: boolean;
+}
+/** The registered kinds of one client. */
+declare class KindRegistry {
+  private readonly kinds;
+  /** Register (or replace) a kind. */
+  register(kind: string, definition: RegisteredKind): void;
+  /** A registered kind, or `undefined`. */
+  get(kind: string): RegisteredKind | undefined;
+}
+//#endregion
+//#region src/core/offline/outbox-store.d.ts
+/** The most entries one game's outbox holds. */
+declare const OUTBOX_MAX_ENTRIES = 500;
+/** The most stored characters one game's outbox holds (about 2 MB of `localStorage`). */
+declare const OUTBOX_MAX_CHARS = 1000000;
+/** One game's outbox. */
+declare class OutboxStore {
+  /** The key prefix of this game's entries. */
+  readonly prefix: string;
+  private readonly store;
+  /** The outbox for game `slug` in `store`. */
+  constructor(slug: string, store: KeyValueStore);
+  /** Every well-formed entry, oldest first. Malformed ones are removed. */
+  list(): OutboxEntry[];
+  /** How many entries are queued. */
+  count(): number;
+  /** One entry, or `undefined` once it is gone (replayed, or removed by another tab). */
+  get(id: string): OutboxEntry | undefined;
+  /** Whether `extra` more stored characters in one more entry still fit under the caps. */
+  fits(extraChars: number): boolean;
+  /** Store an entry (new or updated); `false` when the storage refused it (full or blocked). */
+  put(entry: OutboxEntry): boolean;
+  /** Forget an entry. */
+  remove(id: string): void;
+  /** Whether a storage key belongs to this outbox (for cross-tab `storage` events). */
+  owns(key: string | null): boolean;
+  private entryKeys;
+}
+//#endregion
+//#region src/core/offline/outbox-replayer.d.ts
+/** An op dropped during replay, with why. */
+interface ReplayFailure {
+  /** The dropped op. */
+  readonly entry: OutboxEntry;
+  /** Why it was dropped (the hub's message, or the handler's). */
+  readonly error: string;
+}
+/** Why a replay stopped before the outbox was empty. */
+type ReplayStop = 'connection' | 'backoff' | 'unknown-kind' | 'lease';
+/** What one replay did. */
+interface ReplayReport {
+  /** The ops that landed, in order. */
+  readonly replayed: OutboxEntry[];
+  /** The ops dropped. */
+  readonly failed: ReplayFailure[];
+  /** Why it stopped early, or `undefined` when the outbox is empty. */
+  readonly stoppedBy?: ReplayStop;
+}
+//#endregion
+//#region src/core/offline/outbox.d.ts
+/** A queued operation, as `hub.offline` reports it. */
+type OfflineOp = OutboxEntry;
+/** Each outbox event's detail. */
+interface OfflineEventDetails {
+  /** An op was queued (or folded into a waiting one, which is then the `op`). */
+  queued: {
+    readonly op: OfflineOp;
+  };
+  /** An op landed; `result` is what its handler returned. */
+  replayed: {
+    readonly op: OfflineOp;
+    readonly result?: Json;
+  };
+  /** An op was dropped: the hub refused it, or it kept failing. */
+  failed: {
+    readonly op: OfflineOp;
+    readonly error: string;
+  };
+}
+/** An outbox event's name. */
+type OfflineEventName = keyof OfflineEventDetails;
+/** An outbox event listener. */
+type OfflineListener<Name extends OfflineEventName> = (detail: OfflineEventDetails[Name]) => void;
+/** The code of the error `add` throws when the outbox is full. */
+declare const OUTBOX_FULL_CODE = "offline_queue_full";
+/** What the outbox needs from its client. */
+interface OutboxOptions {
+  /** The game whose outbox it is. */
+  readonly slug: string;
+  /** Where it lives (`localStorage`, or memory). */
+  readonly store: KeyValueStore;
+  /** The REST client its handlers call through. */
+  readonly rest: RestClient;
+  /** Fire a window event (the menu listens). */
+  readonly emit: (name: string, detail: OfflineEventDetails[OfflineEventName]) => void;
+  /** The hub couldn't be reached during a replay. */
+  readonly onUnreachable: () => void;
+  /** The queue length may have changed. */
+  readonly onChange: () => void;
+  /** A retry is due: replay again. */
+  readonly onRetryDue: () => void;
+  readonly now?: () => number;
+}
+/** One game's outbox. */
+declare class Outbox {
+  /** The kinds this client can perform. */
+  readonly kinds: KindRegistry;
+  /** The stored entries. */
+  readonly entries: OutboxStore;
+  private readonly options;
+  private readonly replayer;
+  private readonly now;
+  private sequence;
+  private retryTimer;
+  private retryAt;
+  private readonly listeners;
+  /** The outbox for `options.slug`. */
+  constructor(options: OutboxOptions);
+  /** Register a kind. */
+  define(kind: string, definition: RegisteredKind): void;
+  /** A new, not yet stored, op of `kind`. */
+  stamp(kind: string, payload: Json): OutboxEntry;
+  /**
+   * Queue an op, folding it into a waiting one where its kind says so.
+   * Throws a {@link HubError} (code {@link OUTBOX_FULL_CODE}) when the
+   * outbox is full or the storage refuses it.
+   */
+  add(op: OutboxEntry): void;
+  /** Perform an op now, without queueing it (the online path); throws what its handler throws. */
+  runNow(op: OutboxEntry): Promise<Json | undefined>;
+  /** Replay what is due, in order. `isEager`: the connection just came back, so ops waiting for it go at once. */
+  replay(isEager?: boolean): Promise<ReplayReport>;
+  /** The waiting ops, oldest first. */
+  pending(): OfflineOp[];
+  /** How many ops are waiting. */
+  count(): number;
+  /** Listen for an event; returns the unsubscribe function. */
+  on<Name extends OfflineEventName>(name: Name, listener: OfflineListener<Name>): () => void;
+  private fire;
+  private contextFor;
+  private scheduleRetry;
+  private clearRetry;
+}
+//#endregion
+//#region src/core/offline/offline-api.d.ts
+/** What `hub.offline` drives. */
+interface OfflineHost {
+  /** The game's outbox. */
+  readonly outbox: Outbox;
+  /** Replay now when the hub is reachable (and nothing else is replaying). */
+  requestSync(): void;
+}
+/** The game-facing outbox API. */
+declare class OfflineApi {
+  private readonly host;
+  /** The API over `host`. */
+  constructor(host: OfflineHost);
+  /**
+   * Define what an operation of `kind` does when it replays. Define every
+   * kind at load, before or after enqueueing: waiting ops of an undefined
+   * kind hold the queue until it is defined. `hub.*` kinds are the hub's own.
+   */
+  define<Payload extends GamePayload>(kind: string, definition: OfflineHandler<Payload> | OfflineKindDefinition<Payload>): void;
+  /**
+   * Queue an operation of `kind` and replay it as soon as the hub is
+   * reachable (at once when online). Resolves the queued op; its outcome
+   * arrives as a `replayed` or `failed` event. Throws a `HubError` (code
+   * `offline_queue_full`) when the outbox is full.
+   */
+  enqueue(kind: string, payload: GamePayload): OfflineOp;
+  /** The waiting operations (the hub's and the game's), oldest first. */
+  pending(): OfflineOp[];
+  /** Listen for `queued`, `replayed` or `failed`; returns the unsubscribe function. */
+  on<Name extends OfflineEventName>(name: Name, listener: OfflineListener<Name>): () => void;
+}
+//#endregion
+//#region src/core/resume/local-resume.d.ts
+/** A run as this device saved it. */
+interface LocalRun {
+  readonly status: 'saved';
+  readonly userId: number | null;
+  /** When the game saved it, epoch ms. */
+  readonly at: number;
+  readonly label: string;
+  readonly fraction: number | null;
+  readonly title: string | null;
+  readonly version: number;
+  /** The game's title, for the Resume card before the hub knows the run. */
+  readonly gameTitle: string;
+  readonly state: Json;
+  readonly isSynced: boolean;
+}
+/** A run this device cleared (kept until the hub has the clear). */
+interface LocalClear {
+  readonly status: 'cleared';
+  readonly userId: number | null;
+  readonly at: number;
+  readonly isSynced: boolean;
+}
+/** A device copy of one game's slot. */
+type LocalResume = LocalRun | LocalClear;
+/** The device copies of every game's slot. */
+declare class LocalResumeStore {
+  private readonly store;
+  constructor(store: KeyValueStore);
+  /** `slug`'s copy, or `null`. */
+  read(slug: string): LocalResume | null;
+  /** Store `slug`'s copy; answers whether it stuck (a full storage refuses a large state). */
+  write(slug: string, record: LocalResume): boolean;
+  /** Forget `slug`'s copy. */
+  remove(slug: string): void;
+  /** The hub now has `slug`'s save or clear made at `at`: mark it synced (a clear is simply forgotten). */
+  markSynced(slug: string, at: number): void;
+  /** Every game's copy, by slug. */
+  all(): Map<string, LocalResume>;
+}
+//#endregion
+//#region src/core/saved/local-saved.d.ts
+/** A daily challenge as this device last saw it. */
+interface LocalDaily {
+  readonly id: string;
+  readonly game: string;
+  readonly day: string;
+  readonly seed: number;
+  /** `active` in progress; `finished` (won) or `discarded`, kept until the hub has it. */
+  readonly status: 'active' | 'finished' | 'discarded';
+  readonly userId: number | null;
+  /** When it last changed here, epoch ms. */
+  readonly at: number;
+  readonly label: string;
+  readonly fraction: number | null;
+  readonly title: string | null;
+  readonly version: number;
+  readonly gameTitle: string;
+  /** The state the game last saved, `null` before its first save. */
+  readonly state: Json;
+  readonly isSynced: boolean;
+}
+/** The device copies of daily challenges. */
+declare class LocalDailyStore {
+  private readonly store;
+  constructor(store: KeyValueStore);
+  /** The copy of `game`'s `day`, or `null`. */
+  read(game: string, day: string): LocalDaily | null;
+  /** Store a copy; answers whether it stuck (a full storage refuses a large state). */
+  write(copy: LocalDaily): boolean;
+  /** Forget a copy. */
+  remove(game: string, day: string): void;
+  /** The hub has the change made at `at` (and calls the instance `id`): mark it synced; a closed copy is forgotten. */
+  markSynced(game: string, day: string, at: number, id?: string): void;
+  /** Every copy of `userId`'s, any game. */
+  all(userId: number | null): LocalDaily[];
 }
 //#endregion
 //#region src/core/connection.d.ts
-/** A queued write the hub refused during a sync: dropped, with the hub's message. */
+/** A queued op the hub refused during a sync (or that kept failing): dropped, with the reason. */
 interface SyncConflict {
-  /** The refused op. */
-  readonly op: QueueOp;
-  /** The hub's message. */
+  /** The dropped op. */
+  readonly op: OfflineOp;
+  /** The hub's (or the handler's) message. */
   readonly error?: string;
 }
 /** What one `sync()` did. */
 interface SyncResult {
-  /** Queued writes the hub accepted. */
+  /** Queued ops that landed. */
   readonly flushed: number;
-  /** Queued writes the hub refused (and that were dropped). */
+  /** Queued ops that were dropped. */
   readonly conflicts: SyncConflict[];
 }
 /** The game slug's path field, or a {@link HubError} when the slug is unknown. */
@@ -326,12 +779,22 @@ declare class HubConnection {
   readonly apiBase: string;
   /** Typed REST calls to {@link apiBase}. */
   protected readonly rest: RestClient;
-  /** This game's offline cache, queue and event buffer. */
+  /** This game's offline cache and event buffer. */
   protected readonly store: LocalStore;
+  /** This game's queued operations. */
+  protected readonly outbox: Outbox;
+  /** The device copies of every game's resume slot (`hub.resume`). */
+  protected readonly resumeStore: LocalResumeStore;
+  /** The device copies of daily challenges in progress (every game's). */
+  protected readonly dailyStore: LocalDailyStore;
   private readonly offlineMode;
   private isReachable;
-  private isSyncing;
+  private runningSync;
+  private followingSync;
+  private isFollowingEager;
+  private directSend;
   private lastPrefetchAt;
+  private offlineApi;
   private readonly statusListeners;
   /** A connection for `options` (slug and API base default to the page's). */
   constructor(options?: HubOptions);
@@ -339,13 +802,18 @@ declare class HubConnection {
   get isOffline(): boolean;
   /** `true` while the hub is reachable. */
   get isOnline(): boolean;
-  /** Queued writes plus buffered analytics events waiting to sync. */
+  /**
+   * The offline outbox: define your own kinds of operation, queue them, and
+   * hear how they replay (`hub.offline.define`, `enqueue`, `pending`, `on`).
+   */
+  get offline(): OfflineApi;
+  /** Queued operations plus buffered analytics events waiting to sync. */
   pending(): number;
   /** Subscribe to connection and sync status changes; returns the unsubscribe function. */
   onStatus(listener: (status: HubStatus) => void): () => void;
   /** Tell `onStatus` listeners and the page (`hub:status`) the current status. */
   protected notifyStatus(): void;
-  /** Record reachability; coming back online syncs the queue and re-warms the cache. */
+  /** Record reachability; coming back online replays the outbox and re-warms the cache. */
   protected setReachable(isReachableNow: boolean): void;
   /** `{ slug }` for this game's endpoints; throws when the slug is unknown. */
   protected gameFields(): GameFields;
@@ -355,23 +823,38 @@ declare class HubConnection {
    * status) always reach the caller.
    */
   protected withFallback<Reply>(networkCall: () => Promise<Reply>, offlineAnswer: () => Reply): Promise<Reply>;
-  /** Send one queued write. */
-  private sendOp;
   /**
-   * Apply a write to the offline cache at once, then send it now (online
-   * with an empty queue) or queue it behind the others. Resolves with the
-   * local answer; a real API error on the direct path reaches the caller and
-   * is not queued.
+   * Apply a write to the offline cache at once, then perform it as an op of
+   * `kind`: sent now when online with nothing waiting, else queued behind
+   * the others. Resolves with the local answer (or, sent now, with
+   * `replyAnswer`'s reading of the hub's reply). A real API error on the
+   * direct path reaches the caller and is not queued; a transport failure
+   * queues the op under the same id, so if the request did land, its replay
+   * is recognised by the hub and not applied twice.
    */
-  protected mutateQueued<Reply>(input: QueueOpInput, localAnswer: () => Reply): Promise<Reply>;
+  protected mutateOffline<Reply>(kind: string, payload: Json, localAnswer: () => Reply, replyAnswer?: (result: Json | undefined) => Reply | undefined): Promise<Reply>;
   /**
-   * Replay the queue, then the buffered events, in order. Stops at the first
-   * transport failure (offline again: the rest stays queued); a write the hub
-   * refuses is dropped and reported as a conflict.
+   * Replay the outbox, then the buffered events, in order. Stops at the
+   * first transport failure (offline again: the rest stays queued); an op
+   * the hub refuses is dropped and reported as a conflict.
    */
   sync(): Promise<SyncResult>;
+  /** A retry came due: try again even when the hub was last unreachable (the try is the probe), unless the browser itself is offline. */
+  private retrySync;
+  /**
+   * One replay at a time per client. A call during one queues a single
+   * follow-up replay (eager if any caller asked for that), so an op queued
+   * or a reconnect that happens mid-replay is never missed.
+   */
+  private replayAll;
+  private startReplay;
+  private runReplay;
   /** Send the buffered analytics events; a refused one is dropped (telemetry never blocks). */
   private flushEvents;
+  /** Move a v1 copy's queued writes into the outbox, in their order. */
+  private importLegacyQueue;
+  /** Follow the browser's connection, other tabs' outbox changes, and replay what an earlier page left queued. */
+  private listenToPage;
   /**
    * Warm the offline cache for every game the player has touched, in one
    * request, so going offline later still shows complete progress.
@@ -402,6 +885,16 @@ interface ProfileUpdate<TData extends GamePayload = Json> {
 }
 /** Accounts, profile, saves, stats and leaderboards. */
 declare class HubProgress extends HubConnection {
+  /** Who the page is signed in as, as the hub's events and this client's sign-ins tell it. */
+  protected readonly account: PageAccount;
+  /**
+   * Your user id, or `null` when nobody is signed in (also before an offline
+   * first visit has an account). Synchronous, and it follows the account as
+   * the hub changes it (a new guest's account made by the menu, sign-in,
+   * sign-out) with no `hub.me()` needed. Compare it with a seat's `userId`
+   * to find yours.
+   */
+  userId(): number | null;
   /** The current user (or `null`) and the games they have a profile in. */
   me(): Promise<MeResponse>;
   /**
@@ -425,6 +918,11 @@ declare class HubProgress extends HubConnection {
     ok: true;
   }>;
   private signInLocally;
+  /** Remember who the hub signed in, so the cache's notes about the hub's copies are read for the right player. */
+  private signedIn;
+  /** The cache and the page (`hub.userId()`, `hub.avatar`) learn who is signed in. */
+  private remember;
+  private signedOut;
   /** This game's profile for the current user, or `profile: null`. `TData` is the game's own data type. */
   getProfile<TData = Json>(): Promise<{
     profile: Profile<TData> | null;
@@ -437,10 +935,18 @@ declare class HubProgress extends HubConnection {
   listSaves(): Promise<{
     saves: SaveMeta[];
   }>;
-  /** One slot's contents, or `save: null` when the slot is empty. `TData` is the game's own save type. */
+  /**
+   * One slot's contents, or `save: null` when the slot is empty. `TData` is
+   * the game's own save type. Offline it answers from the device's copy, but
+   * only when the device knows the hub's copy of the slot; otherwise (a fresh
+   * device or cleared browser) it rejects with a {@link HubError} whose
+   * `code` is `save_unknown` (`isOffline` is `true`), never a false "empty".
+   */
   getSave<TData = Json>(slot: string): Promise<{
     save: Save<TData> | null;
   }>;
+  /** The device's copy of `slot`, when it can be trusted offline (see {@link getSave}). */
+  private offlineSave;
   /** Create or overwrite a save slot. `saveData` is any JSON up to 64 KB. */
   putSave<TData extends GamePayload = Json>(slot: string, saveData: TData, label?: string): Promise<{
     ok: true;
@@ -509,7 +1015,7 @@ declare class HubEconomy extends HubProgress {
   favorites(): Promise<{
     games: string[];
   }>;
-  /** Star (`isOn = true`) or unstar a game. Needs a connection. */
+  /** Star (`isOn = true`) or unstar a game. Offline, the local list changes at once and the hub's when it is back. */
   setFavorite(slug: string, isOn: boolean): Promise<{
     games: string[];
   }>;
@@ -519,9 +1025,16 @@ declare class HubEconomy extends HubProgress {
   getInventory(): Promise<InventorySnapshot>;
   /** Another player's available holdings (to compose a trade). */
   playerInventory(userId: number): Promise<InventorySnapshot>;
-  /** Add goods to the player (gameplay rewards); answers the new holdings. */
+  /**
+   * Add goods to the player (gameplay rewards); answers the new holdings.
+   * Offline, the cached holdings change at once and the grant replays later.
+   */
   grant(bundle: GrantBundle): Promise<EndpointReply<'grantInventoryItems'>>;
-  /** An atomic swap with the house: remove `take`, add `give`. */
+  /**
+   * An atomic swap with the house: remove `take`, add `give`. Offline it is
+   * checked against the cached holdings (409 when they can't cover `take`),
+   * applied to them at once, and replayed later; the hub has the last word.
+   */
   exchange(take?: TradeBundle, give?: TradeBundle): Promise<EndpointReply<'exchangeInventoryItems'>>;
   /** Sell items to the house for coins. */
   sell(items: Record<string, number>, coins: number): Promise<EndpointReply<'exchangeInventoryItems'>>;
@@ -572,6 +1085,506 @@ interface HubMenuControl {
   readonly visible: boolean;
 }
 //#endregion
+//#region src/core/offline/hub-kinds/resume-kind.d.ts
+/** Send the run saved at `savedAt`; `state` only when the device copy couldn't hold it. */
+type ResumeSavePayload = {
+  readonly action: 'save';
+  readonly savedAt: number;
+  readonly label: string;
+  readonly fraction: number | null;
+  readonly title: string | null;
+  readonly version: number;
+  readonly state?: Json;
+};
+/** Clear the run, unless one was saved after `before`. */
+type ResumeClearPayload = {
+  readonly action: 'clear';
+  readonly before: number;
+};
+/** One resume op. */
+type ResumePayload = ResumeSavePayload | ResumeClearPayload;
+//#endregion
+//#region src/core/resume/resume-types.d.ts
+/** How far along a run is. */
+interface ResumeProgress {
+  /** A short line the game writes, such as "Level 12" or "Round 3 of 5" (up to 60 characters). */
+  readonly label: string;
+  /** 0 to 1, drawn as a progress bar; leave it out when the game can't say. */
+  readonly fraction?: number | null;
+}
+/** A run to save. `TState` is the game's own JSON-safe state type. */
+interface ResumeSaveInput<TState extends GamePayload> {
+  /** Everything the game needs to pick the run up again (up to 512 KB as JSON). */
+  readonly state: TState;
+  readonly progress: ResumeProgress;
+  /** An optional name for the run ("Klondike, draw 3"), shown under the game's name. */
+  readonly title?: string | null;
+  /** The game's state version (default 0). Bump it when `state` changes shape; see `load({ version })`. */
+  readonly version?: number;
+}
+/** A saved run, read back. */
+interface ResumeRun<TState> {
+  readonly state: TState;
+  readonly progress: {
+    readonly label: string;
+    readonly fraction: number | null;
+  };
+  readonly title: string | null;
+  readonly version: number;
+  /** When the game saved it, epoch ms. */
+  readonly savedAt: number;
+}
+/** Options for reading the run back. */
+interface ResumeLoadOptions {
+  /**
+   * The state version this code reads. A run saved with an older version is
+   * dropped (cleared) and reads as `null`; a newer one (from a newer copy of
+   * the game in another tab) reads as `null` but is kept.
+   */
+  readonly version?: number;
+}
+/** One saved run in the player's list (the home page's Resume card). */
+interface ResumeEntry {
+  /** The game's slug. */
+  readonly slug: string;
+  readonly gameTitle: string;
+  /** The game's URL path, like `/solitaire`. */
+  readonly path: string;
+  /** The game has a tile image (`/_tiles/<slug>`). */
+  readonly hasImage: boolean;
+  readonly progress: {
+    readonly label: string;
+    readonly fraction: number | null;
+  };
+  readonly title: string | null;
+  /** When it was saved, epoch ms. */
+  readonly savedAt: number;
+  /** Saved on this device and not yet sent to the hub (offline, or the tab closed first). */
+  readonly isLocalOnly: boolean;
+}
+/** Why a save was ignored: the page is in a race or an online room. (`'daily'` is no longer returned: a save during a daily goes to the day.) */
+type ResumeBlocker = 'race' | 'daily' | 'room' | 'turns';
+//#endregion
+//#region src/core/resume/hub-resume.d.ts
+/** How long saves must be quiet before the latest is sent, ms. */
+declare const RESUME_DEBOUNCE_MS = 3000;
+/** Largest state, bytes of JSON (the contract's `RESUME_MAX_STATE_BYTES`). */
+declare const RESUME_MAX_STATE_BYTES: number;
+/** What `hub.resume` needs from its client. */
+interface ResumeHost {
+  /** This game's slug; `null` on the home page. */
+  readonly slug: string | null;
+  readonly local: LocalResumeStore;
+  /** The signed-in player's id as the device knows it, or `null`. */
+  currentUserId(): number | null;
+  /** The game's display title. */
+  gameTitle(): string;
+  /** Why saving is off right now, or `null`. */
+  blocker(): ResumeBlocker | null;
+  /** The page's daily challenge while one is being played (saves go to the day instead of the run), else `null`. */
+  daily?(): DailyRoute | null;
+  /** Perform a resume op: at once when online with nothing waiting, else queued. */
+  send(payload: ResumePayload): Promise<void>;
+  /** This game's run on the hub, or `undefined` when the hub can't be reached. */
+  fetchSlot(): Promise<ResumeSlot | null | undefined>;
+  /** The player's runs on the hub, or `undefined` when it can't be reached. */
+  fetchList(): Promise<ResumeSummary[] | undefined>;
+  /** Clear another game's run on the hub (the home page's discard); throws offline. */
+  clearOther(slug: string): Promise<void>;
+  /** The run changed here (saved or cleared): `hub.saved` listeners hear it. */
+  onChange?(): void;
+}
+/** Where a save goes during a daily challenge (`hub.daily`). */
+interface DailyRoute {
+  save(input: ResumeSaveInput<GamePayload>): boolean;
+}
+/** `hub.resume`. */
+declare class HubResume {
+  private readonly host;
+  private timer;
+  private waiting;
+  private isListening;
+  private readonly warnedBlockers;
+  constructor(host: ResumeHost);
+  /**
+   * `true` when the page was opened from the Resume card (`?hub_resume=1`,
+   * taken out of the address bar). Synchronous, so a game can restore before
+   * it routes or draws its title screen.
+   */
+  get requested(): boolean;
+  /** Why a save would be ignored right now (`race`, `daily`, `room`), or `null`. */
+  get blockedBy(): ResumeBlocker | null;
+  /**
+   * Save the run (the latest save wins). Stored on the device at once; sent
+   * after {@link RESUME_DEBOUNCE_MS} of quiet, or when the page is hidden.
+   * Returns `false` (and saves nothing) in a race or an online room; during
+   * a daily challenge the save goes to the day (`hub.daily.save`). Throws a
+   * `HubError` 413 over 512 KB, 400 without a label.
+   */
+  save<TState extends GamePayload>(run: ResumeSaveInput<TState>): boolean;
+  /** Send a waiting save now (the page does this itself when hidden or closed). */
+  flush(): Promise<void>;
+  /** Clear the run: call it when the run ends (won, lost or quit). Works offline. */
+  clear(): Promise<void>;
+  /** Delete the game's saved run (never the day being played). */
+  private clearRun;
+  /** The saved run with its progress and time, or `null`. The newer of the device's copy and the hub's wins. */
+  get<TState = GamePayload>(options?: ResumeLoadOptions): Promise<ResumeRun<TState> | null>;
+  /** The saved state, or `null` (see {@link get} for the version rule). */
+  load<TState = GamePayload>(options?: ResumeLoadOptions): Promise<TState | null>;
+  /** The player's saved runs in every resumable game, newest first (the home page's Resume card). */
+  list(): Promise<ResumeEntry[]>;
+  /** Discard another game's run from the home page (online only: throws a `HubError` offline). */
+  discard(slug: string): Promise<void>;
+  /** Say once per blocker why saves are ignored, so a game that forgot `hub.daily.cancel()` finds out. */
+  private warnBlocked;
+  private requireSlug;
+  private schedule;
+  /** Send a waiting save as soon as the page is hidden or closed. */
+  private listenToPage;
+}
+//#endregion
+//#region src/core/saved/saved-list.d.ts
+/** What the device holds, for one player. */
+interface DeviceCopies {
+  /** Run copies by slug (`hub.resume`). */
+  readonly runs: ReadonlyMap<string, LocalResume>;
+  /** Daily copies (`hub.daily`), any game. */
+  readonly dailies: readonly LocalDaily[];
+}
+//#endregion
+//#region src/core/saved/hub-saved.d.ts
+/** How long changes must be quiet before `on('change')` listeners hear the new list, ms. */
+declare const SAVED_CHANGE_QUIET_MS = 300;
+/** What `hub.saved` needs from its client. */
+interface SavedHost {
+  /** This game's slug; `null` on the home page. */
+  readonly slug: string | null;
+  /** The hub's list (one game, or all), or `undefined` when it can't be reached. */
+  fetchList(game: string | null): Promise<readonly SavedEntry[] | undefined>;
+  /** What this device holds for the signed-in player. */
+  deviceCopies(): DeviceCopies;
+  /** Discard a daily or run (works offline where it can). */
+  discard(entry: SavedEntry): Promise<void>;
+  /** Go to a URL (`location.assign`). */
+  navigate(url: string): void;
+}
+/** A change listener: this game's games in progress. */
+type SavedChangeListener = (games: SavedEntry[]) => void;
+/** An `onOpen` handler: switch to this instance without a reload. */
+type SavedOpenHandler = (instance: SavedEntry) => void | Promise<void>;
+/** The detail of {@link SAVED_OPEN_EVENT}. */
+interface SavedOpenDetail {
+  readonly entry: SavedEntry;
+}
+/** `hub.saved`. */
+declare class HubSaved {
+  private readonly host;
+  /** Each handler with the kinds it takes (every kind when `undefined`). */
+  private readonly openHandlers;
+  private readonly changeListeners;
+  private isListeningForOpen;
+  private isListeningForChange;
+  private changeTimer;
+  constructor(host: SavedHost);
+  /**
+   * The instance this page was opened for (`?hub_open=<id>&hub_kind=<kind>`,
+   * taken out of the address bar), or `null`. Synchronous: read it before
+   * routing or drawing a title screen.
+   */
+  get opened(): SavedOpened | null;
+  /** This game's games in progress: online games waiting on the player first, then the newest. Works offline. */
+  list(options?: SavedListOptions): Promise<SavedEntry[]>;
+  /** Every game's games in progress (the home page and the menu). Online, plus this device's copies. */
+  listAll(): Promise<SavedEntry[]>;
+  /** The badge counts across every game. */
+  counts(): Promise<SavedCounts>;
+  /**
+   * Switch to an instance of THIS game when the player picks it from the
+   * hub menu, without a reload. Without a handler the page reloads with
+   * `?hub_open=<id>`. With `{ kinds }` the handler takes only those kinds;
+   * the others still reload the page (with `?hub_resume=1` or `?daily=` for
+   * a saved run or a daily). Returns a function that removes the handler.
+   */
+  onOpen(handler: SavedOpenHandler, options?: SavedListOptions): () => void;
+  /** Open an instance: in this game through `onOpen` (or a reload), in another game by going there. */
+  open(id: string): Promise<void>;
+  /** Open an entry already in hand (the hub's lists). */
+  openEntry(entry: SavedEntry): void;
+  /**
+   * Discard a daily challenge or a saved run (the caller asks first; the
+   * hub's own lists ask for themselves). Online games are left with
+   * `hub.turns`, never discarded.
+   */
+  discard(id: string): Promise<void>;
+  /** Hear when this game's list changes; returns a function that stops listening. */
+  on(_eventName: 'change', listener: SavedChangeListener): () => void;
+  /** Something of this game's changed (a save here, an event from the hub): tell the listeners, once per quiet spell. */
+  changed(): void;
+  private listenForOpen;
+  private listenForChange;
+}
+//#endregion
+//#region src/core/turns/turn-game.d.ts
+/** The window event the social runtime fires for each `ev:turn`. */
+declare const TURN_EVENT = "hub:turn";
+/** The runtime's live connection (re)opened: anything sent while it was down is fetched again. */
+declare const TURN_RESYNC_EVENT = "hub:turn-resync";
+/** The window event the social runtime fires for each `ev:turn.chat`. */
+declare const TURN_CHAT_EVENT = "hub:turn-chat";
+/** How often a page without the live runtime looks for moves, ms. */
+declare const TURN_POLL_MS = 20000;
+/** How long a visible page waiting on another player's move (or in a lobby) may hear nothing before it fetches the game again, ms. */
+declare const TURN_QUIET_MS = 15000;
+/** A game's end: the winning seats, and optionally places and scores by seat. */
+type TurnOutcome = NonNullable<TurnGameView['outcome']>;
+/** One move as this seat saw it. */
+interface TurnMoveEvent<View, Ev> {
+  readonly seq: number;
+  readonly seat: number;
+  /** The view after the move (for a replayed move, the view now). */
+  readonly view: View;
+  readonly events: readonly Ev[];
+}
+/** What a game's listeners hear. */
+interface TurnGameEvents<View, Ev> {
+  move: TurnMoveEvent<View, Ev>;
+  turn: TurnSummary;
+  ended: {
+    readonly outcome: TurnOutcome | null;
+    readonly view: View;
+  };
+  chat: TurnChatLine;
+}
+/** What a game needs from its client: the REST calls, by name. */
+interface TurnGameHost {
+  get(id: string): Promise<TurnGameView>;
+  start(id: string): Promise<TurnGameView>;
+  move(id: string, seq: number, move: Json): Promise<{
+    game: TurnGameView;
+    events: Json[];
+  }>;
+  history(id: string, since: number): Promise<{
+    seq: number;
+    seat: number;
+    events: Json[];
+  }[]>;
+  leave(id: string): Promise<void>;
+  nudge(id: string): Promise<void>;
+  setNotify(id: string, mode: 'on' | 'off'): Promise<void>;
+  rematch(id: string): Promise<TurnGameView>;
+  invite(id: string, userIds: readonly number[]): Promise<TurnGameView>;
+  share(id: string, share: {
+    readonly link?: boolean;
+    readonly public?: boolean;
+  }): Promise<TurnGameView>;
+  autoPlay(id: string): Promise<TurnGameView>;
+  chat(id: string, send: {
+    readonly text?: string;
+    readonly quick?: string;
+  }): Promise<TurnChatLine>;
+  /** The page has a game open (saves of a run are off while it does). */
+  opened(game: object): void;
+  closed(game: object): void;
+  /** Whether the live runtime is on the page (else the game polls). */
+  isLive(): boolean;
+}
+type Listener<Payload> = (payload: Payload) => void;
+/** How `hub.turns` sets a game up. */
+interface TurnGameOptions {
+  /** Whether this page wants the "your turn" buzz (`hub.turns.setYourTurnBuzz`); read at each buzz. Default on. */
+  readonly isBuzzOn?: () => boolean;
+}
+/** One online game. `View`, `Move` and `Ev` (its events) are the game's own JSON types from its rules. */
+declare class TurnGame<View = GamePayload, Move extends GamePayload = GamePayload, Ev = GamePayload> {
+  readonly id: string;
+  private state;
+  private readonly host;
+  private readonly listeners;
+  private readonly stopListening;
+  private isClosed;
+  private catchingUp;
+  /** The move count this page's own move in flight will make (its live echo is not another player's move). */
+  private ownSeq;
+  /** When the page last heard from the hub about this game (a live event or an answer), epoch ms. */
+  private heardAt;
+  private readonly options;
+  /** This game's own "your turn" buzz switch (`setYourTurnBuzz`). */
+  private isBuzzOn;
+  constructor(host: TurnGameHost, initial: TurnGameView, options?: TurnGameOptions);
+  /** Whose move it is, the seats and the deadline. */
+  get summary(): TurnSummary;
+  /** This seat's view, from the game's rules (`null` before the game starts). */
+  get view(): View;
+  /** This player's seat, or `null` (they left). */
+  get mySeat(): number | null;
+  /** The end, once the game is over. */
+  get outcome(): TurnOutcome | null;
+  /** The last chat lines, oldest first. */
+  get chat(): readonly TurnChatLine[];
+  /** `on`: friends may type (moderated); `quick`: quick-chat and emotes only; `off`. */
+  get chatMode(): TurnGameView['chatMode'];
+  /** The link others can take a seat with (the creator's, while seats are open), else `null`. */
+  get link(): string | null;
+  /** Whether this player may move now without it being their turn (the rules' `mayAct`: a jump-in, calling or catching "UNO"): offer that action. */
+  get mayActNow(): boolean;
+  /** The tournament match this game is, or `null` (show it if you like: "Saturday Cup: your match"). */
+  get tournament(): TurnTournament | null;
+  /**
+   * The "your turn" buzz for this game: a short vibration when this player
+   * becomes due on a live update while the page is visible (never for the
+   * next step of their own turn, a move out of turn, a game just opened or a
+   * catch-up; never when the player turned it off or asks for less motion;
+   * silently nothing where the device can't vibrate). On by default.
+   */
+  setYourTurnBuzz(isOn: boolean): void;
+  /** Creator: start the game (empty seats go to the computer when the game allows). */
+  start(): Promise<void>;
+  /**
+   * Make a move: when it is your turn (`summary.isMyTurn`), or out of turn
+   * when the rules allow it (`mayActNow`). Rejects with a `HubError`: 403
+   * `not_your_turn`, 409 `stale` (the game moved on, or another player's
+   * move got there first: the view is refreshed first), 422 `illegal` with
+   * the rules' own code in `rule`, 500 `rules_error` or 503 `rules_busy`
+   * (the move was not made; the game is fetched again). The answer's `view` is the newest this
+   * page has: moves that arrived live while the answer was on its way (the
+   * computer's, another player's) are never rolled back.
+   */
+  move(move: Move): Promise<{
+    seq: number;
+    view: View;
+    events: Ev[];
+  }>;
+  /** The moves after `sinceSeq`, with their events as this seat may see them ("what happened while you were away"). */
+  history(sinceSeq: number): Promise<{
+    seq: number;
+    seat: number;
+    events: Ev[];
+  }[]>;
+  /** Leave: the computer plays the seat (or, without bots, the others win). The player can't come back. */
+  leave(): Promise<void>;
+  /** Remind whoever must move (once a day). */
+  nudge(): Promise<void>;
+  /** This game's "your turn" alerts. */
+  setNotify(mode: 'on' | 'off'): Promise<void>;
+  /** A finished game: a new one with the same friends (they get an invite). */
+  rematch(): Promise<TurnGame<View, Move, Ev>>;
+  /** Creator, before the start: add an invite link (`link: true`, then read `link`) or list the open seats for anyone (`public`). */
+  share(share: {
+    readonly link?: boolean;
+    readonly public?: boolean;
+  }): Promise<void>;
+  /** Invite friends to free seats (before the start). */
+  invite(userIds: readonly number[]): Promise<void>;
+  /**
+   * Whether "Let the computer play for <name>" may work now: another
+   * player is due, the hub's hand-over wait (`summary.handOverAt`) has
+   * passed and a due player isn't connected (`TurnSeat.connected` false
+   * or unknown), or the turn's `deadline` passed. `false` in a
+   * tournament match, and from a hub too old to say. Re-check it on each
+   * `turn` event (a player coming or going fires one) and when
+   * `handOverAt` comes.
+   */
+  canLetComputerPlay(now?: number): boolean;
+  /**
+   * Let the computer play for whoever is due: a turn whose deadline passed
+   * (or whose player is suspended) is played once; otherwise, when that
+   * player has been due a while (2 minutes) and isn't connected at all, the
+   * computer plays their seat for the rest of the game (it shows as `bot`,
+   * named with who chose it) until they open the game again. Rejects with
+   * 409 `deadline_not_passed` when neither (it never says whether they are
+   * online), and 409 `not_supported` in a tournament match.
+   */
+  letComputerPlay(): Promise<void>;
+  /** Say something: `{ text }` between friends (moderated), `{ quick }` (a quick-chat phrase id) with anyone. */
+  say(send: {
+    readonly text?: string;
+    readonly quick?: string;
+  }): Promise<TurnChatLine>;
+  /**
+   * Fetch the game again, and replay moves missed since the last one this
+   * page saw. An answer older than what the page has by then (live moves
+   * arrived while it was on its way) is dropped, never rolled back to, and
+   * a move that arrived live is never replayed twice.
+   */
+  refresh(): Promise<void>;
+  /** Hear moves, turn changes, the end and chat; returns a function that stops listening. */
+  on<K extends keyof TurnGameEvents<View, Ev>>(eventName: K, listener: Listener<TurnGameEvents<View, Ev>[K]>): () => void;
+  /** Stop live updates for this page (the game itself goes on). */
+  close(): void;
+  /** Take a fresh answer from the hub (one older than what the page has is dropped: no rollback); fire `turn` and `ended` when they changed. */
+  private update;
+  private emit;
+  /** Whether the page is waiting on someone: another player's move, or a lobby. */
+  private isWaitingOnOthers;
+  /** A live `hub:turn` for this game: a move (or a missed run of them), or another change. */
+  private onLive;
+  /** Replay what was missed (one catch-up at a time). */
+  private catchUp;
+  private listen;
+}
+//#endregion
+//#region src/core/turns/hub-turns.d.ts
+/** The query parameter an invite link carries (`/<slug>/?hub_turn_link=<key>`); the client strips it. */
+declare const TURN_LINK_PARAM = "hub_turn_link";
+/** How to make a game. */
+interface TurnCreateOptions {
+  readonly mode?: string;
+  /** The game's own setup choices (at most 2 KB of JSON). */
+  readonly options?: GamePayload;
+  /** Friends to invite (their seats are held). */
+  readonly invite?: readonly number[];
+  /** Make a link others can take a seat with (`game.link`). */
+  readonly link?: boolean;
+  /** List the open seats in Play online for anyone to take. */
+  readonly public?: boolean;
+  /** Seats in all (within `game.turns.players`). */
+  readonly seats?: number;
+  /** Let the computer fill seats nobody took (default true, when the game has bots). */
+  readonly bots?: boolean;
+  /** How long a turn may wait before the others may let the computer play it (default none). */
+  readonly deadline?: TurnDeadline;
+  /** Start by itself once every seat is taken (the creator needn't come back). */
+  readonly autoStart?: boolean;
+}
+/** What `hub.turns` needs from its client. */
+interface TurnsHost extends TurnGameHost {
+  readonly slug: string | null;
+  create(body: CreateTurnGame): ReturnType<TurnGameHost['get']>;
+  join(id: string): ReturnType<TurnGameHost['get']>;
+  joinByLink(key: string): ReturnType<TurnGameHost['get']>;
+  listOpen(game: string | null): Promise<OpenTurnGame[]>;
+  list(): Promise<SavedEntry[]>;
+}
+/** `hub.turns`. */
+declare class HubTurns {
+  private readonly host;
+  private isBuzzOn;
+  private readonly gameOptions;
+  constructor(host: TurnsHost);
+  /**
+   * This page's "your turn" buzz (a short vibration when the player becomes
+   * due in an open game, see `TurnGame.setYourTurnBuzz`): pass `false` if
+   * your game gives its own signal. On by default.
+   */
+  setYourTurnBuzz(isOn: boolean): void;
+  /** The player's own "Buzz when it's my turn" switch on this device (the menu's Settings show it too). */
+  get playerYourTurnBuzz(): boolean;
+  set playerYourTurnBuzz(isOn: boolean);
+  /** The invite link key this page was opened with (`?hub_turn_link=`), taken out of the address bar; `null` when none. Synchronous. */
+  get link(): string | null;
+  /** Make a game in this page's game (its lobby): the player takes the first seat. */
+  create<View = GamePayload, Move extends GamePayload = GamePayload, Event = GamePayload>(options?: TurnCreateOptions): Promise<TurnGame<View, Move, Event>>;
+  /** Take a seat: by the game's id (an invite, an open seat) or by an invite link's key. */
+  join<View = GamePayload, Move extends GamePayload = GamePayload, Event = GamePayload>(idOrLinkKey: string): Promise<TurnGame<View, Move, Event>>;
+  /** Open a game the player sits in (from `hub.saved.opened`, the Continue list, an invite). */
+  open<View = GamePayload, Move extends GamePayload = GamePayload, Event = GamePayload>(id: string): Promise<TurnGame<View, Move, Event>>;
+  /** This game's online games the player sits in (the same rows as `hub.saved.list({ kinds: ['turns'] })`). */
+  list(): Promise<SavedEntry[]>;
+  /** Open-seat games of this game anyone may join (none across a block). */
+  openLobbies(): Promise<OpenTurnGame[]>;
+}
+//#endregion
 //#region src/core/version/hub-version.d.ts
 /** How a hub regards a client version. */
 type ClientSupport =
@@ -589,6 +1602,13 @@ type ClientSupport =
 declare class Hub extends HubEconomy {
   /** This client's package version (sent as `x-hub-client`). */
   readonly clientVersion: string;
+  private resumeApi;
+  private avatarApi;
+  private savedApi;
+  private dailySavesApi;
+  private turnsApi;
+  /** The online games open on this page (a run isn't saved while one is). */
+  private readonly openTurnGames;
   /**
    * The hub's version and the client versions it supports (`GET /_api/version`),
    * read once per page. `null` for a hub from before versioning.
@@ -624,7 +1644,41 @@ declare class Hub extends HubEconomy {
   get notify(): typeof notifyForwarder;
   /** Races: a single-player game becomes multiplayer by racing. */
   get race(): typeof raceForwarder;
-  /** What the daily system needs from this client: its REST calls and window events. */
+  /**
+   * Resume a saved game: `hub.resume.save({ state, progress })` during a long
+   * single-player run, `clear()` when it ends, `load()` and `requested` to
+   * pick it up again (docs: "Resume saved games"). Needs `game.resumable: true`.
+   */
+  get resume(): HubResume;
+  /**
+   * Players' avatars: `hub.avatar.mine()`, `of(userId)`, `from(seat)`,
+   * `bot(seed)`, `on('change')`, `openDesigner()` and `load()` for the renderer
+   * (docs: "Avatars"). No art or renderer until `load()`.
+   */
+  get avatar(): HubAvatar;
+  /**
+   * Every game the player has in progress, of every kind: `hub.saved.list()`
+   * for this game's "Continue" list, `opened` and `onOpen` to open the one
+   * the player picked (docs: "Saved games").
+   */
+  get saved(): HubSaved;
+  /**
+   * Online games played over minutes or days, run by the hub from the
+   * game's rules module (`game.turns`): `hub.turns.create`, `join`, `open`
+   * (docs/multiplayer.md "Turn games").
+   */
+  get turns(): HubTurns;
+  /** What `hub.turns` needs from this client: its REST calls. */
+  private turnsHost;
+  /** What `hub.saved` needs from this client. */
+  private savedHost;
+  /** Discard a daily or run: this game's run through `hub.resume` (works offline), others on the hub. */
+  private discardSaved;
+  /** What `hub.resume` needs from this client. */
+  private resumeHost;
+  /** This game's daily saves (device copies and their sends). */
+  private dailySaves;
+  /** What the daily system needs from this client: its REST calls, the device copies and window events. */
   private dailyHost;
 }
 /** A ready-to-use client, with the slug and API base detected from the page. */
@@ -640,12 +1694,18 @@ declare function createHub(options?: HubOptions): Hub;
 declare const UNSUPPORTED_BY_HUB = "unsupported_by_hub";
 /** The code the social runtime gives a call it could not send (no connection). */
 declare const OFFLINE_CODE = "offline";
+/**
+ * The code `getSave` rejects with when the hub can't be reached and this
+ * device has no copy of the slot it can trust (a fresh device or cleared
+ * browser): the slot may well hold a save, so it is not reported empty.
+ */
+declare const SAVE_UNKNOWN_CODE = "save_unknown";
 /**
  * A machine-readable error code: one of the contract's public codes
  * (`content_rejected`, `rate_limited`, `suspended`, `claim_required`, ...),
  * {@link UNSUPPORTED_BY_HUB}, or a code a newer hub added.
  */
-type HubErrorCode = ErrorCode | typeof UNSUPPORTED_BY_HUB | typeof OFFLINE_CODE | (string & Record<never, never>);
+type HubErrorCode = ErrorCode | typeof UNSUPPORTED_BY_HUB | typeof OFFLINE_CODE | typeof SAVE_UNKNOWN_CODE | (string & Record<never, never>);
 /** The machine-readable extras the hub attaches to an error body. */
 interface HubErrorDetails {
   /** A stable error code, for code to branch on. */
@@ -658,6 +1718,8 @@ interface HubErrorDetails {
   readonly retryAfterMs?: number | undefined;
   /** When a suspension or mute ends (epoch ms). */
   readonly until?: number | undefined;
+  /** An online game's rules refused a move (`illegal`): the rules' own short code. */
+  readonly rule?: string | undefined;
 }
 /**
  * Thrown by every hub call that fails. `status` is the HTTP status when the
@@ -678,6 +1740,8 @@ declare class HubError extends Error {
   readonly retryAfterMs: number | undefined;
   /** When a suspension or mute ends (epoch ms). */
   readonly until: number | undefined;
+  /** An online game's rules refused a move (`code` is `illegal`): the rules' own short code, such as `cell_taken`. */
+  readonly rule: string | undefined;
   /** An error with a player-safe `message`, the HTTP `status` (if any) and the body's extras. */
   constructor(message: string, status?: number, details?: HubErrorDetails);
   /** `true` when the failure was a network or transport error, not an HTTP status. */
@@ -698,9 +1762,21 @@ declare class ContentRejectedError extends HubError {
   constructor(message: string, status: number | undefined, details: HubErrorDetails);
 }
 //#endregion
+//#region src/core/turns/your-turn-buzz.d.ts
+/** The pattern: two short pulses, ms. */
+declare const YOUR_TURN_BUZZ: readonly number[];
+/** Where this device keeps the player's choice (`off` turns it off). */
+declare const YOUR_TURN_BUZZ_KEY = "dg:your-turn-buzz";
+/** Whether going from `previous` to `next` makes this player newly due (the moment to buzz). */
+declare function isNewlyDue(previous: Pick<TurnSummary, 'phase' | 'isMyTurn'>, next: Pick<TurnSummary, 'phase' | 'isMyTurn' | 'isMuted'>): boolean;
+/** The player's own switch on this device (on unless they turned it off). */
+declare function readYourTurnBuzz(): boolean;
+/** Save the player's switch on this device. */
+declare function saveYourTurnBuzz(isOn: boolean): void;
+//#endregion
 //#region src/core/version/client-version.gen.d.ts
 /** This client's package version, sent as `x-hub-client` on REST calls and `client` in `hello`. */
-declare const HUB_CLIENT_VERSION = "2.0.0-next.0";
+declare const HUB_CLIENT_VERSION = "2.0.0-next.10";
 //#endregion
-export { SubmitScoreResult as $, BoardWithTop as A, Json$1 as B, CLIENT_VERSION_HEADER as C, QueuedScoreOptions as D, QueueOpInput as E, GlobalAnalytics as F, Profile as G, LeaderboardResult as H, HubOptions as I, SaveMeta as J, ProfileSummary as K, HubStatus as L, GameInfo$1 as M, GameLeaderboards as N, BufferedEvent as O, GameRecords as P, SubmitScoreOptions as Q, Inventory as R, SyncResult as S, QueueOp as T, MeResponse as U, LeaderboardEntry as V, Metrics$1 as W, SortDir$1 as X, SnapshotResponse as Y, Stats$1 as Z, TradeNoteOptions as _, HubErrorDetails as a, StatResult as b, Hub as c, ClientSupport as d, User as et, HubMenuControl as f, TradeListOptions as g, TradeId as h, HubErrorCode as i, GamePayload as it, GameAnalytics as j, Board$1 as k, createHub as l, TradeBundle as m, ContentRejectedError as n, EndpointName as nt, OfflineError as o, GrantBundle as p, Save as q, HubError as r, EndpointReply as rt, UNSUPPORTED_BY_HUB as s, HUB_CLIENT_VERSION as t, EndpointFields as tt, hub as u, AuthResponse as v, ProfilePatch as w, SyncConflict as x, ProfileUpdate as y, InventorySnapshot as z };
+export { TradeListOptions as $, AvatarModule as $t, TurnGame as A, HubOptions as At, HubResume as B, ProfileSummary as Bt, TURN_LINK_PARAM as C, Board$1 as Ct, TURN_POLL_MS as D, GameLeaderboards as Dt, TURN_EVENT as E, GameInfo$1 as Et, HubSaved as F, LeaderboardEntry as Ft, ResumeLoadOptions as G, Stats$1 as Gt, RESUME_MAX_STATE_BYTES as H, SaveMeta as Ht, SAVED_CHANGE_QUIET_MS as I, LeaderboardResult as It, ResumeSaveInput as J, User as Jt, ResumeProgress as K, SubmitScoreOptions as Kt, SavedChangeListener as L, MeResponse as Lt, TurnGameOptions as M, Inventory$1 as Mt, TurnMoveEvent as N, InventorySnapshot as Nt, TURN_QUIET_MS as O, GameRecords as Ot, TurnOutcome as P, Json$1 as Pt, TradeId as Q, AvatarHost as Qt, SavedOpenDetail as R, Metrics$1 as Rt, HubTurns as S, BufferedEvent as St, TURN_CHAT_EVENT as T, GameAnalytics as Tt, ResumeBlocker as U, SnapshotResponse as Ut, RESUME_DEBOUNCE_MS as V, Save as Vt, ResumeEntry as W, SortDir$1 as Wt, GrantBundle as X, EndpointName as Xt, HubMenuControl as Y, EndpointFields as Yt, TradeBundle as Z, EndpointReply as Zt, UNSUPPORTED_BY_HUB as _, CLIENT_VERSION_HEADER as _t, HUB_CLIENT_VERSION as a, SyncResult as at, hub as b, QueueOpInput as bt, isNewlyDue as c, OfflineEventDetails as ct, ContentRejectedError as d, OfflineOp as dt, HubAvatar as en, TradeNoteOptions as et, HubError as f, OUTBOX_MAX_CHARS as ft, SAVE_UNKNOWN_CODE as g, ReplayContext as gt, OfflineError as h, OfflineKindDefinition as ht, TurnGameView$1 as i, SyncConflict as it, TurnGameEvents as j, HubStatus as jt, TURN_RESYNC_EVENT as k, GlobalAnalytics as kt, readYourTurnBuzz as l, OfflineEventName as lt, HubErrorDetails as m, OfflineHandler as mt, TurnChatLine$1 as n, ProfileUpdate as nt, YOUR_TURN_BUZZ as o, OfflineApi as ot, HubErrorCode as p, OUTBOX_MAX_ENTRIES as pt, ResumeRun as q, SubmitScoreResult as qt, TurnDeadline$1 as r, StatResult as rt, YOUR_TURN_BUZZ_KEY as s, OUTBOX_FULL_CODE as st, OpenTurnGame$1 as t, CarriesLook as tn, AuthResponse as tt, saveYourTurnBuzz as u, OfflineListener as ut, Hub as v, ProfilePatch as vt, TurnCreateOptions as w, BoardWithTop as wt, ClientSupport as x, QueuedScoreOptions as xt, createHub as y, QueueOp as yt, SavedOpenHandler as z, Profile as zt };
 //# sourceMappingURL=index.d.ts.map