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

package/src/core/version/hub-version.ts

@@ -1,62 +1,62 @@
-/**
- * The hub's `GET /_api/version`, read at most once per page and API base
- * (plan §4.3.3), and what it says about this client. Nothing reads it on
- * load: it costs a request only when a game (or `hub-doctor`) asks.
- */
-import type { HubVersion } from '@diffenderfer-games/hub-contract';
-import { HubError, UNSUPPORTED_BY_HUB } from '../errors';
-import type { RestClient } from '../rest/rest-client';
-import { HUB_CLIENT_VERSION } from './client-version.gen';
-import { satisfiesRange } from './semver';
-
-/** How a hub regards a client version. */
-export type ClientSupport =
-  /** In `supported` and not `deprecated`. */
-  | 'supported'
-  /** Still supported, but `deprecated`: update soon. */
-  | 'deprecated'
-  /** Outside `supported`: update now. */
-  | 'unsupported'
-  /** The hub predates versioning (the old hub): nothing to compare. */
-  | 'unknown';
-
-/** How `version` fares against a hub's answer (`null`: a hub from before versioning). */
-export function clientSupport(hubVersion: HubVersion | null, version: string = HUB_CLIENT_VERSION): ClientSupport {
-  if (hubVersion === null) {
-    return 'unknown';
-  }
-  if (!satisfiesRange(version, hubVersion.supported)) {
-    return 'unsupported';
-  }
-  return satisfiesRange(version, hubVersion.deprecated) ? 'deprecated' : 'supported';
-}
-
-const versionsByApiBase = new Map<string, Promise<HubVersion | null>>();
-
-/**
- * The hub's version, fetched once per page and API base. Resolves `null` for
- * a hub from before versioning (it has no `/version` route); a failed
- * request is not cached, so a later call tries again.
- */
-export function readHubVersion(rest: RestClient): Promise<HubVersion | null> {
-  const cached = versionsByApiBase.get(rest.apiBase);
-  if (cached !== undefined) {
-    return cached;
-  }
-  const pending = fetchHubVersion(rest);
-  versionsByApiBase.set(rest.apiBase, pending);
-  return pending;
-}
-
-/** One `GET /version`; `null` when the hub has no such route. */
-async function fetchHubVersion(rest: RestClient): Promise<HubVersion | null> {
-  try {
-    return await rest.call('getHubVersion');
-  } catch (failure) {
-    if (failure instanceof HubError && failure.code === UNSUPPORTED_BY_HUB) {
-      return null;
-    }
-    versionsByApiBase.delete(rest.apiBase);
-    throw failure;
-  }
-}
+/**
+ * The hub's `GET /_api/version`, read at most once per page and API base
+ * (plan §4.3.3), and what it says about this client. Nothing reads it on
+ * load: it costs a request only when a game (or `hub-doctor`) asks.
+ */
+import type { HubVersion } from '@diffenderfer-games/hub-contract';
+import { HubError, UNSUPPORTED_BY_HUB } from '../errors';
+import type { RestClient } from '../rest/rest-client';
+import { HUB_CLIENT_VERSION } from './client-version.gen';
+import { satisfiesRange } from './semver';
+
+/** How a hub regards a client version. */
+export type ClientSupport =
+  /** In `supported` and not `deprecated`. */
+  | 'supported'
+  /** Still supported, but `deprecated`: update soon. */
+  | 'deprecated'
+  /** Outside `supported`: update now. */
+  | 'unsupported'
+  /** The hub predates versioning (the old hub): nothing to compare. */
+  | 'unknown';
+
+/** How `version` fares against a hub's answer (`null`: a hub from before versioning). */
+export function clientSupport(hubVersion: HubVersion | null, version: string = HUB_CLIENT_VERSION): ClientSupport {
+  if (hubVersion === null) {
+    return 'unknown';
+  }
+  if (!satisfiesRange(version, hubVersion.supported)) {
+    return 'unsupported';
+  }
+  return satisfiesRange(version, hubVersion.deprecated) ? 'deprecated' : 'supported';
+}
+
+const versionsByApiBase = new Map<string, Promise<HubVersion | null>>();
+
+/**
+ * The hub's version, fetched once per page and API base. Resolves `null` for
+ * a hub from before versioning (it has no `/version` route); a failed
+ * request is not cached, so a later call tries again.
+ */
+export function readHubVersion(rest: RestClient): Promise<HubVersion | null> {
+  const cached = versionsByApiBase.get(rest.apiBase);
+  if (cached !== undefined) {
+    return cached;
+  }
+  const pending = fetchHubVersion(rest);
+  versionsByApiBase.set(rest.apiBase, pending);
+  return pending;
+}
+
+/** One `GET /version`; `null` when the hub has no such route. */
+async function fetchHubVersion(rest: RestClient): Promise<HubVersion | null> {
+  try {
+    return await rest.call('getHubVersion');
+  } catch (failure) {
+    if (failure instanceof HubError && failure.code === UNSUPPORTED_BY_HUB) {
+      return null;
+    }
+    versionsByApiBase.delete(rest.apiBase);
+    throw failure;
+  }
+}

package/src/core/version/semver.ts

@@ -1,97 +1,97 @@
-/**
- * Just enough semver for version ranges the hub sends (`>=2.0.0-0 <3.0.0`,
- * `<2.2.0`): comparators separated by spaces must all hold, `||` separates
- * alternatives. Versions compare in plain semver order, prereleases included
- * (`2.0.0-next.1 < 2.0.0`); unlike npm, a prerelease is not excluded from a
- * range of another release line, which is why the hub writes `-0` floors.
- */
-
-/** A parsed `major.minor.patch[-prerelease]` version. */
-export interface ParsedVersion {
-  /** `[major, minor, patch]`. */
-  readonly release: readonly [number, number, number];
-  /** The dot-separated prerelease identifiers (empty for a release). */
-  readonly prerelease: readonly string[];
-}
-
-const VERSION_PATTERN = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
-
-/** Parse a version (`2`, `2.1`, `2.1.0`, `2.1.0-next.3`); `undefined` when it is not one. */
-export function parseVersion(text: string): ParsedVersion | undefined {
-  const match = VERSION_PATTERN.exec(text.trim());
-  if (match === null) {
-    return undefined;
-  }
-  const [, major = '0', minor = '0', patch = '0', prerelease] = match;
-  return { release: [Number(major), Number(minor), Number(patch)], prerelease: prerelease === undefined ? [] : prerelease.split('.') };
-}
-
-/** Compare two prerelease identifiers: numbers by value and before words, words as text. */
-function compareIdentifiers(first: string, second: string): number {
-  const isFirstNumeric = /^\d+$/.test(first);
-  const isSecondNumeric = /^\d+$/.test(second);
-  if (isFirstNumeric && isSecondNumeric) {
-    return Number(first) - Number(second);
-  }
-  if (isFirstNumeric !== isSecondNumeric) {
-    return isFirstNumeric ? -1 : 1;
-  }
-  return first < second ? -1 : first > second ? 1 : 0;
-}
-
-/** Negative when `first` is older, positive when newer, 0 when equal. */
-export function compareVersions(first: ParsedVersion, second: ParsedVersion): number {
-  for (let i = 0; i < 3; i += 1) {
-    const difference = (first.release[i] ?? 0) - (second.release[i] ?? 0);
-    if (difference !== 0) {
-      return difference;
-    }
-  }
-  if (first.prerelease.length === 0 || second.prerelease.length === 0) {
-    return second.prerelease.length - first.prerelease.length;
-  }
-  const length = Math.max(first.prerelease.length, second.prerelease.length);
-  for (let i = 0; i < length; i += 1) {
-    const firstIdentifier = first.prerelease[i];
-    const secondIdentifier = second.prerelease[i];
-    if (firstIdentifier === undefined || secondIdentifier === undefined) {
-      return firstIdentifier === undefined ? -1 : 1;
-    }
-    const difference = compareIdentifiers(firstIdentifier, secondIdentifier);
-    if (difference !== 0) {
-      return difference;
-    }
-  }
-  return 0;
-}
-
-const COMPARATOR_PATTERN = /^(>=|<=|>|<|=)?\s*(.+)$/;
-
-/** Whether `version` meets one comparator (`>=2.0.0`); a malformed comparator never holds. */
-function meetsComparator(version: ParsedVersion, comparator: string): boolean {
-  const match = COMPARATOR_PATTERN.exec(comparator);
-  const bound = match?.[2] === undefined ? undefined : parseVersion(match[2]);
-  if (match === null || bound === undefined) {
-    return false;
-  }
-  const order = compareVersions(version, bound);
-  switch (match[1]) {
-    case '>=': return order >= 0;
-    case '<=': return order <= 0;
-    case '>': return order > 0;
-    case '<': return order < 0;
-    default: return order === 0;
-  }
-}
-
-/** Whether `versionText` is in `range`; a malformed version or empty range never is. */
-export function satisfiesRange(versionText: string, range: string): boolean {
-  const version = parseVersion(versionText);
-  if (version === undefined) {
-    return false;
-  }
-  return range.split('||').some((alternative) => {
-    const comparators = alternative.trim().split(/\s+/).filter((comparator) => comparator !== '');
-    return comparators.length > 0 && comparators.every((comparator) => meetsComparator(version, comparator));
-  });
-}
+/**
+ * Just enough semver for version ranges the hub sends (`>=2.0.0-0 <3.0.0`,
+ * `<2.2.0`): comparators separated by spaces must all hold, `||` separates
+ * alternatives. Versions compare in plain semver order, prereleases included
+ * (`2.0.0-next.1 < 2.0.0`); unlike npm, a prerelease is not excluded from a
+ * range of another release line, which is why the hub writes `-0` floors.
+ */
+
+/** A parsed `major.minor.patch[-prerelease]` version. */
+export interface ParsedVersion {
+  /** `[major, minor, patch]`. */
+  readonly release: readonly [number, number, number];
+  /** The dot-separated prerelease identifiers (empty for a release). */
+  readonly prerelease: readonly string[];
+}
+
+const VERSION_PATTERN = /^v?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+
+/** Parse a version (`2`, `2.1`, `2.1.0`, `2.1.0-next.3`); `undefined` when it is not one. */
+export function parseVersion(text: string): ParsedVersion | undefined {
+  const match = VERSION_PATTERN.exec(text.trim());
+  if (match === null) {
+    return undefined;
+  }
+  const [, major = '0', minor = '0', patch = '0', prerelease] = match;
+  return { release: [Number(major), Number(minor), Number(patch)], prerelease: prerelease === undefined ? [] : prerelease.split('.') };
+}
+
+/** Compare two prerelease identifiers: numbers by value and before words, words as text. */
+function compareIdentifiers(first: string, second: string): number {
+  const isFirstNumeric = /^\d+$/.test(first);
+  const isSecondNumeric = /^\d+$/.test(second);
+  if (isFirstNumeric && isSecondNumeric) {
+    return Number(first) - Number(second);
+  }
+  if (isFirstNumeric !== isSecondNumeric) {
+    return isFirstNumeric ? -1 : 1;
+  }
+  return first < second ? -1 : first > second ? 1 : 0;
+}
+
+/** Negative when `first` is older, positive when newer, 0 when equal. */
+export function compareVersions(first: ParsedVersion, second: ParsedVersion): number {
+  for (let i = 0; i < 3; i += 1) {
+    const difference = (first.release[i] ?? 0) - (second.release[i] ?? 0);
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  if (first.prerelease.length === 0 || second.prerelease.length === 0) {
+    return second.prerelease.length - first.prerelease.length;
+  }
+  const length = Math.max(first.prerelease.length, second.prerelease.length);
+  for (let i = 0; i < length; i += 1) {
+    const firstIdentifier = first.prerelease[i];
+    const secondIdentifier = second.prerelease[i];
+    if (firstIdentifier === undefined || secondIdentifier === undefined) {
+      return firstIdentifier === undefined ? -1 : 1;
+    }
+    const difference = compareIdentifiers(firstIdentifier, secondIdentifier);
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  return 0;
+}
+
+const COMPARATOR_PATTERN = /^(>=|<=|>|<|=)?\s*(.+)$/;
+
+/** Whether `version` meets one comparator (`>=2.0.0`); a malformed comparator never holds. */
+function meetsComparator(version: ParsedVersion, comparator: string): boolean {
+  const match = COMPARATOR_PATTERN.exec(comparator);
+  const bound = match?.[2] === undefined ? undefined : parseVersion(match[2]);
+  if (match === null || bound === undefined) {
+    return false;
+  }
+  const order = compareVersions(version, bound);
+  switch (match[1]) {
+    case '>=': return order >= 0;
+    case '<=': return order <= 0;
+    case '>': return order > 0;
+    case '<': return order < 0;
+    default: return order === 0;
+  }
+}
+
+/** Whether `versionText` is in `range`; a malformed version or empty range never is. */
+export function satisfiesRange(versionText: string, range: string): boolean {
+  const version = parseVersion(versionText);
+  if (version === undefined) {
+    return false;
+  }
+  return range.split('||').some((alternative) => {
+    const comparators = alternative.trim().split(/\s+/).filter((comparator) => comparator !== '');
+    return comparators.length > 0 && comparators.every((comparator) => meetsComparator(version, comparator));
+  });
+}

package/src/daily/daily-system.ts

@@ -1,161 +1,168 @@
-/**
- * Daily challenges, client side. A daily-enabled game calls
- * `hub.daily.define({ play })` once at load; `play` receives a
- * {@link DailyChallenge} and starts exactly that challenge. When the player
- * finishes, the game calls `hub.daily.complete({ score, … })`.
- *
- * The system is a page-wide singleton shared by the game's client and the
- * injected menu, so the menu can start a day on the instance the game
- * 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';
-
-const DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-
-/** The window event the injected menu fires to start a day on the game's instance. */
-export const DAILY_START_EVENT = 'hub:daily-start';
-
-/** A day key, or `null` when `candidate` isn't one. */
-// eslint-disable-next-line no-restricted-syntax -- trust boundary: a URL parameter or a window global set by the host page
-function asDayKey(candidate: unknown): string | null {
-  return typeof candidate === 'string' && DAY_PATTERN.test(candidate) ? candidate : null;
-}
-
-/** The day the page was deep-linked to, if any. */
-function readDeepLinkDay(): string | null {
-  // Prefer the value the host's injected snippet captured at parse time: it
-  // survives games that rewrite their own URL on boot.
-  const captured = typeof window === 'undefined' ? null : asDayKey(readField(window, '__hubDailyDeep'));
-  if (captured !== null || typeof location === 'undefined') {
-    return captured;
-  }
-  return asDayKey(new URL(location.href).searchParams.get('daily'));
-}
-
-/** The message of a thrown value. */
-// eslint-disable-next-line no-restricted-syntax -- trust boundary: anything a REST call can throw
-function messageOf(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-/** Daily challenges (`hub.daily`). */
-export class DailySystem {
-  /**
-   * The challenge in progress (set when a day starts, cleared on complete).
-   * A game's win handler checks it: `if (hub.daily.active) hub.daily.complete(…)`.
-   */
-  active: DailyChallenge | null = null;
-  private readonly host: DailyHost;
-  private play: DailyDefinition['play'] | null = null;
-  private pendingDay: string | null = null;
-  private isRelaying = false;
-
-  constructor(host: DailyHost) {
-    this.host = host;
-    if (typeof window !== 'undefined') {
-      // The injected menu (another module instance) asks us to start a day.
-      window.addEventListener(DAILY_START_EVENT, (event) => {
-        if (this.isRelaying) {
-          return;
-        }
-        const day = event instanceof CustomEvent ? readField(event.detail, 'day') : undefined;
-        if (typeof day === 'string') {
-          void this.startAndPlay(day);
-        }
-      });
-    }
-  }
-
-  /** Whether a game registered a daily-challenge handler on this page. */
-  get isDefined(): boolean {
-    return this.play !== null;
-  }
-
-  /**
-   * Register the game's challenge runner. Call once at load. If the page was
-   * deep-linked with `?daily=DATE` (or a start was requested before this),
-   * that day starts now.
-   */
-  define(definition: DailyDefinition): void {
-    this.play = definition.play;
-    const day = readDeepLinkDay() ?? this.pendingDay;
-    this.pendingDay = null;
-    if (day !== null) {
-      void this.startAndPlay(day);
-    }
-  }
-
-  /**
-   * Fetch the signed token for `day`, make it active and call the game's
-   * `play`. Before `define`, the day is kept and played then, so the menu's
-   * own instance never fetches a token; it is also relayed to any other
-   * daily system on the page (a client copy that couldn't share this one).
-   */
-  async startAndPlay(day: string): Promise<void> {
-    const play = this.play;
-    if (play === null) {
-      this.pendingDay = day;
-      this.relayStart(day);
-      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 });
-    } catch (error) {
-      this.host.emit('hub:daily-error', { day, error: messageOf(error) });
-    }
-  }
-
-  /**
-   * Record completion of the active challenge with optional metadata.
-   * Resolves with the new completion count and rank, or `null` when no
-   * challenge is active or the hub refused.
-   */
-  async complete(meta: DailyCompletionMeta = {}): Promise<DailyCompleteResponse | null> {
-    const challenge = this.active;
-    if (challenge === null) {
-      return null;
-    }
-    try {
-      const completed = await this.host.complete(challenge.day, challenge.token, meta);
-      this.active = null;
-      this.host.emit('hub:daily-complete', { day: challenge.day, count: completed.count, rank: completed.rank, meta });
-      return completed;
-    } catch (error) {
-      this.host.emit('hub:daily-error', { day: challenge.day, error: messageOf(error) });
-      return null;
-    }
-  }
-
-  /** Ask the page's other daily systems to start `day` (this one ignores its own event). */
-  private relayStart(day: string): void {
-    if (typeof window === 'undefined') {
-      return;
-    }
-    this.isRelaying = true;
-    try {
-      window.dispatchEvent(new CustomEvent(DAILY_START_EVENT, { detail: { day } }));
-    } finally {
-      this.isRelaying = false;
-    }
-  }
-
-  /** Abandon the active challenge without recording it (e.g. the player quit). */
-  cancel(): void {
-    this.active = null;
-  }
-
-  /** This game's window and the player's completions. */
-  status(): Promise<DailyStatus> {
-    return this.host.status();
-  }
-
-  /** Every daily-enabled game and the global standings (for the home hub). */
-  all(): Promise<DailyAll> {
-    return this.host.all();
-  }
-}
+/**
+ * Daily challenges, client side. A daily-enabled game calls
+ * `hub.daily.define({ play })` once at load; `play` receives a
+ * {@link DailyChallenge} and starts exactly that challenge. When the player
+ * finishes, the game calls `hub.daily.complete({ score, … })`.
+ *
+ * The system is a page-wide singleton shared by the game's client and the
+ * injected menu, so the menu can start a day on the instance the game
+ * 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';
+
+const DAY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+/** The window event the injected menu fires to start a day on the game's instance. */
+export const DAILY_START_EVENT = 'hub:daily-start';
+
+/** A day key, or `null` when `candidate` isn't one. */
+// eslint-disable-next-line no-restricted-syntax -- trust boundary: a URL parameter or a window global set by the host page
+function asDayKey(candidate: unknown): string | null {
+  return typeof candidate === 'string' && DAY_PATTERN.test(candidate) ? candidate : null;
+}
+
+/** The day the page was deep-linked to, if any. */
+function readDeepLinkDay(): string | null {
+  // Prefer the value the host's injected snippet captured at parse time: it
+  // survives games that rewrite their own URL on boot.
+  const captured = typeof window === 'undefined' ? null : asDayKey(readField(window, '__hubDailyDeep'));
+  if (captured !== null || typeof location === 'undefined') {
+    return captured;
+  }
+  return asDayKey(new URL(location.href).searchParams.get('daily'));
+}
+
+/** The message of a thrown value. */
+// eslint-disable-next-line no-restricted-syntax -- trust boundary: anything a REST call can throw
+function messageOf(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** Daily challenges (`hub.daily`). */
+export class DailySystem {
+  /**
+   * The challenge in progress (set when a day starts, cleared on complete).
+   * A game's win handler checks it: `if (hub.daily.active) hub.daily.complete(…)`.
+   */
+  active: DailyChallenge | null = null;
+  private readonly host: DailyHost;
+  private play: DailyDefinition['play'] | null = null;
+  private pendingDay: string | null = null;
+  private isRelaying = false;
+
+  constructor(host: DailyHost) {
+    this.host = host;
+    if (typeof window !== 'undefined') {
+      // The injected menu (another module instance) asks us to start a day.
+      window.addEventListener(DAILY_START_EVENT, (event) => {
+        if (this.isRelaying) {
+          return;
+        }
+        const day = event instanceof CustomEvent ? readField(event.detail, 'day') : undefined;
+        if (typeof day === 'string') {
+          void this.startAndPlay(day);
+        }
+      });
+    }
+  }
+
+  /** Whether a game registered a daily-challenge handler on this page. */
+  get isDefined(): boolean {
+    return this.play !== null;
+  }
+
+  /**
+   * Register the game's challenge runner. Call once at load. If the page was
+   * deep-linked with `?daily=DATE` (or a start was requested before this),
+   * that day starts now.
+   */
+  define(definition: DailyDefinition): void {
+    this.play = definition.play;
+    const day = readDeepLinkDay() ?? this.pendingDay;
+    this.pendingDay = null;
+    if (day !== null) {
+      void this.startAndPlay(day);
+    }
+  }
+
+  /**
+   * Fetch the signed token for `day`, make it active and call the game's
+   * `play`. Before `define`, the day is kept and played then, so the menu's
+   * own instance never fetches a token; it is also relayed to any other
+   * daily system on the page (a client copy that couldn't share this one).
+   */
+  async startAndPlay(day: string): Promise<void> {
+    const play = this.play;
+    if (play === null) {
+      this.pendingDay = day;
+      this.relayStart(day);
+      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 });
+    } catch (error) {
+      this.host.emit('hub:daily-error', { day, error: messageOf(error) });
+    }
+  }
+
+  /**
+   * Record completion of the active challenge with optional metadata.
+   * Resolves with the new completion count and rank, or `null` when no
+   * challenge is active, the hub refused, or the hub can't be reached: then
+   * the completion is queued (`hub:daily-queued`) and replays when it is
+   * back (`hub:daily-complete` follows).
+   */
+  async complete(meta: DailyCompletionMeta = {}): Promise<DailyCompleteResponse | null> {
+    const challenge = this.active;
+    if (challenge === null) {
+      return null;
+    }
+    try {
+      const completed = await this.host.complete(challenge.day, challenge.token, meta);
+      this.active = null;
+      if (completed === null) {
+        // Queued offline: `hub:daily-complete` follows when it replays.
+        this.host.emit('hub:daily-queued', { day: challenge.day, queued: true, meta });
+        return null;
+      }
+      this.host.emit('hub:daily-complete', { day: challenge.day, count: completed.count, rank: completed.rank, meta });
+      return completed;
+    } catch (error) {
+      this.host.emit('hub:daily-error', { day: challenge.day, error: messageOf(error) });
+      return null;
+    }
+  }
+
+  /** Ask the page's other daily systems to start `day` (this one ignores its own event). */
+  private relayStart(day: string): void {
+    if (typeof window === 'undefined') {
+      return;
+    }
+    this.isRelaying = true;
+    try {
+      window.dispatchEvent(new CustomEvent(DAILY_START_EVENT, { detail: { day } }));
+    } finally {
+      this.isRelaying = false;
+    }
+  }
+
+  /** Abandon the active challenge without recording it (e.g. the player quit). */
+  cancel(): void {
+    this.active = null;
+  }
+
+  /** This game's window and the player's completions. */
+  status(): Promise<DailyStatus> {
+    return this.host.status();
+  }
+
+  /** Every daily-enabled game and the global standings (for the home hub). */
+  all(): Promise<DailyAll> {
+    return this.host.all();
+  }
+}