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

package/dist/shared/src.js

@@ -1,58 +1,388 @@
-import { r as _defineProperty } from "./globals.js";
+import { a as readField } from "./globals.js";
+import { t as _defineProperty } from "./defineProperty.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 { f as linkRealtimeToHub } from "./bridge.js";
+import { d as SESSION_EVENT, n as pageBridge, p as linkRealtimeToHub } from "./bridge.js";
 import { t as multiplayerForwarder } from "./mp.js";
+import { t as createRuntimeOpener } from "./runtime-opener.js";
 import { t as raceForwarder } from "./race.js";
 import { n as roomsForwarder, t as isInHubRoom } 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) {
+import { a as isRecord, c as parseJsonText, i as isNumberRecord, l as stringsIn, n as isJsonObject, o as optionalNumber, r as isNullableString, s as optionalString, t as isJson } from "./json-guards.js";
+import { decodeLook, defaultLook, encodeLook, isLookCode } from "@diffenderfer-games/hub-contract/avatar";
+//#region src/core/avatar/avatar-cache.ts
+/**
+* The device's avatar cache (avatars.md §5.6), so faces render offline:
+* your own look (`hub:avatar:me`, read synchronously at startup) and an LRU
+* of other players' codes (`hub:avatar:cache`, 200 entries).
+*/
+const MINE_KEY = "hub:avatar:me";
+const OTHERS_KEY = "hub:avatar:cache";
+const OTHERS_MAX = 200;
+/** The device cache over a key-value store. */
+var AvatarCache = class {
+	constructor(store) {
+		_defineProperty(this, "store", void 0);
+		_defineProperty(this, "others", null);
+		this.store = store;
+	}
+	/** Your cached look, or `null` (never cached, or another player's on this device). */
+	readMine(userId) {
+		const parsed = parseJsonText(this.store.read(MINE_KEY) ?? "");
+		if (!isRecord(parsed)) return null;
+		const id = optionalNumber(parsed.userId);
+		const code = optionalString(parsed.code);
+		if (id === void 0 || code === void 0 || !isLookCode(code) || userId !== null && id !== userId) return null;
+		return {
+			userId: id,
+			code,
+			isDefault: parsed.isDefault === true,
+			updatedAt: optionalNumber(parsed.updatedAt) ?? 0
+		};
+	}
+	/** Remember your look. */
+	writeMine(mine) {
+		this.store.write(MINE_KEY, JSON.stringify(mine));
+		this.remember(mine.userId, mine.code);
+	}
+	/** A player's cached code, or `undefined`. */
+	codeOf(userId) {
+		return this.loadOthers().get(userId);
+	}
+	/** Remember a player's code (most recent last; the oldest drop past 200). */
+	remember(userId, code) {
+		if (code === "") return;
+		const others = this.loadOthers();
+		if (others.get(userId) === code) return;
+		others.delete(userId);
+		others.set(userId, code);
+		while (others.size > OTHERS_MAX) {
+			const oldest = others.keys().next().value;
+			if (oldest === void 0) break;
+			others.delete(oldest);
+		}
+		this.store.write(OTHERS_KEY, JSON.stringify([...others]));
+	}
+	loadOthers() {
+		if (this.others !== null) return this.others;
+		const others = /* @__PURE__ */ new Map();
+		const parsed = parseJsonText(this.store.read(OTHERS_KEY) ?? "[]");
+		if (Array.isArray(parsed)) for (const entry of parsed) {
+			const id = Array.isArray(entry) ? optionalNumber(entry[0]) : void 0;
+			const code = Array.isArray(entry) ? optionalString(entry[1]) : void 0;
+			if (id !== void 0 && code !== void 0 && isLookCode(code)) others.set(id, code);
+		}
+		this.others = others;
+		return others;
+	}
+};
+//#endregion
+//#region src/core/avatar/avatar-ref.ts
+/** Building {@link AvatarRef}s from codes, payloads and seeds. */
+/** A ref for a code (`''` = hidden). */
+function refOf(code, isDefault = false) {
+	if (code === "") return {
+		code: "",
+		look: null,
+		isDefault: false,
+		hidden: true
+	};
+	return {
+		code,
+		look: decodeLook(code)?.look ?? null,
+		isDefault,
+		hidden: false
+	};
+}
+/** A seeded default look as a ref (bots, previews, local pass-and-play seats). */
+function botRef(seed) {
+	const look = defaultLook(seed);
+	return {
+		code: encodeLook(look),
+		look,
+		isDefault: true,
+		hidden: false
+	};
+}
+/** The ref a payload carries; an old hub's payload (no `look`) falls back to the id's default. */
+function refFrom(carrier) {
+	if (carrier.look !== void 0) return refOf(carrier.look);
+	const id = carrier.userId ?? carrier.id ?? carrier.uid;
+	return id === void 0 ? refOf("") : botRef(id);
+}
+//#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 JSON.parse(text);
+		return typeof localStorage === "undefined" ? void 0 : localStorage;
 	} catch {
 		return;
 	}
 }
-/** Whether `candidate` is a JSON object (not an array or `null`). */
-function isJsonObject(candidate) {
-	return isRecord(candidate) && Object.values(candidate).every(isJson);
+/** `localStorage` when available, else a fresh in-memory store. */
+function createPageStore() {
+	const storage = pageStorage();
+	return storage === void 0 ? createMemoryStore() : storageBacked(storage);
 }
 //#endregion
+//#region src/core/avatar/hub-avatar.ts
+const BATCH_MAX = 100;
+const openWithRuntime = createRuntimeOpener(pageBridge);
+/** The look `mine()` gives before the account exists (a new guest's is being made). */
+const NO_ACCOUNT_YET = botRef("you");
+/** `hub.avatar`. */
+var HubAvatar = class {
+	constructor(host) {
+		_defineProperty(this, "host", void 0);
+		_defineProperty(this, "cache", new AvatarCache(createPageStore()));
+		_defineProperty(this, "listeners", /* @__PURE__ */ new Set());
+		_defineProperty(this, "pending", /* @__PURE__ */ new Map());
+		_defineProperty(this, "flushQueued", false);
+		_defineProperty(this, "detachRuntime", null);
+		_defineProperty(this, "lastUserId", void 0);
+		_defineProperty(this, "mineShown", null);
+		_defineProperty(this, "seen", /* @__PURE__ */ new Set());
+		this.host = host;
+		this.lastUserId = host.currentUserId();
+		host.onAccount((user, source) => {
+			this.onAccount(user, source === "session");
+		});
+	}
+	/**
+	* Your look (your default if you never designed one). Works offline from
+	* the device cache. Before your account exists (a new guest's is made just
+	* after the game starts) it resolves at once with a default look, and
+	* `change` brings yours when the account is there.
+	*/
+	async mine() {
+		const userId = this.host.currentUserId();
+		if (userId === null) return this.showMine(NO_ACCOUNT_YET);
+		try {
+			const mine = await this.host.fetchMine();
+			return this.noteMine(userId, mine);
+		} catch (failure) {
+			const cached = this.mineSync();
+			if (cached !== null) return cached;
+			throw failure;
+		}
+	}
+	/** Your cached look, or your default; `null` only while nobody is signed in. */
+	mineSync() {
+		const userId = this.host.currentUserId();
+		if (userId === null) return null;
+		const cached = this.cache.readMine(userId);
+		return this.showMine(cached === null ? botRef(userId) : refOf(cached.code, cached.isDefault));
+	}
+	/** Any player's look: from the cache, else batched with other requests in the same tick. */
+	of(userId) {
+		this.seen.add(userId);
+		const cached = this.cache.codeOf(userId);
+		if (cached !== void 0) return Promise.resolve(refOf(cached));
+		return new Promise((resolve) => {
+			const waiting = this.pending.get(userId) ?? [];
+			waiting.push((code) => {
+				resolve(code === "" ? botRef(userId) : refOf(code));
+			});
+			this.pending.set(userId, waiting);
+			this.scheduleFlush();
+		});
+	}
+	/** Many players' looks at once. */
+	async many(userIds) {
+		const refs = await Promise.all(userIds.map(async (id) => [id, await this.of(id)]));
+		return new Map(refs);
+	}
+	/** The look a payload already carries (a `RoomSeat`, `PlayerLite`, racer or ticket user). No request. */
+	from(carrier) {
+		const ref = refFrom(carrier);
+		const id = carrier.userId ?? carrier.id ?? carrier.uid;
+		if (id !== void 0 && carrier.look !== void 0) {
+			this.seen.add(id);
+			this.cache.remember(id, carrier.look);
+		}
+		return ref;
+	}
+	/** A seeded default for bots, previews and local pass-and-play seats: `bot('local:2')`. */
+	bot(seed) {
+		return botRef(seed);
+	}
+	/** Save your look (designer code paths; queued offline, latest wins). */
+	async save(look) {
+		const code = encodeLook(look);
+		const savedAt = Date.now();
+		const userId = this.host.currentUserId();
+		if (userId !== null) this.noteMine(userId, {
+			code,
+			isDefault: false,
+			updatedAt: savedAt
+		});
+		await this.host.queueSave(code, savedAt);
+		return refOf(code);
+	}
+	/**
+	* Hear about look changes (yours, friends', your room's, and yours when
+	* your account appears). Returns the unsubscribe function. Wait for this
+	* rather than polling `mine()`.
+	*/
+	on(_event, listener) {
+		this.listeners.add(listener);
+		this.attachRuntime();
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	/** Open "Make your avatar" over the game; resolves when it closes. */
+	openDesigner(options = {}) {
+		return new Promise((resolve) => {
+			openWithRuntime((realtime) => {
+				if (realtime.avatar === void 0) {
+					resolve({ saved: false });
+					return;
+				}
+				realtime.avatar.openDesigner(options).then(resolve, () => {
+					resolve({ saved: false });
+				});
+			});
+		});
+	}
+	/** Loads the renderer and its art; resolves when rendering is synchronous. */
+	async load() {
+		const avatar = await import("../avatar.js");
+		await avatar.ready();
+		return avatar;
+	}
+	/** Remember the ref the page was given for your look. */
+	showMine(ref) {
+		this.mineShown = ref.code;
+		return ref;
+	}
+	/** Cache your look; `change` fires when it differs from the one the page last had. */
+	noteMine(userId, mine) {
+		const before = this.mineShown ?? this.cache.readMine(userId)?.code ?? null;
+		this.cache.writeMine({
+			userId,
+			code: mine.code,
+			isDefault: mine.isDefault,
+			updatedAt: mine.updatedAt
+		});
+		const ref = this.showMine(refOf(mine.code, mine.isDefault));
+		if (mine.code !== before) this.emit({
+			userId,
+			ref
+		});
+		return ref;
+	}
+	/** Someone said who is signed in: fetch your look when the account is new or its look isn't the cached one. */
+	onAccount(user, isHello) {
+		const userId = user === null || user.id === 0 ? null : user.id;
+		const isNewAccount = userId !== this.lastUserId;
+		this.lastUserId = userId;
+		if (user === null || userId === null) return;
+		if (isNewAccount || user.look !== null && user.look !== this.cache.readMine(userId)?.code) this.refreshMine(userId);
+		if (isHello) this.recheckSeen();
+	}
+	async refreshMine(userId) {
+		const mine = await this.host.fetchMine().catch(() => null);
+		if (mine !== null && this.host.currentUserId() === userId) this.noteMine(userId, mine);
+	}
+	/** The socket (re)connected: a change sent while it was down never arrived, so ask again. */
+	async recheckSeen() {
+		if (this.listeners.size === 0 || this.seen.size === 0) return;
+		const codes = await this.fetchCodes([...this.seen]);
+		for (const [userId, code] of codes) if (code !== "" && code !== this.cache.codeOf(userId)) {
+			this.cache.remember(userId, code);
+			this.emit({
+				userId,
+				ref: refOf(code)
+			});
+		}
+	}
+	emit(change) {
+		for (const listener of this.listeners) listener(change);
+	}
+	attachRuntime() {
+		if (this.detachRuntime !== null) return;
+		this.detachRuntime = pageBridge.subscribe((realtime) => realtime.avatar?.on("change", ({ userId, code }) => {
+			if (userId === this.host.currentUserId()) {
+				this.noteMine(userId, {
+					code,
+					isDefault: false,
+					updatedAt: Date.now()
+				});
+				return;
+			}
+			this.cache.remember(userId, code);
+			this.emit({
+				userId,
+				ref: refOf(code)
+			});
+		}) ?? (() => void 0));
+	}
+	scheduleFlush() {
+		if (this.flushQueued) return;
+		this.flushQueued = true;
+		queueMicrotask(() => {
+			this.flushQueued = false;
+			this.flush();
+		});
+	}
+	async flush() {
+		const batch = this.pending;
+		this.pending = /* @__PURE__ */ new Map();
+		const codes = await this.fetchCodes([...batch.keys()]);
+		for (const [id, waiting] of batch) {
+			const code = codes.get(id) ?? "";
+			if (code !== "") this.cache.remember(id, code);
+			for (const resolve of waiting) resolve(code);
+		}
+	}
+	/** Players' codes, in batches; offline or failing, the missing ones are left out (they get their default). */
+	async fetchCodes(ids) {
+		const codes = /* @__PURE__ */ new Map();
+		for (let i = 0; i < ids.length; i += BATCH_MAX) {
+			const slice = ids.slice(i, i + BATCH_MAX);
+			const answered = await this.host.fetchCodes(slice).catch(() => ({}));
+			for (const id of slice) {
+				const code = answered[String(id)];
+				if (code !== void 0) codes.set(id, code);
+			}
+		}
+		return codes;
+	}
+};
+//#endregion
 //#region src/core/errors.ts
 /**
 * The code a client gives a call the hub does not have yet (a newer client on
@@ -60,6 +390,12 @@ function isJsonObject(candidate) {
 */
 const UNSUPPORTED_BY_HUB = "unsupported_by_hub";
 /**
+* The code `getSave` rejects with when the hub can't be reached and this
+* device has no copy of the slot it can trust (a fresh device or cleared
+* browser): the slot may well hold a save, so it is not reported empty.
+*/
+const SAVE_UNKNOWN_CODE = "save_unknown";
+/**
 * 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
@@ -75,6 +411,7 @@ var HubError = class extends Error {
 		_defineProperty(this, "hint", void 0);
 		_defineProperty(this, "retryAfterMs", void 0);
 		_defineProperty(this, "until", void 0);
+		_defineProperty(this, "rule", void 0);
 		this.name = "HubError";
 		this.status = status;
 		this.code = details.code;
@@ -82,6 +419,7 @@ var HubError = class extends Error {
 		this.hint = details.hint;
 		this.retryAfterMs = details.retryAfterMs;
 		this.until = details.until;
+		this.rule = details.rule;
 	}
 	/** `true` when the failure was a network or transport error, not an HTTP status. */
 	get isOffline() {
@@ -117,12 +455,13 @@ function readErrorFields(body) {
 		reason: optionalString(body.reason),
 		hint: optionalString(body.hint),
 		retryAfterMs: optionalNumber(body.retryAfterMs),
-		until: optionalNumber(body.until)
+		until: optionalNumber(body.until),
+		rule: optionalString(body.rule)
 	};
 }
 /** 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);
+	return status === 422 && details.code !== "illegal" || 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
@@ -138,50 +477,6 @@ function toHubError(thrown) {
 	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);
-}
-//#endregion
 //#region src/core/offline/favorites.ts
 /**
 * Starred games are site-wide, not per game, so they live under one global
@@ -255,6 +550,36 @@ function gameKind(definition) {
 	};
 }
 //#endregion
+//#region src/core/offline/hub-kinds/avatar-kind.ts
+/** The kind name. */
+const AVATAR_KIND = "hub.avatar";
+function readAvatar(stored) {
+	if (!isRecord(stored)) return;
+	const code = optionalString(stored.code);
+	const savedAt = optionalNumber(stored.savedAt);
+	return code === void 0 || savedAt === void 0 ? void 0 : {
+		code,
+		savedAt
+	};
+}
+/** The avatar kind, by name. */
+function avatarKinds() {
+	return { [AVATAR_KIND]: checkedKind(readAvatar, {
+		mergeKey: () => "avatar",
+		replaces: true,
+		run: async (op, context) => {
+			const look = decodeLook(op.code)?.look;
+			if (look !== void 0) await context.call("saveMyAvatar", {
+				look: {
+					...look,
+					accessories: [...look.accessories]
+				},
+				savedAt: op.savedAt
+			});
+		}
+	}) };
+}
+//#endregion
 //#region src/core/offline/hub-kinds/daily-kind.ts
 /** The kind name. */
 const DAILY_KIND = "hub.daily";
@@ -555,23 +880,36 @@ function mergeStats(waiting, incoming) {
 		case "set": return incoming;
 	}
 }
-/** The progress kinds, by name. */
-function progressKinds(game) {
+/**
+* The progress kinds, by name. A save write replayed from the queue sends
+* the hub's `updatedAt` this device last saw for the slot (`null` when it
+* saw it empty or never saw it), so the hub refuses it (409 `save_conflict`,
+* dropped and reported as a conflict) when another device saved since. A
+* write sent at once, online, always lands, as before.
+*/
+function progressKinds(game, cloudSaves) {
 	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", {
+				if ("deleted" in save) {
+					await context.call("deleteSave", {
+						...game(),
+						slot: save.slot
+					});
+					cloudSaves.rememberCloudSave(save.slot, null);
+					return;
+				}
+				const base = context.isReplay ? { base: cloudSaves.cloudSave(save.slot) ?? null } : {};
+				const written = await context.call("writeSave", {
 					...game(),
 					slot: save.slot,
 					data: save.data,
-					label: save.label
+					label: save.label,
+					...base
 				});
+				cloudSaves.rememberCloudSave(save.slot, written.updatedAt);
 			}
 		}),
 		[PROGRESS_KINDS.stat]: checkedKind(readStat, {
@@ -706,6 +1044,74 @@ function resumeKinds(game, local) {
 	}) };
 }
 //#endregion
+//#region src/core/offline/hub-kinds/saved-kind.ts
+/** The kind name. */
+const SAVED_KIND = "hub.saved";
+function readSaved(stored) {
+	if (!isRecord(stored) || stored.action !== "save" && stored.action !== "discard") return;
+	const game = optionalString(stored.game);
+	const day = optionalString(stored.day);
+	const at = optionalNumber(stored.at);
+	return game === void 0 || day === void 0 || at === void 0 ? void 0 : {
+		action: stored.action,
+		game,
+		day,
+		at
+	};
+}
+/** Whether a failure means the instance is gone or closed on the hub (the change is moot). */
+function isGoneOrClosed(failure) {
+	return failure instanceof HubError && (failure.status === 404 || failure.status === 409);
+}
+/** The hub's id for the copy's day: its own, or the one the hub gives the day when it was started offline (`null`: already completed). */
+async function resolveId(copy, context) {
+	if (!copy.id.startsWith("local:")) return copy.id;
+	return (await context.call("startDailyChallenge", {
+		slug: copy.game,
+		day: copy.day
+	})).instanceId;
+}
+/** Run one op against the copy it names. */
+async function runSaved(op, local, context) {
+	const copy = local.read(op.game, op.day);
+	if (copy === null) return;
+	try {
+		const id = await resolveId(copy, context);
+		if (id === null) {
+			local.remove(op.game, op.day);
+			return;
+		}
+		if (op.action === "discard") {
+			await context.call("discardSavedGame", { id });
+			local.remove(op.game, op.day);
+			return;
+		}
+		if (copy.status === "active") await context.call("saveSavedGameState", {
+			id,
+			state: copy.state,
+			progress: {
+				label: copy.label,
+				fraction: copy.fraction
+			},
+			title: copy.title,
+			version: copy.version,
+			savedAt: copy.at
+		});
+		local.markSynced(op.game, op.day, copy.at, id);
+	} catch (failure) {
+		if (!(failure instanceof Error) || !isGoneOrClosed(failure)) throw failure;
+		local.remove(op.game, op.day);
+	}
+}
+/** The saved-games kind, by name, over the device copies in `local`. */
+function savedKinds(local) {
+	return { [SAVED_KIND]: checkedKind(readSaved, {
+		mergeKey: (op) => `daily:${op.game}#${op.day}`,
+		replaces: true,
+		run: (op, context) => runSaved(op, local, context)
+	}) };
+}
+//#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) {
@@ -774,13 +1180,70 @@ function legacyOperation(op) {
 /** Register every hub kind on `outbox`. */
 function registerHubKinds(outbox, hooks) {
 	const kinds = {
-		...progressKinds(hooks.game),
+		...progressKinds(hooks.game, hooks.cloudSaves),
 		...dailyKinds(hooks.game, hooks.onDailyComplete),
 		...economyKinds(hooks.game, writeLocalFavorites),
-		...resumeKinds(hooks.game, hooks.resume)
+		...resumeKinds(hooks.game, hooks.resume),
+		...avatarKinds(),
+		...savedKinds(hooks.dailies)
 	};
 	for (const [kind, definition] of Object.entries(kinds)) outbox.define(kind, definition);
 }
+//#endregion
+//#region src/core/offline/cloud-saves.ts
+/**
+* What this device last saw of a game's save slots on the hub, per player:
+* each slot's `updatedAt` there, or `null` for a slot known to be empty. It
+* decides two things offline. `getSave` answers from the cache only when
+* the device knows the hub's copy of that slot (so a fresh device or cleared
+* browser never reports "no save" for a slot it simply hasn't seen), and a
+* queued save write sends the hub's `updatedAt` it was built on, so the hub
+* refuses it when the slot has changed since.
+*
+* A snapshot gives the full list (`complete`: any other slot is empty); a
+* single read or write adds that slot to a partial list.
+*/
+/** A stored index, or `null` when missing or malformed. */
+function readCloudSaveIndex(stored) {
+	if (!isRecord(stored) || typeof stored.complete !== "boolean" || !isRecord(stored.saves)) return null;
+	const userId = optionalNumber(stored.userId);
+	if (userId === void 0) return null;
+	const saves = {};
+	for (const [slot, updatedAt] of Object.entries(stored.saves)) {
+		const known = updatedAt === null ? null : optionalNumber(updatedAt);
+		if (known === void 0) return null;
+		saves[slot] = known;
+	}
+	return {
+		userId,
+		complete: stored.complete,
+		saves
+	};
+}
+/**
+* The hub's `updatedAt` for `slot` as `userId` last saw it: a number, `null`
+* when the slot was empty, or `undefined` when this device doesn't know.
+*/
+function cloudSaveOf(index, userId, slot) {
+	if (index?.userId !== userId) return;
+	const updatedAt = index.saves[slot];
+	return updatedAt === void 0 && index.complete ? null : updatedAt;
+}
+/** `index` with `slot` seen at `updatedAt` (`null`: empty) by `userId`; another player's index starts over. */
+function withCloudSave(index, userId, slot, updatedAt) {
+	const base = index?.userId === userId ? index : {
+		userId,
+		complete: false,
+		saves: {}
+	};
+	return {
+		...base,
+		saves: {
+			...base.saves,
+			[slot]: updatedAt
+		}
+	};
+}
 /** The well-formed events of a stored buffer. */
 function readEvents(stored) {
 	if (!Array.isArray(stored)) return [];
@@ -867,7 +1330,7 @@ function withoutGoods(inventory, goods) {
 //#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) {
+function readUser$1(stored) {
 	if (!isRecord(stored)) return null;
 	const id = optionalNumber(stored.id);
 	const username = optionalString(stored.username);
@@ -939,7 +1402,7 @@ var LocalStore = class {
 	}
 	/** The locally known user. */
 	getUser() {
-		return readUser(this.readStored(USER_KEY));
+		return readUser$1(this.readStored(USER_KEY));
 	}
 	/** Remember the user (offline sign-in, or a snapshot). */
 	setUser(user) {
@@ -994,6 +1457,28 @@ var LocalStore = class {
 	deleteSave(slot) {
 		this.store.remove(`${this.prefix}save:${slot}`);
 	}
+	/**
+	* The hub's `updatedAt` for `slot` as the current user last saw it (`null`:
+	* the slot was empty), or `undefined` when this device doesn't know.
+	*/
+	cloudSave(slot) {
+		const user = this.getUser();
+		return user === null ? void 0 : cloudSaveOf(this.readCloudSaves(this.prefix), user.id, slot);
+	}
+	/** Note the hub's copy of `slot` (just read or written) for the current user: its `updatedAt`, or `null` when empty. */
+	rememberCloudSave(slot, updatedAt) {
+		const user = this.getUser();
+		if (user !== null) this.writeStored(`${this.prefix}cloud-saves`, withCloudSave(this.readCloudSaves(this.prefix), user.id, slot, updatedAt));
+	}
+	/** Cache a slot as read from the hub (forgetting it when the hub has none), and note the hub's copy. */
+	cacheCloudSave(slot, save) {
+		if (save === null) this.deleteSave(slot);
+		else this.writeStored(`${this.prefix}save:${slot}`, save);
+		this.rememberCloudSave(slot, save?.updatedAt ?? null);
+	}
+	readCloudSaves(gamePrefix) {
+		return readCloudSaveIndex(this.readStored(`${gamePrefix}cloud-saves`));
+	}
 	/** This game's cached stats. */
 	getStats() {
 		const stored = this.readStored(`${this.prefix}stats`);
@@ -1070,13 +1555,32 @@ var LocalStore = class {
 			ts: Date.now()
 		}));
 	}
-	/** Fan a `/me/snapshot` reply out across every game's cache keys. */
+	/**
+	* Fan a `/me/snapshot` reply out across every game's cache keys. It lists
+	* every save slot of every game the player has played, so each game's
+	* slots on the hub become known (and this game's are all empty when it
+	* isn't listed).
+	*/
 	hydrate(snapshot) {
 		if (snapshot.user !== null) this.writeStored(USER_KEY, snapshot.user);
+		const userId = snapshot.user?.id;
+		if (userId !== void 0 && !Object.keys(snapshot.games).some((slug) => `hub:${slug}:` === this.prefix)) this.writeStored(`${this.prefix}cloud-saves`, {
+			userId,
+			complete: true,
+			saves: {}
+		});
 		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);
+			if (userId !== void 0) {
+				const saves = Object.fromEntries(game.saves.map((save) => [save.slot, save.updatedAt]));
+				this.writeStored(`${gamePrefix}cloud-saves`, {
+					userId,
+					complete: true,
+					saves
+				});
+			}
 			this.writeStored(`${gamePrefix}stats`, game.stats);
 			this.writeStored(`${gamePrefix}inventory`, game.inventory);
 		}
@@ -1171,7 +1675,7 @@ function newEntryId(now, sequence) {
 	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) {
+function readEntry$1(stored) {
 	if (!isRecord(stored) || !isJson(stored.payload)) return;
 	const id = optionalString(stored.id);
 	const kind = optionalString(stored.kind);
@@ -1394,7 +1898,7 @@ var OutboxStore = class {
 		const entries = [];
 		for (const key of this.entryKeys()) {
 			const text = this.store.read(key);
-			const entry = text === null ? void 0 : readEntry(parseJsonText(text));
+			const entry = text === null ? void 0 : readEntry$1(parseJsonText(text));
 			if (entry === void 0) this.store.remove(key);
 			else entries.push(entry);
 		}
@@ -1407,7 +1911,7 @@ var OutboxStore = class {
 	/** 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));
+		return text === null ? void 0 : readEntry$1(parseJsonText(text));
 	}
 	/** Whether `extra` more stored characters in one more entry still fit under the caps. */
 	fits(extraChars) {
@@ -1662,8 +2166,8 @@ function outboxFull() {
 }
 //#endregion
 //#region src/core/resume/local-resume.ts
-const KEY_PATTERN = /^hub:(.+):resume$/;
-function keyFor(slug) {
+const KEY_PATTERN$1 = /^hub:(.+):resume$/;
+function keyFor$1(slug) {
 	return `hub:${slug}:resume`;
 }
 /** A stored record read back, or `null` when missing or malformed. */
@@ -1705,18 +2209,18 @@ var LocalResumeStore = class {
 	}
 	/** `slug`'s copy, or `null`. */
 	read(slug) {
-		const text = this.store.read(keyFor(slug));
+		const text = this.store.read(keyFor$1(slug));
 		return text === null ? null : readRecord(parseJsonText(text));
 	}
 	/** Store `slug`'s copy; answers whether it stuck (a full storage refuses a large state). */
 	write(slug, record) {
 		const text = JSON.stringify(record);
-		this.store.write(keyFor(slug), text);
-		return this.store.read(keyFor(slug)) === text;
+		this.store.write(keyFor$1(slug), text);
+		return this.store.read(keyFor$1(slug)) === text;
 	}
 	/** Forget `slug`'s copy. */
 	remove(slug) {
-		this.store.remove(keyFor(slug));
+		this.store.remove(keyFor$1(slug));
 	}
 	/** The hub now has `slug`'s save or clear made at `at`: mark it synced (a clear is simply forgotten). */
 	markSynced(slug, at) {
@@ -1732,7 +2236,7 @@ var LocalResumeStore = class {
 	all() {
 		const records = /* @__PURE__ */ new Map();
 		for (const key of this.store.keys()) {
-			const slug = KEY_PATTERN.exec(key)?.[1];
+			const slug = KEY_PATTERN$1.exec(key)?.[1];
 			const record = slug === void 0 ? null : this.read(slug);
 			if (slug !== void 0 && record !== null) records.set(slug, record);
 		}
@@ -1740,26 +2244,118 @@ var LocalResumeStore = class {
 	}
 };
 //#endregion
-//#region src/core/page.ts
-/** Whether this code runs in a browser page. */
-function isBrowserPage() {
-	return typeof window !== "undefined";
+//#region src/core/saved/local-saved.ts
+const KEY_PATTERN = /^hub:(.+):daily:(\d{4}-\d{2}-\d{2})$/;
+const STATUSES = [
+	"active",
+	"finished",
+	"discarded"
+];
+function keyFor(game, day) {
+	return `hub:${game}:daily:${day}`;
 }
-/** 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);
+/** A stored copy read back, or `null` when missing or malformed. */
+function readCopy(stored) {
+	if (!isRecord(stored)) return null;
+	const id = optionalString(stored.id);
+	const game = optionalString(stored.game);
+	const day = optionalString(stored.day);
+	const seed = optionalNumber(stored.seed);
+	const at = optionalNumber(stored.at);
+	const label = optionalString(stored.label);
+	const version = optionalNumber(stored.version);
+	const gameTitle = optionalString(stored.gameTitle);
+	const userId = stored.userId === null ? null : optionalNumber(stored.userId);
+	const fraction = stored.fraction === null ? null : optionalNumber(stored.fraction);
+	const status = STATUSES.find((candidate) => candidate === stored.status);
+	if (id === void 0 || game === void 0 || day === void 0 || seed === void 0 || at === void 0 || label === void 0 || version === void 0 || gameTitle === void 0 || userId === void 0 || fraction === void 0 || status === void 0 || !isNullableString(stored.title) || !isJson(stored.state)) return null;
 	return {
-		...slug === void 0 ? {} : { slug },
-		...apiBase === void 0 ? {} : { apiBase }
-	};
-}
-/** The game's display title: the host's injected one, else the page's `<title>`, else `fallback`. */
-function detectGameTitle(fallback) {
-	const injected = isBrowserPage() && isRecord(window.__HUB__) ? optionalString(window.__HUB__.title) : void 0;
-	if (injected !== void 0 && injected !== "") return injected;
-	const pageTitle = typeof document === "undefined" ? "" : document.title.trim();
+		id,
+		game,
+		day,
+		seed,
+		status,
+		userId,
+		at,
+		label,
+		fraction,
+		title: stored.title,
+		version,
+		gameTitle,
+		state: stored.state,
+		isSynced: stored.isSynced === true
+	};
+}
+/** The device copies of daily challenges. */
+var LocalDailyStore = class {
+	constructor(store) {
+		_defineProperty(this, "store", void 0);
+		this.store = store;
+	}
+	/** The copy of `game`'s `day`, or `null`. */
+	read(game, day) {
+		const text = this.store.read(keyFor(game, day));
+		return text === null ? null : readCopy(parseJsonText(text));
+	}
+	/** Store a copy; answers whether it stuck (a full storage refuses a large state). */
+	write(copy) {
+		const text = JSON.stringify(copy);
+		this.store.write(keyFor(copy.game, copy.day), text);
+		return this.store.read(keyFor(copy.game, copy.day)) === text;
+	}
+	/** Forget a copy. */
+	remove(game, day) {
+		this.store.remove(keyFor(game, day));
+	}
+	/** The hub has the change made at `at` (and calls the instance `id`): mark it synced; a closed copy is forgotten. */
+	markSynced(game, day, at, id) {
+		const copy = this.read(game, day);
+		if (copy === null || copy.at !== at) {
+			if (copy !== null && id !== void 0 && copy.id !== id) this.write({
+				...copy,
+				id
+			});
+			return;
+		}
+		if (copy.status === "active") this.write({
+			...copy,
+			id: id ?? copy.id,
+			isSynced: true
+		});
+		else this.remove(game, day);
+	}
+	/** Every copy of `userId`'s, any game. */
+	all(userId) {
+		const copies = [];
+		for (const key of this.store.keys()) {
+			const match = KEY_PATTERN.exec(key);
+			const copy = match?.[1] === void 0 || match[2] === void 0 ? null : this.read(match[1], match[2]);
+			if (copy !== null && copy.userId === userId) copies.push(copy);
+		}
+		return copies;
+	}
+};
+//#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 display title: the host's injected one, else the page's `<title>`, else `fallback`. */
+function detectGameTitle(fallback) {
+	const injected = isBrowserPage() && isRecord(window.__HUB__) ? optionalString(window.__HUB__.title) : void 0;
+	if (injected !== void 0 && injected !== "") return injected;
+	const pageTitle = typeof document === "undefined" ? "" : document.title.trim();
 	return pageTitle === "" ? fallback : pageTitle;
 }
 /** The game's slug: the injected one, else the first URL path segment, else `null`. */
@@ -1969,6 +2565,12 @@ const ROUTES = {
 		query: [],
 		offline: null
 	},
+	resumeDailyChallenge: {
+		method: "POST",
+		path: "/daily/instances/:id/resume",
+		query: [],
+		offline: null
+	},
 	startDailyChallenge: {
 		method: "POST",
 		path: "/games/:slug/daily/:day/start",
@@ -2209,6 +2811,12 @@ const ROUTES = {
 		query: [],
 		offline: null
 	},
+	setQuietHours: {
+		method: "PUT",
+		path: "/social/notify/quiet",
+		query: [],
+		offline: null
+	},
 	subscribeToPush: {
 		method: "POST",
 		path: "/social/push",
@@ -2441,6 +3049,174 @@ const ROUTES = {
 		path: "/me/resume",
 		query: [],
 		offline: null
+	},
+	getMyAvatar: {
+		method: "GET",
+		path: "/avatar/me",
+		query: [],
+		offline: null
+	},
+	recordAvatarNudge: {
+		method: "POST",
+		path: "/avatar/me/nudge",
+		query: [],
+		offline: null
+	},
+	saveMyAvatar: {
+		method: "PUT",
+		path: "/avatar/me",
+		query: [],
+		offline: null
+	},
+	resetMyAvatar: {
+		method: "DELETE",
+		path: "/avatar/me",
+		query: [],
+		offline: null
+	},
+	getAvatar: {
+		method: "GET",
+		path: "/avatar/of/:id",
+		query: [],
+		offline: null
+	},
+	getAvatars: {
+		method: "POST",
+		path: "/avatar/batch",
+		query: [],
+		offline: null
+	},
+	listMySavedGames: {
+		method: "GET",
+		path: "/saved",
+		query: ["game", "kinds"],
+		offline: null
+	},
+	getSavedGame: {
+		method: "GET",
+		path: "/saved/:id",
+		query: [],
+		offline: null
+	},
+	saveSavedGameState: {
+		method: "PUT",
+		path: "/saved/:id/state",
+		query: [],
+		offline: "replay"
+	},
+	discardSavedGame: {
+		method: "POST",
+		path: "/saved/:id/discard",
+		query: [],
+		offline: "replay"
+	},
+	discardGameSavedGames: {
+		method: "POST",
+		path: "/games/:slug/saved/discard",
+		query: [],
+		offline: null
+	},
+	createTurnGame: {
+		method: "POST",
+		path: "/turns",
+		query: [],
+		offline: null
+	},
+	joinTurnGame: {
+		method: "POST",
+		path: "/turns/:id/join",
+		query: [],
+		offline: null
+	},
+	joinTurnGameByLink: {
+		method: "POST",
+		path: "/turns/join",
+		query: [],
+		offline: null
+	},
+	startTurnGame: {
+		method: "POST",
+		path: "/turns/:id/start",
+		query: [],
+		offline: null
+	},
+	moveTurnGame: {
+		method: "POST",
+		path: "/turns/:id/moves",
+		query: [],
+		offline: null
+	},
+	leaveTurnGame: {
+		method: "POST",
+		path: "/turns/:id/leave",
+		query: [],
+		offline: null
+	},
+	nudgeTurnGame: {
+		method: "POST",
+		path: "/turns/:id/nudge",
+		query: [],
+		offline: null
+	},
+	setTurnGameNotify: {
+		method: "PUT",
+		path: "/turns/:id/notify",
+		query: [],
+		offline: null
+	},
+	rematchTurnGame: {
+		method: "POST",
+		path: "/turns/:id/rematch",
+		query: [],
+		offline: null
+	},
+	inviteToTurnGame: {
+		method: "POST",
+		path: "/turns/:id/invite",
+		query: [],
+		offline: null
+	},
+	shareTurnGame: {
+		method: "POST",
+		path: "/turns/:id/share",
+		query: [],
+		offline: null
+	},
+	autoPlayTurn: {
+		method: "POST",
+		path: "/turns/:id/auto",
+		query: [],
+		offline: null
+	},
+	chatInTurnGame: {
+		method: "POST",
+		path: "/turns/:id/chat",
+		query: [],
+		offline: null
+	},
+	getTurnGame: {
+		method: "GET",
+		path: "/turns/:id",
+		query: [],
+		offline: null
+	},
+	getTurnGameHistory: {
+		method: "GET",
+		path: "/turns/:id/history",
+		query: ["since"],
+		offline: null
+	},
+	listOpenTurnGames: {
+		method: "GET",
+		path: "/open-turns",
+		query: ["game"],
+		offline: null
+	},
+	listMyTurnGames: {
+		method: "GET",
+		path: "/turns",
+		query: ["game"],
+		offline: null
 	}
 };
 /** The request header that carries an offline operation key (the contract's `OFFLINE_OP_HEADER`). */
@@ -2565,6 +3341,7 @@ var HubConnection = class {
 		_defineProperty(this, "store", void 0);
 		_defineProperty(this, "outbox", void 0);
 		_defineProperty(this, "resumeStore", void 0);
+		_defineProperty(this, "dailyStore", void 0);
 		_defineProperty(this, "offlineMode", void 0);
 		_defineProperty(this, "isReachable", true);
 		_defineProperty(this, "runningSync", null);
@@ -2587,6 +3364,7 @@ var HubConnection = class {
 		const pageStore = createPageStore();
 		this.store = new LocalStore(this.slug ?? "app", pageStore);
 		this.resumeStore = new LocalResumeStore(pageStore);
+		this.dailyStore = new LocalDailyStore(pageStore);
 		this.outbox = new Outbox({
 			slug: this.slug ?? "app",
 			store: pageStore,
@@ -2605,6 +3383,7 @@ var HubConnection = class {
 		registerHubKinds(this.outbox, {
 			game: () => this.gameFields(),
 			onDailyComplete: (payload, completion) => {
+				if (this.slug !== null) this.dailyStore.remove(this.slug, payload.day);
 				emitWindowEvent("hub:daily-complete", {
 					day: payload.day,
 					count: completion.count,
@@ -2612,7 +3391,9 @@ var HubConnection = class {
 					meta: payload.meta
 				});
 			},
-			resume: this.resumeStore
+			resume: this.resumeStore,
+			dailies: this.dailyStore,
+			cloudSaves: this.store
 		});
 		this.importLegacyQueue();
 		if (typeof navigator !== "undefined" && "onLine" in navigator) this.isReachable = navigator.onLine;
@@ -2844,6 +3625,93 @@ var HubConnection = class {
 	}
 };
 //#endregion
+//#region src/core/page-account.ts
+/**
+* Who the page is signed in as, as the hub tells it, so `hub.userId()` and
+* `hub.avatar` follow the account without the game calling `hub.me()`:
+*
+* - the menu's `hub:account` (every refresh: after it makes a new guest's
+*   account, after sign-in) and `hub:auth` (the account changed);
+* - the social runtime's {@link SESSION_EVENT} each time its socket says
+*   hello (connected, or connected again after a drop);
+* - this client's own sign-in, sign-up, claim and sign-out.
+*
+* One per page: every bundle's copy hears the same window events.
+*/
+/** The window events that say who is signed in (`{ user }`). */
+const ACCOUNT_EVENTS = ["hub:account", "hub:auth"];
+/** The page's account, as last heard. */
+var PageAccount = class {
+	constructor() {
+		_defineProperty(this, "heard", void 0);
+		_defineProperty(this, "listeners", /* @__PURE__ */ new Set());
+		_defineProperty(this, "isListening", false);
+		this.listen();
+	}
+	/** The signed-in player, `null` when signed out, `undefined` before anything said. */
+	get user() {
+		this.listen();
+		return this.heard;
+	}
+	/** Record who is signed in (this client's own sign-in or sign-out) and tell the listeners. */
+	note(user, source = "account") {
+		this.heard = user;
+		for (const listener of [...this.listeners]) listener(user, source);
+	}
+	/** Hear every report; returns the unsubscribe function. */
+	on(listener) {
+		this.listen();
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	/** Listen to the window events (at once in a page; made before a window existed, on first use). */
+	listen() {
+		if (this.isListening || !isBrowserPage()) return;
+		this.isListening = true;
+		for (const eventName of ACCOUNT_EVENTS) window.addEventListener(eventName, (event) => {
+			this.onEvent(event, "account");
+		});
+		window.addEventListener(SESSION_EVENT, (event) => {
+			this.onEvent(event, "session");
+		});
+	}
+	onEvent(event, source) {
+		if (!(event instanceof CustomEvent)) return;
+		const user = readUser(event.detail);
+		if (user !== void 0) this.note(user, source);
+	}
+};
+/** A page user from an account the hub sent (`look` when it has one). */
+function toPageUser(user) {
+	return {
+		id: user.id,
+		look: lookOrNull(user.look)
+	};
+}
+/** A non-empty look code, else `null`. */
+function lookOrNull(look) {
+	return typeof look === "string" && look !== "" ? look : null;
+}
+/** The user in a `{ user }` detail: the user, `null` (signed out), or `undefined` (it doesn't say). */
+function readUser(detail) {
+	const user = readField(detail, "user");
+	if (user === null) return null;
+	const id = readField(user, "id");
+	if (typeof id !== "number" || !Number.isInteger(id)) return;
+	return {
+		id,
+		look: lookOrNull(readField(user, "look"))
+	};
+}
+let pageAccountSingleton = null;
+/** The page's account tracker (made on first use; the hub client makes it at load). */
+function pageAccount() {
+	pageAccountSingleton ?? (pageAccountSingleton = new PageAccount());
+	return pageAccountSingleton;
+}
+//#endregion
 //#region src/core/hub-progress.ts
 /** A profile with the game's own data typed as `TData`. */
 function typedProfile(profile) {
@@ -2861,9 +3729,29 @@ function typedSave(save) {
 }
 /** Accounts, profile, saves, stats and leaderboards. */
 var HubProgress = class extends HubConnection {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "account", pageAccount());
+	}
+	/**
+	* Your user id, or `null` when nobody is signed in (also before an offline
+	* first visit has an account). Synchronous, and it follows the account as
+	* the hub changes it (a new guest's account made by the menu, sign-in,
+	* sign-out) with no `hub.me()` needed. Compare it with a seat's `userId`
+	* to find yours.
+	*/
+	userId() {
+		const heard = this.account.user;
+		const id = heard === void 0 ? this.store.getUser()?.id ?? null : heard?.id ?? null;
+		return id === 0 ? null : id;
+	}
 	/** The current user (or `null`) and the games they have a profile in. */
 	me() {
-		return this.withFallback(() => this.rest.call("getCurrentUser"), () => {
+		return this.withFallback(async () => {
+			const reply = await this.rest.call("getCurrentUser");
+			this.account.note(reply.user === null ? null : toPageUser(reply.user));
+			return reply;
+		}, () => {
 			const profile = this.store.getProfile();
 			return {
 				user: this.store.getUser(),
@@ -2880,16 +3768,14 @@ var HubProgress = class extends HubConnection {
 	* sign-in. Idempotent. Offline, a local guest is used.
 	*/
 	ensureGuest() {
-		return this.withFallback(() => this.rest.call("ensureGuestSession"), () => {
+		return this.withFallback(async () => this.signedIn(await this.rest.call("ensureGuestSession")), () => {
 			const known = this.store.getUser();
 			if (known !== null) return { user: known };
-			const guest = {
+			return this.signInLocally({
 				id: 0,
 				username: "Guest-local",
 				guest: true
-			};
-			this.store.setUser(guest);
-			return { user: guest };
+			});
 		});
 	}
 	/**
@@ -2898,10 +3784,10 @@ var HubProgress = class extends HubConnection {
 	* the name is taken; the player should `login` instead.
 	*/
 	claim(username, password) {
-		return this.withFallback(() => this.rest.call("claimGuestAccount", {
+		return this.withFallback(async () => this.signedIn(await this.rest.call("claimGuestAccount", {
 			username,
 			password
-		}), () => this.signInLocally({
+		})), () => this.signInLocally({
 			id: 0,
 			username,
 			guest: false
@@ -2909,35 +3795,53 @@ var HubProgress = class extends HubConnection {
 	}
 	/** Create an account and sign in. (Offline: a local user is stored.) */
 	signup(username, password) {
-		return this.withFallback(() => this.rest.call("signUpWithPassword", {
+		return this.withFallback(async () => this.signedIn(await this.rest.call("signUpWithPassword", {
 			username,
 			password
-		}), () => this.signInLocally({
+		})), () => 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", {
+		return this.withFallback(async () => this.signedIn(await this.rest.call("logInWithPassword", {
 			username,
 			password
-		}), () => this.signInLocally({
+		})), () => 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 this.withFallback(async () => {
+			const reply = await this.rest.call("logOut");
+			this.signedOut();
+			return reply;
+		}, () => {
+			this.signedOut();
 			return { ok: true };
 		});
 	}
 	signInLocally(user) {
-		this.store.setUser(user);
+		this.remember(user);
 		return { user };
 	}
+	/** Remember who the hub signed in, so the cache's notes about the hub's copies are read for the right player. */
+	signedIn(reply) {
+		this.remember(reply.user);
+		return reply;
+	}
+	/** The cache and the page (`hub.userId()`, `hub.avatar`) learn who is signed in. */
+	remember(user) {
+		this.store.setUser(user);
+		this.account.note(toPageUser(user));
+	}
+	signedOut() {
+		this.store.clearUser();
+		this.account.note(null);
+	}
 	/** 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()) }));
@@ -2960,12 +3864,29 @@ var HubProgress = class extends HubConnection {
 	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. */
+	/**
+	* One slot's contents, or `save: null` when the slot is empty. `TData` is
+	* the game's own save type. Offline it answers from the device's copy, but
+	* only when the device knows the hub's copy of the slot; otherwise (a fresh
+	* device or cleared browser) it rejects with a {@link HubError} whose
+	* `code` is `save_unknown` (`isOffline` is `true`), never a false "empty".
+	*/
 	getSave(slot) {
-		return this.withFallback(async () => ({ save: typedSave((await this.rest.call("getSave", {
-			...this.gameFields(),
-			slot
-		})).save) }), () => ({ save: typedSave(this.store.getSave(slot)) }));
+		return this.withFallback(async () => {
+			const { save } = await this.rest.call("getSave", {
+				...this.gameFields(),
+				slot
+			});
+			if (this.outbox.count() === 0) this.store.cacheCloudSave(slot, save);
+			return { save: typedSave(save) };
+		}, () => ({ save: typedSave(this.offlineSave(slot)) }));
+	}
+	/** The device's copy of `slot`, when it can be trusted offline (see {@link getSave}). */
+	offlineSave(slot) {
+		const isLocalOnly = this.store.getUser()?.id === 0;
+		const hasQueuedWrite = this.outbox.pending().some((op) => op.kind === PROGRESS_KINDS.save && isRecord(op.payload) && op.payload.slot === slot);
+		if (!isLocalOnly && !hasQueuedWrite && this.store.cloudSave(slot) === void 0) throw new HubError(`Hub: offline, and this device hasn't seen save "${slot}" yet.`, void 0, { code: SAVE_UNKNOWN_CODE });
+		return this.store.getSave(slot);
 	}
 	/** Create or overwrite a save slot. `saveData` is any JSON up to 64 KB. */
 	putSave(slot, saveData, label) {
@@ -3376,7 +4297,7 @@ function mergeResumeLists(hub, copies, userId) {
 /** The query parameter (the contract's `RESUME_REQUEST_PARAM`; the browser client carries no contract code). */
 const RESUME_REQUEST_PARAM = "hub_resume";
 /** Where the answer is kept for the page. */
-const PAGE_FLAG = "__HUB_RESUME_REQUESTED__";
+const PAGE_FLAG$2 = "__HUB_RESUME_REQUESTED__";
 /** Take `hub_resume` out of the address bar, keeping the rest of the URL and the history state. */
 function stripParam(url) {
 	url.searchParams.delete(RESUME_REQUEST_PARAM);
@@ -3398,9 +4319,9 @@ function takeParam() {
 /** `true` when the page was opened to resume (synchronous, so a game can decide before it routes or draws). */
 function isResumeRequested() {
 	if (!isBrowserPage()) return false;
-	if (Reflect.has(window, PAGE_FLAG)) return Reflect.get(window, PAGE_FLAG) === true;
+	if (Reflect.has(window, PAGE_FLAG$2)) return Reflect.get(window, PAGE_FLAG$2) === true;
 	const isRequested = takeParam();
-	Reflect.set(window, PAGE_FLAG, isRequested);
+	Reflect.set(window, PAGE_FLAG$2, isRequested);
 	return isRequested;
 }
 //#endregion
@@ -3413,14 +4334,17 @@ const RESUME_MAX_STATE_BYTES = 524288;
 const BLOCKED_HINTS = {
 	daily: "a daily challenge is active. When the player leaves a daily without finishing it, call hub.daily.cancel().",
 	race: "a race is on: races are never resumed.",
-	room: "the page is in a hub room: online games are never resumed."
+	room: "the page is in a hub room: online games are never resumed.",
+	turns: "an online game is open: the hub keeps its state, so nothing is saved on the page."
 };
 /** Longest label or title kept (the contract's `RESUME_TEXT_MAX`). */
-const TEXT_MAX = 60;
+const TEXT_MAX$1 = 60;
+/** The label a daily goes back to when the game clears its run mid-daily (the day restarts from its seed). */
+const DAILY_RESTART_LABEL = "Started";
 /** A label or title trimmed and clipped, or `null` when blank. */
-function shortText(text) {
+function shortText$1(text) {
 	const trimmed = (text ?? "").trim();
-	return trimmed === "" ? null : trimmed.slice(0, TEXT_MAX);
+	return trimmed === "" ? null : trimmed.slice(0, TEXT_MAX$1);
 }
 /** The UTF-8 size of `text`. */
 function byteSize(text) {
@@ -3474,8 +4398,9 @@ var HubResume = class {
 	/**
 	* Save the run (the latest save wins). Stored on the device at once; sent
 	* after {@link RESUME_DEBOUNCE_MS} of quiet, or when the page is hidden.
-	* Returns `false` (and saves nothing) in a race, a daily challenge or an
-	* online room. Throws a `HubError` 413 over 512 KB, 400 without a label.
+	* Returns `false` (and saves nothing) in a race or an online room; during
+	* a daily challenge the save goes to the day (`hub.daily.save`). Throws a
+	* `HubError` 413 over 512 KB, 400 without a label.
 	*/
 	save(run) {
 		const blocker = this.host.blocker();
@@ -3483,8 +4408,10 @@ var HubResume = class {
 			this.warnBlocked(blocker);
 			return false;
 		}
+		const daily = this.host.daily?.() ?? null;
+		if (daily !== null) return daily.save(run);
 		const slug = this.requireSlug();
-		const label = shortText(run.progress.label);
+		const label = shortText$1(run.progress.label);
 		if (label === null) throw new HubError("hub.resume.save: progress.label is required.", 400);
 		const state = toStoredJson(run.state);
 		if (byteSize(JSON.stringify(state)) > 524288) throw new HubError(`hub.resume.save: state exceeds ${String(RESUME_MAX_STATE_BYTES)} bytes.`, 413);
@@ -3495,13 +4422,14 @@ var HubResume = class {
 			at: Date.now(),
 			label,
 			fraction,
-			title: shortText(run.title),
+			title: shortText$1(run.title),
 			version: Math.max(0, Math.floor(run.version ?? 0)),
 			gameTitle: this.host.gameTitle(),
 			state,
 			isSynced: false
 		};
 		const isStored = this.host.local.write(slug, copy);
+		this.host.onChange?.();
 		this.schedule({
 			action: "save",
 			savedAt: copy.at,
@@ -3526,6 +4454,18 @@ var HubResume = class {
 	/** Clear the run: call it when the run ends (won, lost or quit). Works offline. */
 	async clear() {
 		const slug = this.requireSlug();
+		const daily = this.host.daily?.() ?? null;
+		if (daily !== null) {
+			daily.save({
+				state: null,
+				progress: { label: DAILY_RESTART_LABEL }
+			});
+			return;
+		}
+		await this.clearRun(slug);
+	}
+	/** Delete the game's saved run (never the day being played). */
+	async clearRun(slug) {
 		if (this.timer !== null) {
 			clearTimeout(this.timer);
 			this.timer = null;
@@ -3538,6 +4478,7 @@ var HubResume = class {
 			at,
 			isSynced: false
 		});
+		this.host.onChange?.();
 		await this.host.send({
 			action: "clear",
 			before: at
@@ -3556,7 +4497,7 @@ var HubResume = class {
 			run = mine?.status === "saved" && !isClearedElsewhere ? runFromCopy(mine) : null;
 		}
 		if (run === null || options.version === void 0 || run.version === options.version) return run;
-		if (run.version < options.version) await this.clear();
+		if (run.version < options.version) await this.clearRun(slug);
 		return null;
 	}
 	/** The saved state, or `null` (see {@link get} for the version rule). */
@@ -3604,39 +4545,949 @@ var HubResume = class {
 	}
 };
 //#endregion
-//#region src/core/ticket.ts
+//#region src/core/saved/daily-seed.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.
+* The deterministic seed of a (game, day), the same FNV-1a as the
+* contract's `seedForDay` (the browser client carries no contract code; a
+* test keeps the two in step). Used for a day started offline.
 */
-/** 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)
-	});
+/** The uint32 seed for `game` on `day`. */
+function dailySeed(game, day) {
+	let hash = 2166136261;
+	const seedInput = `${game}#${day}`;
+	for (let i = 0; i < seedInput.length; i++) {
+		hash ^= seedInput.charCodeAt(i);
+		hash = Math.imul(hash, 16777619);
+	}
+	return hash >>> 0;
 }
-/** 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;
-	}
+//#endregion
+//#region src/core/saved/saved-order.ts
+/** The player must move in this online game now. */
+function isYourTurn(entry) {
+	return entry.turns?.isMyTurn === true && entry.turns.phase === "playing";
 }
-/** 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;
+/** Online games waiting on the player first (oldest turn first), then the newest. */
+function compareSaved(a, b) {
+	const isATurn = isYourTurn(a);
+	if (isATurn !== isYourTurn(b)) return isATurn ? -1 : 1;
+	if (isATurn && a.turns !== void 0 && b.turns !== void 0 && a.turns.turnStartedAt !== b.turns.turnStartedAt) return a.turns.turnStartedAt - b.turns.turnStartedAt;
+	if (a.updatedAt !== b.updatedAt) return b.updatedAt - a.updatedAt;
+	return a.id < b.id ? 1 : -1;
+}
+/** The badge counts of a list of games in progress. */
+function countSaved(entries) {
+	const counts = {
+		yourTurn: 0,
+		dailies: 0,
+		runs: 0,
+		waiting: 0,
+		total: entries.length
+	};
+	for (const entry of entries) if (entry.kind === "daily") counts.dailies += 1;
+	else if (entry.kind === "run") counts.runs += 1;
+	else if (isYourTurn(entry)) counts.yourTurn += 1;
+	else counts.waiting += 1;
+	return counts;
+}
+//#endregion
+//#region src/core/saved/saved-list.ts
+/**
+* A player's games in progress: the hub's list merged with this device's
+* copies of runs (`hub.resume`) and daily challenges (`hub.daily.save`), so
+* one saved offline (or just before the tab closed) shows at once, and one
+* cleared or discarded offline disappears at once. Pure.
+*/
+/** The id a run saved only on this device goes by until the hub has it. */
+function localRunId(slug) {
+	return `local:${slug}:run`;
+}
+/** The id a daily started only on this device goes by until the hub has it. */
+function localDailyId(slug, day) {
+	return `local:${slug}:${day}`;
+}
+/** A device run as an entry, with the game's catalog fields from the hub's entry when it has one. */
+function runEntry(slug, run, known) {
+	return {
+		id: known?.id ?? localRunId(slug),
+		game: slug,
+		gameTitle: known?.gameTitle ?? run.gameTitle,
+		path: known?.path ?? `/${slug}`,
+		hasImage: known?.hasImage ?? false,
+		kind: "run",
+		status: "active",
+		title: run.title,
+		progress: {
+			label: run.label,
+			fraction: run.fraction
+		},
+		version: run.version,
+		createdAt: known?.createdAt ?? run.at,
+		updatedAt: run.at,
+		finishedAt: null,
+		isLocalOnly: !run.isSynced
+	};
+}
+/** One game's run: the hub's, the device's newer copy, or none (cleared on the device). */
+function mergeRun(slug, hub, copy, isHubKnown) {
+	if (copy === void 0) return hub ?? null;
+	if (copy.status === "cleared") return hub !== void 0 && hub.updatedAt > copy.at ? hub : null;
+	if (hub !== void 0 && hub.updatedAt >= copy.at) return hub;
+	return !copy.isSynced || !isHubKnown || hub !== void 0 ? runEntry(slug, copy, hub) : null;
+}
+/** A device daily as an entry. */
+function dailyEntry(daily, known) {
+	return {
+		id: daily.id,
+		game: daily.game,
+		gameTitle: known?.gameTitle ?? daily.gameTitle,
+		path: known?.path ?? `/${daily.game}`,
+		hasImage: known?.hasImage ?? false,
+		kind: "daily",
+		status: "active",
+		title: daily.title,
+		progress: {
+			label: daily.label,
+			fraction: daily.fraction
+		},
+		version: daily.version,
+		createdAt: known?.createdAt ?? daily.at,
+		updatedAt: daily.at,
+		finishedAt: null,
+		daily: {
+			day: daily.day,
+			seed: daily.seed
+		},
+		isLocalOnly: !daily.isSynced
+	};
+}
+/** One daily: the hub's entry, the device's newer copy, or none (discarded or finished on the device). */
+function mergeDaily(hub, copy, isHubKnown) {
+	if (copy === void 0) return hub ?? null;
+	if (copy.status !== "active") return hub !== void 0 && hub.updatedAt > copy.at ? hub : null;
+	if (hub !== void 0 && hub.updatedAt >= copy.at) return hub;
+	return !copy.isSynced || !isHubKnown || hub !== void 0 ? dailyEntry(copy, hub) : null;
+}
+/** The key that pairs a hub daily with a device copy: its game and day. */
+const dailyKey = (game, day) => `${game}#${day}`;
+/**
+* The entries to show, in the shared list order. `hub` is the hub's list,
+* or `undefined` when it couldn't be reached; `copies` are the device's
+* (already only the player's); `game` limits the device copies to one game.
+*/
+function mergeSavedLists(hub, copies, game) {
+	const isHubKnown = hub !== void 0;
+	const fromHub = hub ?? [];
+	const runs = new Map(fromHub.filter((entry) => entry.kind === "run").map((entry) => [entry.game, entry]));
+	const dailies = new Map(fromHub.flatMap((entry) => entry.kind === "daily" && entry.daily !== void 0 ? [[dailyKey(entry.game, entry.daily.day), entry]] : []));
+	const runCopies = new Map([...copies.runs].filter(([slug]) => game === null || slug === game));
+	const dailyCopies = new Map(copies.dailies.filter((copy) => game === null || copy.game === game).map((copy) => [dailyKey(copy.game, copy.day), copy]));
+	const merged = fromHub.filter((entry) => entry.kind === "turns");
+	for (const slug of /* @__PURE__ */ new Set([...runs.keys(), ...runCopies.keys()])) {
+		const entry = mergeRun(slug, runs.get(slug), runCopies.get(slug), isHubKnown);
+		if (entry !== null) merged.push(entry);
+	}
+	for (const key of /* @__PURE__ */ new Set([...dailies.keys(), ...dailyCopies.keys()])) {
+		const entry = mergeDaily(dailies.get(key), dailyCopies.get(key), isHubKnown);
+		if (entry !== null) merged.push(entry);
+	}
+	return merged.sort(compareSaved);
+}
+//#endregion
+//#region src/core/saved/daily-saves.ts
+/** How long saves must be quiet before the latest is sent, ms (the same as `hub.resume`). */
+const DAILY_SAVE_DEBOUNCE_MS = 3e3;
+/** Largest state, bytes of JSON (the contract's `SAVED_MAX_STATE_BYTES`). */
+const MAX_STATE_BYTES = 524288;
+/** Longest label or title kept. */
+const TEXT_MAX = 60;
+/** The label of a day started and not saved yet. */
+const STARTED_LABEL = "Started";
+/** A label or title trimmed and clipped, or `null` when blank. */
+function shortText(text) {
+	const trimmed = (text ?? "").trim();
+	return trimmed === "" ? null : trimmed.slice(0, TEXT_MAX);
+}
+/** A game's daily saves. */
+var DailySaves = class {
+	constructor(host) {
+		_defineProperty(this, "host", void 0);
+		_defineProperty(this, "timers", /* @__PURE__ */ new Map());
+		_defineProperty(this, "waiting", /* @__PURE__ */ new Map());
+		_defineProperty(this, "isListening", false);
+		this.host = host;
+	}
+	/**
+	* The answer a device-only start gives while the hub can't be reached:
+	* the day's copy here (its saved state) or a fresh one. No token: the
+	* completion fetches one when the hub is back.
+	*/
+	startLocally(day) {
+		const userId = this.host.currentUserId();
+		const existing = this.host.local.read(this.host.slug, day);
+		const copy = existing !== null && existing.status === "active" && existing.userId === userId ? existing : {
+			id: localDailyId(this.host.slug, day),
+			game: this.host.slug,
+			day,
+			seed: dailySeed(this.host.slug, day),
+			status: "active",
+			userId,
+			at: Date.now(),
+			label: STARTED_LABEL,
+			fraction: null,
+			title: null,
+			version: 0,
+			gameTitle: this.host.gameTitle(),
+			state: null,
+			isSynced: false
+		};
+		if (copy !== existing) this.host.local.write(copy);
+		return {
+			token: "",
+			day,
+			seed: copy.seed,
+			expiresAt: 0,
+			alreadyCompleted: false,
+			completedAt: null,
+			meta: null,
+			instanceId: copy.id,
+			saved: copy.state,
+			savedVersion: copy.version,
+			resumed: existing !== null
+		};
+	}
+	/** The hub started (or resumed) a day: keep a copy that knows its id, unless the device has a newer save. */
+	remember(started) {
+		if (started.instanceId === null) return started;
+		const existing = this.host.local.read(this.host.slug, started.day);
+		if (existing !== null && existing.status === "active" && existing.userId === this.host.currentUserId() && !existing.isSynced) {
+			this.host.local.write({
+				...existing,
+				id: started.instanceId
+			});
+			return {
+				...started,
+				saved: existing.state,
+				savedVersion: existing.version
+			};
+		}
+		return started;
+	}
+	/** Save the active day's state: on the device now, to the hub soon. */
+	save(challenge, input) {
+		const label = shortText(input.progress.label);
+		if (label === null) throw new HubError("hub.daily.save: progress.label is required.", 400);
+		const state = toStoredJson(input.state);
+		if (new TextEncoder().encode(JSON.stringify(state)).length > MAX_STATE_BYTES) throw new HubError(`hub.daily.save: state exceeds ${String(MAX_STATE_BYTES)} bytes.`, 413);
+		if (challenge.instanceId === null) return false;
+		const fraction = typeof input.progress.fraction === "number" && Number.isFinite(input.progress.fraction) ? Math.min(1, Math.max(0, input.progress.fraction)) : null;
+		const copy = {
+			id: challenge.instanceId,
+			game: this.host.slug,
+			day: challenge.day,
+			seed: challenge.seed,
+			status: "active",
+			userId: this.host.currentUserId(),
+			at: Date.now(),
+			label,
+			fraction,
+			title: shortText(input.title),
+			version: Math.max(0, Math.floor(input.version ?? 0)),
+			gameTitle: this.host.gameTitle(),
+			state,
+			isSynced: false
+		};
+		if (!this.host.local.write(copy)) return false;
+		this.schedule({
+			action: "save",
+			game: copy.game,
+			day: copy.day,
+			at: copy.at
+		});
+		return true;
+	}
+	/** Give the day up: the copy says so at once, the hub hears it now (or when back online). */
+	async discard(challenge) {
+		this.dropWaiting(challenge.day);
+		const at = Date.now();
+		const base = this.host.local.read(this.host.slug, challenge.day) ?? this.blankCopy(challenge);
+		this.host.local.write({
+			...base,
+			id: challenge.instanceId ?? base.id,
+			status: "discarded",
+			at,
+			isSynced: false
+		});
+		await this.host.send({
+			action: "discard",
+			game: this.host.slug,
+			day: challenge.day,
+			at
+		});
+	}
+	/** The day was won: no save is waiting for it any more, and the lists hide it until the hub confirms. */
+	finished(day) {
+		this.dropWaiting(day);
+		const existing = this.host.local.read(this.host.slug, day);
+		if (existing !== null) this.host.local.write({
+			...existing,
+			status: "finished",
+			at: Date.now(),
+			isSynced: false
+		});
+	}
+	/** The hub recorded the day: forget the copy. */
+	completed(day) {
+		this.host.local.remove(this.host.slug, day);
+	}
+	/** Send every waiting save now. */
+	async flush() {
+		const payloads = [...this.waiting.values()];
+		for (const timer of this.timers.values()) clearTimeout(timer);
+		this.timers.clear();
+		this.waiting.clear();
+		await Promise.all(payloads.map((payload) => this.host.send(payload)));
+	}
+	blankCopy(challenge) {
+		return {
+			id: challenge.instanceId ?? localDailyId(this.host.slug, challenge.day),
+			game: this.host.slug,
+			day: challenge.day,
+			seed: challenge.seed,
+			status: "active",
+			userId: this.host.currentUserId(),
+			at: Date.now(),
+			label: STARTED_LABEL,
+			fraction: null,
+			title: null,
+			version: 0,
+			gameTitle: this.host.gameTitle(),
+			state: null,
+			isSynced: false
+		};
+	}
+	dropWaiting(day) {
+		const timer = this.timers.get(day);
+		if (timer !== void 0) clearTimeout(timer);
+		this.timers.delete(day);
+		this.waiting.delete(day);
+	}
+	schedule(payload) {
+		this.dropWaiting(payload.day);
+		this.waiting.set(payload.day, payload);
+		this.timers.set(payload.day, setTimeout(() => {
+			this.timers.delete(payload.day);
+			this.waiting.delete(payload.day);
+			this.host.send(payload).catch(() => void 0);
+		}, DAILY_SAVE_DEBOUNCE_MS));
+		this.listenToPage();
+	}
+	/** Send waiting saves as soon as the page is hidden or closed. */
+	listenToPage() {
+		if (this.isListening || !isBrowserPage()) return;
+		this.isListening = true;
+		const flushNow = () => {
+			this.flush().catch(() => void 0);
+		};
+		window.addEventListener("pagehide", flushNow);
+		if (typeof document !== "undefined") document.addEventListener("visibilitychange", () => {
+			if (document.visibilityState === "hidden") flushNow();
+		});
+	}
+};
+//#endregion
+//#region src/core/saved/saved-open.ts
+/** The instance id parameter (the contract's `SAVED_OPEN_PARAM`). */
+const SAVED_OPEN_PARAM = "hub_open";
+/** The instance kind parameter (the contract's `SAVED_KIND_PARAM`). */
+const SAVED_KIND_PARAM = "hub_kind";
+/** The window event the hub menu fires to open an instance of this page's game (cancelable). */
+const SAVED_OPEN_EVENT = "hub:saved-open";
+/** The window event the social runtime fires for each `ev:saved` (detail: the `SavedGame`). */
+const SAVED_CHANGE_EVENT = "hub:saved";
+/** Where the answer is kept for the page. */
+const PAGE_FLAG$1 = "__HUB_SAVED_OPENED__";
+const KINDS = [
+	"daily",
+	"run",
+	"turns"
+];
+/** `text` as a kind, or `null`. */
+function asKind(text) {
+	return KINDS.find((kind) => kind === text) ?? null;
+}
+/** The address that opens `game` in its page. */
+function savedGameUrl(game) {
+	const params = new URLSearchParams();
+	if (game.kind === "run") params.set(RESUME_REQUEST_PARAM, "1");
+	if (game.kind === "daily" && game.daily !== void 0) params.set("daily", game.daily.day);
+	params.set(SAVED_OPEN_PARAM, game.id);
+	params.set(SAVED_KIND_PARAM, game.kind);
+	return `${game.path.replace(/\/+$/, "")}/?${params.toString()}`;
+}
+/** Read and strip `hub_open` / `hub_kind`; `null` when absent or malformed. */
+function takeParams() {
+	try {
+		const url = new URL(location.href);
+		const id = url.searchParams.get(SAVED_OPEN_PARAM);
+		const kind = asKind(url.searchParams.get(SAVED_KIND_PARAM));
+		if (!url.searchParams.has("hub_open") && !url.searchParams.has("hub_kind")) return null;
+		url.searchParams.delete(SAVED_OPEN_PARAM);
+		url.searchParams.delete(SAVED_KIND_PARAM);
+		try {
+			history.replaceState(history.state, "", `${url.pathname}${url.search}${url.hash}`);
+		} catch {}
+		return id === null || id === "" || kind === null ? null : {
+			id,
+			kind
+		};
+	} catch {
+		return null;
+	}
+}
+/** A recorded answer read back. */
+function readRecorded(value) {
+	const id = readField(value, "id");
+	const kind = readField(value, "kind");
+	const savedKind = asKind(typeof kind === "string" ? kind : null);
+	return typeof id === "string" && savedKind !== null ? {
+		id,
+		kind: savedKind
+	} : null;
+}
+/** The instance this page was opened for, or `null` (synchronous, so a game can route before it draws). */
+function savedOpenedOnPage() {
+	if (!isBrowserPage()) return null;
+	if (Reflect.has(window, PAGE_FLAG$1)) return readRecorded(Reflect.get(window, PAGE_FLAG$1));
+	const opened = takeParams();
+	Reflect.set(window, PAGE_FLAG$1, opened);
+	return opened;
+}
+//#endregion
+//#region src/core/saved/hub-saved.ts
+/** How long changes must be quiet before `on('change')` listeners hear the new list, ms. */
+const SAVED_CHANGE_QUIET_MS = 300;
+/** Whether an entry is of one of `kinds` (all when absent). */
+function isOfKinds(entry, options) {
+	return options.kinds === void 0 || options.kinds.includes(entry.kind);
+}
+/** `hub.saved`. */
+var HubSaved = class {
+	constructor(host) {
+		_defineProperty(this, "host", void 0);
+		_defineProperty(this, "openHandlers", /* @__PURE__ */ new Map());
+		_defineProperty(this, "changeListeners", /* @__PURE__ */ new Set());
+		_defineProperty(this, "isListeningForOpen", false);
+		_defineProperty(this, "isListeningForChange", false);
+		_defineProperty(this, "changeTimer", null);
+		this.host = host;
+	}
+	/**
+	* The instance this page was opened for (`?hub_open=<id>&hub_kind=<kind>`,
+	* taken out of the address bar), or `null`. Synchronous: read it before
+	* routing or drawing a title screen.
+	*/
+	get opened() {
+		return savedOpenedOnPage();
+	}
+	/** This game's games in progress: online games waiting on the player first, then the newest. Works offline. */
+	async list(options = {}) {
+		const slug = this.host.slug;
+		if (slug === null) return [];
+		return mergeSavedLists(await this.host.fetchList(slug), this.host.deviceCopies(), slug).filter((entry) => isOfKinds(entry, options));
+	}
+	/** Every game's games in progress (the home page and the menu). Online, plus this device's copies. */
+	async listAll() {
+		return mergeSavedLists(await this.host.fetchList(null), this.host.deviceCopies(), null);
+	}
+	/** The badge counts across every game. */
+	async counts() {
+		return countSaved(await this.listAll());
+	}
+	/**
+	* Switch to an instance of THIS game when the player picks it from the
+	* hub menu, without a reload. Without a handler the page reloads with
+	* `?hub_open=<id>`. With `{ kinds }` the handler takes only those kinds;
+	* the others still reload the page (with `?hub_resume=1` or `?daily=` for
+	* a saved run or a daily). Returns a function that removes the handler.
+	*/
+	onOpen(handler, options = {}) {
+		this.openHandlers.set(handler, options);
+		this.listenForOpen();
+		return () => {
+			this.openHandlers.delete(handler);
+		};
+	}
+	/** Open an instance: in this game through `onOpen` (or a reload), in another game by going there. */
+	async open(id) {
+		const entry = (await this.listAll()).find((candidate) => candidate.id === id);
+		if (entry === void 0) return;
+		this.openEntry(entry);
+	}
+	/** Open an entry already in hand (the hub's lists). */
+	openEntry(entry) {
+		if (entry.game === this.host.slug && isBrowserPage()) {
+			const event = new CustomEvent(SAVED_OPEN_EVENT, {
+				detail: { entry },
+				cancelable: true
+			});
+			if (!window.dispatchEvent(event)) return;
+		}
+		this.host.navigate(savedGameUrl(entry));
+	}
+	/**
+	* Discard a daily challenge or a saved run (the caller asks first; the
+	* hub's own lists ask for themselves). Online games are left with
+	* `hub.turns`, never discarded.
+	*/
+	async discard(id) {
+		const entry = (await this.listAll()).find((candidate) => candidate.id === id);
+		if (entry === void 0 || entry.kind === "turns") return;
+		await this.host.discard(entry);
+		this.changed();
+	}
+	/** Hear when this game's list changes; returns a function that stops listening. */
+	on(_eventName, listener) {
+		this.changeListeners.add(listener);
+		this.listenForChange();
+		return () => {
+			this.changeListeners.delete(listener);
+		};
+	}
+	/** Something of this game's changed (a save here, an event from the hub): tell the listeners, once per quiet spell. */
+	changed() {
+		if (this.changeListeners.size === 0 || this.changeTimer !== null) return;
+		this.changeTimer = setTimeout(() => {
+			this.changeTimer = null;
+			this.list().then((games) => {
+				for (const listener of this.changeListeners) listener(games);
+			}, () => void 0);
+		}, 300);
+	}
+	listenForOpen() {
+		if (this.isListeningForOpen || !isBrowserPage()) return;
+		this.isListeningForOpen = true;
+		window.addEventListener(SAVED_OPEN_EVENT, (event) => {
+			const entry = event instanceof CustomEvent ? readEntry(event.detail) : null;
+			const handlers = entry === null ? [] : [...this.openHandlers].filter(([, options]) => isOfKinds(entry, options)).map(([handler]) => handler);
+			if (entry === null || entry.game !== this.host.slug || handlers.length === 0 || event.defaultPrevented) return;
+			event.preventDefault();
+			for (const handler of handlers) Promise.resolve(handler(entry)).catch(() => void 0);
+		});
+	}
+	listenForChange() {
+		if (this.isListeningForChange || !isBrowserPage()) return;
+		this.isListeningForChange = true;
+		window.addEventListener(SAVED_CHANGE_EVENT, (event) => {
+			if ((event instanceof CustomEvent ? readField(event.detail, "game") : void 0) === this.host.slug) this.changed();
+		});
+	}
+};
+/** The entry in an open event's detail (it may come from another bundle), or `null`. */
+function readEntry(detail) {
+	const entry = readField(detail, "entry");
+	const id = readField(entry, "id");
+	const game = readField(entry, "game");
+	const kind = readField(entry, "kind");
+	if (typeof id !== "string" || typeof game !== "string" || kind !== "daily" && kind !== "run" && kind !== "turns") return null;
+	return isSavedEntry(entry) ? entry : null;
+}
+/** Shape check for an entry made by another copy of this client. */
+function isSavedEntry(candidate) {
+	return typeof readField(candidate, "path") === "string" && typeof readField(candidate, "progress") === "object";
+}
+//#endregion
+//#region src/core/turns/turn-game.ts
+/** The window event the social runtime fires for each `ev:turn`. */
+const TURN_EVENT = "hub:turn";
+/** The runtime's live connection (re)opened: anything sent while it was down is fetched again. */
+const TURN_RESYNC_EVENT = "hub:turn-resync";
+/** The window event the social runtime fires for each `ev:turn.chat`. */
+const TURN_CHAT_EVENT = "hub:turn-chat";
+/** How often a page without the live runtime looks for moves, ms. */
+const TURN_POLL_MS = 2e4;
+/** One online game. `View`, `Move` and `Ev` (its events) are the game's own JSON types from its rules. */
+var TurnGame = class TurnGame {
+	constructor(host, initial) {
+		_defineProperty(this, "id", void 0);
+		_defineProperty(this, "state", void 0);
+		_defineProperty(this, "host", void 0);
+		_defineProperty(this, "listeners", {
+			move: /* @__PURE__ */ new Set(),
+			turn: /* @__PURE__ */ new Set(),
+			ended: /* @__PURE__ */ new Set(),
+			chat: /* @__PURE__ */ new Set()
+		});
+		_defineProperty(this, "stopListening", []);
+		_defineProperty(this, "isClosed", false);
+		_defineProperty(this, "catchingUp", null);
+		_defineProperty(this, "ownSeq", null);
+		this.host = host;
+		this.id = initial.id;
+		this.state = initial;
+		host.opened(this);
+		this.listen();
+	}
+	/** Whose move it is, the seats and the deadline. */
+	get summary() {
+		return this.state.summary;
+	}
+	/** This seat's view, from the game's rules (`null` before the game starts). */
+	get view() {
+		return toGameData(this.state.view);
+	}
+	/** This player's seat, or `null` (they left). */
+	get mySeat() {
+		return this.state.mySeat;
+	}
+	/** The end, once the game is over. */
+	get outcome() {
+		return this.state.outcome;
+	}
+	/** The last chat lines, oldest first. */
+	get chat() {
+		return this.state.chat;
+	}
+	/** `on`: friends may type (moderated); `quick`: quick-chat and emotes only; `off`. */
+	get chatMode() {
+		return this.state.chatMode;
+	}
+	/** The link others can take a seat with (the creator's, while seats are open), else `null`. */
+	get link() {
+		return this.state.link === null ? null : new URL(this.state.link, location.origin).href;
+	}
+	/** Creator: start the game (empty seats go to the computer when the game allows). */
+	async start() {
+		this.update(await this.host.start(this.id));
+	}
+	/**
+	* Make a move. Rejects with a `HubError`: 403 `not_your_turn`, 409
+	* `stale` (the game moved on: the view is refreshed first), 422 `illegal`
+	* with the rules' own code in `rule`.
+	*/
+	async move(move) {
+		this.ownSeq = this.state.summary.seq + 1;
+		try {
+			const answer = await this.host.move(this.id, this.state.summary.seq, toPayload(move));
+			this.update(answer.game);
+			return {
+				seq: answer.game.summary.seq,
+				view: this.view,
+				events: answer.events.map((event) => toGameData(event))
+			};
+		} catch (failure) {
+			if (failure instanceof HubError && failure.code === "stale") await this.refresh();
+			throw failure;
+		} finally {
+			this.ownSeq = null;
+		}
+	}
+	/** The moves after `sinceSeq`, with their events as this seat may see them ("what happened while you were away"). */
+	async history(sinceSeq) {
+		return (await this.host.history(this.id, sinceSeq)).map((move) => ({
+			seq: move.seq,
+			seat: move.seat,
+			events: move.events.map((event) => toGameData(event))
+		}));
+	}
+	/** Leave: the computer plays the seat (or, without bots, the others win). The player can't come back. */
+	async leave() {
+		await this.host.leave(this.id);
+		this.close();
+	}
+	/** Remind whoever must move (once a day). */
+	nudge() {
+		return this.host.nudge(this.id);
+	}
+	/** This game's "your turn" alerts. */
+	setNotify(mode) {
+		return this.host.setNotify(this.id, mode);
+	}
+	/** A finished game: a new one with the same friends (they get an invite). */
+	async rematch() {
+		return new TurnGame(this.host, await this.host.rematch(this.id));
+	}
+	/** Creator, before the start: add an invite link (`link: true`, then read `link`) or list the open seats for anyone (`public`). */
+	async share(share) {
+		this.update(await this.host.share(this.id, share));
+	}
+	/** Invite friends to free seats (before the start). */
+	async invite(userIds) {
+		this.update(await this.host.invite(this.id, userIds));
+	}
+	/** The turn's deadline passed (or its player is suspended): let the computer play it. */
+	async letComputerPlay() {
+		this.update(await this.host.autoPlay(this.id));
+	}
+	/** Say something: `{ text }` between friends (moderated), `{ quick }` (a quick-chat phrase id) with anyone. */
+	say(send) {
+		return this.host.chat(this.id, send);
+	}
+	/** Fetch the game again, and replay moves missed since the last one this page saw. */
+	async refresh() {
+		const before = this.state.summary.seq;
+		const fresh = await this.host.get(this.id);
+		if (fresh.summary.seq > before) {
+			const missed = await this.host.history(this.id, before);
+			this.update(fresh);
+			for (const move of missed) this.emit("move", {
+				seq: move.seq,
+				seat: move.seat,
+				view: this.view,
+				events: move.events.map((event) => toGameData(event))
+			});
+		} else this.update(fresh);
+	}
+	/** Hear moves, turn changes, the end and chat; returns a function that stops listening. */
+	on(eventName, listener) {
+		const set = this.listeners[eventName];
+		set.add(listener);
+		return () => {
+			set.delete(listener);
+		};
+	}
+	/** Stop live updates for this page (the game itself goes on). */
+	close() {
+		if (this.isClosed) return;
+		this.isClosed = true;
+		for (const stop of this.stopListening) stop();
+		this.host.closed(this);
+	}
+	/** Take a fresh answer from the hub; fire `turn` and `ended` when they changed. */
+	update(next) {
+		const previous = this.state;
+		this.state = next;
+		if (previous.summary.seq !== next.summary.seq || previous.summary.phase !== next.summary.phase || !sameSeats(previous.summary, next.summary) || previous.chatMode !== next.chatMode || previous.link !== next.link) this.emit("turn", next.summary);
+		if (previous.summary.phase !== "ended" && next.summary.phase === "ended") this.emit("ended", {
+			outcome: next.outcome,
+			view: this.view
+		});
+	}
+	emit(eventName, payload) {
+		const set = this.listeners[eventName];
+		for (const listener of set) listener(payload);
+	}
+	/** A live `hub:turn` for this game: a move (or a missed run of them), or another change. */
+	onLive(detail) {
+		const seq = readField(detail, "seq");
+		const view = readField(detail, "view");
+		const summary = readField(detail, "summary");
+		if (typeof seq !== "number" || !isSummary(summary) || view === void 0) return;
+		if (seq > this.state.summary.seq + 1) {
+			this.catchUp();
+			return;
+		}
+		const seat = readField(detail, "seat");
+		const events = readField(detail, "events");
+		const outcome = readField(detail, "outcome");
+		const isMove = typeof seat === "number" && seq === this.state.summary.seq + 1 && seq !== this.ownSeq;
+		if (summary.phase !== this.state.summary.phase || !sameSeating(this.state.summary, summary)) this.catchUp();
+		this.update({
+			...this.state,
+			summary,
+			view: toPayloadJson(view),
+			outcome: isOutcome(outcome) ? outcome : this.state.outcome
+		});
+		if (isMove) this.emit("move", {
+			seq,
+			seat,
+			view: this.view,
+			events: Array.isArray(events) ? events.map((event) => toGameData(toPayloadJson(event))) : []
+		});
+	}
+	/** Replay what was missed (one catch-up at a time). */
+	catchUp() {
+		this.catchingUp ?? (this.catchingUp = this.refresh().catch(() => void 0).finally(() => {
+			this.catchingUp = null;
+		}));
+		return this.catchingUp;
+	}
+	listen() {
+		if (!isBrowserPage()) return;
+		const onTurn = (event) => {
+			if (!(event instanceof CustomEvent) || readField(event.detail, "id") !== this.id) return;
+			const detail = event.detail;
+			if (typeof detail === "object" && detail !== null) this.onLive(detail);
+		};
+		const onChat = (event) => {
+			if (event instanceof CustomEvent && readField(event.detail, "id") === this.id) {
+				const line = readField(event.detail, "line");
+				if (isChatLine(line)) {
+					this.state = {
+						...this.state,
+						chat: [...this.state.chat, line].slice(-50)
+					};
+					this.emit("chat", line);
+				}
+			}
+		};
+		const onVisible = () => {
+			if (document.visibilityState === "visible") this.catchUp();
+		};
+		const onResync = () => {
+			this.catchUp();
+		};
+		window.addEventListener(TURN_EVENT, onTurn);
+		window.addEventListener(TURN_CHAT_EVENT, onChat);
+		window.addEventListener(TURN_RESYNC_EVENT, onResync);
+		document.addEventListener("visibilitychange", onVisible);
+		const poll = setInterval(() => {
+			if (!this.host.isLive() && document.visibilityState === "visible") this.catchUp();
+		}, TURN_POLL_MS);
+		this.stopListening.push(() => {
+			window.removeEventListener(TURN_EVENT, onTurn);
+		}, () => {
+			window.removeEventListener(TURN_CHAT_EVENT, onChat);
+		}, () => {
+			window.removeEventListener(TURN_RESYNC_EVENT, onResync);
+		}, () => {
+			document.removeEventListener("visibilitychange", onVisible);
+		}, () => {
+			clearInterval(poll);
+		});
+	}
+};
+/** Every seat matches its counterpart by `same`. */
+function eachSeat(a, b, same) {
+	return a.seats.length === b.seats.length && a.seats.every((seat, index) => {
+		const other = b.seats[index];
+		return other !== void 0 && same(seat, other);
+	});
+}
+/** The same players in the same seats with the same statuses (who sits where). */
+function sameSeating(a, b) {
+	return eachSeat(a, b, (seat, other) => seat.status === other.status && seat.userId === other.userId);
+}
+/** The same seating, and the same looks (a player's new avatar is a change: `turn` fires). */
+function sameSeats(a, b) {
+	return sameSeating(a, b) && eachSeat(a, b, (seat, other) => seat.look === other.look);
+}
+/** A game's move as the JSON the hub takes. */
+function toPayload(move) {
+	return toPayloadJson(move);
+}
+/** Any JSON-safe value as `Json` (a JSON round trip). */
+function toPayloadJson(value) {
+	const parsed = parseJsonText(JSON.stringify(value ?? null));
+	return isJson(parsed) ? parsed : null;
+}
+/** Shape checks for a live event's parts (it comes from another bundle). */
+function isSummary(value) {
+	return typeof readField(value, "phase") === "string" && Array.isArray(readField(value, "seats")) && Array.isArray(readField(value, "toAct"));
+}
+function isOutcome(value) {
+	return value === null || Array.isArray(readField(value, "winners"));
+}
+function isChatLine(value) {
+	return typeof readField(value, "text") === "string" && typeof readField(value, "from") === "number";
+}
+//#endregion
+//#region src/core/turns/hub-turns.ts
+/** The query parameter an invite link carries (`/<slug>/?hub_turn_link=<key>`); the client strips it. */
+const TURN_LINK_PARAM = "hub_turn_link";
+/** Where the answer is kept for the page. */
+const PAGE_FLAG = "__HUB_TURN_LINK__";
+/** Read and strip `hub_turn_link`, once per page. */
+function linkOnPage() {
+	if (!isBrowserPage()) return null;
+	if (Reflect.has(window, PAGE_FLAG)) {
+		const recorded = Reflect.get(window, PAGE_FLAG);
+		return typeof recorded === "string" ? recorded : null;
+	}
+	let key = null;
+	try {
+		const url = new URL(location.href);
+		key = url.searchParams.get(TURN_LINK_PARAM);
+		if (key !== null) {
+			url.searchParams.delete(TURN_LINK_PARAM);
+			history.replaceState(history.state, "", `${url.pathname}${url.search}${url.hash}`);
+		}
+	} catch {}
+	Reflect.set(window, PAGE_FLAG, key);
+	return key;
+}
+/** Whether `idOrKey` is a game id (`sg_…`) rather than a link key. */
+function isGameId(idOrKey) {
+	return idOrKey.startsWith("sg_");
+}
+/** `hub.turns`. */
+var HubTurns = class {
+	constructor(host) {
+		_defineProperty(this, "host", void 0);
+		this.host = host;
+	}
+	/** The invite link key this page was opened with (`?hub_turn_link=`), taken out of the address bar; `null` when none. Synchronous. */
+	get link() {
+		return linkOnPage();
+	}
+	/** Make a game in this page's game (its lobby): the player takes the first seat. */
+	async create(options = {}) {
+		const body = {
+			game: this.host.slug ?? "",
+			...options.mode === void 0 ? {} : { mode: options.mode },
+			...options.options === void 0 ? {} : { options: toStoredJson(options.options) },
+			...options.invite === void 0 ? {} : { invite: [...options.invite] },
+			...options.link === void 0 ? {} : { link: options.link },
+			...options.public === void 0 ? {} : { public: options.public },
+			...options.seats === void 0 ? {} : { seats: options.seats },
+			...options.bots === void 0 ? {} : { bots: options.bots },
+			...options.deadline === void 0 ? {} : { deadline: options.deadline },
+			...options.autoStart === void 0 ? {} : { autoStart: options.autoStart }
+		};
+		return new TurnGame(this.host, await this.host.create(body));
+	}
+	/** Take a seat: by the game's id (an invite, an open seat) or by an invite link's key. */
+	async join(idOrLinkKey) {
+		const joined = isGameId(idOrLinkKey) ? await this.host.join(idOrLinkKey) : await this.host.joinByLink(idOrLinkKey);
+		return new TurnGame(this.host, joined);
+	}
+	/** Open a game the player sits in (from `hub.saved.opened`, the Continue list, an invite). */
+	async open(id) {
+		return new TurnGame(this.host, await this.host.get(id));
+	}
+	/** This game's online games the player sits in (the same rows as `hub.saved.list({ kinds: ['turns'] })`). */
+	list() {
+		return this.host.list();
+	}
+	/** Open-seat games of this game anyone may join (none across a block). */
+	openLobbies() {
+		return this.host.listOpen(this.host.slug);
+	}
+};
+//#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);
 	}
@@ -3746,6 +5597,11 @@ var Hub = class extends HubEconomy {
 		super(..._args);
 		_defineProperty(this, "clientVersion", HUB_CLIENT_VERSION);
 		_defineProperty(this, "resumeApi", void 0);
+		_defineProperty(this, "avatarApi", void 0);
+		_defineProperty(this, "savedApi", void 0);
+		_defineProperty(this, "dailySavesApi", void 0);
+		_defineProperty(this, "turnsApi", void 0);
+		_defineProperty(this, "openTurnGames", /* @__PURE__ */ new Set());
 	}
 	/**
 	* The hub's version and the client versions it supports (`GET /_api/version`),
@@ -3820,6 +5676,128 @@ var Hub = class extends HubEconomy {
 		this.resumeApi ?? (this.resumeApi = new HubResume(this.resumeHost()));
 		return this.resumeApi;
 	}
+	/**
+	* Players' avatars: `hub.avatar.mine()`, `of(userId)`, `from(seat)`,
+	* `bot(seed)`, `on('change')`, `openDesigner()` and `load()` for the renderer
+	* (docs: "Avatars"). No art or renderer until `load()`.
+	*/
+	get avatar() {
+		this.avatarApi ?? (this.avatarApi = new HubAvatar({
+			currentUserId: () => this.userId(),
+			onAccount: (listener) => this.account.on(listener),
+			fetchMine: () => this.rest.call("getMyAvatar"),
+			fetchCodes: async (ids) => (await this.rest.call("getAvatars", { ids: [...ids] })).codes,
+			queueSave: async (code, savedAt) => {
+				await this.mutateOffline("hub.avatar", {
+					code,
+					savedAt
+				}, () => void 0);
+			}
+		}));
+		return this.avatarApi;
+	}
+	/**
+	* Every game the player has in progress, of every kind: `hub.saved.list()`
+	* for this game's "Continue" list, `opened` and `onOpen` to open the one
+	* the player picked (docs: "Saved games").
+	*/
+	get saved() {
+		this.savedApi ?? (this.savedApi = new HubSaved(this.savedHost()));
+		return this.savedApi;
+	}
+	/**
+	* Online games played over minutes or days, run by the hub from the
+	* game's rules module (`game.turns`): `hub.turns.create`, `join`, `open`
+	* (docs/multiplayer.md "Turn games").
+	*/
+	get turns() {
+		this.turnsApi ?? (this.turnsApi = new HubTurns(this.turnsHost()));
+		return this.turnsApi;
+	}
+	/** What `hub.turns` needs from this client: its REST calls. */
+	turnsHost() {
+		const { rest } = this;
+		return {
+			slug: this.slug,
+			create: (body) => rest.call("createTurnGame", body),
+			join: (id) => rest.call("joinTurnGame", { id }),
+			joinByLink: (key) => rest.call("joinTurnGameByLink", { key }),
+			get: (id) => rest.call("getTurnGame", { id }),
+			start: (id) => rest.call("startTurnGame", { id }),
+			move: (id, seq, move) => rest.call("moveTurnGame", {
+				id,
+				seq,
+				move
+			}),
+			history: async (id, since) => (await rest.call("getTurnGameHistory", {
+				id,
+				since
+			})).moves,
+			leave: async (id) => {
+				await rest.call("leaveTurnGame", { id });
+			},
+			nudge: async (id) => {
+				await rest.call("nudgeTurnGame", { id });
+			},
+			setNotify: async (id, mode) => {
+				await rest.call("setTurnGameNotify", {
+					id,
+					mode
+				});
+			},
+			rematch: (id) => rest.call("rematchTurnGame", { id }),
+			invite: (id, userIds) => rest.call("inviteToTurnGame", {
+				id,
+				userIds: [...userIds]
+			}),
+			share: (id, share) => rest.call("shareTurnGame", {
+				id,
+				...share
+			}),
+			autoPlay: (id) => rest.call("autoPlayTurn", { id }),
+			chat: (id, send) => rest.call("chatInTurnGame", {
+				id,
+				...send
+			}),
+			listOpen: async (game) => (await rest.call("listOpenTurnGames", game === null ? {} : { game })).games,
+			list: () => this.saved.list({ kinds: ["turns"] }),
+			opened: (game) => {
+				this.openTurnGames.add(game);
+			},
+			closed: (game) => {
+				this.openTurnGames.delete(game);
+			},
+			isLive: () => pageBridge.current() !== null
+		};
+	}
+	/** What `hub.saved` needs from this client. */
+	savedHost() {
+		return {
+			slug: this.slug,
+			fetchList: (game) => this.withFallback(async () => (await this.rest.call("listMySavedGames", game === null ? {} : { game })).games, () => void 0),
+			deviceCopies: () => {
+				const userId = this.store.getUser()?.id ?? null;
+				return {
+					runs: new Map([...this.resumeStore.all()].filter(([, copy]) => copy.userId === userId)),
+					dailies: this.dailyStore.all(userId)
+				};
+			},
+			discard: (entry) => this.discardSaved(entry),
+			navigate: (url) => {
+				location.assign(url);
+			}
+		};
+	}
+	/** Discard a daily or run: this game's run through `hub.resume` (works offline), others on the hub. */
+	async discardSaved(entry) {
+		if (entry.kind === "run" && entry.game === this.slug) {
+			await this.resume.clear();
+			return;
+		}
+		if (!entry.id.startsWith("local:")) await this.rest.call("discardSavedGame", { id: entry.id });
+		if (entry.kind === "run") this.resumeStore.remove(entry.game);
+		else if (entry.daily !== void 0) this.dailyStore.remove(entry.game, entry.daily.day);
+	}
 	/** What `hub.resume` needs from this client. */
 	resumeHost() {
 		return {
@@ -3829,7 +5807,12 @@ var Hub = class extends HubEconomy {
 			gameTitle: () => detectGameTitle(this.slug ?? ""),
 			blocker: () => {
 				if (raceForwarder.current() !== null) return "race";
-				return this.daily.active === null ? isInHubRoom() ? "room" : null : "daily";
+				if (this.openTurnGames.size > 0) return "turns";
+				return isInHubRoom() ? "room" : null;
+			},
+			daily: () => {
+				const daily = this.daily;
+				return daily.active === null ? null : daily;
 			},
 			send: async (payload) => {
 				await this.mutateOffline(RESUME_KIND, payload, () => void 0);
@@ -3845,24 +5828,58 @@ var Hub = class extends HubEconomy {
 			fetchList: () => this.withFallback(async () => (await this.rest.call("listMyResumeSlots")).games, () => void 0),
 			clearOther: async (slug) => {
 				await this.rest.call("clearResumeSlot", { slug });
+			},
+			onChange: () => {
+				this.savedApi?.changed();
 			}
 		};
 	}
-	/** What the daily system needs from this client: its REST calls and window events. */
+	/** This game's daily saves (device copies and their sends). */
+	dailySaves() {
+		const slug = this.slug;
+		if (slug === null) throw new HubError("hub.daily: could not determine the game slug.");
+		this.dailySavesApi ?? (this.dailySavesApi = new DailySaves({
+			slug,
+			local: this.dailyStore,
+			currentUserId: () => this.store.getUser()?.id ?? null,
+			gameTitle: () => detectGameTitle(slug),
+			send: async (payload) => {
+				await this.mutateOffline("hub.saved", payload, () => void 0);
+				this.savedApi?.changed();
+			}
+		}));
+		return this.dailySavesApi;
+	}
+	/** What the daily system needs from this client: its REST calls, the device copies 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", {
+			start: (day) => this.withFallback(async () => this.dailySaves().remember(await this.rest.call("startDailyChallenge", {
 				...this.gameFields(),
 				day
-			}),
-			complete: (day, token, meta) => this.mutateOffline(DAILY_KIND, {
-				day,
-				token,
-				meta
-			}, () => null, (result) => readDailyCompletion(result)),
+			})), () => this.dailySaves().startLocally(day)),
+			resume: async (instanceId) => this.dailySaves().remember(await this.rest.call("resumeDailyChallenge", { id: instanceId })),
+			complete: async (day, token, meta) => {
+				this.dailySaves().finished(day);
+				const completed = await this.mutateOffline(DAILY_KIND, {
+					day,
+					token,
+					meta
+				}, () => null, (result) => readDailyCompletion(result));
+				if (completed !== null) this.dailySaves().completed(day);
+				this.savedApi?.changed();
+				return completed;
+			},
+			save: (challenge, input) => {
+				const isSaved = this.dailySaves().save(challenge, input);
+				this.savedApi?.changed();
+				return isSaved;
+			},
+			flush: () => this.dailySaves().flush(),
+			discard: (challenge) => this.dailySaves().discard(challenge),
+			inProgress: () => this.saved.list({ kinds: ["daily"] }),
 			emit: (eventName, detail) => {
 				emitWindowEvent(eventName, detail);
 			}
@@ -3877,11 +5894,12 @@ linkRealtimeToHub({
 /** A ready-to-use client, with the slug and API base detected from the page. */
 const hub = new Hub();
 isResumeRequested();
+savedOpenedOnPage();
 /** Create a client for another slug or API base, or with other offline behaviour. */
 function createHub(options = {}) {
 	return new Hub(options);
 }
 //#endregion
-export { RESUME_DEBOUNCE_MS as a, OUTBOX_FULL_CODE as c, OfflineApi as d, ContentRejectedError as f, UNSUPPORTED_BY_HUB as h, HubResume as i, OUTBOX_MAX_CHARS as l, OfflineError as m, createHub as n, RESUME_MAX_STATE_BYTES as o, HubError as p, hub as r, CLIENT_VERSION_HEADER as s, Hub as t, OUTBOX_MAX_ENTRIES as u };
+export { UNSUPPORTED_BY_HUB as A, OUTBOX_MAX_CHARS as C, HubError as D, ContentRejectedError as E, OfflineError as O, OUTBOX_FULL_CODE as S, OfflineApi as T, savedGameUrl as _, TURN_LINK_PARAM as a, RESUME_MAX_STATE_BYTES as b, TURN_POLL_MS as c, HubSaved as d, SAVED_CHANGE_QUIET_MS as f, SAVED_OPEN_PARAM as g, SAVED_OPEN_EVENT as h, HubTurns as i, HubAvatar as j, SAVE_UNKNOWN_CODE as k, TURN_RESYNC_EVENT as l, SAVED_KIND_PARAM as m, createHub as n, TURN_CHAT_EVENT as o, SAVED_CHANGE_EVENT as p, hub as r, TURN_EVENT as s, Hub as t, TurnGame as u, HubResume as v, OUTBOX_MAX_ENTRIES as w, CLIENT_VERSION_HEADER as x, RESUME_DEBOUNCE_MS as y };
 
 //# sourceMappingURL=src.js.map