@ovineko/spa-guard 0.0.2-alpha-1 → 0.0.4

package/dist/retryOrchestrator-DNGIHV2M.mjs

@@ -0,0 +1,758 @@
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+//#region package.json
+var name = "@ovineko/spa-guard";
+//#endregion
+//#region src/common/constants.ts
+const optionsWindowKey = "__SPA_GUARD_OPTIONS__";
+const eventSubscribersWindowKey = Symbol.for(`${name}:event-subscribers`);
+const internalConfigWindowKey = Symbol.for(`${name}:internal-config`);
+const initializedKey = Symbol.for(`${name}:initialized`);
+const loggerWindowKey = Symbol.for(`${name}:logger`);
+const RETRY_ID_PARAM = "spaGuardRetryId";
+const RETRY_ATTEMPT_PARAM = "spaGuardRetryAttempt";
+const CACHE_BUST_PARAM = "spaGuardCacheBust";
+const versionCheckStateWindowKey = Symbol.for(`${name}:version-check-state`);
+const inMemoryLastReloadKey = Symbol.for(`${name}:in-memory-last-reload`);
+const staticAssetRecoveryKey = Symbol.for(`${name}:static-asset-recovery`);
+const debugSyncErrorEventType = "spa-guard:debug-sync-error";
+const spinnerStateWindowKey = Symbol.for(`${name}:spinner-state`);
+const fallbackModeKey = Symbol.for(`${name}:fallback-mode`);
+//#endregion
+//#region src/common/events/internal.ts
+if (globalThis.window && !globalThis.window[eventSubscribersWindowKey]) globalThis.window[eventSubscribersWindowKey] = /* @__PURE__ */ new Set();
+if (globalThis.window && !globalThis.window[internalConfigWindowKey]) globalThis.window[internalConfigWindowKey] = {
+	defaultRetryEnabled: true,
+	initialized: false
+};
+const subscribers = globalThis.window?.[eventSubscribersWindowKey] ?? /* @__PURE__ */ new Set();
+const internalConfig = globalThis.window?.[internalConfigWindowKey] ?? {
+	defaultRetryEnabled: true,
+	initialized: false
+};
+const setLogger = (logger) => {
+	if (globalThis.window !== void 0) globalThis.window[loggerWindowKey] = logger;
+};
+const getLogger = () => {
+	return globalThis.window?.[loggerWindowKey];
+};
+const emitEvent = (event, options) => {
+	if (!options?.silent) getLogger()?.logEvent(event);
+	subscribers.forEach((cb) => {
+		try {
+			cb(event);
+		} catch {}
+	});
+};
+const subscribe = (cb) => {
+	subscribers.add(cb);
+	return () => subscribers.delete(cb);
+};
+const isInitialized = () => {
+	return internalConfig.initialized;
+};
+const markInitialized = () => {
+	internalConfig.initialized = true;
+	if (globalThis.window !== void 0) globalThis.window[initializedKey] = true;
+};
+const disableDefaultRetry = () => {
+	internalConfig.defaultRetryEnabled = false;
+};
+const enableDefaultRetry = () => {
+	internalConfig.defaultRetryEnabled = true;
+};
+const isDefaultRetryEnabled = () => {
+	return internalConfig.defaultRetryEnabled;
+};
+//#endregion
+//#region src/common/i18n.ts
+/**
+* Apply i18n translations to a virtual container's data-attributed elements.
+* Patches `[data-spa-guard-content]` and `[data-spa-guard-action]` elements,
+* and applies RTL direction if needed.
+*
+* Must be called on a virtual (detached) container BEFORE inserting into DOM
+* to avoid flash of untranslated content.
+*/
+function applyI18n(container, t) {
+	const contentEls = container.querySelectorAll("[data-spa-guard-content]");
+	for (const el of contentEls) {
+		const key = el.dataset.spaGuardContent;
+		if (key && key in t) {
+			const value = t[key];
+			if (typeof value === "string") el.textContent = value;
+		}
+	}
+	const actionEls = container.querySelectorAll("[data-spa-guard-action]");
+	for (const el of actionEls) {
+		const action = el.dataset.spaGuardAction;
+		const tKey = action === "try-again" ? "tryAgain" : action;
+		if (tKey && tKey in t) {
+			const value = t[tKey];
+			if (typeof value === "string") el.textContent = value;
+		}
+	}
+	if (t.rtl) {
+		for (const child of container.children) if (child instanceof HTMLElement && child.tagName !== "STYLE") child.style.direction = "rtl";
+	}
+}
+/**
+* Read i18n translations from the `<meta name="spa-guard-i18n">` tag.
+* Returns parsed translations or null if the tag is absent or malformed.
+*/
+function getI18n() {
+	try {
+		const el = document.querySelector("meta[name=\"spa-guard-i18n\"]");
+		if (!el) return null;
+		const content = el.getAttribute("content");
+		if (!content) return null;
+		return JSON.parse(content);
+	} catch {
+		return null;
+	}
+}
+/**
+* Write i18n translations to the `<meta name="spa-guard-i18n">` tag.
+* Creates the tag if it doesn't exist, or updates it if it does.
+*
+* Use this at runtime to dynamically patch the inline fallback/loading UI
+* translations without server-side rendering.
+*/
+function setTranslations(translations) {
+	let el = document.querySelector("meta[name=\"spa-guard-i18n\"]");
+	if (!el) {
+		el = document.createElement("meta");
+		el.setAttribute("name", "spa-guard-i18n");
+		document.head.append(el);
+	}
+	el.setAttribute("content", JSON.stringify(translations));
+}
+//#endregion
+//#region src/common/html.generated.ts
+const defaultErrorFallbackHtml = `<style>.spa-guard-error-id:has(.spa-guard-retry-id:empty){display:none}.spa-guard-error-id{font-family:ui-monospace,SFMono-Regular,Consolas,"Liberation Mono",Menlo,monospace}.spa-guard-fallback-root{display:flex;align-items:center;justify-content:center;min-height:100vh;padding:2rem;font-family:system-ui,sans-serif;background:#fff;color:#1a1a1a;color-scheme:light dark}.spa-guard-fallback-icon{stroke:#b0b0b0}.spa-guard-fallback-message{color:#666}.spa-guard-fallback-muted{color:#999}.spa-guard-btn-secondary{border:1px solid #d0d0d0;background:#fff;color:#333}.spa-guard-btn-primary{border:1px solid transparent;background:#111;color:#fff}@media (prefers-color-scheme:dark){.spa-guard-fallback-root{background:#111318;color:#e7eaf0}.spa-guard-fallback-icon{stroke:#8b95a7}.spa-guard-fallback-message{color:#b8bfca}.spa-guard-fallback-muted{color:#8b95a7}.spa-guard-btn-secondary{border-color:#3b4351;background:#1a1f28;color:#d8deea}.spa-guard-btn-primary{background:#e7eaf0;color:#151922}}</style><div class="spa-guard-fallback-root"><div style="text-align:center;max-width:480px"><div style="margin-bottom:1.5rem"><svg class="spa-guard-fallback-icon" xmlns="http://www.w3.org/2000/svg" width="48" height="48" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="8" x2="12" y2="12"/><line x1="12" y1="16" x2="12.01" y2="16"/></svg></div><h1 data-spa-guard-content="heading" style="font-size:1.375rem;font-weight:600;margin:0 0 .5rem;line-height:1.3">Something went wrong</h1><p data-spa-guard-content="message" class="spa-guard-fallback-message" style="max-width:600px;margin:0 auto 1.5rem;font-size:.9375rem;line-height:1.5">Please refresh the page to continue.</p><div style="display:flex;gap:.5rem;justify-content:center;flex-wrap:wrap"><button data-spa-guard-action="try-again" type="button" class="spa-guard-btn-secondary" style="display:none;padding:.5rem 1.25rem;font-size:.875rem;font-family:inherit;border-radius:6px;cursor:pointer;line-height:1.5">Try again</button> <button data-spa-guard-action="reload" type="button" class="spa-guard-btn-primary" style="padding:.5rem 1.25rem;font-size:.875rem;font-family:inherit;border-radius:6px;cursor:pointer;line-height:1.5">Reload page</button></div><p class="spa-guard-error-id spa-guard-fallback-muted" style="margin-top:1.5rem;font-size:.6875rem">Error ID: <span class="spa-guard-retry-id"></span></p></div></div>`;
+const defaultLoadingFallbackHtml = `<style>.spa-guard-loading-root{display:flex;align-items:center;justify-content:center;min-height:100vh;padding:2rem;font-family:system-ui,sans-serif;background:#fff;color:#1a1a1a;color-scheme:light dark}.spa-guard-loading-muted{color:#999}@media (prefers-color-scheme:dark){.spa-guard-loading-root{background:#111318;color:#e7eaf0}.spa-guard-loading-muted{color:#8b95a7}}</style><div class="spa-guard-loading-root"><div style="text-align:center"><div data-spa-guard-spinner style="margin-bottom:1.25rem"></div><h2 data-spa-guard-content="loading" style="font-size:1.125rem;font-weight:600;margin:0 0 .25rem">Loading...</h2><p data-spa-guard-section="retrying" class="spa-guard-loading-muted" style="display:none;font-size:.8125rem;margin:.5rem 0 0"><span data-spa-guard-content="retrying">Retry attempt</span> <span data-spa-guard-content="attempt"></span></p></div></div>`;
+const defaultSpinnerHtml = `<svg width="40" height="40" viewBox="0 0 40 40" style="animation:spa-guard-spin .8s linear infinite"><circle cx="20" cy="20" r="16" fill="none" stroke="#e8e8e8" stroke-width="3"/><circle cx="20" cy="20" r="16" fill="none" stroke="#666" stroke-width="3" stroke-dasharray="80" stroke-dashoffset="60" stroke-linecap="round"/></svg><style>@keyframes spa-guard-spin{to{transform:rotate(360deg)}}</style>`;
+//#endregion
+//#region src/common/options.ts
+var options_exports = /* @__PURE__ */ __exportAll({
+	getOptions: () => getOptions,
+	optionsWindowKey: () => optionsWindowKey
+});
+const defaultOptions = {
+	checkVersion: {
+		cache: "no-store",
+		interval: 3e5,
+		mode: "html",
+		onUpdate: "reload"
+	},
+	enableRetryReset: true,
+	errors: {
+		forceRetry: [],
+		ignore: []
+	},
+	handleUnhandledRejections: {
+		retry: false,
+		sendBeacon: true
+	},
+	html: {
+		fallback: {
+			content: defaultErrorFallbackHtml,
+			selector: "body"
+		},
+		loading: { content: defaultLoadingFallbackHtml },
+		spinner: {
+			background: "#fff",
+			disabled: false
+		}
+	},
+	lazyRetry: {
+		callReloadOnFailure: true,
+		retryDelays: [1e3, 2e3]
+	},
+	minTimeBetweenResets: 5e3,
+	reloadDelays: [
+		1e3,
+		2e3,
+		5e3
+	],
+	staticAssets: {
+		autoRecover: true,
+		recoveryDelay: 500
+	},
+	useRetryId: true
+};
+const getOptions = () => {
+	const windowOptions = globalThis.window?.[optionsWindowKey];
+	return {
+		...defaultOptions,
+		...windowOptions,
+		checkVersion: {
+			...defaultOptions.checkVersion,
+			...windowOptions?.checkVersion
+		},
+		errors: {
+			...defaultOptions.errors,
+			...windowOptions?.errors
+		},
+		handleUnhandledRejections: {
+			...defaultOptions.handleUnhandledRejections,
+			...windowOptions?.handleUnhandledRejections
+		},
+		html: {
+			fallback: {
+				...defaultOptions.html?.fallback,
+				...windowOptions?.html?.fallback
+			},
+			loading: {
+				...defaultOptions.html?.loading,
+				...windowOptions?.html?.loading
+			},
+			spinner: {
+				...defaultOptions.html?.spinner,
+				...windowOptions?.html?.spinner
+			}
+		},
+		lazyRetry: {
+			...defaultOptions.lazyRetry,
+			...windowOptions?.lazyRetry
+		},
+		reportBeacon: {
+			...defaultOptions.reportBeacon,
+			...windowOptions?.reportBeacon
+		},
+		staticAssets: {
+			...defaultOptions.staticAssets,
+			...windowOptions?.staticAssets
+		}
+	};
+};
+//#endregion
+//#region src/common/retryState.ts
+const getRetryStateFromUrl = () => {
+	try {
+		const params = new URLSearchParams(globalThis.window.location.search);
+		const retryId = params.get(RETRY_ID_PARAM);
+		const retryAttempt = params.get(RETRY_ATTEMPT_PARAM);
+		if (retryId && retryAttempt) {
+			if (!/^\d+$/.test(retryAttempt)) return null;
+			const parsed = parseInt(retryAttempt, 10);
+			if (Number.isNaN(parsed) || !Number.isFinite(parsed) || parsed < 0) return null;
+			return {
+				retryAttempt: parsed,
+				retryId
+			};
+		}
+		return null;
+	} catch {
+		return null;
+	}
+};
+const generateRetryId = () => {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+		const array = new Uint32Array(2);
+		crypto.getRandomValues(array);
+		return `${Date.now()}-${array[0].toString(36)}-${array[1].toString(36)}`;
+	}
+	return `${Date.now()}-${Math.random().toString(36).slice(2, 15)}`;
+};
+const getRetryAttemptFromUrl = () => {
+	try {
+		const retryAttempt = new URLSearchParams(globalThis.window.location.search).get(RETRY_ATTEMPT_PARAM);
+		if (retryAttempt) {
+			if (!/^\d+$/.test(retryAttempt)) return null;
+			const parsed = parseInt(retryAttempt, 10);
+			if (Number.isNaN(parsed) || !Number.isFinite(parsed) || parsed < 0) return null;
+			return parsed;
+		}
+		return null;
+	} catch {
+		return null;
+	}
+};
+const getRetryInfoForBeacon = () => {
+	const retryState = getRetryStateFromUrl();
+	if (!retryState) return {};
+	return {
+		retryAttempt: retryState.retryAttempt,
+		retryId: retryState.retryId
+	};
+};
+//#endregion
+//#region src/common/fallbackRendering.ts
+/**
+* Renders the loading UI into the DOM during a retry delay before reload.
+*
+* Fail-safe: if loading content is not configured or the target element is not
+* found, returns silently with no log, no event, and no side effects.
+* All DOM access is wrapped in try/catch.
+*/
+const showLoadingUI = (attempt) => {
+	const options = getOptions();
+	const loadingHtml = options.html?.loading?.content;
+	if (!loadingHtml) return;
+	const selector = options.html?.fallback?.selector ?? "body";
+	try {
+		const targetElement = document.querySelector(selector);
+		if (!targetElement) return;
+		const container = document.createElement("div");
+		container.innerHTML = loadingHtml;
+		const t = getI18n();
+		if (t) applyI18n(container, t);
+		targetElement.innerHTML = container.innerHTML;
+		const retrySection = targetElement.querySelector("[data-spa-guard-section=\"retrying\"]");
+		if (retrySection) {
+			const retrySectionEl = retrySection;
+			retrySectionEl.style.display = "";
+			retrySectionEl.style.visibility = "visible";
+		}
+		const attemptElements = targetElement.querySelectorAll("[data-spa-guard-content=\"attempt\"]");
+		for (const el of attemptElements) el.textContent = String(attempt);
+		const spinnerEl = targetElement.querySelector("[data-spa-guard-spinner]");
+		if (spinnerEl) {
+			const spinnerOptions = options.html?.spinner;
+			if (spinnerOptions?.disabled) spinnerEl.style.display = "none";
+			else if (spinnerOptions?.content) spinnerEl.innerHTML = spinnerOptions.content;
+		}
+	} catch {}
+};
+/**
+* Renders the fallback UI into the DOM.
+*
+* This is a pure rendering helper. It has no lifecycle side effects:
+* it does not set fallback mode, does not check whether fallback mode is
+* already active, and does not modify orchestrator state. The caller is
+* responsible for ensuring the lifecycle transition has already occurred
+* before invoking this function.
+*
+* Fails safely: if fallback HTML is not configured or the target element
+* is not found, logs a warning and returns without side effects or errors.
+*/
+const showFallbackUI = (override) => {
+	const options = getOptions();
+	const fallbackHtml = options.html?.fallback?.content;
+	const selector = options.html?.fallback?.selector ?? "body";
+	if (!fallbackHtml) {
+		getLogger()?.noFallbackConfigured();
+		emitEvent({
+			name: "fallback-ui-not-rendered",
+			reason: "no-html-configured"
+		});
+		return;
+	}
+	try {
+		const targetElement = document.querySelector(selector);
+		if (!targetElement) {
+			getLogger()?.fallbackTargetNotFound(selector);
+			emitEvent({
+				name: "fallback-ui-not-rendered",
+				reason: "target-not-found",
+				selector
+			});
+			return;
+		}
+		const container = document.createElement("div");
+		container.innerHTML = fallbackHtml;
+		const t = getI18n();
+		if (t) applyI18n(container, t);
+		targetElement.innerHTML = container.innerHTML;
+		const reloadBtn = targetElement.querySelector("[data-spa-guard-action=\"reload\"]");
+		if (reloadBtn) reloadBtn.addEventListener("click", () => globalThis.window.location.reload());
+		const retryId = override?.retryId ?? getRetryStateFromUrl()?.retryId;
+		if (retryId) {
+			const retryIdElements = document.getElementsByClassName("spa-guard-retry-id");
+			for (const element of retryIdElements) element.textContent = retryId;
+		}
+		emitEvent({ name: "fallback-ui-shown" });
+	} catch (error) {
+		getLogger()?.fallbackInjectFailed(error);
+	}
+};
+//#endregion
+//#region src/common/fallbackState.ts
+const isInFallbackMode = () => {
+	if (globalThis.window === void 0) return false;
+	return globalThis.window[fallbackModeKey] === true;
+};
+const setFallbackMode = () => {
+	if (globalThis.window === void 0) return;
+	globalThis.window[fallbackModeKey] = true;
+};
+const resetFallbackMode = () => {
+	if (globalThis.window === void 0) return;
+	globalThis.window[fallbackModeKey] = false;
+};
+//#endregion
+//#region src/common/lastReloadTime.ts
+const STORAGE_KEY = "__spa_guard_last_reload_timestamp__";
+const RESET_INFO_KEY = "__spa_guard_last_retry_reset__";
+if (globalThis.window && !globalThis.window[inMemoryLastReloadKey]) globalThis.window[inMemoryLastReloadKey] = {
+	resetInfo: null,
+	storage: null
+};
+const getInMemoryState = () => {
+	const w = globalThis.window;
+	if (!w) return {
+		resetInfo: null,
+		storage: null
+	};
+	return w[inMemoryLastReloadKey] ?? (w[inMemoryLastReloadKey] = {
+		resetInfo: null,
+		storage: null
+	});
+};
+const hasSessionStorage = () => {
+	try {
+		return globalThis.window !== void 0 && typeof sessionStorage !== "undefined";
+	} catch {
+		return false;
+	}
+};
+const setLastReloadTime = (retryId, attemptNumber) => {
+	const data = {
+		attemptNumber,
+		retryId,
+		timestamp: Date.now()
+	};
+	if (hasSessionStorage()) try {
+		sessionStorage.setItem(STORAGE_KEY, JSON.stringify(data));
+	} catch {
+		getInMemoryState().storage = data;
+	}
+	else getInMemoryState().storage = data;
+};
+const getLastReloadTime = () => {
+	if (hasSessionStorage()) try {
+		const stored = sessionStorage.getItem(STORAGE_KEY);
+		if (stored) return JSON.parse(stored);
+	} catch {
+		try {
+			sessionStorage.removeItem(STORAGE_KEY);
+		} catch {}
+		return getInMemoryState().storage;
+	}
+	return getInMemoryState().storage;
+};
+const clearLastReloadTime = () => {
+	if (hasSessionStorage()) try {
+		sessionStorage.removeItem(STORAGE_KEY);
+	} catch {}
+	getInMemoryState().storage = null;
+};
+const shouldResetRetryCycle = (retryState, reloadDelays, minTimeBetweenResets = 5e3) => {
+	if (retryState.retryAttempt === 0) return false;
+	const lastReload = getLastReloadTime();
+	if (!lastReload) return false;
+	if (lastReload.retryId !== retryState.retryId) return false;
+	const lastReset = getLastRetryResetInfo();
+	if (lastReset) {
+		if (Date.now() - lastReset.timestamp < minTimeBetweenResets) return false;
+	}
+	return Date.now() - lastReload.timestamp > (reloadDelays[lastReload.attemptNumber - 1] ?? 1e3) + 3e4;
+};
+const setLastRetryResetInfo = (previousRetryId) => {
+	const data = {
+		previousRetryId,
+		timestamp: Date.now()
+	};
+	if (hasSessionStorage()) try {
+		sessionStorage.setItem(RESET_INFO_KEY, JSON.stringify(data));
+	} catch {
+		getInMemoryState().resetInfo = data;
+	}
+	else getInMemoryState().resetInfo = data;
+};
+const getLastRetryResetInfo = () => {
+	if (hasSessionStorage()) try {
+		const stored = sessionStorage.getItem(RESET_INFO_KEY);
+		if (stored) return JSON.parse(stored);
+	} catch {
+		try {
+			sessionStorage.removeItem(RESET_INFO_KEY);
+		} catch {}
+		return getInMemoryState().resetInfo;
+	}
+	return getInMemoryState().resetInfo;
+};
+const clearLastRetryResetInfo = () => {
+	if (hasSessionStorage()) try {
+		sessionStorage.removeItem(RESET_INFO_KEY);
+	} catch {}
+	getInMemoryState().resetInfo = null;
+};
+//#endregion
+//#region src/common/errors/ForceRetryError.ts
+const FORCE_RETRY_MAGIC = "__SPA_GUARD_FORCE_RETRY__";
+var ForceRetryError = class extends Error {
+	constructor(message, options) {
+		super(`${FORCE_RETRY_MAGIC}${message ?? ""}`, options);
+		this.name = "ForceRetryError";
+	}
+};
+//#endregion
+//#region src/common/shouldIgnore.ts
+/**
+* Checks if any of the provided messages should be ignored based on errors.ignore option.
+*/
+const shouldIgnoreMessages = (messages) => {
+	const ignorePatterns = (getOptions().errors?.ignore ?? []).filter((p) => p !== "");
+	if (ignorePatterns.length === 0) return false;
+	return messages.filter((msg) => typeof msg === "string").some((message) => ignorePatterns.some((pattern) => message.includes(pattern)));
+};
+/**
+* Checks if any of the provided messages match a forceRetry pattern.
+*/
+const shouldForceRetry = (messages) => {
+	const forceRetryPatterns = [...getOptions().errors?.forceRetry ?? [], FORCE_RETRY_MAGIC].filter((p) => p !== "");
+	return messages.filter((msg) => typeof msg === "string").some((message) => forceRetryPatterns.some((pattern) => message.includes(pattern)));
+};
+/**
+* Checks if a beacon should be ignored based on errors.ignore option.
+*/
+const shouldIgnoreBeacon = (beacon) => {
+	return shouldIgnoreMessages([beacon.errorMessage, beacon.eventMessage]);
+};
+//#endregion
+//#region src/common/sendBeacon.ts
+const sendBeacon = (beacon) => {
+	if (shouldIgnoreBeacon(beacon)) return;
+	const options = getOptions();
+	if (!options.reportBeacon?.endpoint) {
+		getLogger()?.noBeaconEndpoint();
+		return;
+	}
+	const enrichedBeacon = options.appName ? {
+		...beacon,
+		appName: options.appName
+	} : beacon;
+	const body = JSON.stringify(enrichedBeacon);
+	if (!(typeof globalThis.window?.navigator?.sendBeacon === "function" && globalThis.window.navigator.sendBeacon(options.reportBeacon.endpoint, body)) && typeof fetch === "function") fetch(options.reportBeacon.endpoint, {
+		body,
+		keepalive: true,
+		method: "POST"
+	}).catch((error) => {
+		getLogger()?.beaconSendFailed(error);
+	});
+};
+//#endregion
+//#region src/common/retryOrchestrator.ts
+const retryOrchestratorKey = Symbol.for(`${name}:retry-orchestrator`);
+const createFreshState = () => ({
+	attempt: 0,
+	phase: "idle",
+	retryId: null,
+	timer: null
+});
+const getState = () => {
+	if (globalThis.window === void 0) return createFreshState();
+	const w = globalThis.window;
+	if (!w[retryOrchestratorKey]) w[retryOrchestratorKey] = createFreshState();
+	return w[retryOrchestratorKey];
+};
+const setState = (updates) => {
+	if (globalThis.window === void 0) return;
+	const w = globalThis.window;
+	if (!w[retryOrchestratorKey]) w[retryOrchestratorKey] = createFreshState();
+	Object.assign(w[retryOrchestratorKey], updates);
+};
+const buildReloadUrl = (retryId, attempt, cacheBust, includeRetryId = true) => {
+	const url = new URL(globalThis.window.location.href);
+	if (includeRetryId) url.searchParams.set(RETRY_ID_PARAM, retryId);
+	url.searchParams.set(RETRY_ATTEMPT_PARAM, String(attempt));
+	if (cacheBust) url.searchParams.set(CACHE_BUST_PARAM, String(Date.now()));
+	return url.toString();
+};
+const parseAttemptFromUrl = () => {
+	try {
+		const raw = new URLSearchParams(globalThis.window.location.search).get(RETRY_ATTEMPT_PARAM);
+		if (!raw) return null;
+		if (!/^\d+$/.test(raw)) return null;
+		const parsed = parseInt(raw, 10);
+		if (Number.isNaN(parsed) || !Number.isFinite(parsed) || parsed < 0) return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+};
+const parseRetryIdFromUrl = () => {
+	try {
+		return new URLSearchParams(globalThis.window.location.search).get(RETRY_ID_PARAM);
+	} catch {
+		return null;
+	}
+};
+const clearRetryFromUrl = () => {
+	try {
+		const url = new URL(globalThis.window.location.href);
+		url.searchParams.delete(RETRY_ID_PARAM);
+		url.searchParams.delete(RETRY_ATTEMPT_PARAM);
+		url.searchParams.delete(CACHE_BUST_PARAM);
+		globalThis.window.history.replaceState(null, "", url.toString());
+	} catch (error) {
+		getLogger()?.error("clearRetryFromUrl failed", error);
+	}
+};
+const triggerRetry = (input = {}) => {
+	const state = getState();
+	if (state.phase === "fallback" || isInFallbackMode()) {
+		getLogger()?.fallbackAlreadyShown(input.error);
+		return { status: "fallback" };
+	}
+	if (state.phase === "scheduled") {
+		getLogger()?.reloadAlreadyScheduled(input.error);
+		return {
+			reason: "already-scheduled",
+			status: "deduped"
+		};
+	}
+	if (!isDefaultRetryEnabled()) return { status: "retry-disabled" };
+	setState({
+		...input.source !== void 0 && { lastSource: input.source },
+		lastTriggerTime: Date.now(),
+		phase: "scheduled"
+	});
+	try {
+		const options = getOptions();
+		const reloadDelays = options.reloadDelays ?? [
+			1e3,
+			2e3,
+			5e3
+		];
+		const useRetryId = options.useRetryId ?? true;
+		const enableRetryReset = options.enableRetryReset ?? true;
+		const minTimeBetweenResets = options.minTimeBetweenResets ?? 5e3;
+		const urlAttempt = parseAttemptFromUrl();
+		const urlRetryId = parseRetryIdFromUrl();
+		let currentAttempt = urlAttempt ?? 0;
+		let retryId = useRetryId && urlRetryId ? urlRetryId : generateRetryId();
+		getLogger()?.retryCycleStarting(retryId, currentAttempt);
+		if (enableRetryReset && urlRetryId && urlAttempt !== null && urlAttempt > 0) {
+			if (shouldResetRetryCycle({
+				retryAttempt: urlAttempt,
+				retryId: urlRetryId
+			}, reloadDelays, minTimeBetweenResets)) {
+				const lastReload = getLastReloadTime();
+				const timeSinceReload = lastReload ? Date.now() - lastReload.timestamp : 0;
+				clearRetryFromUrl();
+				clearLastReloadTime();
+				setLastRetryResetInfo(urlRetryId);
+				const errorMsg = String(input.error);
+				emitEvent({
+					name: "retry-reset",
+					previousAttempt: urlAttempt,
+					previousRetryId: urlRetryId,
+					timeSinceReload
+				}, { silent: shouldIgnoreMessages([errorMsg]) });
+				currentAttempt = 0;
+				retryId = generateRetryId();
+			}
+		}
+		emitEvent({
+			error: input.error,
+			isRetrying: currentAttempt < reloadDelays.length,
+			name: "chunk-error"
+		});
+		if (currentAttempt >= reloadDelays.length) {
+			const errorMsg = String(input.error);
+			emitEvent({
+				finalAttempt: currentAttempt,
+				name: "retry-exhausted",
+				retryId
+			}, { silent: shouldIgnoreMessages([errorMsg]) });
+			sendBeacon({
+				errorMessage: "Exceeded maximum reload attempts",
+				eventName: "chunk_error_max_reloads",
+				retryAttempt: currentAttempt,
+				retryId,
+				serialized: JSON.stringify({
+					error: String(input.error),
+					retryAttempt: currentAttempt,
+					retryId
+				})
+			});
+			setState({
+				attempt: currentAttempt,
+				phase: "fallback",
+				retryId
+			});
+			setFallbackMode();
+			clearRetryFromUrl();
+			showFallbackUI({ retryId });
+			return { status: "fallback" };
+		}
+		const nextAttempt = currentAttempt + 1;
+		const delay = reloadDelays[currentAttempt] ?? 1e3;
+		const errorMsg = String(input.error);
+		emitEvent({
+			attempt: nextAttempt,
+			delay,
+			name: "retry-attempt",
+			retryId
+		}, { silent: shouldIgnoreMessages([errorMsg]) });
+		getLogger()?.retrySchedulingReload(retryId, nextAttempt, delay);
+		setState({
+			attempt: nextAttempt,
+			retryId
+		});
+		showLoadingUI(nextAttempt);
+		setState({ timer: setTimeout(() => {
+			try {
+				if (useRetryId && enableRetryReset) setLastReloadTime(retryId, nextAttempt);
+				const reloadUrl = buildReloadUrl(retryId, nextAttempt, input.cacheBust, useRetryId);
+				globalThis.window.location.href = reloadUrl;
+			} catch (navError) {
+				getLogger()?.error("triggerRetry navigation failed", navError);
+				setState({
+					phase: "idle",
+					timer: null
+				});
+			}
+		}, delay) });
+		return { status: "accepted" };
+	} catch (error) {
+		getLogger()?.error("triggerRetry internal error", error);
+		setState({ phase: "idle" });
+		return { status: "internal-error" };
+	}
+};
+const markRetryHealthyBoot = () => {
+	const state = getState();
+	if (state.timer !== null) clearTimeout(state.timer);
+	clearRetryFromUrl();
+	clearLastReloadTime();
+	clearLastRetryResetInfo();
+	if (globalThis.window !== void 0) globalThis.window[retryOrchestratorKey] = createFreshState();
+	resetFallbackMode();
+};
+const getRetrySnapshot = () => {
+	const state = getState();
+	return {
+		attempt: state.attempt,
+		...state.lastSource !== void 0 && { lastSource: state.lastSource },
+		...state.lastTriggerTime !== void 0 && { lastTriggerTime: state.lastTriggerTime },
+		phase: state.phase,
+		retryId: state.retryId
+	};
+};
+/**
+* Sets orchestrator state to fallback and renders the fallback UI.
+* For use in debug/simulation contexts only — bypasses retry scheduling
+* while keeping the orchestrator snapshot consistent with fallback mode.
+*/
+const setFallbackStateForDebug = () => {
+	const state = getState();
+	if (state.timer !== null) clearTimeout(state.timer);
+	setState({
+		phase: "fallback",
+		timer: null
+	});
+	setFallbackMode();
+	showFallbackUI({ ...state.retryId !== null && { retryId: state.retryId } });
+};
+const resetRetryOrchestratorForTests = () => {
+	const state = getState();
+	if (state.timer !== null) clearTimeout(state.timer);
+	if (globalThis.window !== void 0) globalThis.window[retryOrchestratorKey] = createFreshState();
+	resetFallbackMode();
+};
+//#endregion
+export { markInitialized as A, setTranslations as C, getLogger as D, enableDefaultRetry as E, spinnerStateWindowKey as F, staticAssetRecoveryKey as I, versionCheckStateWindowKey as L, subscribe as M, debugSyncErrorEventType as N, isDefaultRetryEnabled as O, optionsWindowKey as P, getI18n as S, emitEvent as T, options_exports as _, triggerRetry as a, defaultSpinnerHtml as b, shouldIgnoreMessages as c, isInFallbackMode as d, resetFallbackMode as f, getOptions as g, getRetryStateFromUrl as h, setFallbackStateForDebug as i, setLogger as j, isInitialized as k, ForceRetryError as l, getRetryInfoForBeacon as m, markRetryHealthyBoot as n, sendBeacon as o, getRetryAttemptFromUrl as p, resetRetryOrchestratorForTests as r, shouldForceRetry as s, getRetrySnapshot as t, getLastRetryResetInfo as u, defaultErrorFallbackHtml as v, disableDefaultRetry as w, applyI18n as x, defaultLoadingFallbackHtml as y };