@owlmeans/client 0.1.18-rc.40 → 0.1.18-rc.41

package/README.md

@@ -14,7 +14,7 @@ imports everything from here. Server code never uses this package; its equivalen
 ## Installation
 
 ```bash
-bun add @owlmeans/client@^0.1.18-rc.40
+bun add @owlmeans/client@^0.1.18-rc.41
 ```
 
 `react` and `@remix-run/router` are peer dependencies.
@@ -273,7 +273,7 @@ This package ships embedded agent skills under `agent-meta/`. After installing y
 your project's skill store (`.agents/skills/`):
 
 ```sh
-npx @owlmeans/agent-skills@^0.1.18-rc.38
+npx @owlmeans/agent-skills@^0.1.18-rc.39
 ```
 
 The embedded files are version-matched to this package release. Do not edit them

package/agent-meta/manifest.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 2,
   "package": "@owlmeans/client",
-  "version": "0.1.18-rc.40",
-  "generatedAt": "2026-09-23T19:57:40.682Z",
+  "version": "0.1.18-rc.41",
+  "generatedAt": "2026-09-24T14:00:35.038Z",
   "canonicalRepo": "https://github.com/owlmeans/common",
   "entries": [
     {

package/agent-meta/skills/client/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: client
-description: How to use @owlmeans/client — the platform-agnostic React client framework (web and native) — makeClientContext, App/Router, useNavigate/Navigator, useEntrypoint/RoutedComponent, useStoreModel/useStoreList, useValue, the modal and debug services. Auto-invoked when importing client framework primitives, navigating between screens, or reading client state from React.
+description: How to use @owlmeans/client — the platform-agnostic React client framework (web and native) — makeClientContext, App/Router, useNavigate/Navigator, useEntrypoint/RoutedComponent, useStoreModel/useStoreList, useValue, lazyComponent/lazyHandler code-splitting and chunk-failure recovery (retryImport, isChunkLoadError, recoverFromChunkError), the modal and debug services. Auto-invoked when importing client framework primitives, navigating between screens, or reading client state from React.
 user-invocable: false
 ---
 <!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
@@ -8,7 +8,7 @@ user-invocable: false
 # @owlmeans/client
 
 **Layer:** Client
-**Install:** `"@owlmeans/client": "^0.1.18-rc.40"` in `dependencies`
+**Install:** `"@owlmeans/client": "^0.1.18-rc.41"` in `dependencies`
 
 The React substrate `@owlmeans/web-client` (browser) and the native equivalent are built on. A
 cross-platform package imports from here; an application normally imports from the platform
@@ -36,6 +36,9 @@ package, which re-exports what it needs — **except the hooks below, which are
 | `useEntrypoint<T>()` | The `EntrypointContextParams` of the screen currently rendering — `{ alias, path, params, context }` |
 | `RoutedComponent<Extra>` | Type of a component bound to a frontend protocol |
 | `handler(Component, preprender?)` | Wrap a React component as an entrypoint handler |
+| `lazyComponent(load, exportName, opts?)` / `lazyHandler(load, exportName, opts?)` | A code-split component with a static `.preload()`; and `handler(lazyComponent(...))` with `.preload` carried through. Types `LazyComponent`, `LazyHandler`, `LazyComponentOptions`, `LazyErrorRenderer` — see Code-splitting |
+| `retryImport(load, opts?)` / `isChunkLoadError(error)` | Run a dynamic `import()` again while it fails to FETCH; tell a fetch failure from a module that loaded and broke. `RetryImportOptions` — see Chunk failures |
+| `reloadOnce(key, windowMs)` / `recoverFromChunkError()` | The guarded page reload, and the one every chunk-failure path in a tab shares — see Chunk failures |
 | `useStoreModel` / `useStoreList` | React hooks over a `@owlmeans/state` resource — one record by id, or a live query |
 | `useValue(loader, deps?, forceDefault?)` / `UseValueParams<T>` | Render an async result. The second argument is the **dependency list**, not a default — see Async values |
 | `useToggle(opened?)` / `Toggleable` | An open/close/toggle handle, which is what a modal surface binds to |
@@ -43,7 +46,7 @@ package, which re-exports what it needs — **except the hooks below, which are
 | `ModalBodyProps` / `useSetupModalNavigator()` | `{ modal?: ModalService }` — the props a modal body is rendered with; and the hook that lets a body navigate |
 | `appendDebugService` / `createDebugService` / `appendStateDebug(ctx, alias)` / `DebugService` | The debug menu — `context.debug()` |
 | `ClientError`, `ComponentError`, `ComponentPropError`, `ComponentPropUndefined` | The client error family, registered with `ResilientError` |
-| `DEF_MODAL_ALIAS` (`modal`), `DEF_DEBUG_ALIAS` (`debug`), `DEBUGGER_FLAG` / `DEBUG_CONFIG_KEY` (`debugger`) | Constants |
+| `DEF_MODAL_ALIAS` (`modal`), `DEF_DEBUG_ALIAS` (`debug`), `DEBUGGER_FLAG` / `DEBUG_CONFIG_KEY` (`debugger`), `DEF_IMPORT_RETRY_ATTEMPTS` (2), `DEF_IMPORT_RETRY_DELAYS_MS` (500, 1500), `CHUNK_RELOAD_KEY` (`owlmeans:chunk-reload`), `CHUNK_RELOAD_WINDOW_MS` (60 s) | Constants |
 
 ## Subpath Exports
 
@@ -94,6 +97,91 @@ A screen's guards are its own plus every ancestor's, taken from `getGuards()`. A
 open screen; when the list is non-empty and no guard matches, the renderer throws
 `AuthorizationError('frontend-guard')`.
 
+## Code-splitting a screen or component
+
+`lazyComponent(load, exportName, opts?)` turns a dynamic `import()` into a component whose chunk
+loads on first render, with the `Suspense` boundary INSIDE it — the fallback replaces only this
+component and the layout around it stays mounted. `lazyHandler` is `handler(lazyComponent(...))`
+with `.preload` carried through, so it binds exactly like `handler(Component)`. Both are
+re-exported by `@owlmeans/web-client` and `@owlmeans/web-panel` next to `handler`; the
+chunk-failure tools below by `@owlmeans/web-client`.
+
+```tsx
+import { lazyComponent, lazyHandler } from '@owlmeans/client'
+
+// Module scope — never inside a render, a hook or an entrypoint handler factory.
+export const reportsScreen = lazyHandler(
+  () => import('./screens/reports.js'), 'ReportsScreen', { fallback: <Spinner /> }
+)
+const Chart = lazyComponent(() => import('./chart.js'), 'Chart', {
+  fallback: props => <Skeleton height={props.height} />,
+  error: (props, error, retry) => <ChartUnavailable onRetry={retry} />,
+})
+
+// Prefetch on intent: the screen then renders without its fallback.
+<a onMouseEnter={() => void reportsScreen.preload()} onFocus={() => void reportsScreen.preload()}>
+```
+
+- **Module scope only.** The route renderer (`utils/route.tsx`) wraps the resolved screen in a
+  fresh `memo(...)` on every render, so the route subtree remounts on each navigation. A lazy
+  object made at module scope is already resolved by then and renders synchronously; one created
+  during a render or inside a handler factory is a new `React.lazy` each time and re-suspends — the
+  fallback flashes on every visit.
+- **`preload()`** starts or joins the load and resolves to the component. Once loaded, every later
+  render resolves in the same tick — no re-suspend.
+- **`fallback`** is a node or `fallback(props)`. **`error`** is a node or a `LazyErrorRenderer`
+  `(props, error, retry) => ReactNode`; `retry()` resets the piece's boundary and renders the
+  recreated lazy, which loads the chunk again.
+- **`retry`** — the load runs through `retryImport` by default; pass `RetryImportOptions` to tune
+  it or `false` to load once.
+- **An `exportName` the module does not export** rejects with a `SyntaxError` — never retried.
+
+### Chunk failures
+
+A lazy piece ALWAYS carries its own error boundary, so a failed chunk never unmounts what is around
+it:
+
+| The piece fails with | `error` given | `error` omitted |
+|---|---|---|
+| a chunk-load failure (`isChunkLoadError`), after `retryImport` gave up | with `reload` (default for `lazyHandler`): the guarded reload starts, `fallback` stays, and `error` renders once the guard refuses; without it: `error` renders in place | `recoverFromChunkError()` starts the guarded reload; `fallback` stays in place |
+| anything else (a module that loaded and broke, its own render) | `error` renders in place | propagates to the nearest boundary above, as if the piece had none |
+
+Give every piece a deliberate `error`: a leaf that has a plain rendering of the same content (a
+formatter, a highlighter) degrades to it; anything else shows a notice with a retry. A whole screen
+(`lazyHandler`) reloads once before its notice (`reload: true` by default) — it has nothing to
+degrade to.
+
+- **Retry scope.** `retryImport` covers a TRANSIENT fetch failure — a blip, an edge answering 404
+  or 5xx for a moment. Chromium keeps a failed module fetch for the document's lifetime and rejects
+  every later `import()` of that URL at once, so a retry imports the URL the error names with a
+  fresh `t` parameter (`chunkUrlOf` + `cacheBustedUrl`, `bustCache` on by default; same-origin
+  http(s) URLs only): a new URL, fetched again. That recovers a built chunk. It cannot recover a
+  DEV-served module: React Fast Refresh makes every module import itself by its own URL, so the
+  busted copy depends on the remembered failure — only a new document loads it, which is what
+  `reload` and the guarded reload are for. Safari names no URL; its retries repeat `load`.
+- **A failed load stays failed for the instance that saw it** until its `retry()`: React re-renders
+  that instance while recovering from the error, and a fresh load there would suspend again
+  forever. A NEW mount — a navigation back, another place in the tree — takes the recreated lazy and
+  loads again; so does `preload()`.
+- **`isChunkLoadError(error)`** is true for a browser's failed dynamic import (Chromium "Failed to
+  fetch dynamically imported module", Safari "Importing a module script failed", Firefox "error
+  loading dynamically imported module"), Vite's "Unable to preload CSS", webpack's `ChunkLoadError`,
+  a `vite:preloadError` event, and an element's `error` event. It is false for a `SyntaxError`
+  about a missing export and for a throw while the module evaluated — loading those again changes
+  nothing.
+- **`retryImport(load, opts?)`** runs `load` again while `shouldRetry(error)` (default
+  `isChunkLoadError`) holds, `attempts` (2) more times at most, pausing `delaysMs[i]` before retry
+  `i` (500 ms, 1500 ms; the last entry repeats), and rethrows the last failure.
+- **`reloadOnce(key, windowMs)`** reloads the page at most once per `windowMs` per tab, keeping the
+  time in `sessionStorage` under `key`; never while offline and never without storage (with no
+  guard kept, a failure that survives the reload would reload forever); a platform with no page to
+  reload does nothing. It answers whether a reload started.
+- **`recoverFromChunkError()`** is `reloadOnce(CHUNK_RELOAD_KEY, CHUNK_RELOAD_WINDOW_MS)` — the ONE
+  guard a tab shares. An application that also reloads on `vite:preloadError` calls it rather than
+  keeping a guard of its own, so one failure never reloads twice.
+
+Source of truth: `src/lazy.tsx` and `src/lazy-retry.ts` in this package.
+
 ## Client state
 
 State lives on the context as a `@owlmeans/state` resource; these hooks subscribe to it.

package/build/consts.d.ts

@@ -2,4 +2,12 @@ export declare const DEF_MODAL_ALIAS = "modal";
 export declare const DEF_DEBUG_ALIAS = "debug";
 export declare const DEBUGGER_FLAG = "debugger";
 export declare const DEBUG_CONFIG_KEY = "debugger";
+/** How many times `retryImport` loads a chunk again after its first failure. */
+export declare const DEF_IMPORT_RETRY_ATTEMPTS = 2;
+/** The pause before each retry, in order; the last one repeats. */
+export declare const DEF_IMPORT_RETRY_DELAYS_MS: readonly number[];
+/** The `sessionStorage` key `recoverFromChunkError` keeps the time of its last reload under. */
+export declare const CHUNK_RELOAD_KEY = "owlmeans:chunk-reload";
+/** At most one chunk-recovery reload per this window, per tab. */
+export declare const CHUNK_RELOAD_WINDOW_MS = 60000;
 //# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe,UAAU,CAAA;AACtC,eAAO,MAAM,eAAe,UAAU,CAAA;AAEtC,eAAO,MAAM,aAAa,aAAa,CAAA;AACvC,eAAO,MAAM,gBAAgB,aAAa,CAAA"}
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,eAAe,UAAU,CAAA;AACtC,eAAO,MAAM,eAAe,UAAU,CAAA;AAEtC,eAAO,MAAM,aAAa,aAAa,CAAA;AACvC,eAAO,MAAM,gBAAgB,aAAa,CAAA;AAE1C,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,IAAI,CAAA;AAC1C,mEAAmE;AACnE,eAAO,MAAM,0BAA0B,EAAE,SAAS,MAAM,EAAgB,CAAA;AAExE,gGAAgG;AAChG,eAAO,MAAM,gBAAgB,0BAA0B,CAAA;AACvD,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,QAAS,CAAA"}

package/build/consts.js

@@ -2,4 +2,12 @@ export const DEF_MODAL_ALIAS = 'modal';
 export const DEF_DEBUG_ALIAS = 'debug';
 export const DEBUGGER_FLAG = 'debugger';
 export const DEBUG_CONFIG_KEY = 'debugger';
+/** How many times `retryImport` loads a chunk again after its first failure. */
+export const DEF_IMPORT_RETRY_ATTEMPTS = 2;
+/** The pause before each retry, in order; the last one repeats. */
+export const DEF_IMPORT_RETRY_DELAYS_MS = [500, 1500];
+/** The `sessionStorage` key `recoverFromChunkError` keeps the time of its last reload under. */
+export const CHUNK_RELOAD_KEY = 'owlmeans:chunk-reload';
+/** At most one chunk-recovery reload per this window, per tab. */
+export const CHUNK_RELOAD_WINDOW_MS = 60_000;
 //# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -1 +1 @@
-{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAA;AACtC,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAA;AAEtC,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAA;AACvC,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAA"}
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAA;AACtC,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAA;AAEtC,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAA;AACvC,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAA;AAE1C,gFAAgF;AAChF,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAA;AAC1C,mEAAmE;AACnE,MAAM,CAAC,MAAM,0BAA0B,GAAsB,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;AAExE,gGAAgG;AAChG,MAAM,CAAC,MAAM,gBAAgB,GAAG,uBAAuB,CAAA;AACvD,kEAAkE;AAClE,MAAM,CAAC,MAAM,sBAAsB,GAAG,MAAM,CAAA"}

package/build/index.d.ts

@@ -2,6 +2,8 @@ export * from './context.js';
 export * from './components/index.js';
 export * from './services/index.js';
 export * from './helper.js';
+export * from './lazy.js';
+export * from './lazy-retry.js';
 export * from './navigate.js';
 export * from './entrypoint.js';
 export * from './router.js';

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAA;AAC5B,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAA;AAC5B,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA;AACzB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA"}

package/build/index.js

@@ -2,6 +2,8 @@ export * from './context.js';
 export * from './components/index.js';
 export * from './services/index.js';
 export * from './helper.js';
+export * from './lazy.js';
+export * from './lazy-retry.js';
 export * from './navigate.js';
 export * from './entrypoint.js';
 export * from './router.js';

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAA;AAC5B,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,cAAc,CAAA;AAC5B,cAAc,uBAAuB,CAAA;AACrC,cAAc,qBAAqB,CAAA;AACnC,cAAc,aAAa,CAAA;AAC3B,cAAc,WAAW,CAAA;AACzB,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAC1B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA"}

package/build/lazy-retry.d.ts

@@ -0,0 +1,47 @@
+import type { RetryImportOptions } from './types.js';
+/**
+ * Whether `error` is a chunk that could not be FETCHED: a browser's failed dynamic import, Vite's
+ * stylesheet preload failure, webpack's `ChunkLoadError`, Vite's `vite:preloadError` event, or
+ * the `error` event of the element a loader fetched through. A module that was fetched and then
+ * failed — a missing export, a throw while it evaluated — is not one: loading it again changes
+ * nothing.
+ */
+export declare const isChunkLoadError: (error: unknown) => boolean;
+/**
+ * The URL of the chunk a failed dynamic import tried to fetch, when the browser's error names it
+ * and it is an http(s) URL of this page's origin — never an arbitrary URL out of a message. `null`
+ * otherwise (Safari, a non-browser platform, another origin).
+ */
+export declare const chunkUrlOf: (error: unknown) => string | null;
+/**
+ * `href` with a fresh `t` parameter: a URL the browser has not seen, so it fetches the module
+ * again. `t` is the parameter Vite's dev server already gives module URLs; a static host ignores it.
+ */
+export declare const cacheBustedUrl: (href: string, now?: number) => string;
+/**
+ * Run `load` — a dynamic `import()` — and, while it rejects with a chunk-load failure, run it again
+ * after a pause, `attempts` more times at most. Any other rejection is rethrown at once.
+ *
+ * This covers a TRANSIENT failure — a network blip, an edge answering 404 or 5xx for a moment.
+ * A browser remembers a failed module fetch for the document's lifetime (Chromium does) and
+ * rejects every later `import()` of that URL at once, so a retry imports the URL the error names
+ * with a cache-busting parameter instead (`bustCache`, default on): a new URL, fetched again. Where
+ * the error names no URL (Safari), `load` runs again as is; what always recovers is a new
+ * document, which `recoverFromChunkError` starts, once and guarded.
+ */
+export declare const retryImport: <M>(load: () => Promise<M>, opts?: RetryImportOptions) => Promise<M>;
+/**
+ * Reload the page, at most once per `windowMs` in this tab — the time of the last reload is kept
+ * in `sessionStorage` under `key`. Never while offline (the reload would land on the browser's own
+ * error page), and never without storage: with nowhere to keep the guard, a failure that survives
+ * the reload would reload forever. A platform with no page to reload does nothing. Answers whether
+ * a reload was started.
+ */
+export declare const reloadOnce: (key: string, windowMs: number) => boolean;
+/**
+ * The guarded reload a chunk that failed for good ends in: `reloadOnce` under one key every caller
+ * in the tab shares, so a lazy boundary and an application's own `vite:preloadError` listener
+ * never reload twice for one failure.
+ */
+export declare const recoverFromChunkError: () => boolean;
+//# sourceMappingURL=lazy-retry.d.ts.map

package/build/lazy-retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-retry.d.ts","sourceRoot":"","sources":["../src/lazy-retry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAQpD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,UAAW,OAAO,KAAG,OAUjD,CAAA;AAOD;;;;GAIG;AACH,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,MAAM,GAAG,IAgBpD,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,SAAU,MAAM,QAAO,MAAM,KAAgB,MAIvE,CAAA;AAKD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,GAAU,CAAC,QAAQ,MAAM,OAAO,CAAC,CAAC,CAAC,SAAS,kBAAkB,KAAG,OAAO,CAAC,CAAC,CAsBjG,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,QAAS,MAAM,YAAY,MAAM,KAAG,OAoB1D,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,QAAO,OAA+D,CAAA"}

package/build/lazy-retry.js

@@ -0,0 +1,128 @@
+import { CHUNK_RELOAD_KEY, CHUNK_RELOAD_WINDOW_MS, DEF_IMPORT_RETRY_ATTEMPTS, DEF_IMPORT_RETRY_DELAYS_MS } from './consts.js';
+/**
+ * What a browser says when a dynamic `import()` could not fetch its module — Chromium, Safari and
+ * Firefox, in that order — and what Vite's preload helper says when a chunk's stylesheet could not.
+ */
+const CHUNK_FAILURE = /failed to fetch dynamically imported module|importing a module script failed|error loading dynamically imported module|unable to preload css/i;
+/**
+ * Whether `error` is a chunk that could not be FETCHED: a browser's failed dynamic import, Vite's
+ * stylesheet preload failure, webpack's `ChunkLoadError`, Vite's `vite:preloadError` event, or
+ * the `error` event of the element a loader fetched through. A module that was fetched and then
+ * failed — a missing export, a throw while it evaluated — is not one: loading it again changes
+ * nothing.
+ */
+export const isChunkLoadError = (error) => {
+    if (error == null || typeof error !== 'object') {
+        return false;
+    }
+    if (typeof Event !== 'undefined' && error instanceof Event) {
+        return error.type === 'vite:preloadError' || error.type === 'error';
+    }
+    const { name, message } = error;
+    return name === 'ChunkLoadError' || (typeof message === 'string' && CHUNK_FAILURE.test(message));
+};
+const pause = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/** The module URL a Chromium or Firefox import failure names; Safari's message names none. */
+const FAILED_URL = /dynamically imported module:?\s+(\S+)/i;
+/**
+ * The URL of the chunk a failed dynamic import tried to fetch, when the browser's error names it
+ * and it is an http(s) URL of this page's origin — never an arbitrary URL out of a message. `null`
+ * otherwise (Safari, a non-browser platform, another origin).
+ */
+export const chunkUrlOf = (error) => {
+    const message = error?.message;
+    const found = typeof message === 'string' ? FAILED_URL.exec(message)?.[1] : undefined;
+    if (found == null) {
+        return null;
+    }
+    try {
+        const url = new URL(found);
+        const origin = typeof location !== 'undefined' ? location.origin : undefined;
+        if ((url.protocol !== 'https:' && url.protocol !== 'http:') || (origin != null && url.origin !== origin)) {
+            return null;
+        }
+        return url.href;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * `href` with a fresh `t` parameter: a URL the browser has not seen, so it fetches the module
+ * again. `t` is the parameter Vite's dev server already gives module URLs; a static host ignores it.
+ */
+export const cacheBustedUrl = (href, now = Date.now()) => {
+    const url = new URL(href);
+    url.searchParams.set('t', String(now));
+    return url.href;
+};
+const importUrl = (url) => import(/* @vite-ignore */ /* webpackIgnore: true */ url);
+/**
+ * Run `load` — a dynamic `import()` — and, while it rejects with a chunk-load failure, run it again
+ * after a pause, `attempts` more times at most. Any other rejection is rethrown at once.
+ *
+ * This covers a TRANSIENT failure — a network blip, an edge answering 404 or 5xx for a moment.
+ * A browser remembers a failed module fetch for the document's lifetime (Chromium does) and
+ * rejects every later `import()` of that URL at once, so a retry imports the URL the error names
+ * with a cache-busting parameter instead (`bustCache`, default on): a new URL, fetched again. Where
+ * the error names no URL (Safari), `load` runs again as is; what always recovers is a new
+ * document, which `recoverFromChunkError` starts, once and guarded.
+ */
+export const retryImport = async (load, opts) => {
+    const attempts = Math.max(0, opts?.attempts ?? DEF_IMPORT_RETRY_ATTEMPTS);
+    const delays = opts?.delaysMs ?? DEF_IMPORT_RETRY_DELAYS_MS;
+    const shouldRetry = opts?.shouldRetry ?? isChunkLoadError;
+    const bust = opts?.bustCache !== false;
+    const importBusted = opts?.importUrl ?? importUrl;
+    let next = load;
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await next();
+        }
+        catch (error) {
+            if (attempt >= attempts || !shouldRetry(error)) {
+                throw error;
+            }
+            const url = bust ? chunkUrlOf(error) : null;
+            if (url != null) {
+                next = async () => await importBusted(cacheBustedUrl(url));
+            }
+            await pause(delays[Math.min(attempt, delays.length - 1)] ?? 0);
+        }
+    }
+};
+/**
+ * Reload the page, at most once per `windowMs` in this tab — the time of the last reload is kept
+ * in `sessionStorage` under `key`. Never while offline (the reload would land on the browser's own
+ * error page), and never without storage: with nowhere to keep the guard, a failure that survives
+ * the reload would reload forever. A platform with no page to reload does nothing. Answers whether
+ * a reload was started.
+ */
+export const reloadOnce = (key, windowMs) => {
+    const location = typeof window !== 'undefined' ? window.location : undefined;
+    if (typeof location?.reload !== 'function') {
+        return false;
+    }
+    if (typeof navigator !== 'undefined' && navigator.onLine === false) {
+        return false;
+    }
+    try {
+        const now = Date.now();
+        if (now - Number(window.sessionStorage.getItem(key) ?? 0) < windowMs) {
+            return false;
+        }
+        window.sessionStorage.setItem(key, String(now));
+    }
+    catch {
+        return false;
+    }
+    location.reload();
+    return true;
+};
+/**
+ * The guarded reload a chunk that failed for good ends in: `reloadOnce` under one key every caller
+ * in the tab shares, so a lazy boundary and an application's own `vite:preloadError` listener
+ * never reload twice for one failure.
+ */
+export const recoverFromChunkError = () => reloadOnce(CHUNK_RELOAD_KEY, CHUNK_RELOAD_WINDOW_MS);
+//# sourceMappingURL=lazy-retry.js.map

package/build/lazy-retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-retry.js","sourceRoot":"","sources":["../src/lazy-retry.ts"],"names":[],"mappings":"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"}

package/build/lazy.d.ts

@@ -0,0 +1,32 @@
+import type { ComponentExport, ExportProps, LazyComponent, LazyComponentOptions, LazyHandler } from './types.js';
+/**
+ * Wrap an async module import as a stable lazily-loaded component with a `.preload()`.
+ *
+ * MUST be called at module scope, never inside a render, a hook body or an entrypoint handler
+ * factory — the OwlMeans route renderer (`utils/route.tsx`) remounts the whole route subtree on
+ * every navigation (a fresh component identity per render), so a lazy object created during
+ * render would re-suspend on every navigation instead of rendering instantly once loaded.
+ *
+ * The `Suspense` boundary sits inside the returned component, so the fallback replaces only this
+ * component — the layout around it stays mounted while the chunk loads.
+ *
+ * Once loaded, later renders resolve synchronously (no re-suspend), so a component whose chunk
+ * was already preloaded never shows its fallback. A load that fails to fetch is retried in place
+ * (`retryImport`, tuned or turned off by `opts.retry`); one that still fails is never cached: the
+ * internal `React.lazy` is recreated, so the next mount, `retry()` or `preload()` loads for real.
+ *
+ * The component always carries its own error boundary, so a chunk that failed for good never
+ * unmounts what is around it: `opts.error` renders in its place, or — without one — the guarded
+ * reload (`recoverFromChunkError`) starts and the fallback stays. Any other error without
+ * `opts.error` goes on to the nearest boundary above, as if there were none.
+ */
+export declare const lazyComponent: <M, K extends ComponentExport<M>>(load: () => Promise<M>, exportName: K, opts?: LazyComponentOptions) => LazyComponent<ExportProps<M, K>>;
+/**
+ * `handler(lazyComponent(...))`, carrying `.preload()` through — bind it to a screen exactly like
+ * `handler(Component)`. The same module-scope rule applies: call it where the entrypoints are
+ * declared, never inside a render. A screen whose chunk still fails after its retries starts the
+ * guarded reload before showing its `error` (`reload` defaults to `true` here): a whole screen has
+ * nothing to degrade to, and in a dev-served app only a new document can load it again.
+ */
+export declare const lazyHandler: <M, K extends ComponentExport<M>>(load: () => Promise<M>, exportName: K, opts?: LazyComponentOptions) => LazyHandler<ExportProps<M, K>>;
+//# sourceMappingURL=lazy.d.ts.map

package/build/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../src/lazy.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,eAAe,EAAE,WAAW,EAAE,aAAa,EAAE,oBAAoB,EAAE,WAAW,EAC/E,MAAM,YAAY,CAAA;AAKnB;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,QACrD,MAAM,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC,SAAS,oBAAoB,KACjE,aAAa,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAgDjC,CAAA;AA+DD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,QACnD,MAAM,OAAO,CAAC,CAAC,CAAC,cAAc,CAAC,SAAS,oBAAoB,KACjE,WAAW,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAK/B,CAAA"}

package/build/lazy.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { lazy, Suspense, Component, useState } from 'react';
+import { handler } from './helper.js';
+import { isChunkLoadError, recoverFromChunkError, retryImport } from './lazy-retry.js';
+/**
+ * Wrap an async module import as a stable lazily-loaded component with a `.preload()`.
+ *
+ * MUST be called at module scope, never inside a render, a hook body or an entrypoint handler
+ * factory — the OwlMeans route renderer (`utils/route.tsx`) remounts the whole route subtree on
+ * every navigation (a fresh component identity per render), so a lazy object created during
+ * render would re-suspend on every navigation instead of rendering instantly once loaded.
+ *
+ * The `Suspense` boundary sits inside the returned component, so the fallback replaces only this
+ * component — the layout around it stays mounted while the chunk loads.
+ *
+ * Once loaded, later renders resolve synchronously (no re-suspend), so a component whose chunk
+ * was already preloaded never shows its fallback. A load that fails to fetch is retried in place
+ * (`retryImport`, tuned or turned off by `opts.retry`); one that still fails is never cached: the
+ * internal `React.lazy` is recreated, so the next mount, `retry()` or `preload()` loads for real.
+ *
+ * The component always carries its own error boundary, so a chunk that failed for good never
+ * unmounts what is around it: `opts.error` renders in its place, or — without one — the guarded
+ * reload (`recoverFromChunkError`) starts and the fallback stays. Any other error without
+ * `opts.error` goes on to the nearest boundary above, as if there were none.
+ */
+export const lazyComponent = (load, exportName, opts) => {
+    let loaded;
+    let loading;
+    const fetchModule = () => opts?.retry === false ? load() : retryImport(load, opts?.retry);
+    const runLoad = () => loading ??= fetchModule().then(module => {
+        const Comp = module[exportName];
+        if (Comp == null) {
+            throw new SyntaxError(`Lazy module has no component export "${exportName}"`);
+        }
+        return loaded = Comp;
+    }).catch((error) => {
+        loading = undefined;
+        current = createLazy();
+        throw error;
+    });
+    const preload = () => loaded != null ? Promise.resolve(loaded) : runLoad();
+    const createLazy = () => lazy(() => {
+        const ready = loaded;
+        if (ready != null) {
+            // Already resolved: hand React a thenable that settles synchronously, so its lazy
+            // initializer reads the module in the same tick and never suspends.
+            const settled = { then: (resolve) => resolve({ default: ready }) };
+            return settled;
+        }
+        return runLoad().then(Comp => ({ default: Comp }));
+    });
+    let current = createLazy();
+    const Lazy = (props) => {
+        // The lazy THIS instance renders, taken when it mounts: a failed load stays failed for it
+        // while React re-renders it to recover from the error, until `retry` swaps in the recreated
+        // lazy. A new mount — a navigation back, another place — takes the recreated one at once.
+        const [Current, setCurrent] = useState(() => current);
+        const fallback = (typeof opts?.fallback === 'function' ? opts.fallback(props) : opts?.fallback) ?? null;
+        return _jsx(LazyErrorBoundary, { error: opts?.error, reload: opts?.reload === true, fallback: fallback, props: props, onRetry: () => setCurrent(() => current), children: _jsx(Suspense, { fallback: fallback, children: _jsx(Current, { ...props }) }) });
+    };
+    Lazy.displayName = `Lazy(${exportName})`;
+    return Object.assign(Lazy, { preload });
+};
+class LazyErrorBoundary extends Component {
+    state = { failed: false, error: undefined };
+    static getDerivedStateFromError(error) {
+        return { failed: true, error };
+    }
+    componentDidCatch(error) {
+        // A chunk that failed for good is recovered by a new document: always without a surface of its
+        // own, and with one when asked (`reload`) — a whole screen rather than a piece that degrades.
+        // The reload is guarded (once a minute per tab); when the guard refuses, the surface stays.
+        if (isChunkLoadError(error) && (this.props.error === undefined || this.props.reload)) {
+            if (recoverFromChunkError()) {
+                this.setState({ reloading: true });
+            }
+        }
+    }
+    /** Render the children again, over the recreated lazy, which loads anew. */
+    retry = () => {
+        this.setState({ failed: false, error: undefined, reloading: false });
+        this.props.onRetry();
+    };
+    render() {
+        if (!this.state.failed) {
+            return this.props.children;
+        }
+        const { error, fallback, props } = this.props;
+        if (this.state.reloading === true) {
+            return fallback;
+        }
+        if (error !== undefined) {
+            return typeof error === 'function' ? error(props, this.state.error, this.retry) : error;
+        }
+        if (isChunkLoadError(this.state.error)) {
+            return fallback;
+        }
+        // Not a chunk failure and no surface for it: the application's own boundary decides.
+        throw this.state.error;
+    }
+}
+/**
+ * `handler(lazyComponent(...))`, carrying `.preload()` through — bind it to a screen exactly like
+ * `handler(Component)`. The same module-scope rule applies: call it where the entrypoints are
+ * declared, never inside a render. A screen whose chunk still fails after its retries starts the
+ * guarded reload before showing its `error` (`reload` defaults to `true` here): a whole screen has
+ * nothing to degrade to, and in a dev-served app only a new document can load it again.
+ */
+export const lazyHandler = (load, exportName, opts) => {
+    const LazyComp = lazyComponent(load, exportName, { ...opts, reload: opts?.reload ?? true });
+    const refed = handler(LazyComp);
+    return Object.assign(refed, { preload: LazyComp.preload });
+};
+//# sourceMappingURL=lazy.js.map

package/build/lazy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.js","sourceRoot":"","sources":["../src/lazy.tsx"],"names":[],"mappings":"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"}