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

package/src/core/turns/turn-game.ts

@@ -0,0 +1,388 @@
+/**
+ * One online game, as a seated player's page holds it (`hub.turns.open`,
+ * `create`, `join`). The hub runs the game's rules: the page only ever has
+ * its own `view` and sends moves.
+ *
+ * Live changes arrive as the social runtime's `hub:turn` window events
+ * (from `/_ws`): `on('move')` for each move (with its events as this seat may
+ * see them, to animate), `on('turn')` whenever whose move it is or the seats
+ * change, `on('ended')` at the end, `on('chat')` for chat lines. Moves made
+ * while the page was away are replayed from `history` when it comes back
+ * (and, without the runtime, every so often while the page is visible).
+ */
+import type { Json, TurnChatLine, TurnGameView, TurnSeat, TurnSummary } from '@diffenderfer-games/hub-contract';
+import { HubError } from '../errors';
+import { toGameData, type GamePayload } from '../game-data';
+import { isBrowserPage } from '../page';
+import { isJson, parseJsonText } from '../storage/json-guards';
+import { readField } from '../../realtime/cross-bundle';
+
+/** The window event the social runtime fires for each `ev:turn`. */
+export const TURN_EVENT = 'hub:turn';
+
+/** The runtime's live connection (re)opened: anything sent while it was down is fetched again. */
+export const TURN_RESYNC_EVENT = 'hub:turn-resync';
+
+/** The window event the social runtime fires for each `ev:turn.chat`. */
+export const TURN_CHAT_EVENT = 'hub:turn-chat';
+
+/** How often a page without the live runtime looks for moves, ms. */
+export const TURN_POLL_MS = 20_000;
+
+/** A game's end: the winning seats, and optionally places and scores by seat. */
+export type TurnOutcome = NonNullable<TurnGameView['outcome']>;
+
+/** One move as this seat saw it. */
+export 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. */
+export 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. */
+export 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. */
+export class TurnGame<View = GamePayload, Move extends GamePayload = GamePayload, Ev = GamePayload> {
+  readonly id: string;
+  private state: TurnGameView;
+  private readonly host: TurnGameHost;
+  private readonly listeners: { [K in keyof TurnGameEvents<View, Ev>]: Set<Listener<TurnGameEvents<View, Ev>[K]>> } = {
+    move: new Set(), turn: new Set(), ended: new Set(), chat: new Set(),
+  };
+  private readonly stopListening: (() => void)[] = [];
+  private isClosed = false;
+  private catchingUp: Promise<void> | null = null;
+  /** The move count this page's own move in flight will make (its live echo is not another player's move). */
+  private ownSeq: number | null = null;
+
+  constructor(host: TurnGameHost, initial: TurnGameView) {
+    this.host = host;
+    this.id = initial.id;
+    this.state = initial;
+    host.opened(this);
+    this.listen();
+  }
+
+  /** Whose move it is, the seats and the deadline. */
+  get summary(): TurnSummary {
+    return this.state.summary;
+  }
+
+  /** This seat's view, from the game's rules (`null` before the game starts). */
+  get view(): View {
+    return toGameData<View>(this.state.view);
+  }
+
+  /** This player's seat, or `null` (they left). */
+  get mySeat(): number | null {
+    return this.state.mySeat;
+  }
+
+  /** The end, once the game is over. */
+  get outcome(): TurnOutcome | null {
+    return this.state.outcome;
+  }
+
+  /** The last chat lines, oldest first. */
+  get chat(): readonly TurnChatLine[] {
+    return this.state.chat;
+  }
+
+  /** `on`: friends may type (moderated); `quick`: quick-chat and emotes only; `off`. */
+  get chatMode(): TurnGameView['chatMode'] {
+    return this.state.chatMode;
+  }
+
+  /** The link others can take a seat with (the creator's, while seats are open), else `null`. */
+  get link(): string | null {
+    return this.state.link === null ? null : new URL(this.state.link, location.origin).href;
+  }
+
+  /** Creator: start the game (empty seats go to the computer when the game allows). */
+  async start(): Promise<void> {
+    this.update(await this.host.start(this.id));
+  }
+
+  /**
+   * 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`.
+   */
+  async move(move: Move): Promise<{ seq: number; view: View; events: Ev[] }> {
+    this.ownSeq = this.state.summary.seq + 1;
+    try {
+      const answer = await this.host.move(this.id, this.state.summary.seq, toPayload(move));
+      this.update(answer.game);
+      return { seq: answer.game.summary.seq, view: this.view, events: answer.events.map((event) => toGameData<Ev>(event)) };
+    } catch (failure) {
+      if (failure instanceof HubError && failure.code === 'stale') {
+        await this.refresh();
+      }
+      throw failure;
+    } finally {
+      this.ownSeq = null;
+    }
+  }
+
+  /** The moves after `sinceSeq`, with their events as this seat may see them ("what happened while you were away"). */
+  async history(sinceSeq: number): Promise<{ seq: number; seat: number; events: Ev[] }[]> {
+    const moves = await this.host.history(this.id, sinceSeq);
+    return moves.map((move) => ({ seq: move.seq, seat: move.seat, events: move.events.map((event) => toGameData<Ev>(event)) }));
+  }
+
+  /** Leave: the computer plays the seat (or, without bots, the others win). The player can't come back. */
+  async leave(): Promise<void> {
+    await this.host.leave(this.id);
+    this.close();
+  }
+
+  /** Remind whoever must move (once a day). */
+  nudge(): Promise<void> {
+    return this.host.nudge(this.id);
+  }
+
+  /** This game's "your turn" alerts. */
+  setNotify(mode: 'on' | 'off'): Promise<void> {
+    return this.host.setNotify(this.id, mode);
+  }
+
+  /** A finished game: a new one with the same friends (they get an invite). */
+  async rematch(): Promise<TurnGame<View, Move, Ev>> {
+    return new TurnGame<View, Move, Ev>(this.host, await this.host.rematch(this.id));
+  }
+
+  /** Creator, before the start: add an invite link (`link: true`, then read `link`) or list the open seats for anyone (`public`). */
+  async share(share: { readonly link?: boolean; readonly public?: boolean }): Promise<void> {
+    this.update(await this.host.share(this.id, share));
+  }
+
+  /** Invite friends to free seats (before the start). */
+  async invite(userIds: readonly number[]): Promise<void> {
+    this.update(await this.host.invite(this.id, userIds));
+  }
+
+  /** The turn's deadline passed (or its player is suspended): let the computer play it. */
+  async letComputerPlay(): Promise<void> {
+    this.update(await this.host.autoPlay(this.id));
+  }
+
+  /** Say something: `{ text }` between friends (moderated), `{ quick }` (a quick-chat phrase id) with anyone. */
+  say(send: { readonly text?: string; readonly quick?: string }): Promise<TurnChatLine> {
+    return this.host.chat(this.id, send);
+  }
+
+  /** Fetch the game again, and replay moves missed since the last one this page saw. */
+  async refresh(): Promise<void> {
+    const before = this.state.summary.seq;
+    const fresh = await this.host.get(this.id);
+    if (fresh.summary.seq > before) {
+      const missed = await this.host.history(this.id, before);
+      this.update(fresh);
+      for (const move of missed) {
+        this.emit('move', { seq: move.seq, seat: move.seat, view: this.view, events: move.events.map((event) => toGameData<Ev>(event)) });
+      }
+    } else {
+      this.update(fresh);
+    }
+  }
+
+  /** 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 {
+    const set: Set<Listener<TurnGameEvents<View, Ev>[K]>> = this.listeners[eventName];
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+    };
+  }
+
+  /** Stop live updates for this page (the game itself goes on). */
+  close(): void {
+    if (this.isClosed) {
+      return;
+    }
+    this.isClosed = true;
+    for (const stop of this.stopListening) {
+      stop();
+    }
+    this.host.closed(this);
+  }
+
+  /** Take a fresh answer from the hub; fire `turn` and `ended` when they changed. */
+  private update(next: TurnGameView): void {
+    const previous = this.state;
+    this.state = next;
+    const isChanged = previous.summary.seq !== next.summary.seq || previous.summary.phase !== next.summary.phase || !sameSeats(previous.summary, next.summary)
+      || previous.chatMode !== next.chatMode || previous.link !== next.link;
+    if (isChanged) {
+      this.emit('turn', next.summary);
+    }
+    if (previous.summary.phase !== 'ended' && next.summary.phase === 'ended') {
+      this.emit('ended', { outcome: next.outcome, view: this.view });
+    }
+  }
+
+  private emit<K extends keyof TurnGameEvents<View, Ev>>(eventName: K, payload: TurnGameEvents<View, Ev>[K]): void {
+    const set: Set<Listener<TurnGameEvents<View, Ev>[K]>> = this.listeners[eventName];
+    for (const listener of set) {
+      listener(payload);
+    }
+  }
+
+  /** A live `hub:turn` for this game: a move (or a missed run of them), or another change. */
+  private onLive(detail: object): void {
+    const seq = readField(detail, 'seq');
+    const view = readField(detail, 'view');
+    const summary = readField(detail, 'summary');
+    if (typeof seq !== 'number' || !isSummary(summary) || view === undefined) {
+      return;
+    }
+    if (seq > this.state.summary.seq + 1) {
+      void this.catchUp();
+      return;
+    }
+    const seat = readField(detail, 'seat');
+    const events = readField(detail, 'events');
+    const outcome = readField(detail, 'outcome');
+    const isMove = typeof seat === 'number' && seq === this.state.summary.seq + 1 && seq !== this.ownSeq;
+    if (summary.phase !== this.state.summary.phase || !sameSeating(this.state.summary, summary)) {
+      // Who sits where changed (a join, the start, a leave): the chat mode and link may have too, and the live event doesn't carry them.
+      void this.catchUp();
+    }
+    this.update({ ...this.state, summary, view: toPayloadJson(view), outcome: isOutcome(outcome) ? outcome : this.state.outcome });
+    if (isMove) {
+      this.emit('move', { seq, seat, view: this.view, events: Array.isArray(events) ? events.map((event) => toGameData<Ev>(toPayloadJson(event))) : [] });
+    }
+  }
+
+  /** Replay what was missed (one catch-up at a time). */
+  private catchUp(): Promise<void> {
+    this.catchingUp ??= this.refresh().catch(() => undefined).finally(() => {
+      this.catchingUp = null;
+    });
+    return this.catchingUp;
+  }
+
+  private listen(): void {
+    if (!isBrowserPage()) {
+      return;
+    }
+    const onTurn = (event: Event): void => {
+      if (!(event instanceof CustomEvent) || readField(event.detail, 'id') !== this.id) {
+        return;
+      }
+      // eslint-disable-next-line no-restricted-syntax -- trust boundary: another bundle's event detail, read field by field
+      const detail: unknown = event.detail;
+      if (typeof detail === 'object' && detail !== null) {
+        this.onLive(detail);
+      }
+    };
+    const onChat = (event: Event): void => {
+      if (event instanceof CustomEvent && readField(event.detail, 'id') === this.id) {
+        const line = readField(event.detail, 'line');
+        if (isChatLine(line)) {
+          this.state = { ...this.state, chat: [...this.state.chat, line].slice(-50) };
+          this.emit('chat', line);
+        }
+      }
+    };
+    const onVisible = (): void => {
+      if (document.visibilityState === 'visible') {
+        void this.catchUp();
+      }
+    };
+    const onResync = (): void => { void this.catchUp(); };
+    window.addEventListener(TURN_EVENT, onTurn);
+    window.addEventListener(TURN_CHAT_EVENT, onChat);
+    window.addEventListener(TURN_RESYNC_EVENT, onResync);
+    document.addEventListener('visibilitychange', onVisible);
+    const poll = setInterval(() => {
+      if (!this.host.isLive() && document.visibilityState === 'visible') {
+        void this.catchUp();
+      }
+    }, TURN_POLL_MS);
+    this.stopListening.push(
+      () => { window.removeEventListener(TURN_EVENT, onTurn); },
+      () => { window.removeEventListener(TURN_CHAT_EVENT, onChat); },
+      () => { window.removeEventListener(TURN_RESYNC_EVENT, onResync); },
+      () => { document.removeEventListener('visibilitychange', onVisible); },
+      () => { clearInterval(poll); },
+    );
+  }
+}
+
+/** Every seat matches its counterpart by `same`. */
+function eachSeat(a: TurnSummary, b: TurnSummary, same: (seat: TurnSeat, other: TurnSeat) => boolean): boolean {
+  return a.seats.length === b.seats.length && a.seats.every((seat, index) => {
+    const other = b.seats[index];
+    return other !== undefined && same(seat, other);
+  });
+}
+
+/** The same players in the same seats with the same statuses (who sits where). */
+function sameSeating(a: TurnSummary, b: TurnSummary): boolean {
+  return eachSeat(a, b, (seat, other) => seat.status === other.status && seat.userId === other.userId);
+}
+
+/** The same seating, and the same looks (a player's new avatar is a change: `turn` fires). */
+function sameSeats(a: TurnSummary, b: TurnSummary): boolean {
+  return sameSeating(a, b) && eachSeat(a, b, (seat, other) => seat.look === other.look);
+}
+
+/** A game's move as the JSON the hub takes. */
+function toPayload(move: GamePayload): Json {
+  return toPayloadJson(move);
+}
+
+/** Any JSON-safe value as `Json` (a JSON round trip). */
+// eslint-disable-next-line no-restricted-syntax -- trust boundary: a game's own move, or a value from another bundle's event
+function toPayloadJson(value: unknown): Json {
+  const parsed = parseJsonText(JSON.stringify(value ?? null));
+  return isJson(parsed) ? parsed : null;
+}
+
+/** Shape checks for a live event's parts (it comes from another bundle). */
+// eslint-disable-next-line no-restricted-syntax -- trust boundary: another bundle's event detail
+function isSummary(value: unknown): value is TurnSummary {
+  return typeof readField(value, 'phase') === 'string' && Array.isArray(readField(value, 'seats')) && Array.isArray(readField(value, 'toAct'));
+}
+
+// eslint-disable-next-line no-restricted-syntax -- trust boundary: another bundle's event detail
+function isOutcome(value: unknown): value is TurnOutcome | null {
+  return value === null || Array.isArray(readField(value, 'winners'));
+}
+
+// eslint-disable-next-line no-restricted-syntax -- trust boundary: another bundle's event detail
+function isChatLine(value: unknown): value is TurnChatLine {
+  return typeof readField(value, 'text') === 'string' && typeof readField(value, 'from') === 'number';
+}

package/src/core/version/client-version.gen.ts

@@ -1,3 +1,3 @@
-// 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`.
 /** This client's package version, sent as `x-hub-client` on REST calls and `client` in `hello`. */
-export const HUB_CLIENT_VERSION = '2.0.0-next.5';
+export const HUB_CLIENT_VERSION = '2.0.0-next.6';

package/src/daily/daily-system.ts

@@ -9,7 +9,8 @@
  * registered `play` on. Deep links (`/<slug>/?daily=YYYY-MM-DD`) auto-start.
  */
 import { readField } from '../realtime/cross-bundle';
-import type { DailyAll, DailyChallenge, DailyCompleteResponse, DailyCompletionMeta, DailyDefinition, DailyHost, DailyStatus } from './types';
+import type { SavedEntry } from '../core/saved/saved-types';
+import type { DailyAll, DailyChallenge, DailyCompleteResponse, DailyCompletionMeta, DailyDefinition, DailyHost, DailySaveInput, DailyStartResponse, DailyStatus } from './types';
 
 const DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
 
@@ -39,20 +40,32 @@ function messageOf(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
+/** The challenge a start or resume answered. */
+function challengeOf(started: DailyStartResponse): DailyChallenge {
+  return {
+    day: started.day, seed: started.seed, token: started.token, alreadyCompleted: started.alreadyCompleted,
+    instanceId: started.instanceId, saved: started.saved, savedVersion: started.savedVersion, resumed: started.resumed,
+  };
+}
+
 /** Daily challenges (`hub.daily`). */
 export class DailySystem {
   /**
    * The challenge in progress: set when a day starts; cleared the moment the
    * game calls `complete` (whatever the hub answers, and before it answers)
-   * or `cancel`. A game's win handler checks it:
+   * or `cancel` (or `discard`). A game's win handler checks it:
    * `if (hub.daily.active) hub.daily.complete(…)`. While it is set the page
-   * is in a daily run, so `hub.resume.save` saves nothing: a game whose
-   * player leaves a daily unfinished must call `cancel()`.
+   * is in a daily run, so `hub.resume.save` saves to the day instead of the
+   * game's run: a game whose player leaves a daily unfinished must call
+   * `cancel()`.
    */
   active: DailyChallenge | null = null;
   private readonly host: DailyHost;
   private play: DailyDefinition['play'] | null = null;
   private pendingDay: string | null = null;
+  private pendingInstance: string | null = null;
+  /** A start on its way to the hub, so a resume of the same day waits for it instead of starting it twice. */
+  private inFlight: Promise<void> | null = null;
   private isRelaying = false;
 
   constructor(host: DailyHost) {
@@ -84,9 +97,13 @@ export class DailySystem {
   define(definition: DailyDefinition): void {
     this.play = definition.play;
     const day = readDeepLinkDay() ?? this.pendingDay;
+    const instanceId = this.pendingInstance;
     this.pendingDay = null;
+    this.pendingInstance = null;
     if (day !== null) {
       void this.startAndPlay(day);
+    } else if (instanceId !== null) {
+      void this.resume(instanceId);
     }
   }
 
@@ -103,17 +120,91 @@ export class DailySystem {
       this.relayStart(day);
       return;
     }
+    const starting = (async (): Promise<void> => {
+      try {
+        this.begin(play, challengeOf(await this.host.start(day)));
+      } catch (error) {
+        this.host.emit('hub:daily-error', { day, error: messageOf(error) });
+      }
+    })();
+    this.inFlight = starting;
+    await starting;
+    if (this.inFlight === starting) {
+      this.inFlight = null;
+    }
+  }
+
+  /**
+   * Pick up a day in progress by its saved game's id (from `hub.saved`):
+   * a fresh token, then the game's `play` with `challenge.saved`. Finishing
+   * it any time later gives that day's credit. A no-op while that day is
+   * already being played.
+   */
+  async resume(instanceId: string): Promise<void> {
+    // A start may be on its way for the same day (the `?daily=` link of the same open): let it land first.
+    await this.inFlight;
+    if (this.active?.instanceId === instanceId) {
+      return;
+    }
+    const play = this.play;
+    if (play === null) {
+      this.pendingInstance = instanceId;
+      return;
+    }
     try {
-      const started = await this.host.start(day);
-      const challenge: DailyChallenge = { day: started.day, seed: started.seed, token: started.token, alreadyCompleted: started.alreadyCompleted };
-      this.active = challenge;
-      this.host.emit('hub:daily-started', { day: started.day, seed: started.seed, alreadyCompleted: started.alreadyCompleted });
-      play({ ...challenge });
+      this.begin(play, challengeOf(await this.host.resume(instanceId)));
     } catch (error) {
-      this.host.emit('hub:daily-error', { day, error: messageOf(error) });
+      this.host.emit('hub:daily-error', { day: '', error: messageOf(error) });
     }
   }
 
+  /** Make `challenge` the active day and hand it to the game. */
+  private begin(play: DailyDefinition['play'], challenge: DailyChallenge): void {
+    this.active = challenge;
+    this.host.emit('hub:daily-started', { day: challenge.day, seed: challenge.seed, alreadyCompleted: challenge.alreadyCompleted === true, resumed: challenge.resumed === true });
+    if (challenge.resumed === true) {
+      this.host.emit('hub:daily-resumed', { day: challenge.day, seed: challenge.seed, alreadyCompleted: false, resumed: true });
+    }
+    play({ ...challenge });
+  }
+
+  /**
+   * Save the active day's state, so it can be picked up later (a reload,
+   * another device, next week) and still give that day's credit. Kept on
+   * the device at once and sent after a short quiet spell (works offline).
+   * `hub.resume.save` during a daily lands here too. Returns `false` with
+   * no daily active, or for a replay of a completed day (nothing to save).
+   */
+  save(input: DailySaveInput): boolean {
+    const challenge = this.active;
+    if (challenge === null || challenge.instanceId === null) {
+      return false;
+    }
+    return this.host.save(challenge, input);
+  }
+
+  /** This game's days in progress (the calendar marks them, the game can list them). */
+  inProgress(): Promise<SavedEntry[]> {
+    return this.host.inProgress();
+  }
+
+  /**
+   * Give up the active day: its progress is discarded and nothing is
+   * recorded. The day can be started again fresh while it is in the 30-day
+   * window. (The hub's lists ask the player first; a game asks for itself.)
+   */
+  async discard(): Promise<void> {
+    const challenge = this.active;
+    if (challenge === null) {
+      return;
+    }
+    this.active = null;
+    if (challenge.instanceId !== null) {
+      await this.host.discard(challenge);
+    }
+    this.host.emit('hub:daily-discarded', { day: challenge.day, discarded: true });
+  }
+
   /**
    * Record completion of the active challenge with optional metadata.
    * Resolves with the new completion count and rank, or `null` when no
@@ -157,12 +248,20 @@ export class DailySystem {
   }
 
   /**
-   * Abandon the active challenge without recording it: the player quit, or
-   * left the daily for normal play (another level, a new game). Until then
-   * the page counts as in a daily run and `hub.resume.save` saves nothing.
+   * Pause the active day: the player left it unfinished (quit, picked
+   * another level, started a normal game). Nothing is recorded, and the day
+   * stays in progress in "Your games" and the calendar, to finish later
+   * (its last save is sent now). Until then the page counts as in a daily,
+   * so `hub.resume.save` saves to the day: call `cancel()` on every path
+   * that leaves a daily without `complete`. To give a day up, `discard()`.
    */
   cancel(): void {
+    const challenge = this.active;
     this.active = null;
+    if (challenge !== null) {
+      void this.host.flush().catch(() => undefined);
+      this.host.emit('hub:daily-paused', { day: challenge.day, paused: true });
+    }
   }
 
   /** This game's window and the player's completions. */

package/src/daily/page-daily.ts

@@ -8,8 +8,8 @@ import { hasMethods } from '../realtime/cross-bundle';
 import { DailySystem } from './daily-system';
 import type { DailyHost } from './types';
 
-/** The cross-bundle shape number of the `daily` singleton. Bump only on an incompatible change. */
-export const DAILY_SINGLETON_API = 1;
+/** The cross-bundle shape number of the `daily` singleton (2 added save, resume, discard and inProgress). Bump only on an incompatible change. */
+export const DAILY_SINGLETON_API = 2;
 
 /** Whether `candidate` is some bundle's daily system (v1 copies included). */
 // eslint-disable-next-line no-restricted-syntax -- trust boundary: the instance may come from another bundle