@diffenderfer-games/hub 2.0.0-next.4 → 2.0.0-next.6

package/dist/shared/index.d.ts

@@ -1,11 +1,129 @@
-import { s as DailySystem } from "./daily.js";
+import { b 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, Inventory as Inventory$1, Json, Json as Json$1, LeaderboardEntry, Metrics, Metrics as Metrics$1, PublicEndpoints, RejectReason, ResumeSlot, ResumeSummary, SessionUser, SortDir, SortDir as SortDir$1, Stats, Stats as Stats$1 } from "@diffenderfer-games/hub-contract";
+import { Q as OpenDesignerOptions, X as AvatarRef, Y as AvatarChange, Z as DesignerResult, it as socialForwarder, nt as notifyForwarder, rt as presenceForwarder } 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 } 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;
@@ -256,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. */
@@ -278,7 +402,12 @@ declare class LocalStore {
   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
@@ -585,6 +714,43 @@ declare class LocalResumeStore {
   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 op the hub refused during a sync (or that kept failing): dropped, with the reason. */
 interface SyncConflict {
@@ -619,6 +785,8 @@ declare class HubConnection {
   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 runningSync;
@@ -717,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>;
   /**
@@ -740,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;
@@ -752,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;
@@ -971,8 +1162,8 @@ interface ResumeEntry {
   /** 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, a daily challenge or an online room. */
-type ResumeBlocker = 'race' | 'daily' | 'room';
+/** 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. */
@@ -990,6 +1181,8 @@ interface ResumeHost {
   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. */
@@ -998,6 +1191,12 @@ interface ResumeHost {
   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 {
@@ -1018,14 +1217,17 @@ declare class HubResume {
   /**
    * 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, a daily challenge or an
-   * online room. Throws a `HubError` 413 over 512 KB, 400 without a label.
+   * 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). */
@@ -1042,6 +1244,282 @@ declare class HubResume {
   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;
+/** 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;
+/** 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;
+  constructor(host: TurnGameHost, initial: TurnGameView);
+  /** 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;
+  /** Creator: start the game (empty seats go to the computer when the game allows). */
+  start(): Promise<void>;
+  /**
+   * Make a move. Rejects with a `HubError`: 403 `not_your_turn`, 409
+   * `stale` (the game moved on: the view is refreshed first), 422 `illegal`
+   * with the rules' own code in `rule`.
+   */
+  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>;
+  /** The turn's deadline passed (or its player is suspended): let the computer play it. */
+  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. */
+  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; fire `turn` and `ended` when they changed. */
+  private update;
+  private emit;
+  /** 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;
+  constructor(host: TurnsHost);
+  /** 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 =
@@ -1060,6 +1538,12 @@ 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.
@@ -1101,9 +1585,35 @@ declare class Hub extends HubEconomy {
    * 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;
-  /** What the daily system needs from this client: its REST calls and window events. */
+  /** 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. */
@@ -1119,12 +1629,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. */
@@ -1137,6 +1653,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
@@ -1157,6 +1675,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. */
@@ -1179,7 +1699,7 @@ declare class ContentRejectedError extends HubError {
 //#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.4";
+declare const HUB_CLIENT_VERSION = "2.0.0-next.6";
 //#endregion
-export { GameLeaderboards as $, SyncConflict as A, OfflineHandler as B, TradeBundle as C, EndpointReply as Ct, AuthResponse as D, TradeNoteOptions as E, OfflineEventName as F, QueueOp as G, ReplayContext as H, OfflineListener as I, BufferedEvent as J, QueueOpInput as K, OfflineOp as L, OfflineApi as M, OUTBOX_FULL_CODE as N, ProfileUpdate as O, OfflineEventDetails as P, GameInfo$1 as Q, OUTBOX_MAX_CHARS as R, GrantBundle as S, EndpointName as St, TradeListOptions as T, CLIENT_VERSION_HEADER as U, OfflineKindDefinition as V, ProfilePatch as W, BoardWithTop as X, Board$1 as Y, GameAnalytics as Z, ResumeLoadOptions as _, Stats$1 as _t, HubErrorDetails as a, InventorySnapshot as at, ResumeSaveInput as b, User as bt, Hub as c, LeaderboardResult as ct, ClientSupport as d, Profile as dt, GameRecords as et, HubResume as f, ProfileSummary as ft, ResumeEntry as g, SortDir$1 as gt, ResumeBlocker as h, SnapshotResponse as ht, HubErrorCode as i, Inventory$1 as it, SyncResult as j, StatResult as k, createHub as l, MeResponse as lt, RESUME_MAX_STATE_BYTES as m, SaveMeta as mt, ContentRejectedError as n, HubOptions as nt, OfflineError as o, Json$1 as ot, RESUME_DEBOUNCE_MS as p, Save as pt, QueuedScoreOptions as q, HubError as r, HubStatus as rt, UNSUPPORTED_BY_HUB as s, LeaderboardEntry as st, HUB_CLIENT_VERSION as t, GlobalAnalytics as tt, hub as u, Metrics$1 as ut, ResumeProgress as v, SubmitScoreOptions as vt, TradeId as w, GamePayload as wt, HubMenuControl as x, EndpointFields as xt, ResumeRun as y, SubmitScoreResult as yt, OUTBOX_MAX_ENTRIES as z };
+export { OfflineApi as $, SavedChangeListener as A, MeResponse as At, ResumeRun as B, SubmitScoreResult as Bt, TURN_RESYNC_EVENT as C, HubOptions as Ct, TurnOutcome as D, Json$1 as Dt, TurnMoveEvent as E, InventorySnapshot as Et, RESUME_MAX_STATE_BYTES as F, SaveMeta as Ft, TradeId as G, AvatarHost as Gt, HubMenuControl as H, EndpointFields as Ht, ResumeBlocker as I, SnapshotResponse as It, AuthResponse as J, CarriesLook as Jt, TradeListOptions as K, AvatarModule as Kt, ResumeEntry as L, SortDir$1 as Lt, SavedOpenHandler as M, Profile as Mt, HubResume as N, ProfileSummary as Nt, HubSaved as O, LeaderboardEntry as Ot, RESUME_DEBOUNCE_MS as P, Save as Pt, SyncResult as Q, ResumeLoadOptions as R, Stats$1 as Rt, TURN_POLL_MS as S, GlobalAnalytics as St, TurnGameEvents as T, Inventory$1 as Tt, GrantBundle as U, EndpointName as Ut, ResumeSaveInput as V, User as Vt, TradeBundle as W, EndpointReply as Wt, StatResult as X, ProfileUpdate as Y, SyncConflict as Z, HubTurns as _, BoardWithTop as _t, HUB_CLIENT_VERSION as a, OUTBOX_MAX_CHARS as at, TURN_CHAT_EVENT as b, GameLeaderboards as bt, HubErrorCode as c, OfflineKindDefinition as ct, SAVE_UNKNOWN_CODE as d, ProfilePatch as dt, OUTBOX_FULL_CODE as et, UNSUPPORTED_BY_HUB as f, QueueOp as ft, ClientSupport as g, Board$1 as gt, hub as h, BufferedEvent as ht, TurnGameView$1 as i, OfflineOp as it, SavedOpenDetail as j, Metrics$1 as jt, SAVED_CHANGE_QUIET_MS as k, LeaderboardResult as kt, HubErrorDetails as l, ReplayContext as lt, createHub as m, QueuedScoreOptions as mt, TurnChatLine$1 as n, OfflineEventName as nt, ContentRejectedError as o, OUTBOX_MAX_ENTRIES as ot, Hub as p, QueueOpInput as pt, TradeNoteOptions as q, HubAvatar as qt, TurnDeadline$1 as r, OfflineListener as rt, HubError as s, OfflineHandler as st, OpenTurnGame$1 as t, OfflineEventDetails as tt, OfflineError as u, CLIENT_VERSION_HEADER as ut, TURN_LINK_PARAM as v, GameAnalytics as vt, TurnGame as w, HubStatus as wt, TURN_EVENT as x, GameRecords as xt, TurnCreateOptions as y, GameInfo$1 as yt, ResumeProgress as z, SubmitScoreOptions as zt };
 //# sourceMappingURL=index.d.ts.map