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

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`). */

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

@@ -11,8 +11,9 @@
  * - `load()` / `get()` read it back; `requested` says the page was opened to
  *   resume, so the game restores without asking.
  *
- * Saves are ignored while the page is in a race, a daily challenge or an
- * online room: those runs are never resumed.
+ * Saves are ignored while the page is in a race or an online room: those
+ * runs are never resumed. During a daily challenge they go to the day's own
+ * saved game (`hub.daily.save`), so the day can be picked up again.
  */
 import type { ResumeSlot, ResumeSummary } from '@diffenderfer-games/hub-contract';
 import { HubError } from '../errors';
@@ -35,6 +36,7 @@ const BLOCKED_HINTS: Readonly<Record<ResumeBlocker, string>> = {
   daily: 'a daily challenge is active. When the player leaves a daily without finishing it, call hub.daily.cancel().',
   race: 'a race is on: races are never resumed.',
   room: 'the page is in a hub room: online games are never resumed.',
+  turns: 'an online game is open: the hub keeps its state, so nothing is saved on the page.',
 };
 
 /** Longest label or title kept (the contract's `RESUME_TEXT_MAX`). */
@@ -51,6 +53,8 @@ export 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. */
@@ -59,8 +63,18 @@ export 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`). */
+export interface DailyRoute {
+  save(input: ResumeSaveInput<GamePayload>): boolean;
+}
+
+/** The label a daily goes back to when the game clears its run mid-daily (the day restarts from its seed). */
+const DAILY_RESTART_LABEL = 'Started';
+
 /** A label or title trimmed and clipped, or `null` when blank. */
 function shortText(text: string | null | undefined): string | null {
   const trimmed = (text ?? '').trim();
@@ -111,8 +125,9 @@ export 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 {
     const blocker = this.host.blocker();
@@ -120,6 +135,11 @@ export class HubResume {
       this.warnBlocked(blocker);
       return false;
     }
+    const daily = this.host.daily?.() ?? null;
+    if (daily !== null) {
+      // During a daily challenge the run IS the day: it is saved to the day's saved game, not the game's run.
+      return daily.save(run);
+    }
     const slug = this.requireSlug();
     const label = shortText(run.progress.label);
     if (label === null) {
@@ -135,6 +155,7 @@ export class HubResume {
       version: Math.max(0, Math.floor(run.version ?? 0)), gameTitle: this.host.gameTitle(), state, isSynced: false,
     };
     const isStored = this.host.local.write(slug, copy);
+    this.host.onChange?.();
     this.schedule({
       action: 'save', savedAt: copy.at, label, fraction, title: copy.title, version: copy.version,
       ...(isStored ? {} : { state }),
@@ -158,6 +179,17 @@ export class HubResume {
   /** Clear the run: call it when the run ends (won, lost or quit). Works offline. */
   async clear(): Promise<void> {
     const slug = this.requireSlug();
+    const daily = this.host.daily?.() ?? null;
+    if (daily !== null) {
+      // The day's run ended without a win: the day stays in progress, starting over from its seed.
+      daily.save({ state: null, progress: { label: DAILY_RESTART_LABEL } });
+      return;
+    }
+    await this.clearRun(slug);
+  }
+
+  /** Delete the game's saved run (never the day being played). */
+  private async clearRun(slug: string): Promise<void> {
     if (this.timer !== null) {
       clearTimeout(this.timer);
       this.timer = null;
@@ -165,6 +197,7 @@ export class HubResume {
     this.waiting = null;
     const at = Date.now();
     this.host.local.write(slug, { status: 'cleared', userId: this.host.currentUserId(), at, isSynced: false });
+    this.host.onChange?.();
     await this.host.send({ action: 'clear', before: at });
   }
 
@@ -186,7 +219,8 @@ export class HubResume {
       return run;
     }
     if (run.version < options.version) {
-      await this.clear();
+      // A stale saved run is dropped; a daily being played is left alone.
+      await this.clearRun(slug);
     }
     return null;
   }

package/src/core/resume/resume-types.ts

@@ -60,5 +60,5 @@ export interface ResumeEntry {
   readonly isLocalOnly: boolean;
 }
 
-/** Why a save was ignored: the page is in a race, a daily challenge or an online room. */
-export 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.) */
+export type ResumeBlocker = 'race' | 'daily' | 'room' | 'turns';

package/src/core/saved/daily-saves.ts

@@ -0,0 +1,196 @@
+/**
+ * A game's daily challenges in progress on this device: what `hub.daily`
+ * saves and discards, kept in the device copy at once (`LocalDailyStore`)
+ * and sent through the `hub.saved` outbox kind after a short quiet spell
+ * (at once when the page hides), so a day survives a reload, offline play
+ * and a tab closed mid-move. A day started while the hub can't be reached
+ * gets a device-only id; its first send starts it on the hub.
+ */
+import type { DailyChallenge, DailySaveInput, DailyStartResponse } from '../../daily/types';
+import { HubError } from '../errors';
+import { toStoredJson } from '../game-data';
+import type { SavedPayload } from '../offline/hub-kinds';
+import { isBrowserPage } from '../page';
+import { dailySeed } from './daily-seed';
+import type { LocalDaily, LocalDailyStore } from './local-saved';
+import { localDailyId } from './saved-list';
+
+/** How long saves must be quiet before the latest is sent, ms (the same as `hub.resume`). */
+export const DAILY_SAVE_DEBOUNCE_MS = 3000;
+
+/** Largest state, bytes of JSON (the contract's `SAVED_MAX_STATE_BYTES`). */
+const MAX_STATE_BYTES = 512 * 1024;
+
+/** Longest label or title kept. */
+const TEXT_MAX = 60;
+
+/** The label of a day started and not saved yet. */
+const STARTED_LABEL = 'Started';
+
+/** What the daily saves need from their client. */
+export interface DailySavesHost {
+  readonly slug: string;
+  readonly local: LocalDailyStore;
+  currentUserId(): number | null;
+  gameTitle(): string;
+  /** Queue (or send at once) a `hub.saved` op. */
+  send(payload: SavedPayload): Promise<void>;
+}
+
+/** A label or title trimmed and clipped, or `null` when blank. */
+function shortText(text: string | null | undefined): string | null {
+  const trimmed = (text ?? '').trim();
+  return trimmed === '' ? null : trimmed.slice(0, TEXT_MAX);
+}
+
+/** A game's daily saves. */
+export class DailySaves {
+  private readonly host: DailySavesHost;
+  private readonly timers = new Map<string, ReturnType<typeof setTimeout>>();
+  private readonly waiting = new Map<string, SavedPayload>();
+  private isListening = false;
+
+  constructor(host: DailySavesHost) {
+    this.host = host;
+  }
+
+  /**
+   * The answer a device-only start gives while the hub can't be reached:
+   * the day's copy here (its saved state) or a fresh one. No token: the
+   * completion fetches one when the hub is back.
+   */
+  startLocally(day: string): DailyStartResponse {
+    const userId = this.host.currentUserId();
+    const existing = this.host.local.read(this.host.slug, day);
+    const copy: LocalDaily = existing !== null && existing.status === 'active' && existing.userId === userId ? existing : {
+      id: localDailyId(this.host.slug, day), game: this.host.slug, day, seed: dailySeed(this.host.slug, day), status: 'active', userId, at: Date.now(),
+      label: STARTED_LABEL, fraction: null, title: null, version: 0, gameTitle: this.host.gameTitle(), state: null, isSynced: false,
+    };
+    if (copy !== existing) {
+      this.host.local.write(copy);
+    }
+    return {
+      token: '', day, seed: copy.seed, expiresAt: 0, alreadyCompleted: false, completedAt: null, meta: null,
+      instanceId: copy.id, saved: copy.state, savedVersion: copy.version, resumed: existing !== null,
+    };
+  }
+
+  /** The hub started (or resumed) a day: keep a copy that knows its id, unless the device has a newer save. */
+  remember(started: DailyStartResponse): DailyStartResponse {
+    if (started.instanceId === null) {
+      return started;
+    }
+    const existing = this.host.local.read(this.host.slug, started.day);
+    if (existing !== null && existing.status === 'active' && existing.userId === this.host.currentUserId() && !existing.isSynced) {
+      // This device saved after its last send: play on from that.
+      this.host.local.write({ ...existing, id: started.instanceId });
+      return { ...started, saved: existing.state, savedVersion: existing.version };
+    }
+    return started;
+  }
+
+  /** Save the active day's state: on the device now, to the hub soon. */
+  save(challenge: DailyChallenge, input: DailySaveInput): boolean {
+    const label = shortText(input.progress.label);
+    if (label === null) {
+      throw new HubError('hub.daily.save: progress.label is required.', 400);
+    }
+    const state = toStoredJson(input.state);
+    if (new TextEncoder().encode(JSON.stringify(state)).length > MAX_STATE_BYTES) {
+      throw new HubError(`hub.daily.save: state exceeds ${String(MAX_STATE_BYTES)} bytes.`, 413);
+    }
+    if (challenge.instanceId === null) {
+      return false;
+    }
+    const fraction = typeof input.progress.fraction === 'number' && Number.isFinite(input.progress.fraction) ? Math.min(1, Math.max(0, input.progress.fraction)) : null;
+    const copy: LocalDaily = {
+      id: challenge.instanceId, game: this.host.slug, day: challenge.day, seed: challenge.seed, status: 'active', userId: this.host.currentUserId(),
+      at: Date.now(), label, fraction, title: shortText(input.title), version: Math.max(0, Math.floor(input.version ?? 0)),
+      gameTitle: this.host.gameTitle(), state, isSynced: false,
+    };
+    if (!this.host.local.write(copy)) {
+      return false;
+    }
+    this.schedule({ action: 'save', game: copy.game, day: copy.day, at: copy.at });
+    return true;
+  }
+
+  /** Give the day up: the copy says so at once, the hub hears it now (or when back online). */
+  async discard(challenge: DailyChallenge): Promise<void> {
+    this.dropWaiting(challenge.day);
+    const at = Date.now();
+    const base = this.host.local.read(this.host.slug, challenge.day) ?? this.blankCopy(challenge);
+    this.host.local.write({ ...base, id: challenge.instanceId ?? base.id, status: 'discarded', at, isSynced: false });
+    await this.host.send({ action: 'discard', game: this.host.slug, day: challenge.day, at });
+  }
+
+  /** The day was won: no save is waiting for it any more, and the lists hide it until the hub confirms. */
+  finished(day: string): void {
+    this.dropWaiting(day);
+    const existing = this.host.local.read(this.host.slug, day);
+    if (existing !== null) {
+      this.host.local.write({ ...existing, status: 'finished', at: Date.now(), isSynced: false });
+    }
+  }
+
+  /** The hub recorded the day: forget the copy. */
+  completed(day: string): void {
+    this.host.local.remove(this.host.slug, day);
+  }
+
+  /** Send every waiting save now. */
+  async flush(): Promise<void> {
+    const payloads = [...this.waiting.values()];
+    for (const timer of this.timers.values()) {
+      clearTimeout(timer);
+    }
+    this.timers.clear();
+    this.waiting.clear();
+    await Promise.all(payloads.map((payload) => this.host.send(payload)));
+  }
+
+  private blankCopy(challenge: DailyChallenge): LocalDaily {
+    return {
+      id: challenge.instanceId ?? localDailyId(this.host.slug, challenge.day), game: this.host.slug, day: challenge.day, seed: challenge.seed,
+      status: 'active', userId: this.host.currentUserId(), at: Date.now(), label: STARTED_LABEL, fraction: null, title: null, version: 0,
+      gameTitle: this.host.gameTitle(), state: null, isSynced: false,
+    };
+  }
+
+  private dropWaiting(day: string): void {
+    const timer = this.timers.get(day);
+    if (timer !== undefined) {
+      clearTimeout(timer);
+    }
+    this.timers.delete(day);
+    this.waiting.delete(day);
+  }
+
+  private schedule(payload: SavedPayload): void {
+    this.dropWaiting(payload.day);
+    this.waiting.set(payload.day, payload);
+    this.timers.set(payload.day, setTimeout(() => {
+      this.timers.delete(payload.day);
+      this.waiting.delete(payload.day);
+      void this.host.send(payload).catch(() => undefined);
+    }, DAILY_SAVE_DEBOUNCE_MS));
+    this.listenToPage();
+  }
+
+  /** Send waiting saves as soon as the page is hidden or closed. */
+  private listenToPage(): void {
+    if (this.isListening || !isBrowserPage()) {
+      return;
+    }
+    this.isListening = true;
+    const flushNow = (): void => { void this.flush().catch(() => undefined); };
+    window.addEventListener('pagehide', flushNow);
+    if (typeof document !== 'undefined') {
+      document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+          flushNow();
+        }
+      });
+    }
+  }
+}

package/src/core/saved/daily-seed.ts

@@ -0,0 +1,16 @@
+/**
+ * The deterministic seed of a (game, day), the same FNV-1a as the
+ * contract's `seedForDay` (the browser client carries no contract code; a
+ * test keeps the two in step). Used for a day started offline.
+ */
+
+/** The uint32 seed for `game` on `day`. */
+export function dailySeed(game: string, day: string): number {
+  let hash = 2166136261 >>> 0;
+  const seedInput = `${game}#${day}`;
+  for (let i = 0; i < seedInput.length; i++) {
+    hash ^= seedInput.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}