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

package/dist/_internal.js

@@ -1,173 +1,116 @@
-import {
-  SPINNER_ID,
-  defaultSpinnerSvg,
-  extractVersionFromHtml,
-  sanitizeCssValue
-} from "./chunk-3UJ67DPX.js";
-import {
-  createLogger,
-  isChunkError,
-  listenInternal,
-  serializeError
-} from "./chunk-XIFXSNSD.js";
-import {
-  dispatchAsyncRuntimeError,
-  dispatchChunkLoadError,
-  dispatchFinallyError,
-  dispatchForceRetryError,
-  dispatchNetworkTimeout,
-  dispatchSyncRuntimeError,
-  dispatchUnhandledRejection
-} from "./chunk-PERG4557.js";
-import {
-  applyI18n,
-  debugSyncErrorEventType,
-  defaultErrorFallbackHtml,
-  defaultLoadingFallbackHtml,
-  disableDefaultRetry,
-  emitEvent,
-  enableDefaultRetry,
-  getI18n,
-  getOptions,
-  getRetryInfoForBeacon,
-  getRetrySnapshot,
-  isDefaultRetryEnabled,
-  markRetryHealthyBoot,
-  optionsWindowKey,
-  resetRetryOrchestratorForTests,
-  sendBeacon,
-  shouldForceRetry,
-  shouldIgnoreMessages,
-  subscribe,
-  triggerRetry
-} from "./chunk-GE63YJOT.js";
-import "./chunk-MLKGABMK.js";
-
-// src/common/handleErrorWithSpaGuard.ts
-var handleErrorWithSpaGuard = (error, options) => {
-  const {
-    autoRetryChunkErrors = true,
-    errorInfo,
-    eventName,
-    onError,
-    sendBeaconOnError = true
-  } = options;
-  try {
-    onError?.(error);
-  } catch {
-  }
-  const errorMessage = error instanceof Error ? error.message : String(error);
-  if (shouldIgnoreMessages([errorMessage])) {
-    return;
-  }
-  const isChunk = isChunkError(error);
-  const isForceRetry = shouldForceRetry([errorMessage]);
-  if ((isChunk || isForceRetry) && autoRetryChunkErrors) {
-    triggerRetry({ error, source: "error-boundary" });
-  } else if (sendBeaconOnError) {
-    sendBeacon({
-      errorMessage: error instanceof Error ? error.message : String(error),
-      eventName,
-      serialized: serializeError(errorInfo ? { error, errorInfo } : error),
-      ...getRetryInfoForBeacon()
-    });
-  }
+import { E as enableDefaultRetry, M as subscribe, N as debugSyncErrorEventType, O as isDefaultRetryEnabled, P as optionsWindowKey, S as getI18n, T as emitEvent, a as triggerRetry, c as shouldIgnoreMessages, g as getOptions, m as getRetryInfoForBeacon, n as markRetryHealthyBoot, o as sendBeacon, r as resetRetryOrchestratorForTests, s as shouldForceRetry, t as getRetrySnapshot, v as defaultErrorFallbackHtml, w as disableDefaultRetry, x as applyI18n, y as defaultLoadingFallbackHtml } from "./retryOrchestrator-DNGIHV2M.mjs";
+import { i as isChunkError, n as listenInternal, r as serializeError, t as createLogger } from "./logger-Cp1Eyk6S.mjs";
+import { a as sanitizeCssValue, n as defaultSpinnerSvg, s as extractVersionFromHtml, t as SPINNER_ID } from "./spinner-BbZVKZ-6.mjs";
+import { a as dispatchNetworkTimeout, c as dispatchSyncRuntimeError, i as dispatchForceRetryError, l as dispatchUnhandledRejection, n as dispatchChunkLoadError, r as dispatchFinallyError, t as dispatchAsyncRuntimeError } from "./errorDispatchers-Cl_pa0DT.mjs";
+//#region src/common/handleErrorWithSpaGuard.ts
+/**
+* Shared error handling logic with spa-guard integration.
+*
+* Detects chunk errors and automatically retries, or sends beacon for non-chunk errors.
+*/
+const handleErrorWithSpaGuard = (error, options) => {
+	const { autoRetryChunkErrors = true, errorInfo, eventName, onError, sendBeaconOnError = true } = options;
+	try {
+		onError?.(error);
+	} catch {}
+	const errorMessage = error instanceof Error ? error.message : String(error);
+	if (shouldIgnoreMessages([errorMessage])) return;
+	const isChunk = isChunkError(error);
+	const isForceRetry = shouldForceRetry([errorMessage]);
+	if ((isChunk || isForceRetry) && autoRetryChunkErrors) triggerRetry({
+		error,
+		source: "error-boundary"
+	});
+	else if (sendBeaconOnError) sendBeacon({
+		errorMessage: error instanceof Error ? error.message : String(error),
+		eventName,
+		serialized: serializeError(errorInfo ? {
+			error,
+			errorInfo
+		} : error),
+		...getRetryInfoForBeacon()
+	});
 };
-
-// src/common/log.ts
-var logMessage = (msg) => `[spa-guard] ${msg}`;
-
-// src/common/retryImport.ts
-var wait = (ms, signal) => new Promise((resolve, reject) => {
-  if (signal?.aborted) {
-    reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
-    return;
-  }
-  const onAbort = () => {
-    clearTimeout(timeoutId);
-    reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
-  };
-  const timeoutId = setTimeout(() => {
-    signal?.removeEventListener("abort", onAbort);
-    resolve();
-  }, ms);
-  signal?.addEventListener("abort", onAbort, { once: true });
+//#endregion
+//#region src/common/log.ts
+const logMessage = (msg) => `[spa-guard] ${msg}`;
+//#endregion
+//#region src/common/retryImport.ts
+const wait = (ms, signal) => new Promise((resolve, reject) => {
+	if (signal?.aborted) {
+		reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+		return;
+	}
+	const onAbort = () => {
+		clearTimeout(timeoutId);
+		reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+	};
+	const timeoutId = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	signal?.addEventListener("abort", onAbort, { once: true });
 });
-var retryImport = async (importFn, delays, options) => {
-  const { callReloadOnFailure, onRetry, signal } = options ?? {};
-  let lastError = new Error("Import failed after all retry attempts");
-  const totalAttempts = delays.length + 1;
-  const startTime = Date.now();
-  if (delays.length > 0) {
-    emitEvent({ name: "lazy-retry-start", totalAttempts });
-  }
-  for (let attempt = 0; attempt < totalAttempts; attempt++) {
-    if (signal?.aborted) {
-      throw signal.reason ?? new DOMException("Aborted", "AbortError");
-    }
-    try {
-      const result = await importFn();
-      if (attempt > 0) {
-        emitEvent({ attempt, name: "lazy-retry-success", totalTime: Date.now() - startTime });
-      }
-      return result;
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      const currentDelay = delays[attempt];
-      if (currentDelay === void 0) {
-        break;
-      }
-      onRetry?.(attempt + 1, currentDelay);
-      emitEvent({
-        attempt: attempt + 1,
-        delay: currentDelay,
-        error: lastError,
-        name: "lazy-retry-attempt",
-        totalAttempts
-      });
-      await wait(currentDelay, signal);
-    }
-  }
-  const willReload = callReloadOnFailure === true && isChunkError(lastError) && isDefaultRetryEnabled();
-  emitEvent({ error: lastError, name: "lazy-retry-exhausted", totalAttempts, willReload });
-  if (willReload) {
-    triggerRetry({ error: lastError, source: "lazy-import-failure" });
-  }
-  throw lastError;
-};
-export {
-  SPINNER_ID,
-  applyI18n,
-  createLogger,
-  debugSyncErrorEventType,
-  defaultErrorFallbackHtml,
-  defaultLoadingFallbackHtml,
-  defaultSpinnerSvg,
-  disableDefaultRetry,
-  dispatchAsyncRuntimeError,
-  dispatchChunkLoadError,
-  dispatchFinallyError,
-  dispatchForceRetryError,
-  dispatchNetworkTimeout,
-  dispatchSyncRuntimeError,
-  dispatchUnhandledRejection,
-  emitEvent,
-  enableDefaultRetry,
-  extractVersionFromHtml,
-  getI18n,
-  getOptions,
-  getRetrySnapshot,
-  handleErrorWithSpaGuard,
-  isChunkError,
-  isDefaultRetryEnabled,
-  listenInternal,
-  logMessage,
-  markRetryHealthyBoot,
-  optionsWindowKey,
-  resetRetryOrchestratorForTests,
-  retryImport,
-  sanitizeCssValue,
-  serializeError,
-  subscribe,
-  triggerRetry
+/**
+* Retries an import function with configurable delays between attempts.
+*
+* @param importFn - The function that performs the dynamic import
+* @param delays - Array of delays in milliseconds. Each entry represents one retry attempt.
+* @param options - Optional configuration for retry behaviour
+* @returns Promise that resolves with the import result or rejects after all attempts are exhausted
+*
+* @example
+* retryImport(() => import('./MyModule'), [1000, 2000])
+* retryImport(() => import('./MyModule'), [500, 1500], {
+*   onRetry: (attempt, delayMs) => console.log(`Retry ${attempt} after ${delayMs}ms`),
+* })
+*/
+const retryImport = async (importFn, delays, options) => {
+	const { callReloadOnFailure, onRetry, signal } = options ?? {};
+	let lastError = /* @__PURE__ */ new Error("Import failed after all retry attempts");
+	const totalAttempts = delays.length + 1;
+	const startTime = Date.now();
+	if (delays.length > 0) emitEvent({
+		name: "lazy-retry-start",
+		totalAttempts
+	});
+	for (let attempt = 0; attempt < totalAttempts; attempt++) {
+		if (signal?.aborted) throw signal.reason ?? new DOMException("Aborted", "AbortError");
+		try {
+			const result = await importFn();
+			if (attempt > 0) emitEvent({
+				attempt,
+				name: "lazy-retry-success",
+				totalTime: Date.now() - startTime
+			});
+			return result;
+		} catch (error) {
+			lastError = error instanceof Error ? error : new Error(String(error));
+			const currentDelay = delays[attempt];
+			if (currentDelay === void 0) break;
+			onRetry?.(attempt + 1, currentDelay);
+			emitEvent({
+				attempt: attempt + 1,
+				delay: currentDelay,
+				error: lastError,
+				name: "lazy-retry-attempt",
+				totalAttempts
+			});
+			await wait(currentDelay, signal);
+		}
+	}
+	const willReload = callReloadOnFailure === true && isChunkError(lastError) && isDefaultRetryEnabled();
+	emitEvent({
+		error: lastError,
+		name: "lazy-retry-exhausted",
+		totalAttempts,
+		willReload
+	});
+	if (willReload) triggerRetry({
+		error: lastError,
+		source: "lazy-import-failure"
+	});
+	throw lastError;
 };
+//#endregion
+export { SPINNER_ID, applyI18n, createLogger, debugSyncErrorEventType, defaultErrorFallbackHtml, defaultLoadingFallbackHtml, defaultSpinnerSvg, disableDefaultRetry, dispatchAsyncRuntimeError, dispatchChunkLoadError, dispatchFinallyError, dispatchForceRetryError, dispatchNetworkTimeout, dispatchSyncRuntimeError, dispatchUnhandledRejection, emitEvent, enableDefaultRetry, extractVersionFromHtml, getI18n, getOptions, getRetrySnapshot, handleErrorWithSpaGuard, isChunkError, isDefaultRetryEnabled, listenInternal, logMessage, markRetryHealthyBoot, optionsWindowKey, resetRetryOrchestratorForTests, retryImport, sanitizeCssValue, serializeError, subscribe, triggerRetry };

package/dist/chunk-CfYAbeIz.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/common/index.d.ts

@@ -1,9 +1,29 @@
-export { BeaconError } from "./errors/BeaconError";
-export { ForceRetryError } from "./errors/ForceRetryError";
-export * as events from "./events";
-export { disableDefaultRetry, enableDefaultRetry, isDefaultRetryEnabled } from "./events/internal";
-export { isInFallbackMode, resetFallbackMode } from "./fallbackState";
-export { listen } from "./listen";
-export * as options from "./options";
-export { getRetrySnapshot, markRetryHealthyBoot, triggerRetry } from "./retryOrchestrator";
-export type { RetryPhase, RetrySnapshot, TriggerInput, TriggerResult } from "./retryOrchestrator";
+import { a as getRetrySnapshot, c as triggerRetry, d as options_d_exports, f as disableDefaultRetry, g as subscribe, h as isDefaultRetryEnabled, i as TriggerResult, m as enableDefaultRetry, n as RetrySnapshot, o as markRetryHealthyBoot, p as emitEvent, r as TriggerInput, t as RetryPhase } from "../retryOrchestrator-mn9XcIVu.mjs";
+import { a as SPAGuardEventFallbackUINotRendered, c as SPAGuardEventLazyRetryExhausted, d as SPAGuardEventRetryAttempt, f as SPAGuardEventRetryExhausted, g as UnsubscribeFn, h as SubscribeFn, i as SPAGuardEventChunkError, l as SPAGuardEventLazyRetryStart, m as SPAGuardEventStaticAssetLoadFailed, n as InternalConfig, o as SPAGuardEventFallbackUIShown, p as SPAGuardEventRetryReset, r as SPAGuardEvent, s as SPAGuardEventLazyRetryAttempt, t as EmitOptions, u as SPAGuardEventLazyRetrySuccess } from "../types-DrN8pgyc.mjs";
+import { t as BeaconSchema } from "../index-rPxPv6iu.mjs";
+import { t as ForceRetryError } from "../ForceRetryError-BWLv3UVK.mjs";
+
+//#region src/common/errors/BeaconError.d.ts
+declare class BeaconError extends Error {
+  readonly appName: string | undefined;
+  readonly errorMessage: string | undefined;
+  readonly eventMessage: string | undefined;
+  readonly eventName: string | undefined;
+  readonly retryAttempt: number | undefined;
+  readonly retryId: string | undefined;
+  readonly serialized: string | undefined;
+  constructor(beacon: BeaconSchema);
+  toJSON(): Record<string, unknown>;
+}
+declare namespace index_d_exports {
+  export { EmitOptions, InternalConfig, SPAGuardEvent, SPAGuardEventChunkError, SPAGuardEventFallbackUINotRendered, SPAGuardEventFallbackUIShown, SPAGuardEventLazyRetryAttempt, SPAGuardEventLazyRetryExhausted, SPAGuardEventLazyRetryStart, SPAGuardEventLazyRetrySuccess, SPAGuardEventRetryAttempt, SPAGuardEventRetryExhausted, SPAGuardEventRetryReset, SPAGuardEventStaticAssetLoadFailed, SubscribeFn, UnsubscribeFn, emitEvent, subscribe };
+}
+//#endregion
+//#region src/common/fallbackState.d.ts
+declare const isInFallbackMode: () => boolean;
+declare const resetFallbackMode: () => void;
+//#endregion
+//#region src/common/listen/index.d.ts
+declare const listen: () => void;
+//#endregion
+export { BeaconError, ForceRetryError, type RetryPhase, type RetrySnapshot, type TriggerInput, type TriggerResult, disableDefaultRetry, enableDefaultRetry, index_d_exports as events, getRetrySnapshot, isDefaultRetryEnabled, isInFallbackMode, listen, markRetryHealthyBoot, options_d_exports as options, resetFallbackMode, triggerRetry };

package/dist/common/index.js

@@ -1,87 +1,51 @@
-import {
-  createLogger,
-  listenInternal,
-  serializeError
-} from "../chunk-XIFXSNSD.js";
-import {
-  ForceRetryError,
-  disableDefaultRetry,
-  emitEvent,
-  enableDefaultRetry,
-  getRetrySnapshot,
-  isDefaultRetryEnabled,
-  isInFallbackMode,
-  markRetryHealthyBoot,
-  options_exports,
-  resetFallbackMode,
-  subscribe,
-  triggerRetry
-} from "../chunk-GE63YJOT.js";
-import {
-  __export
-} from "../chunk-MLKGABMK.js";
-
-// src/common/errors/BeaconError.ts
+import { t as __exportAll } from "../chunk-CfYAbeIz.mjs";
+import { E as enableDefaultRetry, M as subscribe, O as isDefaultRetryEnabled, T as emitEvent, _ as options_exports, a as triggerRetry, d as isInFallbackMode, f as resetFallbackMode, l as ForceRetryError, n as markRetryHealthyBoot, t as getRetrySnapshot, w as disableDefaultRetry } from "../retryOrchestrator-DNGIHV2M.mjs";
+import { n as listenInternal, r as serializeError, t as createLogger } from "../logger-Cp1Eyk6S.mjs";
+//#region src/common/errors/BeaconError.ts
 var BeaconError = class extends Error {
-  appName;
-  errorMessage;
-  eventMessage;
-  eventName;
-  retryAttempt;
-  retryId;
-  serialized;
-  constructor(beacon) {
-    super(beacon.errorMessage ?? beacon.eventMessage ?? "Unknown beacon error");
-    this.name = "BeaconError";
-    this.appName = beacon.appName;
-    this.errorMessage = beacon.errorMessage;
-    this.eventMessage = beacon.eventMessage;
-    this.eventName = beacon.eventName;
-    this.retryAttempt = beacon.retryAttempt;
-    this.retryId = beacon.retryId;
-    this.serialized = beacon.serialized;
-  }
-  toJSON() {
-    return {
-      appName: this.appName,
-      errorMessage: this.errorMessage,
-      eventMessage: this.eventMessage,
-      eventName: this.eventName,
-      message: this.message,
-      name: this.name,
-      retryAttempt: this.retryAttempt,
-      retryId: this.retryId,
-      serialized: this.serialized
-    };
-  }
+	appName;
+	errorMessage;
+	eventMessage;
+	eventName;
+	retryAttempt;
+	retryId;
+	serialized;
+	constructor(beacon) {
+		super(beacon.errorMessage ?? beacon.eventMessage ?? "Unknown beacon error");
+		this.name = "BeaconError";
+		this.appName = beacon.appName;
+		this.errorMessage = beacon.errorMessage;
+		this.eventMessage = beacon.eventMessage;
+		this.eventName = beacon.eventName;
+		this.retryAttempt = beacon.retryAttempt;
+		this.retryId = beacon.retryId;
+		this.serialized = beacon.serialized;
+	}
+	toJSON() {
+		return {
+			appName: this.appName,
+			errorMessage: this.errorMessage,
+			eventMessage: this.eventMessage,
+			eventName: this.eventName,
+			message: this.message,
+			name: this.name,
+			retryAttempt: this.retryAttempt,
+			retryId: this.retryId,
+			serialized: this.serialized
+		};
+	}
 };
-
-// src/common/events/index.ts
-var events_exports = {};
-__export(events_exports, {
-  emitEvent: () => emitEvent,
-  subscribe: () => subscribe
+//#endregion
+//#region src/common/events/index.ts
+var events_exports = /* @__PURE__ */ __exportAll({
+	emitEvent: () => emitEvent,
+	subscribe: () => subscribe
 });
-
-// src/common/listen/index.ts
-var listen = () => {
-  if (!globalThis.window) {
-    return;
-  }
-  listenInternal(serializeError, createLogger());
-};
-export {
-  BeaconError,
-  ForceRetryError,
-  disableDefaultRetry,
-  enableDefaultRetry,
-  events_exports as events,
-  getRetrySnapshot,
-  isDefaultRetryEnabled,
-  isInFallbackMode,
-  listen,
-  markRetryHealthyBoot,
-  options_exports as options,
-  resetFallbackMode,
-  triggerRetry
+//#endregion
+//#region src/common/listen/index.ts
+const listen = () => {
+	if (!globalThis.window) return;
+	listenInternal(serializeError, createLogger());
 };
+//#endregion
+export { BeaconError, ForceRetryError, disableDefaultRetry, enableDefaultRetry, events_exports as events, getRetrySnapshot, isDefaultRetryEnabled, isInFallbackMode, listen, markRetryHealthyBoot, options_exports as options, resetFallbackMode, triggerRetry };

package/dist/errorDispatchers-Cl_pa0DT.mjs

@@ -0,0 +1,105 @@
+import { N as debugSyncErrorEventType, T as emitEvent, g as getOptions, i as setFallbackStateForDebug, l as ForceRetryError } from "./retryOrchestrator-DNGIHV2M.mjs";
+//#region src/runtime/debug/errorDispatchers.ts
+/**
+* Error dispatchers for the debug panel.
+*
+* Unlike the old errorSimulators (which returned promises that callers could catch),
+* these functions return void. Errors are "fire and forget" — they escape to
+* window event listeners (window.error, window.unhandledrejection) where
+* spa-guard's listenInternal() picks them up.
+*/
+/**
+* Dispatches an async runtime error via setTimeout.
+* Triggers the window "error" event because the throw happens outside
+* any call stack that could catch it.
+*/
+function dispatchAsyncRuntimeError() {
+	setTimeout(() => {
+		throw new Error("Simulated runtime error from spa-guard debug panel");
+	}, 0);
+}
+/**
+* Dispatches an unhandled chunk load error via void Promise.reject().
+* Triggers window "unhandledrejection" with an error matching spa-guard's
+* chunk error detection patterns.
+*/
+function dispatchChunkLoadError() {
+	const error = /* @__PURE__ */ new Error("Failed to fetch dynamically imported module: /nonexistent-chunk-" + Date.now() + ".js");
+	error.name = "ChunkLoadError";
+	Promise.reject(error);
+}
+/**
+* Dispatches an unhandled chunk error via Promise.finally().
+* The throw inside .finally() with no surrounding catch produces
+* a window "unhandledrejection" event.
+*/
+function dispatchFinallyError() {
+	Promise.resolve().finally(() => {
+		throw new Error("Failed to fetch dynamically imported module: /finally-error-chunk.js");
+	});
+}
+/**
+* Dispatches a ForceRetryError via void Promise.reject().
+* Triggers window "unhandledrejection" with a ForceRetryError whose message
+* contains the FORCE_RETRY_MAGIC prefix, exercising the forceRetry path.
+*/
+function dispatchForceRetryError() {
+	Promise.reject(new ForceRetryError("Simulated force-retry from spa-guard debug panel"));
+}
+/**
+* Dispatches an unhandled network timeout error after a delay.
+* Uses setTimeout + void Promise.reject() to trigger window "unhandledrejection".
+*/
+function dispatchNetworkTimeout(delayMs = 3e3) {
+	setTimeout(() => {
+		Promise.reject(/* @__PURE__ */ new TypeError("NetworkError: request timed out"));
+	}, delayMs);
+}
+/**
+* Simulates the retry-exhausted state by emitting the "retry-exhausted" event
+* with finalAttempt equal to the configured reloadDelays length, then renders
+* the fallback UI into the DOM.
+*/
+function dispatchRetryExhausted() {
+	emitEvent({
+		finalAttempt: (getOptions().reloadDelays ?? []).length,
+		name: "retry-exhausted",
+		retryId: ""
+	});
+	setFallbackStateForDebug();
+}
+/**
+* Simulates a static asset 404 by appending a <script> element with a
+* nonexistent hashed URL to document.head. The browser fires an "error"
+* event on the element, which spa-guard's listenInternal() detects via
+* the Resource Timing API-based isLikely404 check.
+*/
+function dispatchStaticAsset404() {
+	const hash = crypto.randomUUID().slice(0, 8);
+	const script = document.createElement("script");
+	script.src = `/assets/index-${hash}.js`;
+	script.addEventListener("error", () => {
+		script.remove();
+	});
+	document.head.append(script);
+}
+/**
+* Dispatches a sync runtime error via CustomEvent.
+* DebugSyncErrorTrigger (a React component) listens for this event,
+* stores the error in state, and throws it during render so that
+* React Error Boundary can catch it.
+*/
+function dispatchSyncRuntimeError() {
+	const error = /* @__PURE__ */ new Error("Simulated sync runtime error from spa-guard debug panel");
+	globalThis.dispatchEvent(new CustomEvent(debugSyncErrorEventType, { detail: { error } }));
+}
+/**
+* Dispatches a plain unhandled promise rejection via void Promise.reject().
+* This is NOT a chunk error and NOT a ForceRetry — it exercises the
+* handleUnhandledRejections config path for generic rejections.
+*/
+function dispatchUnhandledRejection() {
+	Promise.reject(/* @__PURE__ */ new Error("Simulated unhandled promise rejection from spa-guard debug panel"));
+}
+//#endregion
+export { dispatchNetworkTimeout as a, dispatchSyncRuntimeError as c, dispatchForceRetryError as i, dispatchUnhandledRejection as l, dispatchChunkLoadError as n, dispatchRetryExhausted as o, dispatchFinallyError as r, dispatchStaticAsset404 as s, dispatchAsyncRuntimeError as t };

package/dist/i18n/index.d.ts

@@ -1,21 +1,2 @@
-export interface SpaGuardTranslations {
-    heading: string;
-    loading: string;
-    message: string;
-    reload: string;
-    retrying: string;
-    rtl?: boolean;
-    tryAgain: string;
-}
-/**
- * Match a language code or Accept-Language header against available translations.
- *
- * - If `input` is undefined, returns `"en"`.
- * - If `input` contains `,` or `;q=`, it's parsed as an Accept-Language header
- *   with quality values sorted descending.
- * - Otherwise it's treated as a direct language code.
- *
- * Resolution: exact match → prefix match → `"en"` (or first available if `"en"` not in list).
- */
-export declare function matchLang(input: string | undefined, available?: string[]): string;
-export { translations } from "./translations";
+import { n as matchLang, r as translations, t as SpaGuardTranslations } from "../index-DL8CfPXg.mjs";
+export { SpaGuardTranslations, matchLang, translations };