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

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

@@ -1,6 +1,6 @@
 ---
 name: client
-description: How to use @owlmeans/client — platform-agnostic React client framework (works with web and React Native) providing context, components, services, navigate, store. Auto-invoked when importing client framework primitives.
+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,37 +8,300 @@ user-invocable: false
 # @owlmeans/client
 
 **Layer:** Client
-**Install:** `"@owlmeans/client": "^0.1.18-rc.0"` 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
+package, which re-exports what it needs — **except the hooks below, which are only here**.
+
+## What lives where
+
+| Import from `@owlmeans/client` | Import from `@owlmeans/web-client` |
+|---|---|
+| `useNavigate`, `useEntrypoint`, `useStoreModel`, `useStoreList`, `useValue`, `useToggle`, `useSetupModalNavigator` — none of these are re-exported | `renderApp`, `makeContext`, `useAuthenticated`, and protocol binding helpers from `@owlmeans/client-entrypoint` |
+| `RoutedComponent`, `EntrypointContextParams`, `Navigator`, `NavRequest`, `ClientContext` | `AppConfig`, `AppContext` |
+| `App`, `Router`, `makeClientContext` — the platform-agnostic mounts | `WebApp`, `renderApp` — the browser mounts that wrap them |
 
 ## Key Exports
 
 | Export | Description |
 |--------|-------------|
-| `App` / context helpers | Mount the React app, provide context |
-| `navigate` helpers | Programmatic navigation via the router service |
-| `module` helpers | Resolve modules by alias |
-| `store` helpers | Client store integration |
-| `components` | Cross-platform components (e.g. error boundaries) |
-| `value`, `debug` | Render-time helpers |
-| Errors | Client-side typed errors |
-| Constants | Default aliases |
+| `makeClientContext(cfg)` | The React client context: `@owlmeans/client-context` plus the state resource, both config resources, the modal and debug services, the rerender hook and `context.router()` |
+| `ClientContext<C>` | That context's interface — adds `router()`, `registerRerenderer(fn)`, `rerender()`, `modal()`, `debug()` |
+| `App` / `AppProps` | Mount: provides the context and, unless `noRouter`, the router. `children` render inside the provider and before the router |
+| `Context` / `ClientContextContainer` / `useContext()` | The React context container and the hook that reads it |
+| `Router` / `RouterProps` / `RouterProvider` / `makeRouterModel()` | Route rendering. `provide` is optional — omitted, the active router plugin's `compile` is used |
+| `useNavigate()` | The `Navigator` — programmatic navigation by entrypoint alias |
+| `Navigator` / `NavRequest` | `navigate` `go` `press` `back` `pressBack` `location`; a request adds `replace` and `silent` to an `AbstractRequest` |
+| `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 |
+| `appendModalService` / `createModalService` / `ModalService` / `ModalStackLayer` | The modal stack — `context.modal()`: `request` `response` `cancel` `error` `layer()` `link(toggle)` |
+| `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`), `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
 
-- `./utils` — generic client utilities
+- `./utils` — `buildEntrypointTree`, `visitEntrypointTree`, `initializeRouter`, `createRouteRenderer`,
+  `EntrypointContext`. What the router is assembled from; a package building its own routing surface
+  uses these, an application does not.
 
-## Usage
+## Navigation
 
-This is the platform-agnostic substrate that `@owlmeans/web-client` (browser) and the native equivalent build on. Most apps import from `@owlmeans/web-client` directly; use `@owlmeans/client` only for cross-platform code.
+Navigation addresses an ALIAS, never a URL — the path lives in the entrypoint declaration, so a
+component never builds one. `useNavigate()` returns the `Navigator`, which asks the target
+entrypoint for its `url(request)` and hands that to the active router plugin:
 
 ```typescript
-import { navigate } from '@owlmeans/client'
-const navigateTo = navigate(context)
-navigateTo('/projects')
+import { useNavigate } from '@owlmeans/client'
+import type { RoutedComponent } from '@owlmeans/client'
+
+export const ProjectScreen: RoutedComponent = ({ params }) => {
+  const nav = useNavigate()
+
+  // `go` navigates; `press` returns the handler for an onClick. `params` fills the path
+  // parameters of the target entrypoint, `query` the query string, `replace` swaps the
+  // history entry instead of pushing one.
+  void nav.go(PROJECT_ITEM, { params: { id: params.id }, query: { tab: 'files' } })
+
+  return <a onClick={nav.press(PROJECT_LIST)}>Back to the list</a>
+}
 ```
 
+A URL that comes back starting with `http` belongs to another service, and the navigator assigns
+`location.href` rather than pushing a history entry. `nav.navigate(entrypoint, request)` takes the
+entrypoint itself when you already hold it; `nav.back()` / `nav.pressBack()` go one entry back, and
+`nav.location()` reads the current one.
+
+A bound screen receives `{ alias, path, params, context }` as props, and `useEntrypoint()`
+reads the same values from anywhere below it — read path parameters from `params` and pass them
+down; a nested component never resolves route parameters itself.
+
+## Routing and guards
+
+`App` mounts `Router`, which resolves the frontend entrypoints the context holds into a nested
+route tree. Only entrypoints whose route is `AppType.Frontend` are mounted, and among those only
+the ones that name no service at all, name this app's service, or are `sticky`. Each node
+contributes **only its own segment** — its ancestors already carry theirs, so a declaration nests
+by naming a `parent`.
+
+A screen's guards are its own plus every ancestor's, taken from `getGuards()`. An empty list is an
+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.
+
+```typescript
+import { useStoreList, useStoreModel } from '@owlmeans/client'
+
+const task = useStoreModel<Task>(id, TASKS)                              // one record
+const open = useStoreList<Task>({ query: { status: 'open' }, resource: TASKS })  // live query
+```
+
+`useStoreModel` returns a `StateModel` — read `model.record`, write with `model.update({ ... })`.
+Never assign into `model.record` — it is not a snapshot. On a model the store backs, it IS the
+object the store holds: a field assignment mutates what every other holder of that key reads, and
+the next `update()`/`commit()` carries the mutation through, while nothing notifies and nothing
+re-renders. The hook never throws for missing data either — an id the store knows nothing about
+yields a model whose `empty` is true, and nothing is written into the store on the way.
+`useStoreList` takes `{ query?, sort?, resource? }` and matches everything when `query` is omitted.
+Full contract: [[state]].
+
+Both hooks go through `useSyncExternalStore`, and the live subscription React installs is torn down
+with the component. The FIRST snapshot is taken during render, by subscribing and unsubscribing
+again in one statement — a state resource seeds its listener synchronously, so no render runs
+without a value and that momentary subscription never outlives the call. The value is then cached
+and the same reference is returned until something actually changes, which is what keeps React from
+re-rendering forever.
+
+## Async values
+
+`useValue(loader, deps?, forceDefault?)` runs an async loader in an effect and answers with the
+default — `null` when there is none — until it resolves. Its second argument is overloaded, and
+reading it as "a default" is the standard mistake:
+
+```typescript
+useValue(async () => api.load(id), [id])                       // a DependencyList — re-runs on id
+useValue(async () => api.load(id), { default: EMPTY, deps: [id] })   // both, via UseValueParams
+useValue(async () => api.load(id))                             // no deps — the loader runs once
+useValue(async () => api.count(), 0)                           // a bare non-array value IS the default
+```
+
+The deps always come from the argument's SHAPE: an array is the dependency list itself, an object
+with a `deps` key gives `deps ?? []`, and anything else gives `[]`. The default is read from the
+same argument: `default` off a `UseValueParams` object, `null` when an array was passed, the value
+itself otherwise. `forceDefault: true` changes only the second half — the argument is then taken as
+the default whatever its shape, while still deciding the deps.
+
+The loader is handed a `MutableRefObject<boolean>` cancel ref, which the effect's cleanup sets to
+`true`, so a loader that awaits more than once checks `cancel.current` before it commits. A loader that resolves to a **function** is kept aside and returned as it is, rather than
+being run as a state updater — which is what lets a component be an async value.
+
+## Modals
+
+`context.modal()` owns a STACK of body components and one surface. The surface is a component the
+app mounts once: it links a toggle to the service, reads the top layer through `layer()`, and
+renders it with the service as a prop.
+
+```tsx
+import { useContext, useSetupModalNavigator, useToggle, useValue } from '@owlmeans/client'
+import type { ModalBodyProps } from '@owlmeans/client'
+import { useEffect } from 'react'
+import type { FC } from 'react'
+
+export const Modal: FC = () => {
+  useSetupModalNavigator()                     // lets a body navigate; call it once
+  const context = useContext()
+  const toggle = useToggle(false)
+
+  useEffect(() => {
+    void context.waitForInitialized().then(() => context.modal().link(toggle))
+  }, [])
+
+  const Com = useValue<FC<ModalBodyProps> | undefined>(
+    async () => toggle.opened ? context.modal().layer()?.Com : undefined,
+    [toggle.opened]
+  )
+
+  return <Dialog open={toggle.opened} onOpenChange={toggle.set}>
+    {Com != null ? <Com modal={context.modal()} /> : undefined}
+  </Dialog>
+}
+```
+
+A **body is an `FC<ModalBodyProps>`** — it receives the service as an optional `modal` prop, and
+that prop is how it answers. Nothing else reaches it, so whatever a body needs travels in the
+closure of the component that requested it.
+
+```typescript
+const result = await context.modal().request<Answer>(ConfirmBody)   // null when cancelled
+```
+
+`request` pushes the body onto the stack, opens the linked toggle, and resolves when the body calls
+`modal.response(value)`, `modal.cancel()` (which resolves `null`) or `modal.error(e)` (which
+rejects). All three settle the promise first, then pop the layer and close the surface — and
+`request` pops a SECOND time when its own `await` resumes. One completed request therefore removes
+two layers.
+
+**Keep the stack one deep.** A lone body ends on an empty stack and the second pop costs nothing.
+A body requested from inside another body takes its parent down with it: closing the child pops the
+child, sees a layer still there and schedules the surface to reopen 500 ms later, and then the
+child's continuation pops the parent in the microtask before that timer fires. The surface reopens
+with `layer()` answering `undefined` and nothing to render, and the parent's own `request` — whose
+deferred no one is left to settle — never resolves. Chain from the caller instead: await the first
+request, then issue the next.
+
+## Debug menu
+
+`appendDebugService` registers the menu only when `cfg.debug.all` or `cfg.debug.debugger` is set,
+so `context.debug()` answers `undefined` in a normal build and a caller must handle that. A package
+that owns a client resource calls `appendStateDebug(context, alias)` at wiring time to have it
+listed under "Reset states"; "Reset app" erases the whole client DB.
+
 ## Depends On
 
-- `@owlmeans/client-context`, `@owlmeans/client-entrypoint`, `@owlmeans/client-route`
-- `@owlmeans/router`, `@owlmeans/auth-common`
-- `react` (peer)
+- `@owlmeans/client-context`, `@owlmeans/client-entrypoint`, `@owlmeans/client-resource`
+- `@owlmeans/router` (the routing plugin surface), `@owlmeans/state`, `@owlmeans/entrypoint`,
+  `@owlmeans/resource`, `@owlmeans/config`, `@owlmeans/context`, `@owlmeans/auth`, `@owlmeans/error`
+- `react` and `@remix-run/router` (peer)
+
+## Related
+
+- [[web-client]] — the browser layer built on this
+- [[state]] — the store the two state hooks read
+- [[router]] — the routing plugin `context.router()` resolves

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/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,OAAO,CAAA;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAoB/C,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,KAAG,CA8BjH,CAAA;AAED,eAAO,MAAM,sBAAsB,2CAA+C,CAAA;AAElF,eAAO,MAAM,OAAO,uDAAkC,CAAA;AAEtD,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,QAE5E,CAAA"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,OAAO,CAAA;AAEpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAmB/C,eAAO,MAAM,iBAAiB,GAAI,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,KAAG,CA4BjH,CAAA;AAED,eAAO,MAAM,sBAAsB,2CAA+C,CAAA;AAElF,eAAO,MAAM,OAAO,uDAAkC,CAAA;AAEtD,eAAO,MAAM,UAAU,GAAI,CAAC,SAAS,YAAY,EAAE,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,QAE5E,CAAA"}

package/build/context.js

@@ -1,6 +1,6 @@
 import { createContext, useContext as useCtx } from 'react';
 import { makeClientContext as makeBasicContext, PLUGINS } from '@owlmeans/client-context';
-import { AppType, CONFIG_RECORD, Layer } from '@owlmeans/context';
+import { AppType, CONFIG_RECORD } from '@owlmeans/context';
 import { appendStateResource } from '@owlmeans/state';
 import { appendModalService } from './components/modal.js';
 import { appendDebugService } from './services/debug.js';
@@ -9,7 +9,6 @@ import { ROUTER_SERVICE } from '@owlmeans/router';
 const defaultCfg = {
     services: {},
     brand: {},
-    layer: Layer.Service,
     trusted: [],
     [CONFIG_RECORD]: [],
     ready: false,
@@ -40,7 +39,6 @@ export const makeClientContext = (cfg) => {
         };
     }
     context.router = () => context.service(ROUTER_SERVICE);
-    context.makeContext = makeClientContext;
     return context;
 };
 export const ClientContextContainer = createContext(makeClientContext(defaultCfg));

package/build/context.js.map

@@ -1 +1 @@
-{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,UAAU,IAAI,MAAM,EAAE,MAAM,OAAO,CAAA;AAE3D,OAAO,EAAE,iBAAiB,IAAI,gBAAgB,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAEzF,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAEjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAEtE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEjD,MAAM,UAAU,GAAiB;IAC/B,QAAQ,EAAE,EAAE;IACZ,KAAK,EAAE,EAAE;IACT,KAAK,EAAE,KAAK,CAAC,OAAO;IACpB,OAAO,EAAE,EAAE;IACX,CAAC,aAAa,CAAC,EAAE,EAAE;IACnB,KAAK,EAAE,KAAK;IACZ,OAAO,EAAE,EAAE;IACX,KAAK,EAAE,EAAE;IACT,IAAI,EAAE,OAAO,CAAC,QAAQ;CACvB,CAAA;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAwE,GAAM,EAAK,EAAE;IACpH,MAAM,OAAO,GAAG,gBAAgB,CAAC,GAAG,CAAM,CAAA;IAC1C,mBAAmB,CAAO,OAAO,CAAC,CAAA;IAClC,kBAAkB,CAAO,OAAO,CAAC,CAAA;IACjC,oBAAoB,CAAO,OAAO,CAAC,CAAA;IACnC,oBAAoB,CAAO,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,CAAA;IAC3D,kBAAkB,CAAO,OAAO,CAAC,CAAA;IAEjC,IAAI,OAAO,CAAC,kBAAkB,IAAI,IAAI,EAAE,CAAC;QACvC,MAAM,WAAW,GAAuB,EAAE,CAAA;QAE1C,OAAO,CAAC,kBAAkB,GAAG,QAAQ,CAAC,EAAE;YACtC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YAC1B,OAAO,GAAG,EAAE;gBACV,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;gBAC3C,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;oBACf,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;gBAC9B,CAAC;YACH,CAAC,CAAA;QACH,CAAC,CAAA;QACD,OAAO,CAAC,QAAQ,GAAG,GAAG,EAAE;YACtB,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAA;QAC7C,CAAC,CAAA;IACH,CAAC;IAED,OAAO,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAgB,cAAc,CAAC,CAAA;IAErE,OAAO,CAAC,WAAW,GAAG,iBAA+C,CAAA;IAErE,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,sBAAsB,GAAG,aAAa,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC,CAAA;AAElF,MAAM,CAAC,MAAM,OAAO,GAAG,sBAAsB,CAAC,QAAQ,CAAA;AAEtD,MAAM,CAAC,MAAM,UAAU,GAAG,GAAuD,EAAE,CAAC,MAAM,CACxF,sBAAoD,CACrD,CAAA"}
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,UAAU,IAAI,MAAM,EAAE,MAAM,OAAO,CAAA;AAE3D,OAAO,EAAE,iBAAiB,IAAI,gBAAgB,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAA;AAEzF,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAE1D,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC1D,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAEtE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAEjD,MAAM,UAAU,GAAiB;IAC/B,QAAQ,EAAE,EAAE;IACZ,KAAK,EAAE,EAAE;IACT,OAAO,EAAE,EAAE;IACX,CAAC,aAAa,CAAC,EAAE,EAAE;IACnB,KAAK,EAAE,KAAK;IACZ,OAAO,EAAE,EAAE;IACX,KAAK,EAAE,EAAE;IACT,IAAI,EAAE,OAAO,CAAC,QAAQ;CACvB,CAAA;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAwE,GAAM,EAAK,EAAE;IACpH,MAAM,OAAO,GAAG,gBAAgB,CAAC,GAAG,CAAM,CAAA;IAC1C,mBAAmB,CAAO,OAAO,CAAC,CAAA;IAClC,kBAAkB,CAAO,OAAO,CAAC,CAAA;IACjC,oBAAoB,CAAO,OAAO,CAAC,CAAA;IACnC,oBAAoB,CAAO,OAAO,EAAE,OAAO,EAAE,aAAa,CAAC,CAAA;IAC3D,kBAAkB,CAAO,OAAO,CAAC,CAAA;IAEjC,IAAI,OAAO,CAAC,kBAAkB,IAAI,IAAI,EAAE,CAAC;QACvC,MAAM,WAAW,GAAuB,EAAE,CAAA;QAE1C,OAAO,CAAC,kBAAkB,GAAG,QAAQ,CAAC,EAAE;YACtC,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YAC1B,OAAO,GAAG,EAAE;gBACV,MAAM,KAAK,GAAG,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;gBAC3C,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;oBACf,WAAW,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;gBAC9B,CAAC;YACH,CAAC,CAAA;QACH,CAAC,CAAA;QACD,OAAO,CAAC,QAAQ,GAAG,GAAG,EAAE;YACtB,WAAW,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAA;QAC7C,CAAC,CAAA;IACH,CAAC;IAED,OAAO,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAgB,cAAc,CAAC,CAAA;IAErE,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,sBAAsB,GAAG,aAAa,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC,CAAA;AAElF,MAAM,CAAC,MAAM,OAAO,GAAG,sBAAsB,CAAC,QAAQ,CAAA;AAEtD,MAAM,CAAC,MAAM,UAAU,GAAG,GAAuD,EAAE,CAAC,MAAM,CACxF,sBAAoD,CACrD,CAAA"}

package/build/entrypoint.d.ts

@@ -0,0 +1,3 @@
+import type { EntrypointContextParams } from './types.js';
+export declare const useEntrypoint: <T extends {} = {}>() => EntrypointContextParams<T>;
+//# sourceMappingURL=entrypoint.d.ts.map

package/build/entrypoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoint.d.ts","sourceRoot":"","sources":["../src/entrypoint.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAA;AAEzD,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,EAAE,GAAG,EAAE,OAAwC,uBAAuB,CAAC,CAAC,CAAC,CAAA"}

package/build/entrypoint.js

@@ -0,0 +1,4 @@
+import { useContext } from 'react';
+import { EntrypointContext } from './utils/index.js';
+export const useEntrypoint = () => useContext(EntrypointContext);
+//# sourceMappingURL=entrypoint.js.map

package/build/entrypoint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoint.js","sourceRoot":"","sources":["../src/entrypoint.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAA;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAGpD,MAAM,CAAC,MAAM,aAAa,GAAG,GAAsB,EAAE,CAAC,UAAU,CAAC,iBAAiB,CAA+B,CAAA"}

package/build/helper.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { isValidElement } from 'react';
-import { ModuleContext } from './utils/module.js';
+import { EntrypointContext } from './utils/entrypoint.js';
 import { assertContext } from '@owlmeans/context';
 export const handler = (Component, preprender) => ref => (req, res) => {
-    const location = `client-handler:${ref.ref?.getAlias() ?? 'unknown'}`;
+    const location = `client-handler:${ref.ref?.alias ?? 'unknown'}`;
     if (ref.ref == null) {
         throw new SyntaxError('Module reference is not provided');
     }
@@ -23,7 +23,7 @@ export const handler = (Component, preprender) => ref => (req, res) => {
     }
     const Renderer = ({ children, ...props }) => {
         const Renderer = Component;
-        return _jsx(ModuleContext.Provider, { value: props, children: _jsx(Renderer, { ...props, children: children }) });
+        return _jsx(EntrypointContext.Provider, { value: props, children: _jsx(Renderer, { ...props, children: children }) });
     };
     return Renderer;
 };

package/build/helper.js.map

@@ -1 +1 @@
-{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.tsx"],"names":[],"mappings":";AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAEtC,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAEjD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAKjD,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,SAA6B,EAAE,UAAoB,EACxB,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAGrC,GAAM,EAAE,GAAM,EAAO,EAAE;IACvB,MAAM,QAAQ,GAAG,kBAAkB,GAAG,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,SAAS,EAAE,CAAA;IACrE,IAAI,GAAG,CAAC,GAAG,IAAI,IAAI,EAAE,CAAC;QACpB,MAAM,IAAI,WAAW,CAAC,kCAAkC,CAAC,CAAA;IAC3D,CAAC;IACD,MAAM,GAAG,GAAG,aAAa,CAAkB,GAAG,CAAC,GAAG,CAAC,GAAc,EAAE,QAAQ,CAAC,CAAA;IAC5E,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAChB,MAAM,IAAI,WAAW,CAAC,gCAAgC,CAAC,CAAA;IACzD,CAAC;IACD,IAAI,cAAc,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9B,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;QACtB,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACxB,MAAM,QAAQ,GAAG,SAAoC,CAAA;QACrD,MAAM,OAAO,GAAG,KAAC,QAAQ,OAAK,GAAG,EAAE,OAAO,EAAE,GAAG,GAAI,CAAA;QACnD,GAAG,CAAC,OAAO,CAAC,OAA6B,CAAC,CAAA;QAE1C,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,MAAM,QAAQ,GAAoB,CAAC,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE;QAC3D,MAAM,QAAQ,GAAG,SAAoC,CAAA;QACrD,OAAO,KAAC,aAAa,CAAC,QAAQ,IAAC,KAAK,EAAE,KAAK,YACzC,KAAC,QAAQ,OAAK,KAAK,YAAG,QAAQ,GAAY,GACnB,CAAA;IAC3B,CAAC,CAAA;IAED,OAAO,QAAQ,CAAA;AACjB,CAAC,CAAA"}
+{"version":3,"file":"helper.js","sourceRoot":"","sources":["../src/helper.tsx"],"names":[],"mappings":";AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,OAAO,CAAA;AAEtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAEzD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAKjD,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,SAA6B,EAAE,UAAoB,EACxB,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAGrC,GAAM,EAAE,GAAM,EAAO,EAAE;IACvB,MAAM,QAAQ,GAAG,kBAAkB,GAAG,CAAC,GAAG,EAAE,KAAK,IAAI,SAAS,EAAE,CAAA;IAChE,IAAI,GAAG,CAAC,GAAG,IAAI,IAAI,EAAE,CAAC;QACpB,MAAM,IAAI,WAAW,CAAC,kCAAkC,CAAC,CAAA;IAC3D,CAAC;IACD,MAAM,GAAG,GAAG,aAAa,CAAkB,GAAG,CAAC,GAAG,CAAC,GAAc,EAAE,QAAQ,CAAC,CAAA;IAC5E,IAAI,GAAG,IAAI,IAAI,EAAE,CAAC;QAChB,MAAM,IAAI,WAAW,CAAC,gCAAgC,CAAC,CAAA;IACzD,CAAC;IACD,IAAI,cAAc,CAAC,SAAS,CAAC,EAAE,CAAC;QAC9B,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;QACtB,OAAO,SAAS,CAAA;IAClB,CAAC;IAED,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;QACxB,MAAM,QAAQ,GAAG,SAAoC,CAAA;QACrD,MAAM,OAAO,GAAG,KAAC,QAAQ,OAAK,GAAG,EAAE,OAAO,EAAE,GAAG,GAAI,CAAA;QACnD,GAAG,CAAC,OAAO,CAAC,OAA6B,CAAC,CAAA;QAE1C,OAAO,OAAO,CAAA;IAChB,CAAC;IAED,MAAM,QAAQ,GAAoB,CAAC,EAAE,QAAQ,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE;QAC3D,MAAM,QAAQ,GAAG,SAAoC,CAAA;QACrD,OAAO,KAAC,iBAAiB,CAAC,QAAQ,IAAC,KAAK,EAAE,KAAK,YAC7C,KAAC,QAAQ,OAAK,KAAK,YAAG,QAAQ,GAAY,GACf,CAAA;IAC/B,CAAC,CAAA;IAED,OAAO,QAAQ,CAAA;AACjB,CAAC,CAAA"}

package/build/index.d.ts

@@ -2,8 +2,10 @@ 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 './module.js';
+export * from './entrypoint.js';
 export * from './router.js';
 export * from './types.js';
 export * from './store.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,aAAa,CAAA;AAC3B,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,8 +2,10 @@ 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 './module.js';
+export * from './entrypoint.js';
 export * from './router.js';
 export * from './types.js';
 export * from './store.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,aAAa,CAAA;AAC3B,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"}