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

package/README.md

@@ -7,198 +7,47 @@ Core runtime for spa-guard — chunk load error handling, version checking, spin
 
 ## Install
 
-```sh
-npm install @ovineko/spa-guard
-```
-
-## Usage
-
-Call `recommendedSetup` once when your app boots. It dismisses the loading spinner, starts version checking, and returns a cleanup function.
+**pnpm** (recommended):
 
-```ts
-import { recommendedSetup } from "@ovineko/spa-guard/runtime";
-
-const cleanup = recommendedSetup();
-// optionally call cleanup() to stop background checks
+```bash
+pnpm add @ovineko/spa-guard
 ```
 
-`recommendedSetup` is idempotent. Repeated calls return the same cleanup function and do not re-run setup side effects.
-
-By default, `recommendedSetup` uses `healthyBoot: "auto"`:
-
-- if retry params exist in the URL, it waits a dynamic grace period and calls `markRetryHealthyBoot()` only when the orchestrator phase is still `idle`.
-- if no retry params exist, it does nothing.
-
-Auto grace period formula:
-
-- `max(5000, max(reloadDelays)+1000, sum(lazyRetry.retryDelays)+1000)`
-
-If you want strict control, switch to manual healthy-boot mode and call `markRetryHealthyBoot()` yourself.
-
-```ts
-import { markRetryHealthyBoot } from "@ovineko/spa-guard";
-import { recommendedSetup } from "@ovineko/spa-guard/runtime";
+**npm**:
 
-recommendedSetup();
-
-await Promise.all([import("./routes/Home"), import("./routes/Checkout")]);
-
-markRetryHealthyBoot();
+```bash
+npm install @ovineko/spa-guard
 ```
 
-Disable auto healthy boot:
+**yarn**:
 
-```ts
-recommendedSetup({ healthyBoot: "manual" });
+```bash
+yarn add @ovineko/spa-guard
 ```
 
-Disable version checking:
+**bun**:
 
-```ts
-const cleanup = recommendedSetup({ versionCheck: false });
+```bash
+bun add @ovineko/spa-guard
 ```
 
-## Retry behavior and event flow
-
-spa-guard uses a single retry orchestrator (`retryOrchestrator.ts`) as the sole owner of retry lifecycle. All reload scheduling, deduplication, and fallback transitions run through `triggerRetry()`.
-
-### Retry state machine
-
-The orchestrator maintains an explicit phase:
-
-- `idle` — no retry in progress
-- `scheduled` — a reload has been scheduled (timer running); concurrent triggers are deduplicated
-- `fallback` — retries exhausted, fallback UI is shown; further triggers are ignored
-
-### Retry progression
-
-When a recoverable error occurs (chunk load error, unhandled rejection, `vite:preloadError`, or static asset 404):
-
-1. Event listener classifies the event and calls `triggerRetry({ source, error })`.
-2. Orchestrator checks phase — if already `scheduled` or `fallback`, returns immediately without scheduling another reload.
-3. On first trigger: reads `RETRY_ATTEMPT_PARAM` from URL to restore attempt count after a reload.
-4. If attempts remain: increments attempt, calls `showLoadingUI(nextAttempt)` to render the loading UI immediately (before the timer fires), sets a timer for `reloadDelays[currentAttempt]`, encodes `retryId` and attempt count into the reload URL, then navigates. Requires `options.html.loading.content` to be configured; if absent, `showLoadingUI` returns silently and the retry still proceeds.
-5. If attempts are exhausted: transitions to `fallback`, calls `setFallbackMode()`, sends a beacon, and renders fallback UI.
-
-### URL params
-
-The orchestrator serializes state into URL params for cross-reload continuity:
-
-- `RETRY_ATTEMPT_PARAM` — current attempt count (strict non-negative integer; malformed values are ignored)
-- `RETRY_ID_PARAM` — unique ID for this retry session
-- `CACHE_BUST_PARAM` — timestamp for cache busting (set when `cacheBust: true` is passed, e.g. for static asset errors)
-
-### Loading UI during retry delay
+**deno**:
 
-When `options.html.loading.content` is configured, `showLoadingUI(attempt)` is called before the reload timer fires. It injects the loading HTML into the target element (selector from `options.html.fallback.selector`, defaulting to `body`), reveals the `data-spa-guard-section="retrying"` element, fills attempt numbers into `[data-spa-guard-content="attempt"]` elements, applies i18n via `applyI18n`/`getI18n`, and optionally hides or replaces the spinner based on `options.html.spinner`. If loading content is not configured or the target element is not found, `showLoadingUI` returns silently — the retry still proceeds normally.
-
-Default fallback/loading templates are theme-aware: they set `color-scheme: light dark` and apply neutral dark colors automatically via `@media (prefers-color-scheme: dark)`.
-
-### Unhandledrejection serialization
-
-`serializeError` handles `PromiseRejectionEvent` with strict redaction guardrails. For HTTP-like errors it extracts only safe metadata: `status`, `statusText`, `url`, `method`, `response.type`, and `X-Request-ID` from response headers when present. Response body, request/response payload, and the full headers object are **never** included in serialized output. For request wrappers (`reason.request` / `reason.config`) only `method`, `url`, and `baseURL` are extracted. Deep object traversal is bounded by `MAX_DEPTH=4`, `MAX_KEYS=20`, and `MAX_STRING_LEN=500` to prevent oversized beacons. Circular references are handled via a `WeakSet` visited tracker. The output also includes `isTrusted`, `timeStamp` from the event, and runtime context (`pageUrl`, `constructorName`).
-This HTTP-like extraction also applies to `Error` subclasses that carry a `response` field (for example `ResponseError`), not only to plain objects.
-
-### Retry reset
-
-If enough time has passed since the last reload (configurable via `minTimeBetweenResets`, default 5000 ms), the orchestrator resets the attempt counter and starts a fresh retry cycle instead of continuing to fallback. This prevents stale URL params from triggering fallback on a clean page load.
-
-### Healthy boot
-
-After a successful app boot following a retry reload, `markRetryHealthyBoot()` clears retry URL params, cancels any pending timer, and resets orchestrator state.
-
-Default behavior in `recommendedSetup`: auto healthy-boot after a grace period (`healthyBoot: "auto"`).
-Manual override: set `healthyBoot: "manual"` and call `markRetryHealthyBoot()` yourself once critical boot is confirmed.
-
-### Avoid false retry loops from app errors
-
-By default, regular `unhandledrejection` events also trigger `triggerRetry()` (`handleUnhandledRejections.retry: true`). If your app has non-chunk unhandled rejections, this can look like retry looping even though chunks are healthy. In that case, disable reload-on-unhandled-rejection:
-
-```ts
-window.__SPA_GUARD_OPTIONS__ = {
-  handleUnhandledRejections: {
-    retry: false,
-    sendBeacon: true,
-  },
-};
+```bash
+deno add npm:@ovineko/spa-guard
 ```
 
-### Static asset burst coalescing
-
-Multiple 404'd asset errors within a short window (default 500 ms) are coalesced into a single `triggerRetry({ cacheBust: true, source: "static-asset-error" })`. The orchestrator's deduplication ensures only one reload is scheduled.
-
-### Retry ownership rule
-
-Only `retryOrchestrator.ts` may schedule reloads, advance retry state, or transition to fallback. Listeners, renderers, and other modules must not schedule their own retry timers or set fallback state directly.
-
-## API
-
-### `@ovineko/spa-guard` (common)
-
-- `listen` — subscribe to spa-guard events
-- `events` — event type constants
-- `options` — runtime options helpers
-- `disableDefaultRetry` / `enableDefaultRetry` / `isDefaultRetryEnabled` — control default retry behaviour
-- `isInFallbackMode` — returns `true` when fallback UI is active (retries exhausted)
-- `resetFallbackMode` — clears the fallback flag; use in tests or programmatic recovery flows
-- `BeaconError` — error class for beacon failures
-- `ForceRetryError` — error class to force a retry
-
-**Retry orchestrator (single owner of retry lifecycle):**
-
-- `triggerRetry(input?)` — trigger a retry from any source; returns `TriggerResult`:
-  - `{ status: "accepted" }` — reload scheduled
-  - `{ status: "deduped", reason: string }` — ignored because another retry is already scheduled or an internal error occurred
-  - `{ status: "fallback" }` — already in fallback mode; no retry scheduled
-  - `{ status: "retry-disabled" }` — retry is disabled via `disableDefaultRetry()`
-- `markRetryHealthyBoot()` — call after a successful boot following a retry reload; clears URL params, cancels timers, resets orchestrator state and fallback flag
-- `getRetrySnapshot()` — returns current orchestrator state: `{ phase, attempt, retryId, lastSource, lastTriggerTime }`
-- `resetRetryOrchestratorForTests()` — resets all orchestrator state including fallback flag; use in test teardown
-
-### `@ovineko/spa-guard/runtime`
-
-- `recommendedSetup(options?)` — enable recommended runtime features; idempotent and returns cleanup function
-- `RecommendedSetupOptions` — `{ versionCheck?: boolean; healthyBoot?: "auto" | "manual" | "off" | false | { mode?: "auto"; graceMs?: number } }`
-  - `healthyBoot.graceMs` acts as a lower bound override for auto mode (`max(computedGraceMs, graceMs)`)
-- `startVersionCheck` / `stopVersionCheck` — manual version check control
-- `getState` / `subscribeToState` — runtime state access
-- `SpaGuardState` — state type
-- `showSpinner` / `dismissSpinner` / `getSpinnerHtml` — spinner helpers
-- `setTranslations` — override i18n strings
-- `ForceRetryError`
-
-### `@ovineko/spa-guard/schema`
-
-Schemas for spa-guard configuration.
-
-### `@ovineko/spa-guard/i18n`
-
-Built-in translation strings.
-
-### `@ovineko/spa-guard/runtime/debug`
-
-Debug helpers for testing error scenarios. Use `createDebugger()` to mount an in-page panel with buttons for each scenario.
+## Usage
 
-Available error scenarios:
+```ts
+import { recommendedSetup } from "@ovineko/spa-guard/runtime";
 
-- `dispatchChunkLoadError` — unhandled ChunkLoadError rejection
-- `dispatchNetworkTimeout` — unhandled network timeout after a delay
-- `dispatchSyncRuntimeError` — sync error thrown during React render
-- `dispatchAsyncRuntimeError` — uncaught error via setTimeout
-- `dispatchFinallyError` — unhandled rejection from Promise.finally
-- `dispatchForceRetryError` — ForceRetryError to exercise the force-retry path
-- `dispatchUnhandledRejection` — generic unhandled promise rejection
-- `dispatchRetryExhausted` — renders fallback UI directly (bypasses orchestrator; orchestrator phase remains `idle`)
-- `dispatchStaticAsset404` — appends a hashed `<script>` that 404s, exercising the Resource Timing API-based static asset detection path
+const cleanup = recommendedSetup();
+```
 
-## Related packages
+## Documentation
 
-- [@ovineko/spa-guard-react](../react/README.md) — `lazyWithRetry` and React error boundary
-- [@ovineko/spa-guard-react-router](../react-router/README.md) — React Router error boundary
-- [@ovineko/spa-guard-vite](../vite/README.md) — Vite plugin (injects runtime script)
-- [@ovineko/spa-guard-node](../node/README.md) — Node.js cache and builder API
-- [@ovineko/spa-guard-fastify](../fastify/README.md) — Fastify plugin
-- [@ovineko/spa-guard-eslint](../eslint/README.md) — ESLint rules
+Full documentation: [ovineko.com/docs/spa-guard/core](https://ovineko.com/docs/spa-guard/core)
 
 ## License
 

package/dist/ForceRetryError-BWLv3UVK.d.mts

@@ -0,0 +1,6 @@
+//#region src/common/errors/ForceRetryError.d.ts
+declare class ForceRetryError extends Error {
+  constructor(message?: string, options?: ErrorOptions);
+}
+//#endregion
+export { ForceRetryError as t };

package/dist/_internal.d.ts

@@ -1,20 +1,149 @@
-export { debugSyncErrorEventType } from "./common/constants";
-export { disableDefaultRetry, emitEvent, enableDefaultRetry, isDefaultRetryEnabled, subscribe, } from "./common/events/internal";
-export type { SPAGuardEvent, SPAGuardEventChunkError, UnsubscribeFn } from "./common/events/types";
-export { handleErrorWithSpaGuard } from "./common/handleErrorWithSpaGuard";
-export type { ErrorInfoLike, HandleErrorOptions } from "./common/handleErrorWithSpaGuard";
-export { defaultErrorFallbackHtml, defaultLoadingFallbackHtml } from "./common/html.generated";
-export { applyI18n, getI18n } from "./common/i18n";
-export { isChunkError } from "./common/isChunkError";
-export { listenInternal } from "./common/listen/internal";
-export { logMessage } from "./common/log";
-export { createLogger } from "./common/logger";
-export { getOptions, optionsWindowKey } from "./common/options";
-export type { Options } from "./common/options";
-export { extractVersionFromHtml } from "./common/parseVersion";
-export { retryImport } from "./common/retryImport";
-export { getRetrySnapshot, markRetryHealthyBoot, resetRetryOrchestratorForTests, triggerRetry, } from "./common/retryOrchestrator";
-export type { RetryPhase, RetrySnapshot, TriggerInput, TriggerResult, } from "./common/retryOrchestrator";
-export { serializeError } from "./common/serializeError";
-export { defaultSpinnerSvg, sanitizeCssValue, SPINNER_ID } from "./common/spinner";
-export { dispatchAsyncRuntimeError, dispatchChunkLoadError, dispatchFinallyError, dispatchForceRetryError, dispatchNetworkTimeout, dispatchSyncRuntimeError, dispatchUnhandledRejection, } from "./runtime/debug/errorDispatchers";
+import { _ as Logger, a as getRetrySnapshot, b as optionsWindowKey, c as triggerRetry, f as disableDefaultRetry, g as subscribe, h as isDefaultRetryEnabled, i as TriggerResult, l as Options, m as enableDefaultRetry, n as RetrySnapshot, o as markRetryHealthyBoot, p as emitEvent, r as TriggerInput, s as resetRetryOrchestratorForTests, t as RetryPhase, u as getOptions, v as createLogger, y as debugSyncErrorEventType } from "./retryOrchestrator-mn9XcIVu.mjs";
+import { g as UnsubscribeFn, i as SPAGuardEventChunkError, r as SPAGuardEvent } from "./types-DrN8pgyc.mjs";
+import { a as sanitizeCssValue, c as getI18n, n as defaultSpinnerSvg, s as applyI18n, t as SPINNER_ID } from "./spinner-X23gI09z.mjs";
+
+//#region src/common/handleErrorWithSpaGuard.d.ts
+/** Minimal subset of React.ErrorInfo used for beacon serialization. */
+interface ErrorInfoLike {
+  componentStack?: null | string;
+  digest?: string;
+}
+interface HandleErrorOptions {
+  autoRetryChunkErrors?: boolean;
+  errorInfo?: ErrorInfoLike;
+  eventName: string;
+  onError?: (error: unknown) => void;
+  sendBeaconOnError?: boolean;
+}
+/**
+ * Shared error handling logic with spa-guard integration.
+ *
+ * Detects chunk errors and automatically retries, or sends beacon for non-chunk errors.
+ */
+declare const handleErrorWithSpaGuard: (error: unknown, options: HandleErrorOptions) => void;
+//#endregion
+//#region src/common/html.generated.d.ts
+declare 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>";
+declare 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>";
+//#endregion
+//#region src/common/isChunkError.d.ts
+declare const isChunkError: (error: unknown) => boolean;
+//#endregion
+//#region src/common/listen/internal.d.ts
+declare const listenInternal: (serializeError: (error: unknown) => string, logger?: Logger) => void;
+//#endregion
+//#region src/common/log.d.ts
+declare const logMessage: (msg: string) => string;
+//#endregion
+//#region src/common/parseVersion.d.ts
+/**
+ * Extract the SPA Guard version string from an HTML document.
+ *
+ * Tries the new `__SPA_GUARD_VERSION__` format first, then falls back
+ * to the legacy `__SPA_GUARD_OPTIONS__` object with a `version` key.
+ *
+ * Returns `null` when neither marker is found.
+ */
+declare function extractVersionFromHtml(html: string): null | string;
+//#endregion
+//#region src/common/retryImport.d.ts
+/**
+ * Options for configuring the retry behaviour of {@link retryImport}.
+ */
+interface RetryImportOptions {
+  /**
+   * If true and all retries fail with a chunk error, triggers a page reload via the orchestrator before rethrowing.
+   * @default true (when used via lazyWithRetry)
+   */
+  callReloadOnFailure?: boolean;
+  /**
+   * Optional callback invoked before each retry attempt.
+   * Useful for logging or analytics.
+   *
+   * @param attempt - The 1-based attempt number (1 = first retry)
+   * @param delay - The delay in milliseconds before this retry attempt
+   *
+   * @example
+   * onRetry: (attempt, delay) => console.log(`Retry ${attempt} after ${delay}ms`)
+   */
+  onRetry?: (attempt: number, delay: number) => void;
+  /**
+   * AbortSignal to cancel pending retries and clear timers.
+   * When aborted, any in-progress wait is cancelled immediately (preventing memory leaks),
+   * and the retryImport promise rejects with an AbortError.
+   * Useful when the caller no longer needs the import result (e.g. component unmounted).
+   */
+  signal?: AbortSignal;
+}
+/**
+ * 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`),
+ * })
+ */
+declare const retryImport: <T>(importFn: () => Promise<T>, delays: number[], options?: RetryImportOptions) => Promise<T>;
+//#endregion
+//#region src/common/serializeError.d.ts
+declare const serializeError: (error: unknown) => string;
+//#endregion
+//#region src/runtime/debug/errorDispatchers.d.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.
+ */
+declare function dispatchAsyncRuntimeError(): void;
+/**
+ * Dispatches an unhandled chunk load error via void Promise.reject().
+ * Triggers window "unhandledrejection" with an error matching spa-guard's
+ * chunk error detection patterns.
+ */
+declare function dispatchChunkLoadError(): void;
+/**
+ * Dispatches an unhandled chunk error via Promise.finally().
+ * The throw inside .finally() with no surrounding catch produces
+ * a window "unhandledrejection" event.
+ */
+declare function dispatchFinallyError(): void;
+/**
+ * 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.
+ */
+declare function dispatchForceRetryError(): void;
+/**
+ * Dispatches an unhandled network timeout error after a delay.
+ * Uses setTimeout + void Promise.reject() to trigger window "unhandledrejection".
+ */
+declare function dispatchNetworkTimeout(delayMs?: number): void;
+/**
+ * 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.
+ */
+declare function dispatchSyncRuntimeError(): void;
+/**
+ * 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.
+ */
+declare function dispatchUnhandledRejection(): void;
+//#endregion
+export { type ErrorInfoLike, type HandleErrorOptions, type Options, type RetryPhase, type RetrySnapshot, type SPAGuardEvent, type SPAGuardEventChunkError, SPINNER_ID, type TriggerInput, type TriggerResult, type UnsubscribeFn, 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 };