@diffenderfer-games/hub 0.0.0-stage → 2.0.0-next.1

package/dist/shared/src.js

@@ -0,0 +1,2164 @@
+import { r as _defineProperty } from "./globals.js";
+import { n as getDaily } from "./daily.js";
+import { t as HUB_CLIENT_VERSION } from "./client-version.gen.js";
+import { n as getInput } from "./input.js";
+import { t as getUiStack } from "./page-stack.js";
+import { d as linkRealtimeToHub } from "./bridge.js";
+import { t as multiplayerForwarder } from "./mp.js";
+import { t as raceForwarder } from "./race.js";
+import { t as roomsForwarder } from "./rooms.js";
+import { n as presenceForwarder, r as socialForwarder, t as notifyForwarder } from "./social.js";
+//#region src/core/storage/json-guards.ts
+/** Whether `candidate` is a non-null, non-array object. */
+function isRecord(candidate) {
+	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+}
+/** `candidate` when it is a string, else `undefined`. */
+function optionalString(candidate) {
+	return typeof candidate === "string" ? candidate : void 0;
+}
+/** `candidate` when it is a finite number, else `undefined`. */
+function optionalNumber(candidate) {
+	return typeof candidate === "number" && Number.isFinite(candidate) ? candidate : void 0;
+}
+/** Whether `candidate` is a string or `null`. */
+function isNullableString(candidate) {
+	return candidate === null || typeof candidate === "string";
+}
+/** Whether `candidate` is a JSON value (what `JSON.parse` can return). */
+function isJson(candidate) {
+	if (candidate === null || typeof candidate === "string" || typeof candidate === "boolean") return true;
+	if (typeof candidate === "number") return Number.isFinite(candidate);
+	if (Array.isArray(candidate)) return candidate.every(isJson);
+	return isRecord(candidate) && Object.values(candidate).every(isJson);
+}
+/** Whether `candidate` is an object whose every value is a finite number. */
+function isNumberRecord(candidate) {
+	return isRecord(candidate) && Object.values(candidate).every((entry) => optionalNumber(entry) !== void 0);
+}
+/** The strings in `candidate`, or an empty list when it is not an array. */
+function stringsIn(candidate) {
+	return Array.isArray(candidate) ? candidate.filter((entry) => typeof entry === "string") : [];
+}
+/** Parse JSON text without throwing: `undefined` when it is not JSON. */
+function parseJsonText(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/core/errors.ts
+/**
+* The code a client gives a call the hub does not have yet (a newer client on
+* an older hub, plan §4.3.3). Deploy the hub first, or use an older client.
+*/
+const UNSUPPORTED_BY_HUB = "unsupported_by_hub";
+/**
+* Thrown by every hub call that fails. `status` is the HTTP status when the
+* hub answered (401 = not signed in, 404 = unknown game or board, 413 = too
+* large), or `undefined` for a transport failure (offline, no host). Social
+* and multiplayer errors also carry {@link HubErrorDetails}.
+*/
+var HubError = class extends Error {
+	/** An error with a player-safe `message`, the HTTP `status` (if any) and the body's extras. */
+	constructor(message, status, details = {}) {
+		super(message);
+		_defineProperty(this, "status", void 0);
+		_defineProperty(this, "code", void 0);
+		_defineProperty(this, "reason", void 0);
+		_defineProperty(this, "hint", void 0);
+		_defineProperty(this, "retryAfterMs", void 0);
+		_defineProperty(this, "until", void 0);
+		this.name = "HubError";
+		this.status = status;
+		this.code = details.code;
+		this.reason = details.reason;
+		this.hint = details.hint;
+		this.retryAfterMs = details.retryAfterMs;
+		this.until = details.until;
+	}
+	/** `true` when the failure was a network or transport error, not an HTTP status. */
+	get isOffline() {
+		return this.status === void 0;
+	}
+};
+/** Thrown when an action that genuinely needs the hub is attempted offline. */
+var OfflineError = class extends HubError {
+	/** An offline error; the default message is "This needs a connection.". */
+	constructor(message = "This needs a connection.") {
+		super(message);
+		this.name = "OfflineError";
+	}
+};
+/**
+* Text was refused by the safety filter (HTTP 422, or a socket ack with
+* `code: 'content_rejected'`). Keep the player's draft and show `hint`; when
+* `reason` is `muted` or `rate_limited`, `retryAfterMs` says how long to wait.
+*/
+var ContentRejectedError = class extends HubError {
+	/** A content reject with the hub's message, status and extras. */
+	constructor(message, status, details) {
+		super(message, status, details);
+		this.name = "ContentRejectedError";
+	}
+};
+/** Read the fields this client understands from an error body (or any thrown object). */
+function readErrorFields(body) {
+	if (!isRecord(body)) return {};
+	return {
+		error: optionalString(body.error),
+		code: optionalString(body.code),
+		reason: optionalString(body.reason),
+		hint: optionalString(body.hint),
+		retryAfterMs: optionalNumber(body.retryAfterMs),
+		until: optionalNumber(body.until)
+	};
+}
+/** The right error class for a failure: a 422 or `content_rejected` is a {@link ContentRejectedError}. */
+function errorFor(message, status, details) {
+	return status === 422 || details.code === "content_rejected" ? new ContentRejectedError(message, status, details) : new HubError(message, status, details);
+}
+/**
+* Re-create an error from another bundle (the social runtime, or another
+* client copy on the page) as this bundle's class, so `instanceof` works in
+* games.
+*/
+function toHubError(thrown) {
+	if (thrown instanceof HubError) return thrown;
+	if (!isRecord(thrown)) return new HubError(String(thrown));
+	const fields = readErrorFields(thrown);
+	const message = optionalString(thrown.message) ?? "Request failed";
+	if (fields.code === "offline") return new OfflineError(message);
+	return errorFor(message, optionalNumber(thrown.status), fields);
+}
+//#endregion
+//#region src/core/storage/key-value.ts
+/** A store backed by a `Storage` (`localStorage`). */
+function storageBacked(storage) {
+	return {
+		read: (key) => storage.getItem(key),
+		write: (key, text) => {
+			try {
+				storage.setItem(key, text);
+			} catch {}
+		},
+		remove: (key) => {
+			storage.removeItem(key);
+		},
+		keys: () => Object.keys(storage)
+	};
+}
+/** A store held in memory for this page only. */
+function createMemoryStore() {
+	const entries = /* @__PURE__ */ new Map();
+	return {
+		read: (key) => entries.get(key) ?? null,
+		write: (key, text) => {
+			entries.set(key, text);
+		},
+		remove: (key) => {
+			entries.delete(key);
+		},
+		keys: () => [...entries.keys()]
+	};
+}
+/** The page's `localStorage`, or `undefined` when it is missing or throws (privacy mode). */
+function pageStorage() {
+	try {
+		return typeof localStorage === "undefined" ? void 0 : localStorage;
+	} catch {
+		return;
+	}
+}
+/** `localStorage` when available, else a fresh in-memory store. */
+function createPageStore() {
+	const storage = pageStorage();
+	return storage === void 0 ? createMemoryStore() : storageBacked(storage);
+}
+/** The well-formed events of a stored buffer. */
+function readEvents(stored) {
+	if (!Array.isArray(stored)) return [];
+	return stored.flatMap((entry) => {
+		if (!isRecord(entry)) return [];
+		const type = optionalString(entry.type);
+		const ts = optionalNumber(entry.ts);
+		return type === void 0 || ts === void 0 ? [] : [{
+			type,
+			ts
+		}];
+	});
+}
+/** The buffer with one more event, trimmed to {@link EVENT_BUFFER_CAP}: oldest heartbeats go first, then the oldest events. */
+function appendEvent(events, incoming) {
+	let buffered = [...events, incoming];
+	let excess = buffered.length - 100;
+	if (excess <= 0) return buffered;
+	buffered = buffered.filter((event) => {
+		if (excess > 0 && event.type === "heartbeat") {
+			excess -= 1;
+			return false;
+		}
+		return true;
+	});
+	return buffered.length > 100 ? buffered.slice(buffered.length - 100) : buffered;
+}
+//#endregion
+//#region src/core/offline/queue.ts
+/** The score options in a stored op, or `undefined` when they are malformed. */
+function readScoreOptions(stored) {
+	const title = optionalString(stored.title);
+	const sort = stored.sort === "asc" || stored.sort === "desc" ? stored.sort : void 0;
+	if (stored.meta !== void 0 && !isJson(stored.meta)) return;
+	return {
+		...title === void 0 ? {} : { title },
+		...sort === void 0 ? {} : { sort },
+		...stored.meta === void 0 ? {} : { meta: stored.meta }
+	};
+}
+/** The profile patch in a stored op, or `undefined` when it is malformed. */
+function readProfilePatch(stored) {
+	if (stored.displayName !== void 0 && !isNullableString(stored.displayName) || stored.data !== void 0 && !isJson(stored.data)) return;
+	const patch = {};
+	if (stored.displayName !== void 0) patch.displayName = stored.displayName;
+	if (stored.data !== void 0) patch.data = stored.data;
+	return patch;
+}
+/** One stored op's write, or `undefined` when it is not a known, well-formed op. */
+function readOpInput(stored) {
+	const slot = optionalString(stored.slot);
+	const key = optionalString(stored.key);
+	const statValue = optionalNumber(stored.value);
+	switch (stored.kind) {
+		case "putSave": return slot !== void 0 && isJson(stored.data) && isNullableString(stored.label) ? {
+			kind: "putSave",
+			slot,
+			data: stored.data,
+			label: stored.label
+		} : void 0;
+		case "deleteSave": return slot === void 0 ? void 0 : {
+			kind: "deleteSave",
+			slot
+		};
+		case "setStat":
+		case "maxStat": return key !== void 0 && statValue !== void 0 ? {
+			kind: stored.kind,
+			key,
+			value: statValue
+		} : void 0;
+		case "incrStat": {
+			const amount = optionalNumber(stored.amount);
+			return key !== void 0 && amount !== void 0 ? {
+				kind: "incrStat",
+				key,
+				amount
+			} : void 0;
+		}
+		case "submitScore": {
+			const score = optionalNumber(stored.score);
+			const opts = isRecord(stored.opts) ? readScoreOptions(stored.opts) : void 0;
+			return key !== void 0 && score !== void 0 && opts !== void 0 ? {
+				kind: "submitScore",
+				key,
+				score,
+				opts
+			} : void 0;
+		}
+		case "setProfile": {
+			const patch = isRecord(stored.patch) ? readProfilePatch(stored.patch) : void 0;
+			return patch === void 0 ? void 0 : {
+				kind: "setProfile",
+				patch
+			};
+		}
+		default: return;
+	}
+}
+/** The well-formed ops of a stored queue, in order; anything malformed is dropped. */
+function readQueue(stored) {
+	if (!Array.isArray(stored)) return [];
+	return stored.flatMap((entry) => {
+		if (!isRecord(entry)) return [];
+		const input = readOpInput(entry);
+		const id = optionalString(entry.id);
+		const ts = optionalNumber(entry.ts);
+		return input === void 0 || id === void 0 || ts === void 0 ? [] : [{
+			...input,
+			id,
+			ts
+		}];
+	});
+}
+/** The better of two scores on a board sorted `sort` (`desc` by default). */
+function betterScore(first, second, sort) {
+	return sort === "asc" ? Math.min(first, second) : Math.max(first, second);
+}
+/** The op that `queued` becomes when `incoming` collapses into it, or `undefined` when they don't collapse. */
+function collapsedOp(queued, incoming) {
+	if (queued.kind === "incrStat" && incoming.kind === "incrStat" && queued.key === incoming.key) return {
+		...queued,
+		amount: queued.amount + incoming.amount
+	};
+	if (queued.kind === "maxStat" && incoming.kind === "maxStat" && queued.key === incoming.key) return {
+		...queued,
+		value: Math.max(queued.value, incoming.value)
+	};
+	if (queued.kind === "setStat" && incoming.kind === "setStat" && queued.key === incoming.key) return {
+		...queued,
+		value: incoming.value
+	};
+	if (queued.kind === "submitScore" && incoming.kind === "submitScore" && queued.key === incoming.key) return {
+		...queued,
+		score: betterScore(queued.score, incoming.score, incoming.opts.sort),
+		opts: incoming.opts
+	};
+	if (queued.kind === "setProfile" && incoming.kind === "setProfile") return {
+		...queued,
+		patch: {
+			...queued.patch,
+			...incoming.patch
+		}
+	};
+}
+/** Whether an op writes save slot `slot`. */
+function writesSlot(op, slot) {
+	return (op.kind === "putSave" || op.kind === "deleteSave") && op.slot === slot;
+}
+/**
+* The queue with `incoming` added: a save or delete replaces any queued
+* write to the same slot (and goes last); a compatible op merges into the
+* first queued one in place; anything else is appended.
+*/
+function enqueueOp(queue, incoming) {
+	if (incoming.kind === "putSave" || incoming.kind === "deleteSave") return [...queue.filter((op) => !writesSlot(op, incoming.slot)), incoming];
+	const mergeAt = queue.findIndex((op) => collapsedOp(op, incoming) !== void 0);
+	if (mergeAt < 0) return [...queue, incoming];
+	return queue.map((op, i) => i === mergeAt ? collapsedOp(op, incoming) ?? op : op);
+}
+//#endregion
+//#region src/core/offline/local-store.ts
+/** The key of the locally known user, shared by every game (like the real session). */
+const USER_KEY = "hub:user";
+function readUser(stored) {
+	if (!isRecord(stored)) return null;
+	const id = optionalNumber(stored.id);
+	const username = optionalString(stored.username);
+	if (id === void 0 || username === void 0) return null;
+	return typeof stored.guest === "boolean" ? {
+		id,
+		username,
+		guest: stored.guest
+	} : {
+		id,
+		username
+	};
+}
+function readSave(stored) {
+	if (!isRecord(stored)) return null;
+	const slot = optionalString(stored.slot);
+	const updatedAt = optionalNumber(stored.updatedAt);
+	if (slot === void 0 || updatedAt === void 0 || !isNullableString(stored.label) || !isJson(stored.data)) return null;
+	return {
+		slot,
+		label: stored.label,
+		data: stored.data,
+		updatedAt
+	};
+}
+function readProfile(stored) {
+	if (!isRecord(stored)) return null;
+	const game = optionalString(stored.game);
+	const updatedAt = optionalNumber(stored.updatedAt);
+	if (game === void 0 || updatedAt === void 0 || !isNullableString(stored.displayName) || !isJson(stored.data)) return null;
+	return {
+		game,
+		displayName: stored.displayName,
+		data: stored.data,
+		updatedAt
+	};
+}
+function readLocalBoard(stored) {
+	if (!isRecord(stored) || !isRecord(stored.board)) return null;
+	const key = optionalString(stored.board.key);
+	const title = optionalString(stored.board.title);
+	const sortDir = stored.board.sortDir === "asc" || stored.board.sortDir === "desc" ? stored.board.sortDir : void 0;
+	const best = optionalNumber(stored.best);
+	if (key === void 0 || title === void 0 || sortDir === void 0 || best === void 0) return null;
+	return {
+		board: {
+			key,
+			title,
+			sortDir
+		},
+		best
+	};
+}
+/** One game's offline cache, queue and event buffer. */
+var LocalStore = class {
+	/** The cache for game `slug` in `store` (default: `localStorage`, or memory without it). */
+	constructor(slug, store = createPageStore()) {
+		_defineProperty(this, "prefix", void 0);
+		_defineProperty(this, "store", void 0);
+		_defineProperty(this, "sequence", 0);
+		this.prefix = `hub:${slug}:`;
+		this.store = store;
+	}
+	readStored(key) {
+		const text = this.store.read(key);
+		return text === null ? void 0 : parseJsonText(text);
+	}
+	writeStored(key, stored) {
+		this.store.write(key, JSON.stringify(stored));
+	}
+	/** The locally known user. */
+	getUser() {
+		return readUser(this.readStored(USER_KEY));
+	}
+	/** Remember the user (offline sign-in, or a snapshot). */
+	setUser(user) {
+		this.writeStored(USER_KEY, user);
+	}
+	/** Forget the user (offline sign-out). */
+	clearUser() {
+		this.store.remove(USER_KEY);
+	}
+	/** This game's cached profile. */
+	getProfile() {
+		return readProfile(this.readStored(`${this.prefix}profile`));
+	}
+	/** Store this game's profile and return it. */
+	setProfile(game, displayName, profileData) {
+		const profile = {
+			game,
+			displayName,
+			data: profileData,
+			updatedAt: Date.now()
+		};
+		this.writeStored(`${this.prefix}profile`, profile);
+		return profile;
+	}
+	/** Every cached save's metadata, newest first. */
+	listSaves() {
+		return this.store.keys().filter((key) => key.startsWith(`${this.prefix}save:`)).flatMap((key) => {
+			const save = readSave(this.readStored(key));
+			return save === null ? [] : [{
+				slot: save.slot,
+				label: save.label,
+				updatedAt: save.updatedAt
+			}];
+		}).sort((first, second) => second.updatedAt - first.updatedAt);
+	}
+	/** One cached save, or `null`. */
+	getSave(slot) {
+		return readSave(this.readStored(`${this.prefix}save:${slot}`));
+	}
+	/** Store a save and return its `updatedAt`. */
+	putSave(slot, saveData, label) {
+		const updatedAt = Date.now();
+		this.writeStored(`${this.prefix}save:${slot}`, {
+			slot,
+			label,
+			data: saveData,
+			updatedAt
+		});
+		return updatedAt;
+	}
+	/** Forget a save. */
+	deleteSave(slot) {
+		this.store.remove(`${this.prefix}save:${slot}`);
+	}
+	/** This game's cached stats. */
+	getStats() {
+		const stored = this.readStored(`${this.prefix}stats`);
+		return isNumberRecord(stored) ? { ...stored } : {};
+	}
+	/** Apply one stat update and return the stat's new value. */
+	updateStat(key, amount, mode) {
+		const stats = this.getStats();
+		const current = stats[key] ?? 0;
+		const updated = mode === "incr" ? current + amount : mode === "max" ? Math.max(current, amount) : amount;
+		this.writeStored(`${this.prefix}stats`, {
+			...stats,
+			[key]: updated
+		});
+		return updated;
+	}
+	/** The boards this player has a local best on (offline boards only know the player's own best). */
+	listBoards() {
+		return this.store.keys().filter((key) => key.startsWith(`${this.prefix}lb:`)).flatMap((key) => {
+			const local = readLocalBoard(this.readStored(key));
+			return local === null ? [] : [local.board];
+		});
+	}
+	/** One board's local best, or `null`. */
+	getBoard(key) {
+		return readLocalBoard(this.readStored(`${this.prefix}lb:${key}`));
+	}
+	/** Record a score locally, keeping the best one; returns the board and best. */
+	submitScore(key, score, options) {
+		const existing = this.getBoard(key);
+		const sortDir = existing?.board.sortDir ?? (options.sort === "asc" ? "asc" : "desc");
+		const board = existing?.board ?? {
+			key,
+			title: options.title !== void 0 && options.title !== "" ? options.title : key,
+			sortDir
+		};
+		const best = existing === null ? score : betterScore(existing.best, score, sortDir);
+		this.writeStored(`${this.prefix}lb:${key}`, {
+			board,
+			best
+		});
+		return {
+			board,
+			best
+		};
+	}
+	/** The queued writes, oldest first. */
+	getQueue() {
+		return readQueue(this.readStored(`${this.prefix}queue`));
+	}
+	/** Replace the queue. */
+	setQueue(queue) {
+		this.writeStored(`${this.prefix}queue`, queue);
+	}
+	/** How many writes are queued. */
+	queueLength() {
+		return this.getQueue().length;
+	}
+	/** Queue a write, collapsing it with a compatible queued one. */
+	enqueue(input) {
+		this.sequence += 1;
+		const now = Date.now();
+		this.setQueue(enqueueOp(this.getQueue(), {
+			...input,
+			id: `${String(now)}-${String(this.sequence)}`,
+			ts: now
+		}));
+	}
+	/** The buffered analytics events, oldest first. */
+	getEvents() {
+		return readEvents(this.readStored(`${this.prefix}events`));
+	}
+	/** Replace the event buffer. */
+	setEvents(events) {
+		this.writeStored(`${this.prefix}events`, events);
+	}
+	/** Buffer one event (capped; heartbeats are dropped first). */
+	bufferEvent(type) {
+		this.setEvents(appendEvent(this.getEvents(), {
+			type,
+			ts: Date.now()
+		}));
+	}
+	/** Fan a `/me/snapshot` reply out across every game's cache keys. */
+	hydrate(snapshot) {
+		if (snapshot.user !== null) this.writeStored(USER_KEY, snapshot.user);
+		for (const [slug, game] of Object.entries(snapshot.games)) {
+			const gamePrefix = `hub:${slug}:`;
+			if (game.profile !== null) this.writeStored(`${gamePrefix}profile`, game.profile);
+			for (const save of game.saves) this.writeStored(`${gamePrefix}save:${save.slot}`, save);
+			this.writeStored(`${gamePrefix}stats`, game.stats);
+			this.writeStored(`${gamePrefix}inventory`, game.inventory);
+		}
+		for (const gameRecords of snapshot.records) for (const record of gameRecords.records) this.writeStored(`hub:${gameRecords.slug}:lb:${record.key}`, {
+			board: {
+				key: record.key,
+				title: record.title,
+				sortDir: record.sortDir
+			},
+			best: record.score
+		});
+		this.writeStored("hub:records", snapshot.records);
+		this.writeStored("hub:leaderboards", snapshot.leaderboards);
+	}
+};
+//#endregion
+//#region src/core/page.ts
+/** Whether this code runs in a browser page. */
+function isBrowserPage() {
+	return typeof window !== "undefined";
+}
+/** The injected config's slug and API base, read defensively (empty outside a hub page). */
+function injectedConfig() {
+	if (!isBrowserPage() || !isRecord(window.__HUB__)) return {};
+	const slug = optionalString(window.__HUB__.slug);
+	const apiBase = optionalString(window.__HUB__.apiBase);
+	return {
+		...slug === void 0 ? {} : { slug },
+		...apiBase === void 0 ? {} : { apiBase }
+	};
+}
+/** The game's slug: the injected one, else the first URL path segment, else `null`. */
+function detectSlug() {
+	const injectedSlug = injectedConfig().slug;
+	if (injectedSlug !== void 0 && injectedSlug !== "") return injectedSlug;
+	if (typeof location === "undefined") return null;
+	return location.pathname.split("/").find((segment) => segment !== "") ?? null;
+}
+/** An API base made absolute against the page origin (`http://localhost` outside a browser), without a trailing slash. */
+function absoluteApiBase(apiBase) {
+	const origin = typeof location === "undefined" ? "http://localhost" : location.origin;
+	return new URL(apiBase, origin).toString().replace(/\/$/, "");
+}
+/** The page's API base: the injected one, else `/_api`, made absolute. */
+function detectApiBase() {
+	return absoluteApiBase(injectedConfig().apiBase ?? "/_api");
+}
+/** Dispatch a `CustomEvent` on `window` (no-op outside a browser; listener errors never reach the caller). */
+function emitWindowEvent(eventName, detail) {
+	if (!isBrowserPage()) return;
+	try {
+		window.dispatchEvent(new CustomEvent(eventName, { detail }));
+	} catch {}
+}
+//#endregion
+//#region src/core/rest/routes.gen.ts
+/** Every public REST endpoint's method, path (under `/_api`) and query keys, from the contract. */
+const ROUTES = {
+	ensureGuestSession: {
+		method: "POST",
+		path: "/auth/guest",
+		query: []
+	},
+	signUpWithPassword: {
+		method: "POST",
+		path: "/auth/signup",
+		query: []
+	},
+	logInWithPassword: {
+		method: "POST",
+		path: "/auth/login",
+		query: []
+	},
+	logOut: {
+		method: "POST",
+		path: "/auth/logout",
+		query: []
+	},
+	getCurrentUser: {
+		method: "GET",
+		path: "/me",
+		query: []
+	},
+	claimGuestAccount: {
+		method: "POST",
+		path: "/auth/claim",
+		query: []
+	},
+	listGames: {
+		method: "GET",
+		path: "/games",
+		query: []
+	},
+	listWhatsNewNotes: {
+		method: "GET",
+		path: "/changes",
+		query: ["game", "since"]
+	},
+	listFavoriteGames: {
+		method: "GET",
+		path: "/favorites",
+		query: []
+	},
+	setGameFavorite: {
+		method: "PUT",
+		path: "/favorites/:slug",
+		query: []
+	},
+	markWhatsNewSeen: {
+		method: "POST",
+		path: "/changes/seen",
+		query: []
+	},
+	getGameStats: {
+		method: "GET",
+		path: "/games/:slug/stats",
+		query: ["user"]
+	},
+	getGameProfile: {
+		method: "GET",
+		path: "/games/:slug/profile",
+		query: []
+	},
+	setGameProfile: {
+		method: "PUT",
+		path: "/games/:slug/profile",
+		query: []
+	},
+	listSaves: {
+		method: "GET",
+		path: "/games/:slug/saves",
+		query: []
+	},
+	getSave: {
+		method: "GET",
+		path: "/games/:slug/saves/:slot",
+		query: []
+	},
+	writeSave: {
+		method: "PUT",
+		path: "/games/:slug/saves/:slot",
+		query: []
+	},
+	deleteSave: {
+		method: "DELETE",
+		path: "/games/:slug/saves/:slot",
+		query: []
+	},
+	updateGameStat: {
+		method: "POST",
+		path: "/games/:slug/stats",
+		query: []
+	},
+	resetMyGameProgress: {
+		method: "POST",
+		path: "/games/:slug/reset",
+		query: []
+	},
+	listMyLeaderboardRecords: {
+		method: "GET",
+		path: "/me/records",
+		query: ["game"]
+	},
+	getMyOfflineSnapshot: {
+		method: "GET",
+		path: "/me/snapshot",
+		query: ["top"]
+	},
+	listTopOfEveryLeaderboard: {
+		method: "GET",
+		path: "/leaderboards",
+		query: ["top"]
+	},
+	listGameLeaderboards: {
+		method: "GET",
+		path: "/games/:slug/leaderboards",
+		query: []
+	},
+	getLeaderboard: {
+		method: "GET",
+		path: "/games/:slug/leaderboards/:key",
+		query: ["limit"]
+	},
+	submitScore: {
+		method: "POST",
+		path: "/games/:slug/leaderboards/:key/scores",
+		query: []
+	},
+	listDailyChallengesForAllGames: {
+		method: "GET",
+		path: "/daily",
+		query: []
+	},
+	getGameDailyChallenges: {
+		method: "GET",
+		path: "/games/:slug/daily",
+		query: []
+	},
+	startDailyChallenge: {
+		method: "POST",
+		path: "/games/:slug/daily/:day/start",
+		query: []
+	},
+	completeDailyChallenge: {
+		method: "POST",
+		path: "/games/:slug/daily/:day/complete",
+		query: []
+	},
+	getMyInventory: {
+		method: "GET",
+		path: "/games/:slug/inventory",
+		query: []
+	},
+	grantInventoryItems: {
+		method: "POST",
+		path: "/games/:slug/inventory/grant",
+		query: []
+	},
+	exchangeInventoryItems: {
+		method: "POST",
+		path: "/games/:slug/inventory/exchange",
+		query: []
+	},
+	getPlayerInventory: {
+		method: "GET",
+		path: "/games/:slug/players/:userId/inventory",
+		query: []
+	},
+	listTradePartners: {
+		method: "GET",
+		path: "/games/:slug/trades/players",
+		query: []
+	},
+	listMyTrades: {
+		method: "GET",
+		path: "/games/:slug/trades",
+		query: ["box", "status"]
+	},
+	declineTrade: {
+		method: "POST",
+		path: "/games/:slug/trades/:id/decline",
+		query: []
+	},
+	cancelTrade: {
+		method: "POST",
+		path: "/games/:slug/trades/:id/cancel",
+		query: []
+	},
+	createTrade: {
+		method: "POST",
+		path: "/games/:slug/trades",
+		query: []
+	},
+	acceptTrade: {
+		method: "POST",
+		path: "/games/:slug/trades/:id/accept",
+		query: []
+	},
+	counterTradeOffer: {
+		method: "POST",
+		path: "/games/:slug/trades/:id/counter",
+		query: []
+	},
+	getSiteAnalytics: {
+		method: "GET",
+		path: "/analytics",
+		query: []
+	},
+	reportClientError: {
+		method: "POST",
+		path: "/client-log",
+		query: []
+	},
+	recordGameEvent: {
+		method: "POST",
+		path: "/games/:slug/events",
+		query: []
+	},
+	getGameAnalytics: {
+		method: "GET",
+		path: "/games/:slug/analytics",
+		query: []
+	},
+	getSocialConfig: {
+		method: "GET",
+		path: "/social/config",
+		query: []
+	},
+	getOnlineCounts: {
+		method: "GET",
+		path: "/social/counts",
+		query: []
+	},
+	getMySocialProfile: {
+		method: "GET",
+		path: "/social/me",
+		query: []
+	},
+	listFriendsAndRequests: {
+		method: "GET",
+		path: "/social/friends",
+		query: []
+	},
+	findPlayerByName: {
+		method: "GET",
+		path: "/social/players/by-name/:name",
+		query: []
+	},
+	getPlayerCard: {
+		method: "GET",
+		path: "/social/players/:id",
+		query: []
+	},
+	updateMySocialProfile: {
+		method: "PUT",
+		path: "/social/me",
+		query: []
+	},
+	setParentChatLock: {
+		method: "POST",
+		path: "/social/chat-lock",
+		query: []
+	},
+	sendFriendRequest: {
+		method: "POST",
+		path: "/social/friends",
+		query: []
+	},
+	acceptFriendRequest: {
+		method: "POST",
+		path: "/social/friends/:id/accept",
+		query: []
+	},
+	declineFriendRequest: {
+		method: "POST",
+		path: "/social/friends/:id/decline",
+		query: []
+	},
+	removeFriend: {
+		method: "DELETE",
+		path: "/social/friends/:id",
+		query: []
+	},
+	setFriendNotifications: {
+		method: "PUT",
+		path: "/social/friends/:id/notify",
+		query: []
+	},
+	blockPlayer: {
+		method: "POST",
+		path: "/social/blocks",
+		query: []
+	},
+	unblockPlayer: {
+		method: "DELETE",
+		path: "/social/blocks/:id",
+		query: []
+	},
+	listRecentPlayers: {
+		method: "GET",
+		path: "/social/recent",
+		query: []
+	},
+	listConversations: {
+		method: "GET",
+		path: "/social/conversations",
+		query: []
+	},
+	listDirectMessages: {
+		method: "GET",
+		path: "/social/messages/:userId",
+		query: ["before"]
+	},
+	sendDirectMessage: {
+		method: "POST",
+		path: "/social/messages/:userId",
+		query: []
+	},
+	markDirectMessagesRead: {
+		method: "POST",
+		path: "/social/messages/:userId/read",
+		query: []
+	},
+	getNotificationPreferences: {
+		method: "GET",
+		path: "/social/notify",
+		query: []
+	},
+	unsubscribeFromPush: {
+		method: "DELETE",
+		path: "/social/push",
+		query: []
+	},
+	setNotificationPreferences: {
+		method: "PUT",
+		path: "/social/notify",
+		query: []
+	},
+	subscribeToPush: {
+		method: "POST",
+		path: "/social/push",
+		query: []
+	},
+	fileReport: {
+		method: "POST",
+		path: "/social/reports",
+		query: []
+	},
+	listPublicSuggestions: {
+		method: "GET",
+		path: "/suggestions",
+		query: ["sort"]
+	},
+	submitSuggestion: {
+		method: "POST",
+		path: "/suggestions",
+		query: []
+	},
+	voteForSuggestion: {
+		method: "POST",
+		path: "/suggestions/:id/vote",
+		query: []
+	},
+	removeSuggestionVote: {
+		method: "DELETE",
+		path: "/suggestions/:id/vote",
+		query: []
+	},
+	withdrawSuggestion: {
+		method: "DELETE",
+		path: "/suggestions/:id",
+		query: []
+	},
+	sendGameInvite: {
+		method: "POST",
+		path: "/mp/invites",
+		query: []
+	},
+	acceptGameInvite: {
+		method: "POST",
+		path: "/mp/invites/:id/accept",
+		query: []
+	},
+	declineGameInvite: {
+		method: "POST",
+		path: "/mp/invites/:id/decline",
+		query: []
+	},
+	cancelGameInvite: {
+		method: "DELETE",
+		path: "/mp/invites/:id",
+		query: []
+	},
+	redeemLaunchToken: {
+		method: "GET",
+		path: "/mp/launch/:token",
+		query: []
+	},
+	setPartyJoinInfo: {
+		method: "POST",
+		path: "/mp/parties/:id/join-info",
+		query: []
+	},
+	leaveParty: {
+		method: "POST",
+		path: "/mp/parties/:id/leave",
+		query: []
+	},
+	launchIntoFriendsRoom: {
+		method: "POST",
+		path: "/mp/join",
+		query: []
+	},
+	getGameServerTicket: {
+		method: "POST",
+		path: "/mp/ticket",
+		query: []
+	},
+	listMyRaceHistory: {
+		method: "GET",
+		path: "/race/history",
+		query: [
+			"game",
+			"with",
+			"before",
+			"limit"
+		]
+	},
+	getHubVersion: {
+		method: "GET",
+		path: "/version",
+		query: []
+	}
+};
+//#endregion
+//#region src/core/rest/rest-client.ts
+/**
+* The REST transport: a small fetch router over the contract's route table
+* (plan §12 A10). It splits one merged fields object into the path, query
+* and JSON body the way ayepi's client does, stamps `x-hub-client`, and turns
+* failures into {@link HubError}s. It carries no schemas: replies are typed
+* from the contract and trusted, as ayepi's zod-free client trusts them.
+*/
+/** The header that tells the hub which client version is calling. */
+const CLIENT_VERSION_HEADER = "x-hub-client";
+/** What both hubs answer for a route they do not have. */
+const NO_SUCH_ENDPOINT = "No such API endpoint.";
+/** One field value as URL text. */
+function urlText(fieldValue) {
+	if (typeof fieldValue === "string") return fieldValue;
+	if (typeof fieldValue === "number" || typeof fieldValue === "boolean") return String(fieldValue);
+	return JSON.stringify(fieldValue);
+}
+/**
+* Split merged fields into path, query and body for one endpoint: `:name`
+* segments take their field, query keys go to the query string, and the
+* rest is the JSON body. POST and PUT always send a body (`{}` when empty),
+* as the v1 client did; DELETE sends one only when it has fields.
+*/
+function planRequest(name, fields) {
+	const route = ROUTES[name];
+	const remaining = new Map(Object.entries(isRecord(fields) ? fields : {}).filter(([, fieldValue]) => fieldValue !== void 0));
+	const path = route.path.replace(/:([A-Za-z]+)/g, (_segment, paramName) => {
+		const paramValue = remaining.get(paramName);
+		remaining.delete(paramName);
+		return encodeURIComponent(urlText(paramValue));
+	});
+	const queryKeys = route.method === "GET" ? [...remaining.keys()] : route.query;
+	const query = new URLSearchParams();
+	for (const key of queryKeys) {
+		const queryValue = remaining.get(key);
+		remaining.delete(key);
+		if (queryValue !== void 0 && queryValue !== null) query.set(key, urlText(queryValue));
+	}
+	const queryText = query.toString();
+	const hasBody = route.method === "POST" || route.method === "PUT" || route.method === "DELETE" && remaining.size > 0;
+	return {
+		pathAndQuery: queryText === "" ? path : `${path}?${queryText}`,
+		method: route.method,
+		bodyText: hasBody ? JSON.stringify(Object.fromEntries(remaining)) : void 0
+	};
+}
+/**
+* The reply body, typed by the contract. This is the client's one trust
+* boundary on replies: there is no zod in the browser bundle (plan D16).
+*/
+async function readReply(response) {
+	try {
+		return await response.json();
+	} catch {
+		throw new HubError("The hub sent a reply that is not JSON.", response.status);
+	}
+}
+/** The error for a failed response. */
+async function failureOf(name, response) {
+	let fields = readErrorFields(void 0);
+	try {
+		fields = readErrorFields(await response.json());
+	} catch {}
+	if (response.status === 404 && fields.error === NO_SUCH_ENDPOINT) return new HubError(`This hub does not have "${name}" yet: deploy the hub first, or use an older client.`, 404, { code: UNSUPPORTED_BY_HUB });
+	return errorFor(fields.error ?? `Request failed (${response.status})`, response.status, fields);
+}
+/** A REST client for one API base. */
+function createRestClient(options) {
+	async function send(name, fields) {
+		const planned = planRequest(name, fields);
+		let response;
+		try {
+			response = await options.fetch(options.apiBase + planned.pathAndQuery, {
+				method: planned.method,
+				credentials: "same-origin",
+				headers: {
+					"content-type": "application/json",
+					[CLIENT_VERSION_HEADER]: HUB_CLIENT_VERSION
+				},
+				...planned.bodyText === void 0 ? {} : { body: planned.bodyText }
+			});
+		} catch (failure) {
+			throw new HubError(`Hub unreachable: ${failure instanceof Error ? failure.message : String(failure)}`);
+		}
+		options.onReachable?.();
+		if (!response.ok) throw await failureOf(name, response);
+		return readReply(response);
+	}
+	return {
+		apiBase: options.apiBase,
+		call: (name, ...fieldsArgument) => send(name, fieldsArgument[0])
+	};
+}
+//#endregion
+//#region src/core/connection.ts
+/**
+* The machinery under every `Hub` call: reaching the REST API, falling back
+* to the offline cache, queueing writes made offline and replaying them,
+* buffering analytics, warming the cache for every game, and reporting
+* online/offline/sync status (to `onStatus` listeners and as `hub:*` window
+* events, which the injected menu listens for).
+*/
+/** How long `prefetchAll()` waits between snapshots unless forced. */
+const PREFETCH_INTERVAL_MS = 3e4;
+/** Whether a failure means "the hub can't be reached" (rather than a refusal). */
+function isTransportFailure(failure) {
+	return failure instanceof HubError && failure.isOffline;
+}
+/** The connection, offline cache and sync machinery shared by every `Hub` method. */
+var HubConnection = class {
+	/** A connection for `options` (slug and API base default to the page's). */
+	constructor(options = {}) {
+		_defineProperty(this, "slug", void 0);
+		_defineProperty(this, "apiBase", void 0);
+		_defineProperty(this, "rest", void 0);
+		_defineProperty(this, "store", void 0);
+		_defineProperty(this, "offlineMode", void 0);
+		_defineProperty(this, "isReachable", true);
+		_defineProperty(this, "isSyncing", false);
+		_defineProperty(this, "lastPrefetchAt", 0);
+		_defineProperty(this, "statusListeners", /* @__PURE__ */ new Set());
+		this.slug = options.slug ?? detectSlug();
+		this.apiBase = options.apiBase === void 0 ? detectApiBase() : absoluteApiBase(options.apiBase);
+		this.offlineMode = options.offline ?? "auto";
+		this.rest = createRestClient({
+			apiBase: this.apiBase,
+			fetch: options.fetch ?? globalThis.fetch.bind(globalThis),
+			onReachable: () => {
+				this.setReachable(true);
+			}
+		});
+		this.store = new LocalStore(this.slug ?? "app");
+		if (typeof navigator !== "undefined" && "onLine" in navigator) this.isReachable = navigator.onLine;
+		if (isBrowserPage()) {
+			window.addEventListener("online", () => {
+				this.setReachable(true);
+			});
+			window.addEventListener("offline", () => {
+				this.setReachable(false);
+			});
+		}
+	}
+	/** `true` when calls are being served from the offline cache rather than the hub. */
+	get isOffline() {
+		return this.offlineMode === "always" || this.offlineMode === "auto" && !this.isReachable;
+	}
+	/** `true` while the hub is reachable. */
+	get isOnline() {
+		return this.isReachable;
+	}
+	/** Queued writes plus buffered analytics events waiting to sync. */
+	pending() {
+		return this.store.queueLength() + this.store.getEvents().length;
+	}
+	/** Subscribe to connection and sync status changes; returns the unsubscribe function. */
+	onStatus(listener) {
+		this.statusListeners.add(listener);
+		return () => {
+			this.statusListeners.delete(listener);
+		};
+	}
+	/** Tell `onStatus` listeners and the page (`hub:status`) the current status. */
+	notifyStatus() {
+		const status = {
+			online: this.isReachable,
+			offline: this.isOffline,
+			pending: this.pending()
+		};
+		for (const listener of this.statusListeners) try {
+			listener(status);
+		} catch {}
+		emitWindowEvent("hub:status", status);
+	}
+	/** Record reachability; coming back online syncs the queue and re-warms the cache. */
+	setReachable(isReachableNow) {
+		if (isReachableNow === this.isReachable) return;
+		this.isReachable = isReachableNow;
+		emitWindowEvent(isReachableNow ? "hub:online" : "hub:offline", { pending: this.pending() });
+		this.notifyStatus();
+		if (isReachableNow) {
+			this.sync();
+			this.prefetchAll().catch(() => void 0);
+		}
+	}
+	/** `{ slug }` for this game's endpoints; throws when the slug is unknown. */
+	gameFields() {
+		if (this.slug === null) throw new HubError("Hub: could not determine the game slug.");
+		return { slug: this.slug };
+	}
+	/**
+	* Run the network call, falling back to the offline answer when the hub
+	* can't be reached (per the offline mode). Real API errors (with an HTTP
+	* status) always reach the caller.
+	*/
+	async withFallback(networkCall, offlineAnswer) {
+		if (this.isOffline) return offlineAnswer();
+		try {
+			return await networkCall();
+		} catch (failure) {
+			if (!isTransportFailure(failure) || this.offlineMode === "never") throw failure;
+			this.setReachable(false);
+			return offlineAnswer();
+		}
+	}
+	/** Send one queued write. */
+	async sendOp(op) {
+		const game = this.gameFields();
+		switch (op.kind) {
+			case "putSave":
+				await this.rest.call("writeSave", {
+					...game,
+					slot: op.slot,
+					data: op.data,
+					label: op.label
+				});
+				return;
+			case "deleteSave":
+				await this.rest.call("deleteSave", {
+					...game,
+					slot: op.slot
+				});
+				return;
+			case "setStat":
+				await this.rest.call("updateGameStat", {
+					...game,
+					key: op.key,
+					value: op.value,
+					mode: "set"
+				});
+				return;
+			case "maxStat":
+				await this.rest.call("updateGameStat", {
+					...game,
+					key: op.key,
+					value: op.value,
+					mode: "max"
+				});
+				return;
+			case "incrStat":
+				await this.rest.call("updateGameStat", {
+					...game,
+					key: op.key,
+					value: op.amount,
+					mode: "incr"
+				});
+				return;
+			case "submitScore":
+				await this.rest.call("submitScore", {
+					...game,
+					key: op.key,
+					score: op.score,
+					...op.opts
+				});
+				return;
+			case "setProfile":
+				await this.rest.call("setGameProfile", {
+					...game,
+					...op.patch
+				});
+				return;
+		}
+	}
+	/**
+	* Apply a write to the offline cache at once, then send it now (online
+	* with an empty queue) or queue it behind the others. Resolves with the
+	* local answer; a real API error on the direct path reaches the caller and
+	* is not queued.
+	*/
+	async mutateQueued(input, localAnswer) {
+		const answer = localAnswer();
+		if (this.isOffline || this.store.queueLength() > 0) {
+			this.store.enqueue(input);
+			this.notifyStatus();
+			if (!this.isOffline) this.sync();
+			return answer;
+		}
+		try {
+			await this.sendOp(input);
+			return answer;
+		} catch (failure) {
+			if (!isTransportFailure(failure)) throw failure;
+			this.setReachable(false);
+			this.store.enqueue(input);
+			this.notifyStatus();
+			return answer;
+		}
+	}
+	/**
+	* Replay the queue, then the buffered events, in order. Stops at the first
+	* transport failure (offline again: the rest stays queued); a write the hub
+	* refuses is dropped and reported as a conflict.
+	*/
+	async sync() {
+		if (this.isSyncing || this.isOffline || this.slug === null) return {
+			flushed: 0,
+			conflicts: []
+		};
+		this.isSyncing = true;
+		let flushed = 0;
+		const conflicts = [];
+		try {
+			let queue = this.store.getQueue();
+			for (let op = queue[0]; op !== void 0; op = queue[0]) {
+				try {
+					await this.sendOp(op);
+					flushed += 1;
+				} catch (failure) {
+					if (isTransportFailure(failure)) break;
+					conflicts.push({
+						op,
+						error: failure instanceof Error ? failure.message : String(failure)
+					});
+				}
+				queue = queue.slice(1);
+				this.store.setQueue(queue);
+			}
+			await this.flushEvents();
+		} finally {
+			this.isSyncing = false;
+		}
+		emitWindowEvent("hub:sync", {
+			pending: this.pending(),
+			flushed,
+			conflicts
+		});
+		this.notifyStatus();
+		return {
+			flushed,
+			conflicts
+		};
+	}
+	/** Send the buffered analytics events; a refused one is dropped (telemetry never blocks). */
+	async flushEvents() {
+		let events = this.store.getEvents();
+		for (let event = events[0]; event !== void 0; event = events[0]) {
+			try {
+				await this.rest.call("recordGameEvent", {
+					...this.gameFields(),
+					type: event.type
+				});
+			} catch (failure) {
+				if (isTransportFailure(failure)) return;
+			}
+			events = events.slice(1);
+			this.store.setEvents(events);
+		}
+	}
+	/**
+	* Warm the offline cache for every game the player has touched, in one
+	* request, so going offline later still shows complete progress.
+	* Throttled to once per 30 s unless `isForced`; `null` when offline or throttled.
+	*/
+	async prefetchAll(isForced = false) {
+		if (this.isOffline || !isForced && Date.now() - this.lastPrefetchAt < PREFETCH_INTERVAL_MS) return null;
+		let snapshot;
+		try {
+			snapshot = await this.rest.call("getMyOfflineSnapshot");
+		} catch (failure) {
+			if (isTransportFailure(failure)) return null;
+			throw failure;
+		}
+		this.lastPrefetchAt = Date.now();
+		this.store.hydrate(snapshot);
+		emitWindowEvent("hub:prefetch", { games: Object.keys(snapshot.games).length });
+		return snapshot;
+	}
+};
+//#endregion
+//#region src/core/game-data.ts
+/** Always true: a game's payload is sent as JSON (`JSON.stringify` drops what JSON can't hold). */
+function isSentAsJson(_payload) {
+	return true;
+}
+/** Always true: JSON the game stored is read back as the game's type. */
+function isGameOwnData(_stored) {
+	return true;
+}
+/** A game's payload as the JSON the hub stores. */
+function toStoredJson(payload) {
+	if (isSentAsJson(payload)) return payload;
+	throw new TypeError("unreachable: every payload is sent as JSON");
+}
+/** JSON the game stored, typed as the game's own type. */
+function toGameData(stored) {
+	if (isGameOwnData(stored)) return stored;
+	throw new TypeError("unreachable: stored game data is the game's own");
+}
+//#endregion
+//#region src/core/hub-progress.ts
+/** A profile with the game's own data typed as `TData`. */
+function typedProfile(profile) {
+	return profile === null ? null : {
+		...profile,
+		data: toGameData(profile.data)
+	};
+}
+/** A save with the game's own data typed as `TData`. */
+function typedSave(save) {
+	return save === null ? null : {
+		...save,
+		data: toGameData(save.data)
+	};
+}
+/** Accounts, profile, saves, stats and leaderboards. */
+var HubProgress = class extends HubConnection {
+	/** The current user (or `null`) and the games they have a profile in. */
+	me() {
+		return this.withFallback(() => this.rest.call("getCurrentUser"), () => {
+			const profile = this.store.getProfile();
+			return {
+				user: this.store.getUser(),
+				profiles: profile === null ? [] : [{
+					game: profile.game,
+					displayName: profile.displayName
+				}]
+			};
+		});
+	}
+	/**
+	* Make sure a session exists, creating a guest (a random name, no
+	* password) when the player isn't signed in, so progress saves without a
+	* sign-in. Idempotent. Offline, a local guest is used.
+	*/
+	ensureGuest() {
+		return this.withFallback(() => this.rest.call("ensureGuestSession"), () => {
+			const known = this.store.getUser();
+			if (known !== null) return { user: known };
+			const guest = {
+				id: 0,
+				username: "Guest-local",
+				guest: true
+			};
+			this.store.setUser(guest);
+			return { user: guest };
+		});
+	}
+	/**
+	* Turn the current guest into a registered account (the same identity, so
+	* all progress carries over). Rejects with 409 when already registered or
+	* the name is taken; the player should `login` instead.
+	*/
+	claim(username, password) {
+		return this.withFallback(() => this.rest.call("claimGuestAccount", {
+			username,
+			password
+		}), () => this.signInLocally({
+			id: 0,
+			username,
+			guest: false
+		}));
+	}
+	/** Create an account and sign in. (Offline: a local user is stored.) */
+	signup(username, password) {
+		return this.withFallback(() => this.rest.call("signUpWithPassword", {
+			username,
+			password
+		}), () => this.signInLocally({
+			id: 0,
+			username
+		}));
+	}
+	/** Sign in. (Offline: a local user is stored so signed-in flows work.) */
+	login(username, password) {
+		return this.withFallback(() => this.rest.call("logInWithPassword", {
+			username,
+			password
+		}), () => this.signInLocally({
+			id: 0,
+			username
+		}));
+	}
+	/** Sign out (ends the session shared by every game). */
+	logout() {
+		return this.withFallback(() => this.rest.call("logOut"), () => {
+			this.store.clearUser();
+			return { ok: true };
+		});
+	}
+	signInLocally(user) {
+		this.store.setUser(user);
+		return { user };
+	}
+	/** This game's profile for the current user, or `profile: null`. `TData` is the game's own data type. */
+	getProfile() {
+		return this.withFallback(async () => ({ profile: typedProfile((await this.rest.call("getGameProfile", this.gameFields())).profile) }), () => ({ profile: typedProfile(this.store.getProfile()) }));
+	}
+	/** Create or update this game's profile for the current user. */
+	setProfile(patch) {
+		const queued = {};
+		if (patch.displayName !== void 0) queued.displayName = patch.displayName;
+		if (patch.data !== void 0) queued.data = toStoredJson(patch.data);
+		return this.mutateQueued({
+			kind: "setProfile",
+			patch: queued
+		}, () => {
+			const stored = this.store.setProfile(this.slug ?? "app", patch.displayName ?? null, queued.data ?? {});
+			return { profile: {
+				...stored,
+				data: toGameData(stored.data)
+			} };
+		});
+	}
+	/** Metadata for every save slot (no payloads), newest first. */
+	listSaves() {
+		return this.withFallback(() => this.rest.call("listSaves", this.gameFields()), () => ({ saves: this.store.listSaves() }));
+	}
+	/** One slot's contents, or `save: null` when the slot is empty. `TData` is the game's own save type. */
+	getSave(slot) {
+		return this.withFallback(async () => ({ save: typedSave((await this.rest.call("getSave", {
+			...this.gameFields(),
+			slot
+		})).save) }), () => ({ save: typedSave(this.store.getSave(slot)) }));
+	}
+	/** Create or overwrite a save slot. `saveData` is any JSON up to 64 KB. */
+	putSave(slot, saveData, label) {
+		const stored = toStoredJson(saveData);
+		return this.mutateQueued({
+			kind: "putSave",
+			slot,
+			data: stored,
+			label: label ?? null
+		}, () => ({
+			ok: true,
+			updatedAt: this.store.putSave(slot, stored, label ?? null)
+		}));
+	}
+	/** Delete a save slot. */
+	deleteSave(slot) {
+		return this.mutateQueued({
+			kind: "deleteSave",
+			slot
+		}, () => {
+			this.store.deleteSave(slot);
+			return { ok: true };
+		});
+	}
+	/** Numeric stats for the current user, or another player's via `userId`. */
+	getStats(userId) {
+		return this.withFallback(() => this.rest.call("getGameStats", {
+			...this.gameFields(),
+			...userId === void 0 ? {} : { user: userId }
+		}), () => ({ stats: this.store.getStats() }));
+	}
+	/** Overwrite a stat. */
+	setStat(key, value) {
+		return this.mutateQueued({
+			kind: "setStat",
+			key,
+			value
+		}, () => ({
+			key,
+			value: this.store.updateStat(key, value, "set")
+		}));
+	}
+	/** Add to a stat (creating it at `amount` when absent). */
+	incrStat(key, amount = 1) {
+		return this.mutateQueued({
+			kind: "incrStat",
+			key,
+			amount
+		}, () => ({
+			key,
+			value: this.store.updateStat(key, amount, "incr")
+		}));
+	}
+	/** Keep the larger of the stored and the given value. */
+	maxStat(key, value) {
+		return this.mutateQueued({
+			kind: "maxStat",
+			key,
+			value
+		}, () => ({
+			key,
+			value: this.store.updateStat(key, value, "max")
+		}));
+	}
+	/** Submit a score. The board is created on first use; only a player's best score sticks. */
+	submitScore(boardKey, score, opts = {}) {
+		const queued = {
+			...opts.title === void 0 ? {} : { title: opts.title },
+			...opts.sort === void 0 ? {} : { sort: opts.sort },
+			...opts.meta === void 0 ? {} : { meta: toStoredJson(opts.meta) }
+		};
+		return this.mutateQueued({
+			kind: "submitScore",
+			key: boardKey,
+			score,
+			opts: queued
+		}, () => ({
+			...this.store.submitScore(boardKey, score, queued),
+			rank: 1
+		}));
+	}
+	/** One board's ranked entries (top `limit`, default 50). Offline: only the player's own best. */
+	getLeaderboard(boardKey, limit = 50) {
+		return this.withFallback(() => this.rest.call("getLeaderboard", {
+			...this.gameFields(),
+			key: boardKey,
+			limit
+		}), () => {
+			const local = this.store.getBoard(boardKey);
+			if (local === null) return {
+				board: {
+					key: boardKey,
+					title: boardKey,
+					sortDir: "desc"
+				},
+				entries: []
+			};
+			const user = this.store.getUser();
+			return {
+				board: local.board,
+				entries: [{
+					rank: 1,
+					userId: user?.id ?? 0,
+					username: user?.username ?? "you",
+					score: local.best,
+					meta: null
+				}]
+			};
+		});
+	}
+	/** The boards this game owns (keys and titles, no entries). */
+	listLeaderboards() {
+		return this.withFallback(() => this.rest.call("listGameLeaderboards", this.gameFields()), () => ({ boards: this.store.listBoards() }));
+	}
+};
+//#endregion
+//#region src/core/offline/favorites.ts
+/**
+* Starred games are site-wide, not per game, so they live under one global
+* key (`hub:favorites`, the v1 client's) rather than in a game's cache. The
+* list mirrors the hub's so the menu still shows it offline.
+*/
+/** The key of the mirrored favorites list. */
+const FAVORITES_KEY = "hub:favorites";
+/** The mirrored favorite slugs (empty when none or unreadable). */
+function readLocalFavorites() {
+	const text = createPageStore().read(FAVORITES_KEY);
+	return text === null ? [] : stringsIn(parseJsonText(text));
+}
+/** Mirror the hub's favorites list. */
+function writeLocalFavorites(games) {
+	createPageStore().write(FAVORITES_KEY, JSON.stringify(games));
+}
+//#endregion
+//#region src/core/hub-economy.ts
+/**
+* Analytics, the catalog, favorites, records, inventory and trades. Analytics
+* calls are fire-and-forget and never throw (telemetry must not break a game);
+* offline they are buffered and sent when the hub is back. Method names are
+* the v1 client's, unchanged.
+*/
+/** Analytics, catalog, favorites, records, inventory and trades. */
+var HubEconomy = class extends HubProgress {
+	/** Record a "play". Call once when the game starts. */
+	recordPlay() {
+		return this.event("play");
+	}
+	/** Record a "heartbeat". Call periodically while the game is active. */
+	heartbeat() {
+		return this.event("heartbeat");
+	}
+	/** Record a custom event. Never throws; offline, events are buffered and sent on reconnect. */
+	async event(type) {
+		if (this.slug === null) return;
+		if (this.isOffline) {
+			this.store.bufferEvent(type);
+			this.notifyStatus();
+			return;
+		}
+		try {
+			await this.rest.call("recordGameEvent", {
+				...this.gameFields(),
+				type
+			});
+		} catch (failure) {
+			if (failure instanceof HubError && failure.isOffline) {
+				this.setReachable(false);
+				this.store.bufferEvent(type);
+			}
+		}
+	}
+	/** This game's play counts. */
+	analytics() {
+		return this.withFallback(() => this.rest.call("getGameAnalytics", this.gameFields()), () => ({
+			slug: this.slug ?? "app",
+			totalPlays: 0,
+			uniquePlayers: 0,
+			activeNow: 0
+		}));
+	}
+	/** Catalog-wide play counts with a per-game breakdown. */
+	globalAnalytics() {
+		return this.withFallback(() => this.rest.call("getSiteAnalytics"), () => ({
+			global: {
+				totalPlays: 0,
+				uniquePlayers: 0,
+				activeNow: 0
+			},
+			games: []
+		}));
+	}
+	/** The listed games, for "jump to another game" navigation. */
+	listGames() {
+		return this.withFallback(() => this.rest.call("listGames"), () => ({ games: [] }));
+	}
+	/** Every board of every game, each with its top `top` entries (default 5). */
+	allLeaderboards(top = 5) {
+		return this.withFallback(() => this.rest.call("listTopOfEveryLeaderboard", { top }), () => ({ games: [] }));
+	}
+	/**
+	* The starred games (slugs), shown first in the menu's game list. Kept per
+	* account by the hub and mirrored to `localStorage`, so it shows offline.
+	*/
+	favorites() {
+		return this.withFallback(async () => {
+			const reply = await this.rest.call("listFavoriteGames");
+			writeLocalFavorites(reply.games);
+			return reply;
+		}, () => ({ games: readLocalFavorites() }));
+	}
+	/** Star (`isOn = true`) or unstar a game. Needs a connection. */
+	async setFavorite(slug, isOn) {
+		const reply = await this.rest.call("setGameFavorite", {
+			slug,
+			on: isOn
+		});
+		writeLocalFavorites(reply.games);
+		return reply;
+	}
+	/** The player's leaderboard standings, grouped by game (every game, or one via `forSlug`). Empty offline or signed out. */
+	myRecords(forSlug) {
+		return this.withFallback(() => this.rest.call("listMyLeaderboardRecords", forSlug === void 0 || forSlug === "" ? {} : { game: forSlug }), () => ({ games: [] }));
+	}
+	/** This game's inventory and coin balance for the current user. */
+	getInventory() {
+		return this.withFallback(() => this.rest.call("getMyInventory", this.gameFields()), () => ({
+			items: [],
+			coins: 0
+		}));
+	}
+	/** Another player's available holdings (to compose a trade). */
+	playerInventory(userId) {
+		return this.withFallback(() => this.rest.call("getPlayerInventory", {
+			...this.gameFields(),
+			userId
+		}), () => ({
+			items: [],
+			coins: 0
+		}));
+	}
+	/** Add goods to the player (gameplay rewards); answers the new holdings. */
+	grant(bundle) {
+		return this.rest.call("grantInventoryItems", {
+			...this.gameFields(),
+			...bundle
+		});
+	}
+	/** An atomic swap with the house: remove `take`, add `give`. */
+	exchange(take, give) {
+		return this.rest.call("exchangeInventoryItems", {
+			...this.gameFields(),
+			...take === void 0 ? {} : { take },
+			...give === void 0 ? {} : { give }
+		});
+	}
+	/** Sell items to the house for coins. */
+	sell(items, coins) {
+		return this.exchange({ items }, { coins });
+	}
+	/** Buy items from the house with coins. */
+	buy(coins, items) {
+		return this.exchange({ coins }, { items });
+	}
+	/** Wipe the player's progress in this game (saves, stats, inventory and coins). */
+	resetGame() {
+		return this.rest.call("resetMyGameProgress", this.gameFields());
+	}
+	/** Players this player can trade with in this game. */
+	listPlayers() {
+		return this.withFallback(() => this.rest.call("listTradePartners", this.gameFields()), () => ({ players: [] }));
+	}
+	/** The player's trades (`box`: `incoming` or `outgoing`; `status` filters). */
+	listTrades(opts = {}) {
+		return this.withFallback(() => this.rest.call("listMyTrades", {
+			...this.gameFields(),
+			...opts
+		}), () => ({ offers: [] }));
+	}
+	/** Offer a trade to another player (by id or name). */
+	createTrade(toUser, give, want, opts = {}) {
+		return this.rest.call("createTrade", {
+			...this.gameFields(),
+			toUser: String(toUser),
+			...give === void 0 ? {} : { give },
+			...want === void 0 ? {} : { want },
+			...opts
+		});
+	}
+	/** Accept a trade offered to the player. */
+	acceptTrade(id) {
+		return this.rest.call("acceptTrade", {
+			...this.gameFields(),
+			id: Number(id)
+		});
+	}
+	/** Decline a trade offered to the player. */
+	declineTrade(id) {
+		return this.rest.call("declineTrade", {
+			...this.gameFields(),
+			id: Number(id)
+		});
+	}
+	/** Cancel a trade the player offered. */
+	cancelTrade(id) {
+		return this.rest.call("cancelTrade", {
+			...this.gameFields(),
+			id: Number(id)
+		});
+	}
+	/** Answer a trade with a counter-offer. */
+	counterTrade(id, give, want, opts = {}) {
+		return this.rest.call("counterTradeOffer", {
+			...this.gameFields(),
+			id: Number(id),
+			...give === void 0 ? {} : { give },
+			...want === void 0 ? {} : { want },
+			...opts
+		});
+	}
+};
+//#endregion
+//#region src/core/menu-control.ts
+/**
+* `hub.menu`: show or hide the injected hub menu button. The menu
+* (`/_hub/menu.js`) may load before or after the game, and the game may
+* bundle its own client copy, so the shared state is a window global and a
+* window event rather than an object:
+*
+* - `window.__HUB_MENU_VISIBLE__` (boolean; absent means visible);
+* - `hub:menu-visibility` (`CustomEvent`, detail `{ visible }`).
+*
+* The menu reads the global on boot and listens for the event.
+*/
+/** The page's menu control (one per page; every client copy shares the window state). */
+const hubMenu = {
+	setVisible(isVisible) {
+		if (!isBrowserPage()) return;
+		const wasVisible = window.__HUB_MENU_VISIBLE__;
+		if (wasVisible === isVisible || wasVisible === void 0 && isVisible) return;
+		window.__HUB_MENU_VISIBLE__ = isVisible;
+		emitWindowEvent("hub:menu-visibility", { visible: isVisible });
+	},
+	show() {
+		hubMenu.setVisible(true);
+	},
+	hide() {
+		hubMenu.setVisible(false);
+	},
+	get visible() {
+		return !isBrowserPage() || window.__HUB_MENU_VISIBLE__ !== false;
+	}
+};
+//#endregion
+//#region src/core/ticket.ts
+/**
+* The own-server ticket request (`hub.mp.ticket()`): a 60-second identity
+* ticket for this game's own server, fetched straight from the hub. It must
+* not depend on the social runtime: on the first visit after a deploy the
+* service worker can still serve an older menu that never loads it. When the
+* page has no session yet, a guest one is created and the request retried
+* once.
+*/
+/** A REST client for the page's API base that uses the global fetch at call time. */
+function pageRestClient() {
+	return createRestClient({
+		apiBase: detectApiBase(),
+		fetch: (input, init) => globalThis.fetch(input, init)
+	});
+}
+/** One ticket request; a transport failure is an {@link OfflineError}. */
+async function requestTicket(rest, slug) {
+	try {
+		return (await rest.call("getGameServerTicket", { slug })).ticket;
+	} catch (failure) {
+		throw failure instanceof HubError && failure.isOffline ? new OfflineError() : failure;
+	}
+}
+/** A ticket for this page's game; signs in a guest first when the page has no session. */
+async function fetchGameServerTicket() {
+	const slug = detectSlug();
+	if (slug === null) throw new HubError("Hub: could not determine the game slug.");
+	const rest = pageRestClient();
+	try {
+		return await requestTicket(rest, slug);
+	} catch (failure) {
+		if (!(failure instanceof HubError) || failure.status !== 401) throw failure;
+		await rest.call("ensureGuestSession");
+		return requestTicket(rest, slug);
+	}
+}
+//#endregion
+//#region src/core/version/semver.ts
+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. */
+function parseVersion(text) {
+	const match = VERSION_PATTERN.exec(text.trim());
+	if (match === null) return;
+	const [, major = "0", minor = "0", patch = "0", prerelease] = match;
+	return {
+		release: [
+			Number(major),
+			Number(minor),
+			Number(patch)
+		],
+		prerelease: prerelease === void 0 ? [] : prerelease.split(".")
+	};
+}
+/** Compare two prerelease identifiers: numbers by value and before words, words as text. */
+function compareIdentifiers(first, second) {
+	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. */
+function compareVersions(first, second) {
+	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 === void 0 || secondIdentifier === void 0) return firstIdentifier === void 0 ? -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, comparator) {
+	const match = COMPARATOR_PATTERN.exec(comparator);
+	const bound = match?.[2] === void 0 ? void 0 : parseVersion(match[2]);
+	if (match === null || bound === void 0) 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. */
+function satisfiesRange(versionText, range) {
+	const version = parseVersion(versionText);
+	if (version === void 0) 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));
+	});
+}
+//#endregion
+//#region src/core/version/hub-version.ts
+/** How `version` fares against a hub's answer (`null`: a hub from before versioning). */
+function clientSupport(hubVersion, version = HUB_CLIENT_VERSION) {
+	if (hubVersion === null) return "unknown";
+	if (!satisfiesRange(version, hubVersion.supported)) return "unsupported";
+	return satisfiesRange(version, hubVersion.deprecated) ? "deprecated" : "supported";
+}
+const versionsByApiBase = /* @__PURE__ */ new Map();
+/**
+* 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.
+*/
+function readHubVersion(rest) {
+	const cached = versionsByApiBase.get(rest.apiBase);
+	if (cached !== void 0) 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) {
+	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;
+	}
+}
+//#endregion
+//#region src/core/hub.ts
+/** The hub client. Use the ready-made {@link hub}, or `createHub()` for another slug or API base. */
+var Hub = class extends HubEconomy {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "clientVersion", HUB_CLIENT_VERSION);
+	}
+	/**
+	* The hub's version and the client versions it supports (`GET /_api/version`),
+	* read once per page. `null` for a hub from before versioning.
+	*/
+	hubVersion() {
+		return readHubVersion(this.rest);
+	}
+	/** How the hub regards this client: `supported`, `deprecated`, `unsupported`, or `unknown` (an older hub). */
+	async clientSupport() {
+		return clientSupport(await this.hubVersion());
+	}
+	/**
+	* The input system (keyboard, touch and gamepad): `hub.input.define({ ... })`,
+	* `hub.input.value('jump')`. Page-wide; remaps are saved locally and to the
+	* reserved `__controls` save slot.
+	*/
+	get input() {
+		return getInput({
+			slug: this.slug,
+			saveToCloud: (overrides) => {
+				this.putSave("__controls", overrides).catch(() => void 0);
+			}
+		});
+	}
+	/** Hub UI covering the game (menu, dialogs, chat): open/close events and `autoPause`. Page-wide. */
+	get overlay() {
+		return getUiStack();
+	}
+	/** Show or hide the injected hub menu button (page-wide). */
+	get menu() {
+		return hubMenu;
+	}
+	/**
+	* Daily challenges: call `hub.daily.define({ play })` once at load and
+	* `hub.daily.complete({ ... })` on finish. Page-wide, shared with the
+	* injected menu, which can start a clicked day on the same instance.
+	*/
+	get daily() {
+		return getDaily(this.dailyHost());
+	}
+	/** Tell friends what the player is doing in this game. */
+	get presence() {
+		return presenceForwarder;
+	}
+	/** Friends, players and the hub's social dialogs. */
+	get social() {
+		return socialForwarder;
+	}
+	/** Invites, launches, the leave guard and own-server tickets. */
+	get mp() {
+		return multiplayerForwarder;
+	}
+	/** Hub relay rooms, for games without a server. */
+	get rooms() {
+		return roomsForwarder;
+	}
+	/** Toast behaviour during intense play. */
+	get notify() {
+		return notifyForwarder;
+	}
+	/** Races: a single-player game becomes multiplayer by racing. */
+	get race() {
+		return raceForwarder;
+	}
+	/** What the daily system needs from this client: its REST calls and window events. */
+	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.rest.call("completeDailyChallenge", {
+				...this.gameFields(),
+				day,
+				token,
+				meta
+			}),
+			emit: (eventName, detail) => {
+				emitWindowEvent(eventName, detail);
+			}
+		};
+	}
+};
+linkRealtimeToHub({
+	toHubError,
+	createOfflineError: (message) => new OfflineError(message),
+	getGameServerTicket: fetchGameServerTicket
+});
+/** A ready-to-use client, with the slug and API base detected from the page. */
+const hub = new Hub();
+/** Create a client for another slug or API base, or with other offline behaviour. */
+function createHub(options = {}) {
+	return new Hub(options);
+}
+//#endregion
+export { ContentRejectedError as a, UNSUPPORTED_BY_HUB as c, CLIENT_VERSION_HEADER as i, createHub as n, HubError as o, hub as r, OfflineError as s, Hub as t };
+
+//# sourceMappingURL=src.js.map