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

package/src/core/hub.ts

@@ -10,16 +10,23 @@ import { getInput, getUiStack, type InputSystem } from '../input';
 import { mp } from '../mp';
 import { race } from '../race';
 import { rooms } from '../rooms';
+import { pageBridge } from '../realtime/bridge';
 import { isInHubRoom } from '../realtime/rooms-forwarder';
 import { linkRealtimeToHub, notify, presence, social } from '../social';
+import { HubAvatar } from './avatar/hub-avatar';
 import { HubError, OfflineError, toHubError } from './errors';
 import { HubEconomy } from './hub-economy';
-import { DAILY_KIND, RESUME_KIND } from './offline/hub-kinds';
+import { AVATAR_KIND, DAILY_KIND, RESUME_KIND, SAVED_KIND } from './offline/hub-kinds';
 import { readDailyCompletion } from './offline/hub-kinds/daily-kind';
 import { hubMenu, type HubMenuControl } from './menu-control';
 import { detectGameTitle, emitWindowEvent } from './page';
 import { HubResume, type ResumeHost } from './resume/hub-resume';
 import { isResumeRequested } from './resume/resume-request';
+import { DailySaves } from './saved/daily-saves';
+import { HubSaved, type SavedHost } from './saved/hub-saved';
+import { HubTurns, type TurnsHost } from './turns/hub-turns';
+import { savedOpenedOnPage } from './saved/saved-open';
+import type { SavedEntry } from './saved/saved-types';
 import { fetchGameServerTicket } from './ticket';
 import { clientSupport, readHubVersion, type ClientSupport } from './version/hub-version';
 import { HUB_CLIENT_VERSION } from './version/client-version.gen';
@@ -31,6 +38,12 @@ export class Hub extends HubEconomy {
   readonly clientVersion: string = HUB_CLIENT_VERSION;
 
   private resumeApi: HubResume | undefined;
+  private avatarApi: HubAvatar | undefined;
+  private savedApi: HubSaved | undefined;
+  private dailySavesApi: DailySaves | undefined;
+  private turnsApi: HubTurns | undefined;
+  /** The online games open on this page (a run isn't saved while one is). */
+  private readonly openTurnGames = new Set<object>();
 
   /**
    * The hub's version and the client versions it supports (`GET /_api/version`),
@@ -118,6 +131,110 @@ export class Hub extends HubEconomy {
     return this.resumeApi;
   }
 
+  /**
+   * 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 {
+    this.avatarApi ??= new HubAvatar({
+      currentUserId: () => this.userId(),
+      onAccount: (listener) => this.account.on(listener),
+      fetchMine: () => this.rest.call('getMyAvatar'),
+      fetchCodes: async (ids) => (await this.rest.call('getAvatars', { ids: [...ids] })).codes,
+      queueSave: async (code, savedAt) => {
+        await this.mutateOffline(AVATAR_KIND, { code, savedAt }, () => undefined);
+      },
+    });
+    return this.avatarApi;
+  }
+
+  /**
+   * 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 {
+    this.savedApi ??= new HubSaved(this.savedHost());
+    return this.savedApi;
+  }
+
+  /**
+   * 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 {
+    this.turnsApi ??= new HubTurns(this.turnsHost());
+    return this.turnsApi;
+  }
+
+  /** What `hub.turns` needs from this client: its REST calls. */
+  private turnsHost(): TurnsHost {
+    const { rest } = this;
+    return {
+      slug: this.slug,
+      create: (body) => rest.call('createTurnGame', body),
+      join: (id) => rest.call('joinTurnGame', { id }),
+      joinByLink: (key) => rest.call('joinTurnGameByLink', { key }),
+      get: (id) => rest.call('getTurnGame', { id }),
+      start: (id) => rest.call('startTurnGame', { id }),
+      move: (id, seq, move) => rest.call('moveTurnGame', { id, seq, move }),
+      history: async (id, since) => (await rest.call('getTurnGameHistory', { id, since })).moves,
+      leave: async (id) => { await rest.call('leaveTurnGame', { id }); },
+      nudge: async (id) => { await rest.call('nudgeTurnGame', { id }); },
+      setNotify: async (id, mode) => { await rest.call('setTurnGameNotify', { id, mode }); },
+      rematch: (id) => rest.call('rematchTurnGame', { id }),
+      invite: (id, userIds) => rest.call('inviteToTurnGame', { id, userIds: [...userIds] }),
+      share: (id, share) => rest.call('shareTurnGame', { id, ...share }),
+      autoPlay: (id) => rest.call('autoPlayTurn', { id }),
+      chat: (id, send) => rest.call('chatInTurnGame', { id, ...send }),
+      listOpen: async (game) => (await rest.call('listOpenTurnGames', game === null ? {} : { game })).games,
+      list: () => this.saved.list({ kinds: ['turns'] }),
+      opened: (game) => { this.openTurnGames.add(game); },
+      closed: (game) => { this.openTurnGames.delete(game); },
+      isLive: () => pageBridge.current() !== null,
+    };
+  }
+
+  /** What `hub.saved` needs from this client. */
+  private savedHost(): SavedHost {
+    return {
+      slug: this.slug,
+      fetchList: (game) => this.withFallback<readonly SavedEntry[] | undefined>(
+        async () => (await this.rest.call('listMySavedGames', game === null ? {} : { game })).games,
+        () => undefined,
+      ),
+      deviceCopies: () => {
+        const userId = this.store.getUser()?.id ?? null;
+        return {
+          runs: new Map([...this.resumeStore.all()].filter(([, copy]) => copy.userId === userId)),
+          dailies: this.dailyStore.all(userId),
+        };
+      },
+      discard: (entry) => this.discardSaved(entry),
+      navigate: (url) => {
+        location.assign(url);
+      },
+    };
+  }
+
+  /** Discard a daily or run: this game's run through `hub.resume` (works offline), others on the hub. */
+  private async discardSaved(entry: SavedEntry): Promise<void> {
+    if (entry.kind === 'run' && entry.game === this.slug) {
+      await this.resume.clear();
+      return;
+    }
+    if (!entry.id.startsWith('local:')) {
+      await this.rest.call('discardSavedGame', { id: entry.id });
+    }
+    if (entry.kind === 'run') {
+      this.resumeStore.remove(entry.game);
+    } else if (entry.daily !== undefined) {
+      this.dailyStore.remove(entry.game, entry.daily.day);
+    }
+  }
+
   /** What `hub.resume` needs from this client. */
   private resumeHost(): ResumeHost {
     return {
@@ -129,7 +246,14 @@ export class Hub extends HubEconomy {
         if (race.current() !== null) {
           return 'race';
         }
-        return this.daily.active === null ? (isInHubRoom() ? 'room' : null) : 'daily';
+        if (this.openTurnGames.size > 0) {
+          return 'turns';
+        }
+        return isInHubRoom() ? 'room' : null;
+      },
+      daily: () => {
+        const daily = this.daily;
+        return daily.active === null ? null : daily;
       },
       send: async (payload) => {
         await this.mutateOffline(RESUME_KIND, payload, () => undefined);
@@ -148,17 +272,59 @@ export class Hub extends HubEconomy {
       clearOther: async (slug) => {
         await this.rest.call('clearResumeSlot', { slug });
       },
+      onChange: () => {
+        this.savedApi?.changed();
+      },
     };
   }
 
-  /** 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(): DailySaves {
+    const slug = this.slug;
+    if (slug === null) {
+      throw new HubError('hub.daily: could not determine the game slug.');
+    }
+    this.dailySavesApi ??= new DailySaves({
+      slug,
+      local: this.dailyStore,
+      currentUserId: () => this.store.getUser()?.id ?? null,
+      gameTitle: () => detectGameTitle(slug),
+      send: async (payload) => {
+        await this.mutateOffline(SAVED_KIND, payload, () => undefined);
+        this.savedApi?.changed();
+      },
+    });
+    return this.dailySavesApi;
+  }
+
+  /** What the daily system needs from this client: its REST calls, the device copies and window events. */
   private dailyHost(): DailyHost {
     return {
       slug: this.slug,
       status: () => this.rest.call('getGameDailyChallenges', this.gameFields()),
       all: () => this.rest.call('listDailyChallengesForAllGames'),
-      start: (day) => this.rest.call('startDailyChallenge', { ...this.gameFields(), day }),
-      complete: (day, token, meta) => this.mutateOffline<DailyCompleteResponse | null>(DAILY_KIND, { day, token, meta }, () => null, (result) => readDailyCompletion(result)),
+      start: (day) => this.withFallback(
+        async () => this.dailySaves().remember(await this.rest.call('startDailyChallenge', { ...this.gameFields(), day })),
+        () => this.dailySaves().startLocally(day),
+      ),
+      resume: async (instanceId) => this.dailySaves().remember(await this.rest.call('resumeDailyChallenge', { id: instanceId })),
+      complete: async (day, token, meta) => {
+        this.dailySaves().finished(day);
+        const completed = await this.mutateOffline<DailyCompleteResponse | null>(DAILY_KIND, { day, token, meta }, () => null, (result) => readDailyCompletion(result));
+        if (completed !== null) {
+          this.dailySaves().completed(day);
+        }
+        this.savedApi?.changed();
+        return completed;
+      },
+      save: (challenge, input) => {
+        const isSaved = this.dailySaves().save(challenge, input);
+        this.savedApi?.changed();
+        return isSaved;
+      },
+      flush: () => this.dailySaves().flush(),
+      discard: (challenge) => this.dailySaves().discard(challenge),
+      inProgress: () => this.saved.list({ kinds: ['daily'] }),
       emit: (eventName, detail) => {
         emitWindowEvent(eventName, detail);
       },
@@ -175,8 +341,10 @@ linkRealtimeToHub({
 /** A ready-to-use client, with the slug and API base detected from the page. */
 export const hub: Hub = new Hub();
 
-// Take `?hub_resume` out of the address bar before the game's router sees it (the answer stays on `hub.resume.requested`).
+// Take `?hub_resume`, `?hub_open` and `?hub_kind` out of the address bar before the game's router sees them
+// (the answers stay on `hub.resume.requested` and `hub.saved.opened`).
 isResumeRequested();
+savedOpenedOnPage();
 
 /** Create a client for another slug or API base, or with other offline behaviour. */
 export function createHub(options: HubOptions = {}): Hub {

package/src/core/offline/hub-kinds/avatar-kind.ts

@@ -0,0 +1,42 @@
+/**
+ * The hub's avatar kind (`hub.avatar`, avatars.md §5.6): save your look.
+ * Latest wins: a newer save replaces a waiting one, and the hub keeps the
+ * newer of the replayed save and one another device made since (`savedAt`).
+ */
+import type { Json } from '@diffenderfer-games/hub-contract';
+import { decodeLook } from '@diffenderfer-games/hub-contract/avatar';
+import { isRecord, optionalNumber, optionalString } from '../../storage/json-guards';
+import { checkedKind } from '../kind-adapters';
+import type { RegisteredKind } from '../outbox-kinds';
+
+/** The kind name. */
+export const AVATAR_KIND = 'hub.avatar';
+
+/** Save this look (its code) as of `savedAt`. */
+export type AvatarPayload = { readonly code: string; readonly savedAt: number };
+
+function readAvatar(stored: Json): AvatarPayload | undefined {
+  if (!isRecord(stored)) {
+    return undefined;
+  }
+  const code = optionalString(stored.code);
+  const savedAt = optionalNumber(stored.savedAt);
+  return code === undefined || savedAt === undefined ? undefined : { code, savedAt };
+}
+
+/** The avatar kind, by name. */
+export function avatarKinds(): Record<string, RegisteredKind> {
+  return {
+    [AVATAR_KIND]: checkedKind(readAvatar, {
+      mergeKey: () => 'avatar',
+      replaces: true,
+      run: async (op, context) => {
+        const look = decodeLook(op.code)?.look;
+        if (look !== undefined) {
+          await context.call('saveMyAvatar', { look: { ...look, accessories: [...look.accessories] }, savedAt: op.savedAt });
+        }
+        return undefined;
+      },
+    }),
+  };
+}

package/src/core/offline/hub-kinds/index.ts

@@ -3,18 +3,23 @@
  * client's outbox. The docs' "Offline and replay" table lists them.
  */
 import type { LocalResumeStore } from '../../resume/local-resume';
+import type { LocalDailyStore } from '../../saved/local-saved';
 import { writeLocalFavorites } from '../favorites';
 import type { Outbox } from '../outbox';
+import { avatarKinds } from './avatar-kind';
 import { dailyKinds, type DailyCompletion, type DailyPayload } from './daily-kind';
 import { economyKinds } from './economy-kinds';
 import type { GameFieldsSource } from './game-fields';
 import { progressKinds, type CloudSaveTracker } from './progress-kinds';
 import { resumeKinds } from './resume-kind';
+import { savedKinds } from './saved-kind';
 
+export { AVATAR_KIND, type AvatarPayload } from './avatar-kind';
 export { DAILY_KIND, type DailyPayload } from './daily-kind';
 export { ECONOMY_KINDS, type ExchangePayload, type FavoritePayload } from './economy-kinds';
 export { legacyOperation } from './legacy-ops';
 export { RESUME_KIND, type ResumePayload } from './resume-kind';
+export { SAVED_KIND, type SavedPayload } from './saved-kind';
 export { PROGRESS_KINDS, type CloudSaveTracker, type ProfilePayload, type SavePayload, type ScorePayload, type StatPayload } from './progress-kinds';
 
 /** What the hub kinds report back to their client. */
@@ -25,6 +30,8 @@ export interface HubKindHooks {
   readonly onDailyComplete: (payload: DailyPayload, completion: DailyCompletion) => void;
   /** The device copies of each game's resume slot (`hub.resume`). */
   readonly resume: LocalResumeStore;
+  /** The device copies of daily challenges in progress (`hub.saved`). */
+  readonly dailies: LocalDailyStore;
   /** What this device last saw of the game's save slots on the hub. */
   readonly cloudSaves: CloudSaveTracker;
 }
@@ -36,6 +43,8 @@ export function registerHubKinds(outbox: Outbox, hooks: HubKindHooks): void {
     ...dailyKinds(hooks.game, hooks.onDailyComplete),
     ...economyKinds(hooks.game, writeLocalFavorites),
     ...resumeKinds(hooks.game, hooks.resume),
+    ...avatarKinds(),
+    ...savedKinds(hooks.dailies),
   };
   for (const [kind, definition] of Object.entries(kinds)) {
     outbox.define(kind, definition);

package/src/core/offline/hub-kinds/saved-kind.ts

@@ -0,0 +1,93 @@
+/**
+ * The hub's saved-games kind (`hub.saved`): send a daily challenge's state,
+ * or discard the day, from the device copy (`LocalDailyStore`). One op per
+ * (game, day): a newer one replaces a waiting one, so a discard after a
+ * save drops the save. The op carries only which day and when; when it runs
+ * it sends the newest state the device holds, so the outbox stays small.
+ *
+ * A day started offline has a device-only id (`local:<slug>:<day>`): the op
+ * first starts the day on the hub, which finds or makes its saved game (one
+ * per player, game and day), then saves to that. A save or discard that
+ * finds the day already finished or discarded elsewhere (409, 404) is done:
+ * the device copy is dropped.
+ */
+import type { Json } from '@diffenderfer-games/hub-contract';
+import { HubError } from '../../errors';
+import type { LocalDaily, LocalDailyStore } from '../../saved/local-saved';
+import { isRecord, optionalNumber, optionalString } from '../../storage/json-guards';
+import { checkedKind } from '../kind-adapters';
+import type { RegisteredKind, ReplayContext } from '../outbox-kinds';
+
+/** The kind name. */
+export const SAVED_KIND = 'hub.saved';
+
+/** Send (`save`) or discard a day's saved game; `at` is when the device copy changed. */
+export type SavedPayload = { readonly action: 'save' | 'discard'; readonly game: string; readonly day: string; readonly at: number };
+
+function readSaved(stored: Json): SavedPayload | undefined {
+  if (!isRecord(stored) || (stored.action !== 'save' && stored.action !== 'discard')) {
+    return undefined;
+  }
+  const game = optionalString(stored.game);
+  const day = optionalString(stored.day);
+  const at = optionalNumber(stored.at);
+  return game === undefined || day === undefined || at === undefined ? undefined : { action: stored.action, game, day, at };
+}
+
+/** Whether a failure means the instance is gone or closed on the hub (the change is moot). */
+function isGoneOrClosed(failure: Error): boolean {
+  return failure instanceof HubError && (failure.status === 404 || failure.status === 409);
+}
+
+/** The hub's id for the copy's day: its own, or the one the hub gives the day when it was started offline (`null`: already completed). */
+async function resolveId(copy: LocalDaily, context: ReplayContext): Promise<string | null> {
+  if (!copy.id.startsWith('local:')) {
+    return copy.id;
+  }
+  const started = await context.call('startDailyChallenge', { slug: copy.game, day: copy.day });
+  return started.instanceId;
+}
+
+/** Run one op against the copy it names. */
+async function runSaved(op: SavedPayload, local: LocalDailyStore, context: ReplayContext): Promise<undefined> {
+  const copy = local.read(op.game, op.day);
+  if (copy === null) {
+    return undefined;
+  }
+  try {
+    const id = await resolveId(copy, context);
+    if (id === null) {
+      local.remove(op.game, op.day);
+      return undefined;
+    }
+    if (op.action === 'discard') {
+      await context.call('discardSavedGame', { id });
+      local.remove(op.game, op.day);
+      return undefined;
+    }
+    // A null state is sent too: it is hub.resume.clear() during the day (start over from the seed).
+    if (copy.status === 'active') {
+      await context.call('saveSavedGameState', {
+        id, state: copy.state, progress: { label: copy.label, fraction: copy.fraction }, title: copy.title, version: copy.version, savedAt: copy.at,
+      });
+    }
+    local.markSynced(op.game, op.day, copy.at, id);
+  } catch (failure) {
+    if (!(failure instanceof Error) || !isGoneOrClosed(failure)) {
+      throw failure;
+    }
+    local.remove(op.game, op.day);
+  }
+  return undefined;
+}
+
+/** The saved-games kind, by name, over the device copies in `local`. */
+export function savedKinds(local: LocalDailyStore): Record<string, RegisteredKind> {
+  return {
+    [SAVED_KIND]: checkedKind(readSaved, {
+      mergeKey: (op) => `daily:${op.game}#${op.day}`,
+      replaces: true,
+      run: (op, context) => runSaved(op, local, context),
+    }),
+  };
+}

package/src/core/page-account.ts

@@ -0,0 +1,121 @@
+/**
+ * Who the page is signed in as, as the hub tells it, so `hub.userId()` and
+ * `hub.avatar` follow the account without the game calling `hub.me()`:
+ *
+ * - the menu's `hub:account` (every refresh: after it makes a new guest's
+ *   account, after sign-in) and `hub:auth` (the account changed);
+ * - the social runtime's {@link SESSION_EVENT} each time its socket says
+ *   hello (connected, or connected again after a drop);
+ * - this client's own sign-in, sign-up, claim and sign-out.
+ *
+ * One per page: every bundle's copy hears the same window events.
+ */
+import { readField } from '../realtime/cross-bundle';
+import { SESSION_EVENT } from '../realtime/runtime-api';
+import { isBrowserPage } from './page';
+
+/** The window events that say who is signed in (`{ user }`). */
+const ACCOUNT_EVENTS = ['hub:account', 'hub:auth'] as const;
+
+/** The signed-in player as the page heard it. */
+export 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). */
+export type AccountSource = 'account' | 'session';
+
+/** Hears every report of who is signed in. */
+export type AccountListener = (user: PageUser | null, source: AccountSource) => void;
+
+/** The page's account, as last heard. */
+export class PageAccount {
+  /** `undefined` until something said; `null` when signed out. */
+  private heard: PageUser | null | undefined = undefined;
+  private readonly listeners = new Set<AccountListener>();
+  private isListening = false;
+
+  constructor() {
+    this.listen();
+  }
+
+  /** The signed-in player, `null` when signed out, `undefined` before anything said. */
+  get user(): PageUser | null | undefined {
+    this.listen();
+    return this.heard;
+  }
+
+  /** Record who is signed in (this client's own sign-in or sign-out) and tell the listeners. */
+  note(user: PageUser | null, source: AccountSource = 'account'): void {
+    this.heard = user;
+    for (const listener of [...this.listeners]) {
+      listener(user, source);
+    }
+  }
+
+  /** Hear every report; returns the unsubscribe function. */
+  on(listener: AccountListener): () => void {
+    this.listen();
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+
+  /** Listen to the window events (at once in a page; made before a window existed, on first use). */
+  private listen(): void {
+    if (this.isListening || !isBrowserPage()) {
+      return;
+    }
+    this.isListening = true;
+    for (const eventName of ACCOUNT_EVENTS) {
+      window.addEventListener(eventName, (event) => { this.onEvent(event, 'account'); });
+    }
+    window.addEventListener(SESSION_EVENT, (event) => { this.onEvent(event, 'session'); });
+  }
+
+  private onEvent(event: Event, source: AccountSource): void {
+    if (!(event instanceof CustomEvent)) {
+      return;
+    }
+    const user = readUser(event.detail);
+    if (user !== undefined) {
+      this.note(user, source);
+    }
+  }
+}
+
+/** A page user from an account the hub sent (`look` when it has one). */
+export function toPageUser(user: { readonly id: number; readonly look?: string | undefined }): PageUser {
+  return { id: user.id, look: lookOrNull(user.look) };
+}
+
+/** A non-empty look code, else `null`. */
+// eslint-disable-next-line no-restricted-syntax -- trust boundary: a field of another bundle's event detail
+function lookOrNull(look: unknown): string | null {
+  return typeof look === 'string' && look !== '' ? look : null;
+}
+
+/** The user in a `{ user }` detail: the user, `null` (signed out), or `undefined` (it doesn't say). */
+// eslint-disable-next-line no-restricted-syntax -- trust boundary: another bundle's event detail, read field by field
+function readUser(detail: unknown): PageUser | null | undefined {
+  const user = readField(detail, 'user');
+  if (user === null) {
+    return null;
+  }
+  const id = readField(user, 'id');
+  if (typeof id !== 'number' || !Number.isInteger(id)) {
+    return undefined;
+  }
+  return { id, look: lookOrNull(readField(user, 'look')) };
+}
+
+let pageAccountSingleton: PageAccount | null = null;
+
+/** The page's account tracker (made on first use; the hub client makes it at load). */
+export function pageAccount(): PageAccount {
+  pageAccountSingleton ??= new PageAccount();
+  return pageAccountSingleton;
+}

package/src/core/rest/routes.gen.ts

@@ -1,4 +1,4 @@
-// Generated by tools/hub-client/generate.ts. Do not edit; run `npm run gen:hub-client` in next/.
+// Generated by tools/hub-client/generate.ts. Do not edit; run `npm run gen:hub-client`.
 /** Every public REST endpoint's method, path (under `/_api`), query keys and offline mode (`'replay'` when it may be queued offline), from the contract. */
 export const ROUTES = {
   ensureGuestSession: { method: 'POST', path: '/auth/guest', query: [], offline: null },
@@ -31,6 +31,7 @@ export const ROUTES = {
   submitScore: { method: 'POST', path: '/games/:slug/leaderboards/:key/scores', query: [], offline: 'replay' },
   listDailyChallengesForAllGames: { method: 'GET', path: '/daily', query: [], offline: null },
   getGameDailyChallenges: { method: 'GET', path: '/games/:slug/daily', query: [], offline: null },
+  resumeDailyChallenge: { method: 'POST', path: '/daily/instances/:id/resume', query: [], offline: null },
   startDailyChallenge: { method: 'POST', path: '/games/:slug/daily/:day/start', query: [], offline: null },
   completeDailyChallenge: { method: 'POST', path: '/games/:slug/daily/:day/complete', query: [], offline: 'replay' },
   getMyInventory: { method: 'GET', path: '/games/:slug/inventory', query: [], offline: null },
@@ -71,6 +72,7 @@ export const ROUTES = {
   getNotificationPreferences: { method: 'GET', path: '/social/notify', query: [], offline: null },
   unsubscribeFromPush: { method: 'DELETE', path: '/social/push', query: [], offline: null },
   setNotificationPreferences: { method: 'PUT', path: '/social/notify', query: [], offline: null },
+  setQuietHours: { method: 'PUT', path: '/social/notify/quiet', query: [], offline: null },
   subscribeToPush: { method: 'POST', path: '/social/push', query: [], offline: null },
   fileReport: { method: 'POST', path: '/social/reports', query: [], offline: null },
   listPublicSuggestions: { method: 'GET', path: '/suggestions', query: ['sort'], offline: null },
@@ -109,6 +111,34 @@ export const ROUTES = {
   saveResumeSlot: { method: 'PUT', path: '/games/:slug/resume', query: [], offline: 'replay' },
   clearResumeSlot: { method: 'DELETE', path: '/games/:slug/resume', query: ['before'], offline: 'replay' },
   listMyResumeSlots: { method: 'GET', path: '/me/resume', query: [], offline: null },
+  getMyAvatar: { method: 'GET', path: '/avatar/me', query: [], offline: null },
+  recordAvatarNudge: { method: 'POST', path: '/avatar/me/nudge', query: [], offline: null },
+  saveMyAvatar: { method: 'PUT', path: '/avatar/me', query: [], offline: null },
+  resetMyAvatar: { method: 'DELETE', path: '/avatar/me', query: [], offline: null },
+  getAvatar: { method: 'GET', path: '/avatar/of/:id', query: [], offline: null },
+  getAvatars: { method: 'POST', path: '/avatar/batch', query: [], offline: null },
+  listMySavedGames: { method: 'GET', path: '/saved', query: ['game', 'kinds'], offline: null },
+  getSavedGame: { method: 'GET', path: '/saved/:id', query: [], offline: null },
+  saveSavedGameState: { method: 'PUT', path: '/saved/:id/state', query: [], offline: 'replay' },
+  discardSavedGame: { method: 'POST', path: '/saved/:id/discard', query: [], offline: 'replay' },
+  discardGameSavedGames: { method: 'POST', path: '/games/:slug/saved/discard', query: [], offline: null },
+  createTurnGame: { method: 'POST', path: '/turns', query: [], offline: null },
+  joinTurnGame: { method: 'POST', path: '/turns/:id/join', query: [], offline: null },
+  joinTurnGameByLink: { method: 'POST', path: '/turns/join', query: [], offline: null },
+  startTurnGame: { method: 'POST', path: '/turns/:id/start', query: [], offline: null },
+  moveTurnGame: { method: 'POST', path: '/turns/:id/moves', query: [], offline: null },
+  leaveTurnGame: { method: 'POST', path: '/turns/:id/leave', query: [], offline: null },
+  nudgeTurnGame: { method: 'POST', path: '/turns/:id/nudge', query: [], offline: null },
+  setTurnGameNotify: { method: 'PUT', path: '/turns/:id/notify', query: [], offline: null },
+  rematchTurnGame: { method: 'POST', path: '/turns/:id/rematch', query: [], offline: null },
+  inviteToTurnGame: { method: 'POST', path: '/turns/:id/invite', query: [], offline: null },
+  shareTurnGame: { method: 'POST', path: '/turns/:id/share', query: [], offline: null },
+  autoPlayTurn: { method: 'POST', path: '/turns/:id/auto', query: [], offline: null },
+  chatInTurnGame: { method: 'POST', path: '/turns/:id/chat', query: [], offline: null },
+  getTurnGame: { method: 'GET', path: '/turns/:id', query: [], offline: null },
+  getTurnGameHistory: { method: 'GET', path: '/turns/:id/history', query: ['since'], offline: null },
+  listOpenTurnGames: { method: 'GET', path: '/open-turns', query: ['game'], offline: null },
+  listMyTurnGames: { method: 'GET', path: '/turns', query: ['game'], offline: null },
 } as const;
 
 /** The request header that carries an offline operation key (the contract's `OFFLINE_OP_HEADER`). */