gemi 0.192.0 → 0.193.1

package/dist/chunks/{ThemeProvider-BnmnRvEc.js → ThemeProvider-G2g5Z1ZS.js}

@@ -1053,7 +1053,7 @@ function loadedRealtimeClient() {
 }
 var loading = null;
 /** The lazily loaded client. Replaceable in tests, to simulate a failed load. */
-var lazyModules = { client: () => import("./RealtimeClient-CyGWZr6p.js") };
+var lazyModules = { client: () => import("./RealtimeClient-BVQeh_yg.js") };
 /**
 * `./live`, loaded by the first live query. `<Page>` in `gemi/testing` sets
 * `current` up front, so a live query on a provided socket subscribes during
@@ -1061,7 +1061,7 @@ var lazyModules = { client: () => import("./RealtimeClient-CyGWZr6p.js") };
 */
 var liveModule = {
 	current: null,
-	load: () => import("./live-B4RW02g2.js").then((n) => n.n)
+	load: () => import("./live-C2Sck5PO.js").then((n) => n.n)
 };
 /**
 * The tab's client, loading its module and creating it on first use. `null`
@@ -3244,6 +3244,8 @@ function flattenComponentTree(componentTree) {
 * inside the cooldown is left to the route's error boundary. Per URL rather
 * than per tab (#1056): while two releases serve at once every navigation can
 * miss, and a tab-wide cooldown sent the second one to the error boundary.
+* Where `sessionStorage` cannot be used, the marker lives in `window.name`
+* instead (#1186); see `chunkReloadGuard`.
 *
 * The same guard covers a navigation whose data came from another build
 * (`recoverFromBuildMismatch`).
@@ -3283,6 +3285,7 @@ var pendingLoad = null;
 function configureChunkLoadRecovery(next) {
 	enabled = next !== false;
 	options = next || {};
+	tidyWindowName();
 }
 /**
 * The router calls this as each client-side navigation starts. A full load
@@ -3389,46 +3392,155 @@ function cooldownMs() {
 }
 function reloadBlock(url) {
 	if (typeof navigator !== "undefined" && navigator.onLine === false) return "offline";
-	let raw;
-	try {
-		raw = window.sessionStorage.getItem(CHUNK_RELOAD_MARKER);
-	} catch {
-		return "storage";
-	}
-	const at = parseMarker(raw)[url];
-	return at !== void 0 && withinCooldown(Date.now() - at, cooldownMs()) ? "cooldown" : null;
+	const verdict = chunkReloadGuard(CHUNK_RELOAD_MARKER, url, cooldownMs(), false);
+	return verdict === "ok" ? null : verdict;
 }
 function withinCooldown(elapsed, cooldownMs) {
 	return elapsed >= 0 && elapsed < cooldownMs;
 }
+function markReload(url) {
+	if (chunkReloadGuard("gemi:chunk-reload", url, cooldownMs(), true) !== "ok") return false;
+	tidyWindowName();
+	return true;
+}
+var tidyTimer;
 /**
-* The marker: when each URL was last reloaded onto, `{ [url]: at }`. Anything
-* else in it (a marker written by an earlier gemi as `{ url, at }`) is ignored.
+* Takes gemi's marker out of `window.name` (back to `""`) once it guards
+* nothing (#1188): the page may want the name for itself, under the same
+* "only while it is empty" rule gemi follows. Now when nothing in it is live,
+* otherwise once the newest entry's cooldown has passed, checked again then
+* since a reload may have been recorded in the meantime. Only a name that
+* holds gemi's marker is ever cleared; see `chunkReloadGuard`'s `"tidy"`.
 */
-function parseMarker(raw) {
-	let parsed;
+function tidyWindowName() {
+	clearTimeout(tidyTimer);
+	tidyTimer = void 0;
+	if (typeof window === "undefined") return;
+	let delay;
 	try {
-		parsed = raw ? JSON.parse(raw) : null;
+		if (chunkReloadGuard("gemi:chunk-reload", window.location.href, cooldownMs(), "tidy") !== "cooldown") return;
+		const held = JSON.parse(window.name.slice(18));
+		const now = Date.now();
+		delay = Math.max(...Object.values(held.m).filter((at) => typeof at === "number" && at <= now)) + cooldownMs() - now;
 	} catch {
-		return {};
-	}
-	const marker = {};
-	if (parsed && typeof parsed === "object") {
-		for (const [url, at] of Object.entries(parsed)) if (typeof at === "number") marker[url] = at;
+		return;
 	}
-	return marker;
+	if (!Number.isFinite(delay)) return;
+	tidyTimer = setTimeout(tidyWindowName, Math.max(0, delay) + 1);
 }
-function markReload(url) {
+/**
+* The cross-document guard, shared by the client and the server's reload stub
+* (which embeds this function's source, so it uses nothing but globals and its
+* arguments). With `claim` false it only reads: `"cooldown"` when a reload
+* onto `url` was recorded inside `cooldownMs`, `"storage"` when no marker can
+* be read at all, otherwise `"ok"`. With `claim` true it also records the
+* reload, and answers `"ok"` only once the record was written and read back
+* unchanged; a caller navigates on nothing less. With `"tidy"` it only looks
+* at `window.name`: a gemi marker with no live entry for this origin (expired,
+* from the future, another origin's, or one that does not parse) is cleared
+* to `""` and `"ok"` answered; `"cooldown"` while an entry is still live.
+*
+* Two places can hold the marker:
+*
+* - `sessionStorage[key]`: `{ [url]: at }`, the format earlier releases read
+*   and write, so a page from one and a stub from another share the guard.
+* - `window.name`, when `sessionStorage` throws or will not take the write
+*   (#1186). It survives a load in the same tab, but it is shared state: the
+*   page may use it, and another origin the tab goes to can read it. So it is
+*   used only while it is empty or already holds gemi's marker — a value of
+*   anyone else's is left exactly as it is, and the guard then fails closed —
+*   and it holds no URL: `key + ":" + { o: hash(origin), m: { [hash(origin +
+*   pathname)]: at } }`. A marker written by another origin (`o` differs) or
+*   one that does not parse holds no reloads and is replaced on the next
+*   write. Two paths whose hashes collide share one cooldown, which only ever
+*   refuses a reload.
+*
+* A reload recorded in either place counts. Entries past the cooldown — and
+* from the future, after the clock was set back — are dropped as a new one is
+* written, so the marker holds only the reloads it still guards.
+*/
+function chunkReloadGuard(key, url, cooldownMs, claim) {
+	const now = Date.now();
+	const fresh = function(at) {
+		return typeof at === "number" && now - at >= 0 && now - at < cooldownMs;
+	};
+	const parse = function(raw) {
+		try {
+			const value = raw ? JSON.parse(raw) : null;
+			return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+		} catch {
+			return {};
+		}
+	};
+	const live = function(marker) {
+		const kept = {};
+		for (const k in marker) if (fresh(marker[k])) kept[k] = marker[k];
+		return kept;
+	};
+	const hash = function(text) {
+		let h = 2166136261;
+		for (let i = 0; i < text.length; i++) h = Math.imul(h ^ text.charCodeAt(i), 16777619);
+		return (h >>> 0).toString(36);
+	};
+	let storage = null;
+	let stored = {};
 	try {
-		const now = Date.now();
-		const marker = {};
-		for (const [other, at] of Object.entries(parseMarker(window.sessionStorage.getItem(CHUNK_RELOAD_MARKER)))) if (withinCooldown(now - at, cooldownMs())) marker[other] = at;
-		marker[url] = now;
-		window.sessionStorage.setItem(CHUNK_RELOAD_MARKER, JSON.stringify(marker));
-		return true;
+		storage = window.sessionStorage;
+		stored = parse(storage.getItem(key));
 	} catch {
-		return false;
+		storage = null;
 	}
+	const prefix = key + ":";
+	let origin = "";
+	let page = "";
+	try {
+		const target = new URL(url, window.location.href);
+		origin = hash(new URL(window.location.href).origin);
+		page = hash(target.origin + target.pathname);
+	} catch {}
+	let named = null;
+	try {
+		const name = window.name;
+		if (!page) named = null;
+		else if (name === "") named = {};
+		else if (name.indexOf(prefix) === 0) {
+			const held = parse(name.slice(prefix.length));
+			const entries = held.m;
+			named = held.o === origin && entries && typeof entries === "object" && !Array.isArray(entries) ? entries : {};
+		}
+	} catch {
+		named = null;
+	}
+	if (claim === "tidy") {
+		try {
+			const current = window.name;
+			if (named === null || current.indexOf(prefix) !== 0) return "ok";
+			for (const k in named) if (fresh(named[k])) return "cooldown";
+			window.name = "";
+		} catch {}
+		return "ok";
+	}
+	if (fresh(stored[url]) || named && fresh(named[page])) return "cooldown";
+	if (!storage && !named) return "storage";
+	if (!claim) return "ok";
+	if (storage) try {
+		const nextStored = live(stored);
+		nextStored[url] = now;
+		const serialised = JSON.stringify(nextStored);
+		storage.setItem(key, serialised);
+		if (storage.getItem(key) === serialised) return "ok";
+	} catch {}
+	if (named) try {
+		const nextNamed = live(named);
+		nextNamed[page] = now;
+		const value = prefix + JSON.stringify({
+			o: origin,
+			m: nextNamed
+		});
+		window.name = value;
+		if (window.name === value) return "ok";
+	} catch {}
+	return "storage";
 }
 //#endregion
 //#region client/ComponentContext.tsx
@@ -4055,4 +4167,4 @@ function useTheme() {
 //#endregion
 export { QueryManagerProvider as $, useNavigate as A, createMemoryHistory as B, loadDictionaryForRender as C, routeDataUrl as D, readRoutePayload as E, useLocation as F, realtime as G, configureRealtime as H, domainUrl as I, loadedModule as J, reconnectRealtime as K, isAbsoluteUrl as L, I18nProvider as M, ServerDataContext as N, useRoute as O, ServerDataProvider as P, QueryManagerContext as Q, ProgressManager as R, loadDictionary as S, setActiveLocale as T, followLive as U, RealtimeContext as V, liveModule as W, applyParams as X, toVariantKey as Y, QueryConfigContext as Z, isChunkLoadError as _, Subject as _t, useRouteTransition as a, resetAuthenticationIncident as at, recoverFromBuildMismatch as b, ClientRouterContext as c, isExternalRedirect as ct, ComponentsProvider as d, equalJitter as dt, USER_QUERY_CONFIG_KEYS as et, initialViewModulesReady as f, isRetryableQueryError as ft, configureChunkLoadRecovery as g, QueryError as gt, CHUNK_RELOAD_MARKER as h, shouldRetryQuery as ht, RouteTransitionProvider as i, reportAuthenticationRefusal as it, I18nContext as j, useSearchParams as k, ClientRouterProvider as l, safeRedirectPath as lt, subscribeViewModules as m, retryDelayFor as mt, useTheme as n, DEFAULT_STALE_TIME as nt, useChannelSubscription as o, setAuthenticationNavigator as ot, loadViewModule as p, parseRetryAfter as pt, loadLazy as q, m as r, configureAuthenticationErrors as rt, useCoalesced as s, INTENDED_URL_PARAM as st, ThemeProvider as t, pickDefined as tt, ComponentsContext as u, readResponseBody as ut, navigationStarted as v, registerDictionary as w, recoverFromChunkLoadError as x, otherBuild as y, Action as z };
 
-//# sourceMappingURL=ThemeProvider-BnmnRvEc.js.map
+//# sourceMappingURL=ThemeProvider-G2g5Z1ZS.js.map