@diffenderfer-games/hub 2.0.0-next.1 → 2.0.0-next.3

package/dist/shared/src.js

@@ -3,7 +3,7 @@ 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 { f 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";
@@ -48,6 +48,10 @@ function parseJsonText(text) {
 		return;
 	}
 }
+/** Whether `candidate` is a JSON object (not an array or `null`). */
+function isJsonObject(candidate) {
+	return isRecord(candidate) && Object.values(candidate).every(isJson);
+}
 //#endregion
 //#region src/core/errors.ts
 /**
@@ -177,37 +181,212 @@ 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
-		}];
-	});
+//#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));
 }
-/** 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;
+/** Mirror the hub's favorites list. */
+function writeLocalFavorites(games) {
+	createPageStore().write(FAVORITES_KEY, JSON.stringify(games));
+}
+//#endregion
+//#region src/core/game-data.ts
+/** 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: a copy of exactly what
+* `JSON.stringify` sends, so an optional field left `undefined` is simply
+* absent (as on the wire) and the outbox's payload checks accept it, and a
+* later change to the game's object can't alter a queued write.
+*/
+function toStoredJson(payload) {
+	const stored = parseJsonText(JSON.stringify(payload));
+	if (isJson(stored)) return stored;
+	throw new TypeError("This value cannot be stored 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/offline/kind-adapters.ts
+/** A kind whose payloads are checked by `read` (the hub's own kinds). */
+function checkedKind(read, definition) {
+	const readOrThrow = (stored) => {
+		const payload = read(stored);
+		if (payload === void 0) throw new Error("Malformed offline operation payload.");
+		return payload;
+	};
+	const { mergeKey, merge } = definition;
+	return {
+		run: (stored, context) => definition.run(readOrThrow(stored), context),
+		accepts: (stored) => read(stored) !== void 0,
+		...mergeKey === void 0 ? {} : { mergeKey: (stored) => mergeKey(readOrThrow(stored)) },
+		...merge === void 0 ? {} : { merge: (waiting, incoming) => merge(readOrThrow(waiting), readOrThrow(incoming)) },
+		replaces: definition.replaces === true
+	};
+}
+/** A game's kind: a bare handler or a full definition, its payload typed by the game. */
+function gameKind(definition) {
+	const full = typeof definition === "function" ? { run: definition } : definition;
+	const { mergeKey, merge } = full;
+	return {
+		run: (stored, context) => full.run(toGameData(stored), context),
+		accepts: () => true,
+		...mergeKey === void 0 ? {} : { mergeKey: (stored) => mergeKey(toGameData(stored)) },
+		...merge === void 0 ? {} : { merge: (waiting, incoming) => {
+			const merged = merge(toGameData(waiting), toGameData(incoming));
+			return merged === void 0 ? void 0 : toStoredJson(merged);
+		} },
+		replaces: full.replaces === true
+	};
+}
+//#endregion
+//#region src/core/offline/hub-kinds/daily-kind.ts
+/** The kind name. */
+const DAILY_KIND = "hub.daily";
+function readDaily(stored) {
+	if (!isRecord(stored) || !isJsonObject(stored.meta)) return;
+	const day = optionalString(stored.day);
+	const token = optionalString(stored.token);
+	return day === void 0 || token === void 0 ? void 0 : {
+		day,
+		token,
+		meta: stored.meta
+	};
+}
+/** A completion reply read back, or `undefined` when it doesn't read as one. */
+function readDailyCompletion(result) {
+	if (!isRecord(result) || result.ok !== true) return;
+	const day = optionalString(result.day);
+	const count = optionalNumber(result.count);
+	const rank = result.rank === null ? null : optionalNumber(result.rank);
+	return day === void 0 || count === void 0 || rank === void 0 ? void 0 : {
+		ok: true,
+		day,
+		count,
+		rank
+	};
+}
+/** The daily kind, by name; `onCompleted` hears each completion that lands from the queue. */
+function dailyKinds(game, onCompleted) {
+	return { [DAILY_KIND]: checkedKind(readDaily, { run: async ({ day, token, meta }, context) => {
+		let completion;
+		try {
+			completion = await context.call("completeDailyChallenge", {
+				...game(),
+				day,
+				token,
+				meta
+			});
+		} catch (failure) {
+			if (!(failure instanceof HubError) || failure.status !== 401) throw failure;
+			const started = await context.call("startDailyChallenge", {
+				...game(),
+				day
+			});
+			completion = await context.call("completeDailyChallenge", {
+				...game(),
+				day,
+				token: started.token,
+				meta
+			});
 		}
-		return true;
-	});
-	return buffered.length > 100 ? buffered.slice(buffered.length - 100) : buffered;
+		if (context.isReplay) onCompleted({
+			day,
+			token,
+			meta
+		}, completion);
+		return completion;
+	} }) };
+}
+//#endregion
+//#region src/core/offline/hub-kinds/economy-kinds.ts
+/** The kind names. */
+const ECONOMY_KINDS = {
+	grant: "hub.grant",
+	exchange: "hub.exchange",
+	favorite: "hub.favorite"
+};
+/** Goods read back, or `undefined` when malformed. */
+function readGoods(stored) {
+	if (!isRecord(stored)) return;
+	const coins = stored.coins === void 0 ? void 0 : optionalNumber(stored.coins);
+	if (stored.coins !== void 0 && coins === void 0) return;
+	const items = {};
+	if (stored.items !== void 0) {
+		if (!isRecord(stored.items)) return;
+		for (const [key, qty] of Object.entries(stored.items)) {
+			const count = optionalNumber(qty);
+			if (count === void 0) return;
+			items[key] = count;
+		}
+	}
+	return {
+		...stored.items === void 0 ? {} : { items },
+		...coins === void 0 ? {} : { coins }
+	};
+}
+function readExchange(stored) {
+	if (!isRecord(stored)) return;
+	const take = stored.take === void 0 ? void 0 : readGoods(stored.take);
+	const give = stored.give === void 0 ? void 0 : readGoods(stored.give);
+	if (stored.take !== void 0 && take === void 0 || stored.give !== void 0 && give === void 0) return;
+	return {
+		...take === void 0 ? {} : { take },
+		...give === void 0 ? {} : { give }
+	};
+}
+function readFavorite(stored) {
+	if (!isRecord(stored) || typeof stored.on !== "boolean") return;
+	const slug = optionalString(stored.slug);
+	return slug === void 0 ? void 0 : {
+		slug,
+		on: stored.on
+	};
+}
+/** The economy kinds, by name; `onFavorites` hears the starred list each star answers with. */
+function economyKinds(game, onFavorites) {
+	return {
+		[ECONOMY_KINDS.grant]: checkedKind(readGoods, { run: (goods, context) => context.call("grantInventoryItems", {
+			...game(),
+			...goods
+		}) }),
+		[ECONOMY_KINDS.exchange]: checkedKind(readExchange, { run: (exchange, context) => context.call("exchangeInventoryItems", {
+			...game(),
+			...exchange
+		}) }),
+		[ECONOMY_KINDS.favorite]: checkedKind(readFavorite, {
+			mergeKey: (favorite) => favorite.slug,
+			replaces: true,
+			run: async (favorite, context) => {
+				const reply = await context.call("setGameFavorite", {
+					slug: favorite.slug,
+					on: favorite.on
+				});
+				onFavorites(reply.games);
+				return reply;
+			}
+		})
+	};
 }
 //#endregion
 //#region src/core/offline/queue.ts
 /** The score options in a stored op, or `undefined` when they are malformed. */
-function readScoreOptions(stored) {
+function readScoreOptions$1(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;
@@ -257,7 +436,7 @@ function readOpInput(stored) {
 		}
 		case "submitScore": {
 			const score = optionalNumber(stored.score);
-			const opts = isRecord(stored.opts) ? readScoreOptions(stored.opts) : void 0;
+			const opts = isRecord(stored.opts) ? readScoreOptions$1(stored.opts) : void 0;
 			return key !== void 0 && score !== void 0 && opts !== void 0 ? {
 				kind: "submitScore",
 				key,
@@ -294,47 +473,310 @@ function readQueue(stored) {
 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
+//#endregion
+//#region src/core/offline/hub-kinds/progress-kinds.ts
+/** The kind names. */
+const PROGRESS_KINDS = {
+	save: "hub.save",
+	stat: "hub.stat",
+	score: "hub.score",
+	profile: "hub.profile"
+};
+function readSave$1(stored) {
+	if (!isRecord(stored)) return;
+	const slot = optionalString(stored.slot);
+	if (slot === void 0) return;
+	if (stored.deleted === true) return {
+		slot,
+		deleted: true
 	};
-	if (queued.kind === "maxStat" && incoming.kind === "maxStat" && queued.key === incoming.key) return {
-		...queued,
-		value: Math.max(queued.value, incoming.value)
+	return isJson(stored.data) && isNullableString(stored.label) ? {
+		slot,
+		data: stored.data,
+		label: stored.label
+	} : void 0;
+}
+function readStat(stored) {
+	if (!isRecord(stored)) return;
+	const key = optionalString(stored.key);
+	const value = optionalNumber(stored.value);
+	const mode = stored.mode === "set" || stored.mode === "incr" || stored.mode === "max" ? stored.mode : void 0;
+	return key === void 0 || value === void 0 || mode === void 0 ? void 0 : {
+		key,
+		mode,
+		value
 	};
-	if (queued.kind === "setStat" && incoming.kind === "setStat" && queued.key === incoming.key) return {
-		...queued,
-		value: incoming.value
+}
+/** Score options read back, or `undefined` when malformed. */
+function readScoreOptions(stored) {
+	if (!isRecord(stored)) return;
+	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 }
 	};
-	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
+}
+function readScore(stored) {
+	if (!isRecord(stored) || !isJson(stored.opts)) return;
+	const key = optionalString(stored.key);
+	const score = optionalNumber(stored.score);
+	const opts = readScoreOptions(stored.opts);
+	return key === void 0 || score === void 0 || opts === void 0 ? void 0 : {
+		key,
+		score,
+		opts
 	};
-	if (queued.kind === "setProfile" && incoming.kind === "setProfile") return {
-		...queued,
-		patch: {
-			...queued.patch,
-			...incoming.patch
-		}
+}
+/** A profile patch read back, or `undefined` when malformed. */
+function readProfile$1(stored) {
+	if (!isRecord(stored)) return;
+	const { displayName, data: profileData } = stored;
+	if (displayName !== void 0 && !isNullableString(displayName) || profileData !== void 0 && !isJson(profileData)) return;
+	return {
+		...displayName === void 0 ? {} : { displayName },
+		...profileData === void 0 ? {} : { data: profileData }
 	};
 }
-/** Whether an op writes save slot `slot`. */
-function writesSlot(op, slot) {
-	return (op.kind === "putSave" || op.kind === "deleteSave") && op.slot === slot;
+/** Two waiting stat updates of one key folded together, or `undefined` when their modes differ. */
+function mergeStats(waiting, incoming) {
+	if (waiting.mode !== incoming.mode) return;
+	switch (incoming.mode) {
+		case "incr": return {
+			...waiting,
+			value: waiting.value + incoming.value
+		};
+		case "max": return {
+			...waiting,
+			value: Math.max(waiting.value, incoming.value)
+		};
+		case "set": return incoming;
+	}
 }
+/** The progress kinds, by name. */
+function progressKinds(game) {
+	return {
+		[PROGRESS_KINDS.save]: checkedKind(readSave$1, {
+			mergeKey: (save) => save.slot,
+			replaces: true,
+			run: async (save, context) => {
+				if ("deleted" in save) await context.call("deleteSave", {
+					...game(),
+					slot: save.slot
+				});
+				else await context.call("writeSave", {
+					...game(),
+					slot: save.slot,
+					data: save.data,
+					label: save.label
+				});
+			}
+		}),
+		[PROGRESS_KINDS.stat]: checkedKind(readStat, {
+			mergeKey: (stat) => stat.key,
+			merge: mergeStats,
+			run: async (stat, context) => {
+				await context.call("updateGameStat", {
+					...game(),
+					key: stat.key,
+					value: stat.value,
+					mode: stat.mode
+				});
+			}
+		}),
+		[PROGRESS_KINDS.score]: checkedKind(readScore, {
+			mergeKey: (submission) => submission.key,
+			merge: (waiting, incoming) => ({
+				...waiting,
+				score: betterScore(waiting.score, incoming.score, incoming.opts.sort),
+				opts: incoming.opts
+			}),
+			run: async (submission, context) => {
+				await context.call("submitScore", {
+					...game(),
+					key: submission.key,
+					score: submission.score,
+					...submission.opts
+				});
+			}
+		}),
+		[PROGRESS_KINDS.profile]: checkedKind(readProfile$1, {
+			mergeKey: () => "profile",
+			merge: (waiting, incoming) => ({
+				...waiting,
+				...incoming
+			}),
+			run: async (patch, context) => {
+				await context.call("setGameProfile", {
+					...game(),
+					...patch
+				});
+			}
+		})
+	};
+}
+//#endregion
+//#region src/core/offline/hub-kinds/legacy-ops.ts
+/** The outbox operation for a v1 queued write, or `undefined` when it no longer reads as one. */
+function legacyOperation(op) {
+	switch (op.kind) {
+		case "putSave": return {
+			kind: PROGRESS_KINDS.save,
+			payload: {
+				slot: op.slot,
+				data: op.data,
+				label: op.label
+			}
+		};
+		case "deleteSave": return {
+			kind: PROGRESS_KINDS.save,
+			payload: {
+				slot: op.slot,
+				deleted: true
+			}
+		};
+		case "setStat": return {
+			kind: PROGRESS_KINDS.stat,
+			payload: {
+				key: op.key,
+				mode: "set",
+				value: op.value
+			}
+		};
+		case "maxStat": return {
+			kind: PROGRESS_KINDS.stat,
+			payload: {
+				key: op.key,
+				mode: "max",
+				value: op.value
+			}
+		};
+		case "incrStat": return {
+			kind: PROGRESS_KINDS.stat,
+			payload: {
+				key: op.key,
+				mode: "incr",
+				value: op.amount
+			}
+		};
+		case "submitScore": {
+			const opts = readScoreOptions({ ...op.opts });
+			return opts === void 0 ? void 0 : {
+				kind: PROGRESS_KINDS.score,
+				payload: {
+					key: op.key,
+					score: op.score,
+					opts
+				}
+			};
+		}
+		case "setProfile": {
+			const patch = readProfile$1({ ...op.patch });
+			return patch === void 0 ? void 0 : {
+				kind: PROGRESS_KINDS.profile,
+				payload: patch
+			};
+		}
+	}
+}
+//#endregion
+//#region src/core/offline/hub-kinds/index.ts
 /**
-* 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.
+* Every kind the hub itself queues offline (`hub.*`), registered on a
+* client's outbox. The docs' "Offline and replay" table lists them.
 */
-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);
+/** Register every hub kind on `outbox`. */
+function registerHubKinds(outbox, hooks) {
+	const kinds = {
+		...progressKinds(hooks.game),
+		...dailyKinds(hooks.game, hooks.onDailyComplete),
+		...economyKinds(hooks.game, writeLocalFavorites)
+	};
+	for (const [kind, definition] of Object.entries(kinds)) outbox.define(kind, definition);
+}
+/** 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/local-inventory.ts
+/** An empty inventory. */
+const EMPTY_INVENTORY = {
+	items: [],
+	coins: 0
+};
+/** A cached inventory, or `null` when there is none or it is malformed. */
+function readInventory(stored) {
+	if (!isRecord(stored) || !Array.isArray(stored.items)) return null;
+	const coins = optionalNumber(stored.coins);
+	const items = stored.items.flatMap((item) => {
+		const key = isRecord(item) ? optionalString(item.key) : void 0;
+		const qty = isRecord(item) ? optionalNumber(item.qty) : void 0;
+		return key === void 0 || qty === void 0 ? [] : [{
+			key,
+			qty
+		}];
+	});
+	return coins === void 0 ? null : {
+		items,
+		coins
+	};
+}
+/** The holdings as a key-to-quantity map. */
+function quantities(inventory) {
+	return new Map(inventory.items.map((item) => [item.key, item.qty]));
+}
+/** The holdings from a map (positive counts only, sorted by key). */
+function fromQuantities(held, coins) {
+	return {
+		items: [...held].filter(([, qty]) => qty > 0).sort(([first], [second]) => first.localeCompare(second)).map(([key, qty]) => ({
+			key,
+			qty
+		})),
+		coins
+	};
+}
+/** `inventory` with `goods` added. */
+function withGoods(inventory, goods) {
+	const held = quantities(inventory);
+	for (const [key, qty] of Object.entries(goods.items ?? {})) held.set(key, (held.get(key) ?? 0) + qty);
+	return fromQuantities(held, inventory.coins + (goods.coins ?? 0));
+}
+/** `inventory` with `goods` removed, or the hub's refusal message when it can't cover them. */
+function withoutGoods(inventory, goods) {
+	if ((goods.coins ?? 0) > inventory.coins) return "You don't have enough coins.";
+	const held = quantities(inventory);
+	for (const [key, qty] of Object.entries(goods.items ?? {})) {
+		const have = held.get(key) ?? 0;
+		if (qty > have) return `You don't have ${String(qty)}× "${key}".`;
+		held.set(key, have - qty);
+	}
+	return fromQuantities(held, inventory.coins - (goods.coins ?? 0));
 }
 //#endregion
 //#region src/core/offline/local-store.ts
@@ -400,7 +842,6 @@ var LocalStore = class {
 	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;
 	}
@@ -514,27 +955,20 @@ var LocalStore = class {
 			best
 		};
 	}
-	/** The queued writes, oldest first. */
-	getQueue() {
-		return readQueue(this.readStored(`${this.prefix}queue`));
+	/** The v1 client's queued writes, removed from storage (the caller moves them into the outbox). */
+	takeLegacyQueue() {
+		const queue = readQueue(this.readStored(`${this.prefix}queue`));
+		this.store.remove(`${this.prefix}queue`);
+		return queue;
 	}
-	/** Replace the queue. */
-	setQueue(queue) {
-		this.writeStored(`${this.prefix}queue`, queue);
-	}
-	/** How many writes are queued. */
-	queueLength() {
-		return this.getQueue().length;
+	/** This game's cached inventory (empty when none is cached). */
+	getInventory() {
+		return readInventory(this.readStored(`${this.prefix}inventory`)) ?? EMPTY_INVENTORY;
 	}
-	/** 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
-		}));
+	/** Store this game's inventory and return it. */
+	setInventory(inventory) {
+		this.writeStored(`${this.prefix}inventory`, inventory);
+		return inventory;
 	}
 	/** The buffered analytics events, oldest first. */
 	getEvents() {
@@ -574,6 +1008,574 @@ var LocalStore = class {
 	}
 };
 //#endregion
+//#region src/core/offline/outbox-kinds.ts
+/** The prefix reserved for the hub's own kinds. */
+const HUB_KIND_PREFIX = "hub.";
+/** The registered kinds of one client. */
+var KindRegistry = class {
+	constructor() {
+		_defineProperty(this, "kinds", /* @__PURE__ */ new Map());
+	}
+	/** Register (or replace) a kind. */
+	register(kind, definition) {
+		this.kinds.set(kind, definition);
+	}
+	/** A registered kind, or `undefined`. */
+	get(kind) {
+		return this.kinds.get(kind);
+	}
+};
+//#endregion
+//#region src/core/offline/offline-api.ts
+/**
+* `hub.offline`: the outbox, opened to games. A game defines its own kinds
+* (a handler per kind, which may make several dependent calls) and enqueues
+* operations of them; the hub queues them in order, replays them when it is
+* reachable, and reports what happened.
+*/
+/** The game-facing outbox API. */
+var OfflineApi = class {
+	/** The API over `host`. */
+	constructor(host) {
+		_defineProperty(this, "host", void 0);
+		this.host = host;
+	}
+	/**
+	* Define what an operation of `kind` does when it replays. Define every
+	* kind at load, before or after enqueueing: waiting ops of an undefined
+	* kind hold the queue until it is defined. `hub.*` kinds are the hub's own.
+	*/
+	define(kind, definition) {
+		if (kind.startsWith("hub.") || kind === "") throw new HubError(`Offline kinds starting with "${HUB_KIND_PREFIX}" are the hub's own; name yours after your game.`);
+		this.host.outbox.define(kind, gameKind(definition));
+		this.host.requestSync();
+	}
+	/**
+	* Queue an operation of `kind` and replay it as soon as the hub is
+	* reachable (at once when online). Resolves the queued op; its outcome
+	* arrives as a `replayed` or `failed` event. Throws a `HubError` (code
+	* `offline_queue_full`) when the outbox is full.
+	*/
+	enqueue(kind, payload) {
+		const op = this.host.outbox.stamp(kind, toStoredJson(payload));
+		this.host.outbox.add(op);
+		this.host.requestSync();
+		return op;
+	}
+	/** The waiting operations (the hub's and the game's), oldest first. */
+	pending() {
+		return this.host.outbox.pending();
+	}
+	/** Listen for `queued`, `replayed` or `failed`; returns the unsubscribe function. */
+	on(name, listener) {
+		return this.host.outbox.on(name, listener);
+	}
+};
+//#endregion
+//#region src/core/offline/outbox-entry.ts
+/** How wide the time part of an id is (enough for epoch ms until the year 5138). */
+const TIME_DIGITS = 14;
+/** How wide the sequence part of an id is. */
+const SEQUENCE_DIGITS = 6;
+/**
+* A new entry id: the queue time, a per-page sequence and a random tag, so
+* ids sort by time and two tabs queueing in the same millisecond never clash.
+*/
+function newEntryId(now, sequence) {
+	const tag = Math.floor(Math.random() * 36 ** 6).toString(36).padStart(6, "0");
+	return `${String(now).padStart(TIME_DIGITS, "0")}-${String(sequence % 10 ** SEQUENCE_DIGITS).padStart(SEQUENCE_DIGITS, "0")}-${tag}`;
+}
+/** A stored entry, or `undefined` when it is malformed. */
+function readEntry(stored) {
+	if (!isRecord(stored) || !isJson(stored.payload)) return;
+	const id = optionalString(stored.id);
+	const kind = optionalString(stored.kind);
+	const createdAt = optionalNumber(stored.createdAt);
+	const attempts = optionalNumber(stored.attempts);
+	const retryAt = optionalNumber(stored.retryAt);
+	const lastError = optionalString(stored.lastError);
+	if (id === void 0 || kind === void 0 || createdAt === void 0 || attempts === void 0 || retryAt === void 0) return;
+	return {
+		id,
+		kind,
+		payload: stored.payload,
+		createdAt,
+		attempts,
+		retryAt,
+		...lastError === void 0 ? {} : { lastError }
+	};
+}
+//#endregion
+//#region src/core/offline/outbox-merge.ts
+/** How `incoming` (of kind `kind`) joins `entries` (oldest first). */
+function planEnqueue(entries, incoming, kind) {
+	const separately = {
+		put: incoming,
+		remove: [],
+		isMerged: false
+	};
+	const { mergeKey } = kind;
+	if (mergeKey === void 0) return separately;
+	const key = mergeKey(incoming.payload);
+	const sameKey = entries.filter((entry) => entry.kind === incoming.kind && kind.accepts(entry.payload) && mergeKey(entry.payload) === key);
+	if (kind.replaces) return {
+		put: incoming,
+		remove: sameKey.filter((entry) => entry.attempts === 0).map((entry) => entry.id),
+		isMerged: false
+	};
+	const newest = sameKey.at(-1);
+	if (kind.merge === void 0 || newest === void 0 || newest.attempts > 0) return separately;
+	const merged = kind.merge(newest.payload, incoming.payload);
+	return merged === void 0 ? separately : {
+		put: {
+			...newest,
+			payload: merged
+		},
+		remove: [],
+		isMerged: true
+	};
+}
+//#endregion
+//#region src/core/offline/replay-policy.ts
+/**
+* What a failed replay does next, and how long it waits:
+*
+* - `offline`: the hub (or the network) can't be reached. The op stays at
+*   the head of the queue and replay waits for the connection.
+* - `retry`: the hub answered with a passing problem (408, 429, 5xx) or a
+*   game handler's fetch failed. The op stays at the head and is retried with
+*   backoff, up to {@link MAX_RETRIES} times, then dropped.
+* - `drop`: the hub refused it (any other status) or the handler threw
+*   something else. The op is dropped and reported, and the queue moves on.
+*/
+/** The first retry's delay. */
+const BASE_DELAY_MS = 1e3;
+/** The longest delay between tries. */
+const MAX_DELAY_MS = 6e4;
+/** Statuses that mean "try again later". */
+const PASSING_STATUSES = /* @__PURE__ */ new Set([
+	408,
+	425,
+	429
+]);
+/** The verdict for a failure. */
+function verdictFor(failure) {
+	if (failure instanceof HubError) {
+		if (failure.status === void 0) return "offline";
+		return failure.status >= 500 || PASSING_STATUSES.has(failure.status) ? "retry" : "drop";
+	}
+	return failure instanceof TypeError ? "retry" : "drop";
+}
+/** The delay before try `attempts + 1`: doubling from 1 s, capped at 60 s, with jitter so tabs and players spread out. */
+function backoffMs(attempts, random = Math.random) {
+	const ceiling = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** Math.max(0, attempts - 1));
+	return Math.round(ceiling / 2 + ceiling / 2 * random());
+}
+/** A failure's message, for reports. */
+function failureMessage(failure) {
+	return failure instanceof Error ? failure.message : String(failure);
+}
+//#endregion
+//#region src/core/offline/outbox-replayer.ts
+/** A report for a replay that didn't get the lease. */
+const LEASE_HELD = {
+	replayed: [],
+	failed: [],
+	stoppedBy: "lease"
+};
+/** Replays one game's outbox. */
+var OutboxReplayer = class {
+	/** A replayer over `parts`. */
+	constructor(parts) {
+		_defineProperty(this, "parts", void 0);
+		this.parts = parts;
+	}
+	/** Replay everything due, in order. `isEager` skips the backoff of ops waiting for the connection (it just came back). */
+	async replay(isEager = false) {
+		let report = LEASE_HELD;
+		return await this.parts.lease.hold(async () => {
+			report = await this.drain(isEager);
+		}) ? report : LEASE_HELD;
+	}
+	async drain(isEager) {
+		const { store, kinds, now } = this.parts;
+		const replayed = [];
+		const failed = [];
+		for (let head = store.list()[0]; head !== void 0; head = store.list()[0]) {
+			if (head.retryAt > now() && !(isEager && head.lastError === void 0)) {
+				this.parts.scheduleRetry(head.retryAt - now());
+				return {
+					replayed,
+					failed,
+					stoppedBy: "backoff"
+				};
+			}
+			const kind = kinds.get(head.kind);
+			if (kind === void 0) return {
+				replayed,
+				failed,
+				stoppedBy: "unknown-kind"
+			};
+			if (!kind.accepts(head.payload)) {
+				store.remove(head.id);
+				this.drop(failed, head, "Malformed offline operation payload.");
+				continue;
+			}
+			const started = {
+				...head,
+				attempts: head.attempts + 1
+			};
+			store.put(started);
+			try {
+				const result = await kind.run(head.payload, this.parts.contextFor(head, started.attempts));
+				store.remove(head.id);
+				replayed.push(started);
+				this.parts.onReplayed(started, result ?? void 0);
+			} catch (failure) {
+				const stop = this.settleFailure(started, failure, failed);
+				if (stop !== void 0) return {
+					replayed,
+					failed,
+					stoppedBy: stop
+				};
+			}
+		}
+		return {
+			replayed,
+			failed
+		};
+	}
+	/** Record a failed try; answers why replay stops, or `undefined` to carry on with the next op. */
+	settleFailure(started, failure, failed) {
+		const { store, now } = this.parts;
+		const verdict = verdictFor(failure);
+		const message = failureMessage(failure);
+		if (verdict === "drop" || verdict === "retry" && started.attempts >= 8) {
+			store.remove(started.id);
+			this.drop(failed, started, message);
+			return;
+		}
+		const delay = backoffMs(started.attempts);
+		const { id, kind, payload, createdAt, attempts } = started;
+		const retrying = {
+			id,
+			kind,
+			payload,
+			createdAt,
+			attempts,
+			retryAt: now() + delay
+		};
+		const waiting = verdict === "offline" ? retrying : {
+			...retrying,
+			lastError: message
+		};
+		store.put(waiting);
+		if (verdict === "offline") this.parts.onUnreachable();
+		this.parts.scheduleRetry(delay);
+		return verdict === "offline" ? "connection" : "backoff";
+	}
+	drop(failed, entry, error) {
+		const failure = {
+			entry,
+			error
+		};
+		failed.push(failure);
+		this.parts.onFailed(failure);
+	}
+};
+//#endregion
+//#region src/core/offline/outbox-store.ts
+/**
+* Where the outbox lives: one `localStorage` key per entry,
+* `hub:<slug>:outbox:<id>`, read back in id (queue) order. A tab adding an
+* entry and another removing one touch different keys, so neither loses the
+* other's change. The outbox is capped by entry count and stored size.
+*/
+/** The most entries one game's outbox holds. */
+const OUTBOX_MAX_ENTRIES = 500;
+/** The most stored characters one game's outbox holds (about 2 MB of `localStorage`). */
+const OUTBOX_MAX_CHARS = 1e6;
+/** One game's outbox. */
+var OutboxStore = class {
+	/** The outbox for game `slug` in `store`. */
+	constructor(slug, store) {
+		_defineProperty(this, "prefix", void 0);
+		_defineProperty(this, "store", void 0);
+		this.prefix = `hub:${slug}:outbox:`;
+		this.store = store;
+	}
+	/** Every well-formed entry, oldest first. Malformed ones are removed. */
+	list() {
+		const entries = [];
+		for (const key of this.entryKeys()) {
+			const text = this.store.read(key);
+			const entry = text === null ? void 0 : readEntry(parseJsonText(text));
+			if (entry === void 0) this.store.remove(key);
+			else entries.push(entry);
+		}
+		return entries;
+	}
+	/** How many entries are queued. */
+	count() {
+		return this.entryKeys().length;
+	}
+	/** One entry, or `undefined` once it is gone (replayed, or removed by another tab). */
+	get(id) {
+		const text = this.store.read(this.prefix + id);
+		return text === null ? void 0 : readEntry(parseJsonText(text));
+	}
+	/** Whether `extra` more stored characters in one more entry still fit under the caps. */
+	fits(extraChars) {
+		const keys = this.entryKeys();
+		if (keys.length >= 500) return false;
+		return keys.reduce((total, key) => total + (this.store.read(key)?.length ?? 0), 0) + extraChars <= OUTBOX_MAX_CHARS;
+	}
+	/** Store an entry (new or updated); `false` when the storage refused it (full or blocked). */
+	put(entry) {
+		const text = JSON.stringify(entry);
+		this.store.write(this.prefix + entry.id, text);
+		return this.store.read(this.prefix + entry.id) === text;
+	}
+	/** Forget an entry. */
+	remove(id) {
+		this.store.remove(this.prefix + id);
+	}
+	/** Whether a storage key belongs to this outbox (for cross-tab `storage` events). */
+	owns(key) {
+		return key === null || key.startsWith(this.prefix);
+	}
+	entryKeys() {
+		return this.store.keys().filter((key) => key.startsWith(this.prefix)).sort();
+	}
+};
+//#endregion
+//#region src/core/offline/replay-lease.ts
+/**
+* One replayer at a time per game, across tabs and across the client copies
+* on one page: a Web Lock where the browser has them, else a lease in
+* `localStorage` that its holder renews while it works and that lapses if
+* the tab dies. A replayer that can't get it simply doesn't run; the holder
+* replays for everyone.
+*/
+/** How long a `localStorage` lease lasts without renewal. */
+const STORAGE_LEASE_MS = 15e3;
+/** How often the holder renews it. */
+const RENEW_EVERY_MS = 5e3;
+/** A lease on the Web Locks API. */
+function webLockLease(locks, name) {
+	return { hold: (work) => locks.request(name, { ifAvailable: true }, async (lock) => {
+		if (lock === null) return false;
+		await work();
+		return true;
+	}) };
+}
+/** The lease's holder and expiry, or `undefined` when there is none. */
+function readLease(text) {
+	const stored = text === null ? void 0 : parseJsonText(text);
+	if (!isRecord(stored)) return;
+	const owner = optionalString(stored.owner);
+	const until = optionalNumber(stored.until);
+	return owner === void 0 || until === void 0 ? void 0 : {
+		owner,
+		until
+	};
+}
+/** A lease kept in `store` under `key`, for pages without Web Locks. */
+function storageLease(store, key, now = Date.now) {
+	const owner = `${String(now())}-${Math.random().toString(36).slice(2)}`;
+	const claim = () => {
+		const current = readLease(store.read(key));
+		if (current !== void 0 && current.owner !== owner && current.until > now()) return false;
+		store.write(key, JSON.stringify({
+			owner,
+			until: now() + STORAGE_LEASE_MS
+		}));
+		return readLease(store.read(key))?.owner === owner;
+	};
+	return { async hold(work) {
+		if (!claim()) return false;
+		const renewal = setInterval(claim, RENEW_EVERY_MS);
+		try {
+			await work();
+		} finally {
+			clearInterval(renewal);
+			if (readLease(store.read(key))?.owner === owner) store.remove(key);
+		}
+		return true;
+	} };
+}
+/** The page's Web Locks, when it has them. */
+function pageLocks() {
+	return typeof navigator !== "undefined" && "locks" in navigator ? navigator.locks : void 0;
+}
+/** The lease for game `slug`'s outbox: a Web Lock when available, else one in `store`. */
+function createReplayLease(slug, store) {
+	const name = `hub:${slug}:outbox-lease`;
+	const locks = pageLocks();
+	return locks === void 0 ? storageLease(store, name) : webLockLease(locks, name);
+}
+//#endregion
+//#region src/core/offline/outbox.ts
+/** The code of the error `add` throws when the outbox is full. */
+const OUTBOX_FULL_CODE = "offline_queue_full";
+/** How long a replayer that lost the lease waits before checking again. */
+const LEASE_RECHECK_MS = 3e3;
+/** One game's outbox. */
+var Outbox = class {
+	/** The outbox for `options.slug`. */
+	constructor(options) {
+		_defineProperty(this, "kinds", new KindRegistry());
+		_defineProperty(this, "entries", void 0);
+		_defineProperty(this, "options", void 0);
+		_defineProperty(this, "replayer", void 0);
+		_defineProperty(this, "now", void 0);
+		_defineProperty(this, "sequence", 0);
+		_defineProperty(this, "retryTimer", void 0);
+		_defineProperty(this, "retryAt", Number.POSITIVE_INFINITY);
+		_defineProperty(this, "listeners", {
+			queued: /* @__PURE__ */ new Set(),
+			replayed: /* @__PURE__ */ new Set(),
+			failed: /* @__PURE__ */ new Set()
+		});
+		this.options = options;
+		this.now = options.now ?? Date.now;
+		this.entries = new OutboxStore(options.slug, options.store);
+		this.replayer = new OutboxReplayer({
+			store: this.entries,
+			kinds: this.kinds,
+			lease: createReplayLease(options.slug, options.store),
+			contextFor: (entry, attempt) => this.contextFor(entry, attempt, true),
+			onReplayed: (op, result) => {
+				this.fire("replayed", result === void 0 ? { op } : {
+					op,
+					result
+				});
+			},
+			onFailed: ({ entry, error }) => {
+				this.fire("failed", {
+					op: entry,
+					error
+				});
+			},
+			onUnreachable: options.onUnreachable,
+			scheduleRetry: (delayMs) => {
+				this.scheduleRetry(delayMs);
+			},
+			now: this.now
+		});
+	}
+	/** Register a kind. */
+	define(kind, definition) {
+		this.kinds.register(kind, definition);
+	}
+	/** A new, not yet stored, op of `kind`. */
+	stamp(kind, payload) {
+		this.sequence += 1;
+		const now = this.now();
+		return {
+			id: newEntryId(now, this.sequence),
+			kind,
+			payload,
+			createdAt: now,
+			attempts: 0,
+			retryAt: 0
+		};
+	}
+	/**
+	* Queue an op, folding it into a waiting one where its kind says so.
+	* Throws a {@link HubError} (code {@link OUTBOX_FULL_CODE}) when the
+	* outbox is full or the storage refuses it.
+	*/
+	add(op) {
+		const kind = this.kinds.get(op.kind);
+		const plan = kind === void 0 ? {
+			put: op,
+			remove: [],
+			isMerged: false
+		} : planEnqueue(this.entries.list(), op, kind);
+		const extra = plan.isMerged ? 0 : JSON.stringify(plan.put).length;
+		if (plan.remove.length === 0 && !plan.isMerged && !this.entries.fits(extra)) throw outboxFull();
+		if (!this.entries.put(plan.put)) throw outboxFull();
+		for (const id of plan.remove) this.entries.remove(id);
+		this.fire("queued", { op: plan.put });
+		this.options.onChange();
+	}
+	/** Perform an op now, without queueing it (the online path); throws what its handler throws. */
+	async runNow(op) {
+		const kind = this.kinds.get(op.kind);
+		if (kind === void 0) throw new HubError(`No offline kind "${op.kind}" is defined.`);
+		return await kind.run(op.payload, this.contextFor(op, 1, false)) ?? void 0;
+	}
+	/** Replay what is due, in order. `isEager`: the connection just came back, so ops waiting for it go at once. */
+	async replay(isEager = false) {
+		this.clearRetry();
+		const report = await this.replayer.replay(isEager);
+		if (report.stoppedBy === "lease" && this.entries.count() > 0 || report.stoppedBy === "unknown-kind") this.scheduleRetry(report.stoppedBy === "lease" ? LEASE_RECHECK_MS : backoffMs(this.entries.list()[0]?.attempts ?? 1));
+		this.options.onChange();
+		return report;
+	}
+	/** The waiting ops, oldest first. */
+	pending() {
+		return this.entries.list();
+	}
+	/** How many ops are waiting. */
+	count() {
+		return this.entries.count();
+	}
+	/** Listen for an event; returns the unsubscribe function. */
+	on(name, listener) {
+		const listeners = this.listeners[name];
+		listeners.add(listener);
+		return () => {
+			listeners.delete(listener);
+		};
+	}
+	fire(name, detail) {
+		const listeners = this.listeners[name];
+		for (const listener of listeners) try {
+			listener(detail);
+		} catch {}
+		this.options.emit(`hub:offline-${name}`, detail);
+	}
+	contextFor(op, attempt, isReplay) {
+		const { rest } = this.options;
+		let step = 0;
+		return {
+			opId: op.id,
+			attempt,
+			isReplay,
+			key: (stepName) => `${op.id}.${stepName}`,
+			call: (name, ...fieldsArgument) => {
+				const opKey = `${op.id}.${String(step)}`;
+				step += 1;
+				return rest.callOnce(opKey, name, ...fieldsArgument);
+			}
+		};
+	}
+	scheduleRetry(delayMs) {
+		const at = this.now() + delayMs;
+		if (at >= this.retryAt) return;
+		this.clearRetry();
+		this.retryAt = at;
+		this.retryTimer = setTimeout(() => {
+			this.retryTimer = void 0;
+			this.retryAt = Number.POSITIVE_INFINITY;
+			this.options.onRetryDue();
+		}, delayMs);
+	}
+	clearRetry() {
+		if (this.retryTimer !== void 0) {
+			clearTimeout(this.retryTimer);
+			this.retryTimer = void 0;
+		}
+		this.retryAt = Number.POSITIVE_INFINITY;
+	}
+};
+/** The error for a full outbox. */
+function outboxFull() {
+	return new HubError("Too many changes are waiting to sync. Reconnect to save more.", 507, { code: OUTBOX_FULL_CODE });
+}
+//#endregion
 //#region src/core/page.ts
 /** Whether this code runs in a browser page. */
 function isBrowserPage() {
@@ -614,427 +1616,547 @@ function emitWindowEvent(eventName, detail) {
 }
 //#endregion
 //#region src/core/rest/routes.gen.ts
-/** Every public REST endpoint's method, path (under `/_api`) and query keys, from the contract. */
+/** Every public REST endpoint's method, path (under `/_api`), query keys and offline mode (`'replay'` when it may be queued offline), from the contract. */
 const ROUTES = {
 	ensureGuestSession: {
 		method: "POST",
 		path: "/auth/guest",
-		query: []
+		query: [],
+		offline: null
 	},
 	signUpWithPassword: {
 		method: "POST",
 		path: "/auth/signup",
-		query: []
+		query: [],
+		offline: null
 	},
 	logInWithPassword: {
 		method: "POST",
 		path: "/auth/login",
-		query: []
+		query: [],
+		offline: null
 	},
 	logOut: {
 		method: "POST",
 		path: "/auth/logout",
-		query: []
+		query: [],
+		offline: null
 	},
 	getCurrentUser: {
 		method: "GET",
 		path: "/me",
-		query: []
+		query: [],
+		offline: null
 	},
 	claimGuestAccount: {
 		method: "POST",
 		path: "/auth/claim",
-		query: []
+		query: [],
+		offline: null
+	},
+	getGamePlayerCounts: {
+		method: "GET",
+		path: "/catalog/players",
+		query: [],
+		offline: null
+	},
+	getMyGameActivity: {
+		method: "GET",
+		path: "/games/:slug/me/activity",
+		query: [],
+		offline: null
 	},
 	listGames: {
 		method: "GET",
 		path: "/games",
-		query: []
+		query: [],
+		offline: null
 	},
 	listWhatsNewNotes: {
 		method: "GET",
 		path: "/changes",
-		query: ["game", "since"]
+		query: ["game", "since"],
+		offline: null
 	},
 	listFavoriteGames: {
 		method: "GET",
 		path: "/favorites",
-		query: []
+		query: [],
+		offline: null
 	},
 	setGameFavorite: {
 		method: "PUT",
 		path: "/favorites/:slug",
-		query: []
+		query: [],
+		offline: "replay"
 	},
 	markWhatsNewSeen: {
 		method: "POST",
 		path: "/changes/seen",
-		query: []
+		query: [],
+		offline: null
 	},
 	getGameStats: {
 		method: "GET",
 		path: "/games/:slug/stats",
-		query: ["user"]
+		query: ["user"],
+		offline: null
 	},
 	getGameProfile: {
 		method: "GET",
 		path: "/games/:slug/profile",
-		query: []
+		query: [],
+		offline: null
 	},
 	setGameProfile: {
 		method: "PUT",
 		path: "/games/:slug/profile",
-		query: []
+		query: [],
+		offline: "replay"
 	},
 	listSaves: {
 		method: "GET",
 		path: "/games/:slug/saves",
-		query: []
+		query: [],
+		offline: null
 	},
 	getSave: {
 		method: "GET",
 		path: "/games/:slug/saves/:slot",
-		query: []
+		query: [],
+		offline: null
 	},
 	writeSave: {
 		method: "PUT",
 		path: "/games/:slug/saves/:slot",
-		query: []
+		query: [],
+		offline: "replay"
 	},
 	deleteSave: {
 		method: "DELETE",
 		path: "/games/:slug/saves/:slot",
-		query: []
+		query: [],
+		offline: "replay"
 	},
 	updateGameStat: {
 		method: "POST",
 		path: "/games/:slug/stats",
-		query: []
+		query: [],
+		offline: "replay"
 	},
 	resetMyGameProgress: {
 		method: "POST",
 		path: "/games/:slug/reset",
-		query: []
+		query: [],
+		offline: null
 	},
 	listMyLeaderboardRecords: {
 		method: "GET",
 		path: "/me/records",
-		query: ["game"]
+		query: ["game"],
+		offline: null
 	},
 	getMyOfflineSnapshot: {
 		method: "GET",
 		path: "/me/snapshot",
-		query: ["top"]
+		query: ["top"],
+		offline: null
 	},
 	listTopOfEveryLeaderboard: {
 		method: "GET",
 		path: "/leaderboards",
-		query: ["top"]
+		query: ["top"],
+		offline: null
 	},
 	listGameLeaderboards: {
 		method: "GET",
 		path: "/games/:slug/leaderboards",
-		query: []
+		query: [],
+		offline: null
 	},
 	getLeaderboard: {
 		method: "GET",
 		path: "/games/:slug/leaderboards/:key",
-		query: ["limit"]
+		query: ["limit"],
+		offline: null
 	},
 	submitScore: {
 		method: "POST",
 		path: "/games/:slug/leaderboards/:key/scores",
-		query: []
+		query: [],
+		offline: "replay"
 	},
 	listDailyChallengesForAllGames: {
 		method: "GET",
 		path: "/daily",
-		query: []
+		query: [],
+		offline: null
 	},
 	getGameDailyChallenges: {
 		method: "GET",
 		path: "/games/:slug/daily",
-		query: []
+		query: [],
+		offline: null
 	},
 	startDailyChallenge: {
 		method: "POST",
 		path: "/games/:slug/daily/:day/start",
-		query: []
+		query: [],
+		offline: null
 	},
 	completeDailyChallenge: {
 		method: "POST",
 		path: "/games/:slug/daily/:day/complete",
-		query: []
+		query: [],
+		offline: "replay"
 	},
 	getMyInventory: {
 		method: "GET",
 		path: "/games/:slug/inventory",
-		query: []
+		query: [],
+		offline: null
 	},
 	grantInventoryItems: {
 		method: "POST",
 		path: "/games/:slug/inventory/grant",
-		query: []
+		query: [],
+		offline: "replay"
 	},
 	exchangeInventoryItems: {
 		method: "POST",
 		path: "/games/:slug/inventory/exchange",
-		query: []
+		query: [],
+		offline: "replay"
 	},
 	getPlayerInventory: {
 		method: "GET",
 		path: "/games/:slug/players/:userId/inventory",
-		query: []
+		query: [],
+		offline: null
 	},
 	listTradePartners: {
 		method: "GET",
 		path: "/games/:slug/trades/players",
-		query: []
+		query: [],
+		offline: null
 	},
 	listMyTrades: {
 		method: "GET",
 		path: "/games/:slug/trades",
-		query: ["box", "status"]
+		query: ["box", "status"],
+		offline: null
 	},
 	declineTrade: {
 		method: "POST",
 		path: "/games/:slug/trades/:id/decline",
-		query: []
+		query: [],
+		offline: null
 	},
 	cancelTrade: {
 		method: "POST",
 		path: "/games/:slug/trades/:id/cancel",
-		query: []
+		query: [],
+		offline: null
 	},
 	createTrade: {
 		method: "POST",
 		path: "/games/:slug/trades",
-		query: []
+		query: [],
+		offline: null
 	},
 	acceptTrade: {
 		method: "POST",
 		path: "/games/:slug/trades/:id/accept",
-		query: []
+		query: [],
+		offline: null
 	},
 	counterTradeOffer: {
 		method: "POST",
 		path: "/games/:slug/trades/:id/counter",
-		query: []
+		query: [],
+		offline: null
 	},
 	getSiteAnalytics: {
 		method: "GET",
 		path: "/analytics",
-		query: []
+		query: [],
+		offline: null
 	},
 	reportClientError: {
 		method: "POST",
 		path: "/client-log",
-		query: []
+		query: [],
+		offline: null
 	},
 	recordGameEvent: {
 		method: "POST",
 		path: "/games/:slug/events",
-		query: []
+		query: [],
+		offline: null
 	},
 	getGameAnalytics: {
 		method: "GET",
 		path: "/games/:slug/analytics",
-		query: []
+		query: [],
+		offline: null
 	},
 	getSocialConfig: {
 		method: "GET",
 		path: "/social/config",
-		query: []
+		query: [],
+		offline: null
 	},
 	getOnlineCounts: {
 		method: "GET",
 		path: "/social/counts",
-		query: []
+		query: [],
+		offline: null
 	},
 	getMySocialProfile: {
 		method: "GET",
 		path: "/social/me",
-		query: []
+		query: [],
+		offline: null
 	},
 	listFriendsAndRequests: {
 		method: "GET",
 		path: "/social/friends",
-		query: []
+		query: [],
+		offline: null
 	},
 	findPlayerByName: {
 		method: "GET",
 		path: "/social/players/by-name/:name",
-		query: []
+		query: [],
+		offline: null
 	},
 	getPlayerCard: {
 		method: "GET",
 		path: "/social/players/:id",
-		query: []
+		query: [],
+		offline: null
 	},
 	updateMySocialProfile: {
 		method: "PUT",
 		path: "/social/me",
-		query: []
+		query: [],
+		offline: null
 	},
 	setParentChatLock: {
 		method: "POST",
 		path: "/social/chat-lock",
-		query: []
+		query: [],
+		offline: null
 	},
 	sendFriendRequest: {
 		method: "POST",
 		path: "/social/friends",
-		query: []
+		query: [],
+		offline: null
 	},
 	acceptFriendRequest: {
 		method: "POST",
 		path: "/social/friends/:id/accept",
-		query: []
+		query: [],
+		offline: null
 	},
 	declineFriendRequest: {
 		method: "POST",
 		path: "/social/friends/:id/decline",
-		query: []
+		query: [],
+		offline: null
 	},
 	removeFriend: {
 		method: "DELETE",
 		path: "/social/friends/:id",
-		query: []
+		query: [],
+		offline: null
 	},
 	setFriendNotifications: {
 		method: "PUT",
 		path: "/social/friends/:id/notify",
-		query: []
+		query: [],
+		offline: null
 	},
 	blockPlayer: {
 		method: "POST",
 		path: "/social/blocks",
-		query: []
+		query: [],
+		offline: null
 	},
 	unblockPlayer: {
 		method: "DELETE",
 		path: "/social/blocks/:id",
-		query: []
+		query: [],
+		offline: null
 	},
 	listRecentPlayers: {
 		method: "GET",
 		path: "/social/recent",
-		query: []
+		query: [],
+		offline: null
 	},
 	listConversations: {
 		method: "GET",
 		path: "/social/conversations",
-		query: []
+		query: [],
+		offline: null
 	},
 	listDirectMessages: {
 		method: "GET",
 		path: "/social/messages/:userId",
-		query: ["before"]
+		query: ["before"],
+		offline: null
 	},
 	sendDirectMessage: {
 		method: "POST",
 		path: "/social/messages/:userId",
-		query: []
+		query: [],
+		offline: null
 	},
 	markDirectMessagesRead: {
 		method: "POST",
 		path: "/social/messages/:userId/read",
-		query: []
+		query: [],
+		offline: null
 	},
 	getNotificationPreferences: {
 		method: "GET",
 		path: "/social/notify",
-		query: []
+		query: [],
+		offline: null
 	},
 	unsubscribeFromPush: {
 		method: "DELETE",
 		path: "/social/push",
-		query: []
+		query: [],
+		offline: null
 	},
 	setNotificationPreferences: {
 		method: "PUT",
 		path: "/social/notify",
-		query: []
+		query: [],
+		offline: null
 	},
 	subscribeToPush: {
 		method: "POST",
 		path: "/social/push",
-		query: []
+		query: [],
+		offline: null
 	},
 	fileReport: {
 		method: "POST",
 		path: "/social/reports",
-		query: []
+		query: [],
+		offline: null
 	},
 	listPublicSuggestions: {
 		method: "GET",
 		path: "/suggestions",
-		query: ["sort"]
+		query: ["sort"],
+		offline: null
 	},
 	submitSuggestion: {
 		method: "POST",
 		path: "/suggestions",
-		query: []
+		query: [],
+		offline: null
 	},
 	voteForSuggestion: {
 		method: "POST",
 		path: "/suggestions/:id/vote",
-		query: []
+		query: [],
+		offline: null
 	},
 	removeSuggestionVote: {
 		method: "DELETE",
 		path: "/suggestions/:id/vote",
-		query: []
+		query: [],
+		offline: null
 	},
 	withdrawSuggestion: {
 		method: "DELETE",
 		path: "/suggestions/:id",
-		query: []
+		query: [],
+		offline: null
 	},
 	sendGameInvite: {
 		method: "POST",
 		path: "/mp/invites",
-		query: []
+		query: [],
+		offline: null
 	},
 	acceptGameInvite: {
 		method: "POST",
 		path: "/mp/invites/:id/accept",
-		query: []
+		query: [],
+		offline: null
 	},
 	declineGameInvite: {
 		method: "POST",
 		path: "/mp/invites/:id/decline",
-		query: []
+		query: [],
+		offline: null
+	},
+	createInviteLink: {
+		method: "POST",
+		path: "/mp/links",
+		query: [],
+		offline: null
+	},
+	listInviteLinks: {
+		method: "GET",
+		path: "/mp/links",
+		query: ["game"],
+		offline: null
+	},
+	revokeInviteLink: {
+		method: "DELETE",
+		path: "/mp/links/:token",
+		query: [],
+		offline: null
 	},
 	cancelGameInvite: {
 		method: "DELETE",
 		path: "/mp/invites/:id",
-		query: []
+		query: [],
+		offline: null
 	},
 	redeemLaunchToken: {
 		method: "GET",
 		path: "/mp/launch/:token",
-		query: []
+		query: [],
+		offline: null
+	},
+	openInviteLink: {
+		method: "POST",
+		path: "/mp/links/:token/open",
+		query: [],
+		offline: null
 	},
 	setPartyJoinInfo: {
 		method: "POST",
 		path: "/mp/parties/:id/join-info",
-		query: []
+		query: [],
+		offline: null
 	},
 	leaveParty: {
 		method: "POST",
 		path: "/mp/parties/:id/leave",
-		query: []
+		query: [],
+		offline: null
 	},
 	launchIntoFriendsRoom: {
 		method: "POST",
 		path: "/mp/join",
-		query: []
+		query: [],
+		offline: null
 	},
 	getGameServerTicket: {
 		method: "POST",
 		path: "/mp/ticket",
-		query: []
+		query: [],
+		offline: null
 	},
 	listMyRaceHistory: {
 		method: "GET",
@@ -1044,14 +2166,90 @@ const ROUTES = {
 			"with",
 			"before",
 			"limit"
-		]
+		],
+		offline: null
+	},
+	listTournaments: {
+		method: "GET",
+		path: "/tournaments",
+		query: ["game"],
+		offline: null
+	},
+	getTournament: {
+		method: "GET",
+		path: "/tournaments/:id",
+		query: ["key"],
+		offline: null
+	},
+	createTournament: {
+		method: "POST",
+		path: "/tournaments",
+		query: [],
+		offline: null
+	},
+	inviteToTournament: {
+		method: "POST",
+		path: "/tournaments/:id/invites",
+		query: [],
+		offline: null
+	},
+	followTournament: {
+		method: "PUT",
+		path: "/tournaments/:id/follow",
+		query: [],
+		offline: null
+	},
+	unfollowTournament: {
+		method: "DELETE",
+		path: "/tournaments/:id/follow",
+		query: [],
+		offline: null
+	},
+	startTournament: {
+		method: "POST",
+		path: "/tournaments/:id/start",
+		query: [],
+		offline: null
+	},
+	cancelTournament: {
+		method: "DELETE",
+		path: "/tournaments/:id",
+		query: [],
+		offline: null
+	},
+	joinTournament: {
+		method: "POST",
+		path: "/tournaments/:id/join",
+		query: [],
+		offline: null
+	},
+	leaveTournament: {
+		method: "POST",
+		path: "/tournaments/:id/leave",
+		query: [],
+		offline: null
+	},
+	launchTournamentMatch: {
+		method: "POST",
+		path: "/tournaments/:id/matches/:match/launch",
+		query: [],
+		offline: null
+	},
+	getPlayOnline: {
+		method: "GET",
+		path: "/play-online",
+		query: [],
+		offline: null
 	},
 	getHubVersion: {
 		method: "GET",
 		path: "/version",
-		query: []
+		query: [],
+		offline: null
 	}
 };
+/** The request header that carries an offline operation key (the contract's `OFFLINE_OP_HEADER`). */
+const OFFLINE_OP_HEADER = "x-hub-op";
 //#endregion
 //#region src/core/rest/rest-client.ts
 /**
@@ -1122,7 +2320,7 @@ async function failureOf(name, response) {
 }
 /** A REST client for one API base. */
 function createRestClient(options) {
-	async function send(name, fields) {
+	async function send(name, fields, opKey) {
 		const planned = planRequest(name, fields);
 		let response;
 		try {
@@ -1131,7 +2329,8 @@ function createRestClient(options) {
 				credentials: "same-origin",
 				headers: {
 					"content-type": "application/json",
-					[CLIENT_VERSION_HEADER]: HUB_CLIENT_VERSION
+					[CLIENT_VERSION_HEADER]: HUB_CLIENT_VERSION,
+					...opKey !== void 0 && ROUTES[name].offline === "replay" ? { [OFFLINE_OP_HEADER]: opKey } : {}
 				},
 				...planned.bodyText === void 0 ? {} : { body: planned.bodyText }
 			});
@@ -1144,20 +2343,19 @@ function createRestClient(options) {
 	}
 	return {
 		apiBase: options.apiBase,
-		call: (name, ...fieldsArgument) => send(name, fieldsArgument[0])
+		call: (name, ...fieldsArgument) => send(name, fieldsArgument[0]),
+		callOnce: (opKey, name, ...fieldsArgument) => send(name, fieldsArgument[0], opKey)
 	};
 }
 //#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;
+/** A sync that did nothing. */
+const NOTHING_SYNCED = {
+	flushed: 0,
+	conflicts: []
+};
 /** Whether a failure means "the hub can't be reached" (rather than a refusal). */
 function isTransportFailure(failure) {
 	return failure instanceof HubError && failure.isOffline;
@@ -1170,10 +2368,15 @@ var HubConnection = class {
 		_defineProperty(this, "apiBase", void 0);
 		_defineProperty(this, "rest", void 0);
 		_defineProperty(this, "store", void 0);
+		_defineProperty(this, "outbox", void 0);
 		_defineProperty(this, "offlineMode", void 0);
 		_defineProperty(this, "isReachable", true);
-		_defineProperty(this, "isSyncing", false);
+		_defineProperty(this, "runningSync", null);
+		_defineProperty(this, "followingSync", null);
+		_defineProperty(this, "isFollowingEager", false);
+		_defineProperty(this, "directSend", null);
 		_defineProperty(this, "lastPrefetchAt", 0);
+		_defineProperty(this, "offlineApi", void 0);
 		_defineProperty(this, "statusListeners", /* @__PURE__ */ new Set());
 		this.slug = options.slug ?? detectSlug();
 		this.apiBase = options.apiBase === void 0 ? detectApiBase() : absoluteApiBase(options.apiBase);
@@ -1185,16 +2388,37 @@ var HubConnection = class {
 				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", () => {
+		const pageStore = createPageStore();
+		this.store = new LocalStore(this.slug ?? "app", pageStore);
+		this.outbox = new Outbox({
+			slug: this.slug ?? "app",
+			store: pageStore,
+			rest: this.rest,
+			emit: emitWindowEvent,
+			onUnreachable: () => {
 				this.setReachable(false);
-			});
-		}
+			},
+			onChange: () => {
+				this.notifyStatus();
+			},
+			onRetryDue: () => {
+				this.retrySync();
+			}
+		});
+		registerHubKinds(this.outbox, {
+			game: () => this.gameFields(),
+			onDailyComplete: (payload, completion) => {
+				emitWindowEvent("hub:daily-complete", {
+					day: payload.day,
+					count: completion.count,
+					rank: completion.rank,
+					meta: payload.meta
+				});
+			}
+		});
+		this.importLegacyQueue();
+		if (typeof navigator !== "undefined" && "onLine" in navigator) this.isReachable = navigator.onLine;
+		if (isBrowserPage()) this.listenToPage();
 	}
 	/** `true` when calls are being served from the offline cache rather than the hub. */
 	get isOffline() {
@@ -1204,9 +2428,22 @@ var HubConnection = class {
 	get isOnline() {
 		return this.isReachable;
 	}
-	/** Queued writes plus buffered analytics events waiting to sync. */
+	/**
+	* The offline outbox: define your own kinds of operation, queue them, and
+	* hear how they replay (`hub.offline.define`, `enqueue`, `pending`, `on`).
+	*/
+	get offline() {
+		this.offlineApi ?? (this.offlineApi = new OfflineApi({
+			outbox: this.outbox,
+			requestSync: () => {
+				if (!this.isOffline) this.sync();
+			}
+		}));
+		return this.offlineApi;
+	}
+	/** Queued operations plus buffered analytics events waiting to sync. */
 	pending() {
-		return this.store.queueLength() + this.store.getEvents().length;
+		return this.outbox.count() + this.store.getEvents().length;
 	}
 	/** Subscribe to connection and sync status changes; returns the unsubscribe function. */
 	onStatus(listener) {
@@ -1227,16 +2464,13 @@ var HubConnection = class {
 		} catch {}
 		emitWindowEvent("hub:status", status);
 	}
-	/** Record reachability; coming back online syncs the queue and re-warms the cache. */
+	/** Record reachability; coming back online replays the outbox 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);
-		}
+		if (isReachableNow) this.replayAll(true).then(() => this.prefetchAll()).catch(() => void 0);
 	}
 	/** `{ slug }` for this game's endpoints; throws when the slug is unknown. */
 	gameFields() {
@@ -1258,132 +2492,96 @@ var HubConnection = class {
 			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.
+	* Apply a write to the offline cache at once, then perform it as an op of
+	* `kind`: sent now when online with nothing waiting, else queued behind
+	* the others. Resolves with the local answer (or, sent now, with
+	* `replyAnswer`'s reading of the hub's reply). A real API error on the
+	* direct path reaches the caller and is not queued; a transport failure
+	* queues the op under the same id, so if the request did land, its replay
+	* is recognised by the hub and not applied twice.
 	*/
-	async mutateQueued(input, localAnswer) {
+	async mutateOffline(kind, payload, localAnswer, replyAnswer) {
 		const answer = localAnswer();
-		if (this.isOffline || this.store.queueLength() > 0) {
-			this.store.enqueue(input);
-			this.notifyStatus();
+		const op = this.outbox.stamp(kind, payload);
+		if (this.isOffline || this.outbox.count() > 0 || this.runningSync !== null || this.directSend !== null) {
+			this.outbox.add(op);
 			if (!this.isOffline) this.sync();
 			return answer;
 		}
+		const sending = this.outbox.runNow(op);
+		this.directSend = sending;
 		try {
-			await this.sendOp(input);
-			return answer;
+			const result = await sending;
+			return replyAnswer?.(result) ?? answer;
 		} catch (failure) {
 			if (!isTransportFailure(failure)) throw failure;
 			this.setReachable(false);
-			this.store.enqueue(input);
-			this.notifyStatus();
+			this.outbox.add({
+				...op,
+				attempts: 1
+			});
 			return answer;
+		} finally {
+			if (this.directSend === sending) this.directSend = null;
 		}
 	}
 	/**
-	* 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.
+	* Replay the outbox, then the buffered events, in order. Stops at the
+	* first transport failure (offline again: the rest stays queued); an op
+	* the hub refuses is dropped and reported as a conflict.
+	*/
+	sync() {
+		return this.isOffline ? Promise.resolve(NOTHING_SYNCED) : this.replayAll(false);
+	}
+	/** A retry came due: try again even when the hub was last unreachable (the try is the probe), unless the browser itself is offline. */
+	retrySync() {
+		const isBrowserOffline = typeof navigator !== "undefined" && "onLine" in navigator && !navigator.onLine;
+		return this.offlineMode === "always" || isBrowserOffline ? Promise.resolve(NOTHING_SYNCED) : this.replayAll(false);
+	}
+	/**
+	* One replay at a time per client. A call during one queues a single
+	* follow-up replay (eager if any caller asked for that), so an op queued
+	* or a reconnect that happens mid-replay is never missed.
 	*/
-	async sync() {
-		if (this.isSyncing || this.isOffline || this.slug === null) return {
-			flushed: 0,
-			conflicts: []
+	replayAll(isEager) {
+		if (this.slug === null || this.offlineMode === "always") return Promise.resolve(NOTHING_SYNCED);
+		const running = this.runningSync;
+		if (running === null) return this.startReplay(isEager);
+		this.isFollowingEager || (this.isFollowingEager = isEager);
+		this.followingSync ?? (this.followingSync = running.catch(() => NOTHING_SYNCED).then(() => {
+			const isFollowUpEager = this.isFollowingEager;
+			this.isFollowingEager = false;
+			this.followingSync = null;
+			return this.startReplay(isFollowUpEager);
+		}));
+		return this.followingSync;
+	}
+	startReplay(isEager) {
+		const run = this.runReplay(isEager).finally(() => {
+			if (this.runningSync === run) this.runningSync = null;
+		});
+		this.runningSync = run;
+		return run;
+	}
+	async runReplay(isEager) {
+		if (this.directSend !== null) await this.directSend.catch(() => void 0);
+		const report = await this.outbox.replay(isEager);
+		const conflicts = report.failed.map((failure) => ({
+			op: failure.entry,
+			error: failure.error
+		}));
+		if (report.stoppedBy !== "connection") await this.flushEvents();
+		const result = {
+			flushed: report.replayed.length,
+			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
+			...result
 		});
 		this.notifyStatus();
-		return {
-			flushed,
-			conflicts
-		};
+		return result;
 	}
 	/** Send the buffered analytics events; a refused one is dropped (telemetry never blocks). */
 	async flushEvents() {
@@ -1401,6 +2599,31 @@ var HubConnection = class {
 			this.store.setEvents(events);
 		}
 	}
+	/** Move a v1 copy's queued writes into the outbox, in their order. */
+	importLegacyQueue() {
+		if (this.slug === null) return;
+		try {
+			for (const legacy of this.store.takeLegacyQueue()) {
+				const operation = legacyOperation(legacy);
+				if (operation !== void 0) this.outbox.add(this.outbox.stamp(operation.kind, operation.payload));
+			}
+		} catch {}
+	}
+	/** Follow the browser's connection, other tabs' outbox changes, and replay what an earlier page left queued. */
+	listenToPage() {
+		window.addEventListener("online", () => {
+			this.setReachable(true);
+		});
+		window.addEventListener("offline", () => {
+			this.setReachable(false);
+		});
+		window.addEventListener("storage", (event) => {
+			if (event instanceof StorageEvent && this.outbox.entries.owns(event.key)) this.notifyStatus();
+		});
+		if (this.outbox.count() > 0) setTimeout(() => {
+			this.sync();
+		}, 0);
+	}
 	/**
 	* Warm the offline cache for every game the player has touched, in one
 	* request, so going offline later still shows complete progress.
@@ -1416,32 +2639,13 @@ var HubConnection = class {
 			throw failure;
 		}
 		this.lastPrefetchAt = Date.now();
+		if (this.outbox.count() > 0) return snapshot;
 		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) {
@@ -1542,13 +2746,11 @@ var HubProgress = class extends HubConnection {
 	}
 	/** 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 queued = {
+			...patch.displayName === void 0 ? {} : { displayName: patch.displayName },
+			...patch.data === void 0 ? {} : { data: toStoredJson(patch.data) }
+		};
+		return this.mutateOffline(PROGRESS_KINDS.profile, queued, () => {
 			const stored = this.store.setProfile(this.slug ?? "app", patch.displayName ?? null, queued.data ?? {});
 			return { profile: {
 				...stored,
@@ -1570,8 +2772,7 @@ var HubProgress = class extends HubConnection {
 	/** 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",
+		return this.mutateOffline(PROGRESS_KINDS.save, {
 			slot,
 			data: stored,
 			label: label ?? null
@@ -1582,9 +2783,9 @@ var HubProgress = class extends HubConnection {
 	}
 	/** Delete a save slot. */
 	deleteSave(slot) {
-		return this.mutateQueued({
-			kind: "deleteSave",
-			slot
+		return this.mutateOffline(PROGRESS_KINDS.save, {
+			slot,
+			deleted: true
 		}, () => {
 			this.store.deleteSave(slot);
 			return { ok: true };
@@ -1599,9 +2800,9 @@ var HubProgress = class extends HubConnection {
 	}
 	/** Overwrite a stat. */
 	setStat(key, value) {
-		return this.mutateQueued({
-			kind: "setStat",
+		return this.mutateOffline(PROGRESS_KINDS.stat, {
 			key,
+			mode: "set",
 			value
 		}, () => ({
 			key,
@@ -1610,10 +2811,10 @@ var HubProgress = class extends HubConnection {
 	}
 	/** Add to a stat (creating it at `amount` when absent). */
 	incrStat(key, amount = 1) {
-		return this.mutateQueued({
-			kind: "incrStat",
+		return this.mutateOffline(PROGRESS_KINDS.stat, {
 			key,
-			amount
+			mode: "incr",
+			value: amount
 		}, () => ({
 			key,
 			value: this.store.updateStat(key, amount, "incr")
@@ -1621,9 +2822,9 @@ var HubProgress = class extends HubConnection {
 	}
 	/** Keep the larger of the stored and the given value. */
 	maxStat(key, value) {
-		return this.mutateQueued({
-			kind: "maxStat",
+		return this.mutateOffline(PROGRESS_KINDS.stat, {
 			key,
+			mode: "max",
 			value
 		}, () => ({
 			key,
@@ -1637,8 +2838,7 @@ var HubProgress = class extends HubConnection {
 			...opts.sort === void 0 ? {} : { sort: opts.sort },
 			...opts.meta === void 0 ? {} : { meta: toStoredJson(opts.meta) }
 		};
-		return this.mutateQueued({
-			kind: "submitScore",
+		return this.mutateOffline(PROGRESS_KINDS.score, {
 			key: boardKey,
 			score,
 			opts: queued
@@ -1682,31 +2882,20 @@ var HubProgress = class extends HubConnection {
 	}
 };
 //#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));
+//#region src/core/hub-economy.ts
+/** Goods as queued: `null` parts left out. */
+function goodsOf(bundle) {
+	const items = bundle?.items ?? void 0;
+	const coins = bundle?.coins ?? void 0;
+	return {
+		...items === void 0 ? {} : { items },
+		...coins === void 0 ? {} : { coins }
+	};
 }
-/** Mirror the hub's favorites list. */
-function writeLocalFavorites(games) {
-	createPageStore().write(FAVORITES_KEY, JSON.stringify(games));
+/** The holdings in a grant or exchange reply, or `undefined` when it doesn't read as one. */
+function inventoryReply(result) {
+	return readInventory(result) ?? void 0;
 }
-//#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. */
@@ -1776,14 +2965,17 @@ var HubEconomy = class extends HubProgress {
 			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", {
+	/** Star (`isOn = true`) or unstar a game. Offline, the local list changes at once and the hub's when it is back. */
+	setFavorite(slug, isOn) {
+		return this.mutateOffline(ECONOMY_KINDS.favorite, {
 			slug,
 			on: isOn
-		});
-		writeLocalFavorites(reply.games);
-		return reply;
+		}, () => {
+			const others = readLocalFavorites().filter((starred) => starred !== slug);
+			const games = isOn ? [...others, slug] : others;
+			writeLocalFavorites(games);
+			return { games };
+		}, (result) => isRecord(result) ? { games: stringsIn(result.games) } : void 0);
 	}
 	/** The player's leaderboard standings, grouped by game (every game, or one via `forSlug`). Empty offline or signed out. */
 	myRecords(forSlug) {
@@ -1791,10 +2983,7 @@ var HubEconomy = class extends HubProgress {
 	}
 	/** This game's inventory and coin balance for the current user. */
 	getInventory() {
-		return this.withFallback(() => this.rest.call("getMyInventory", this.gameFields()), () => ({
-			items: [],
-			coins: 0
-		}));
+		return this.withFallback(async () => this.store.setInventory(await this.rest.call("getMyInventory", this.gameFields())), () => this.store.getInventory());
 	}
 	/** Another player's available holdings (to compose a trade). */
 	playerInventory(userId) {
@@ -1806,20 +2995,32 @@ var HubEconomy = class extends HubProgress {
 			coins: 0
 		}));
 	}
-	/** Add goods to the player (gameplay rewards); answers the new holdings. */
+	/**
+	* Add goods to the player (gameplay rewards); answers the new holdings.
+	* Offline, the cached holdings change at once and the grant replays later.
+	*/
 	grant(bundle) {
-		return this.rest.call("grantInventoryItems", {
-			...this.gameFields(),
-			...bundle
-		});
+		const goods = goodsOf(bundle);
+		return this.mutateOffline(ECONOMY_KINDS.grant, goods, () => this.store.setInventory(withGoods(this.store.getInventory(), goods)), inventoryReply);
 	}
-	/** An atomic swap with the house: remove `take`, add `give`. */
+	/**
+	* An atomic swap with the house: remove `take`, add `give`. Offline it is
+	* checked against the cached holdings (409 when they can't cover `take`),
+	* applied to them at once, and replayed later; the hub has the last word.
+	*/
 	exchange(take, give) {
-		return this.rest.call("exchangeInventoryItems", {
-			...this.gameFields(),
-			...take === void 0 ? {} : { take },
-			...give === void 0 ? {} : { give }
-		});
+		const payload = {
+			...take === void 0 ? {} : { take: goodsOf(take) },
+			...give === void 0 ? {} : { give: goodsOf(give) }
+		};
+		return this.mutateOffline(ECONOMY_KINDS.exchange, payload, () => {
+			const remaining = withoutGoods(this.store.getInventory(), payload.take ?? {});
+			if (typeof remaining === "string") {
+				if (this.isOffline) throw new HubError(remaining, 409);
+				return this.store.getInventory();
+			}
+			return this.store.setInventory(withGoods(remaining, payload.give ?? {}));
+		}, inventoryReply);
 	}
 	/** Sell items to the house for coins. */
 	sell(items, coins) {
@@ -2135,12 +3336,11 @@ var Hub = class extends HubEconomy {
 				...this.gameFields(),
 				day
 			}),
-			complete: (day, token, meta) => this.rest.call("completeDailyChallenge", {
-				...this.gameFields(),
+			complete: (day, token, meta) => this.mutateOffline(DAILY_KIND, {
 				day,
 				token,
 				meta
-			}),
+			}, () => null, (result) => readDailyCompletion(result)),
 			emit: (eventName, detail) => {
 				emitWindowEvent(eventName, detail);
 			}
@@ -2159,6 +3359,6 @@ 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 };
+export { OUTBOX_FULL_CODE as a, OfflineApi as c, OfflineError as d, UNSUPPORTED_BY_HUB as f, CLIENT_VERSION_HEADER as i, ContentRejectedError as l, createHub as n, OUTBOX_MAX_CHARS as o, hub as r, OUTBOX_MAX_ENTRIES as s, Hub as t, HubError as u };
 
 //# sourceMappingURL=src.js.map