tempest-react-sdk 0.78.0 → 0.80.0

package/dist/sw/register-service-worker.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"register-service-worker.cjs","names":[],"sources":["../../src/sw/register-service-worker.ts"],"sourcesContent":["export interface RegisterServiceWorkerOptions {\n    /** Public URL of the compiled service worker file (e.g. `/sw.js`). */\n    url: string;\n    /** SW scope (default: SW directory). */\n    scope?: string;\n    /** Called once the registration is active. */\n    onReady?: (registration: ServiceWorkerRegistration) => void;\n    /**\n     * Called when a new worker has finished installing while another worker\n     * still controls the page. The host app typically prompts the user to\n     * reload and then calls {@link skipWaiting} on the returned worker.\n     *\n     * Fires for a worker that was already `waiting` when `register()` resolved\n     * — the state a user returning after a deploy actually finds — as well as\n     * for one that installs during this session, and at most once per worker.\n     */\n    onUpdate?: (waiting: ServiceWorker, registration: ServiceWorkerRegistration) => void;\n    /** Called on registration failure. */\n    onError?: (error: unknown) => void;\n    /**\n     * When `true`, poll the server for a fresh service worker on an interval\n     * (see {@link RegisterServiceWorkerOptions.updateIntervalMs}) and, unless\n     * {@link RegisterServiceWorkerOptions.reloadOnActivate} is disabled, reload\n     * the page as soon as a new worker takes control. Mirrors the auto-update\n     * behaviour of `vite-plugin-pwa` without depending on it. Default `false`.\n     */\n    autoUpdate?: boolean;\n    /**\n     * How often, in ms, to call `registration.update()` while `autoUpdate` is\n     * on. Browsers already re-check roughly every 24h; an hourly poll keeps\n     * long-lived sessions current without flooding the network. Default\n     * `3600000` (1 hour).\n     */\n    updateIntervalMs?: number;\n    /**\n     * When `autoUpdate` is on, reload the page once a new worker takes control\n     * (`controllerchange`), guarded against reload loops. Set to `false` to\n     * keep polling but leave the reload to the host app. Default `true`.\n     */\n    reloadOnActivate?: boolean;\n}\n\nconst DEFAULT_UPDATE_INTERVAL_MS = 60 * 60 * 1000;\n\n/**\n * Workers already handed to `onUpdate`, so no worker is announced twice.\n *\n * Two paths reach the same waiting worker and both are needed: `updatefound`\n * catches the worker that installs while the tab is open, and the `waiting`\n * read at registration catches the one that installed on an earlier visit. In\n * the session where a deploy lands *and* the tab stays open, both fire for the\n * same worker — without this the app prompts twice.\n *\n * Keyed by worker identity rather than by registration, so a second deploy in\n * the same session still announces: that is a different `ServiceWorker` object.\n * A `WeakSet` because the entry should die with the worker it names.\n */\nconst announcedWorkers = new WeakSet<ServiceWorker>();\n\n/**\n * Hand a waiting worker to `onUpdate`, at most once per worker.\n *\n * @param worker - The worker that finished installing.\n * @param registration - The registration it belongs to.\n * @param options - The caller's options, whose `onUpdate` is invoked.\n */\nfunction announceUpdate(\n    worker: ServiceWorker,\n    registration: ServiceWorkerRegistration,\n    options: RegisterServiceWorkerOptions,\n): void {\n    if (announcedWorkers.has(worker)) return;\n    announcedWorkers.add(worker);\n    options.onUpdate?.(worker, registration);\n}\n\nlet controllerReloadWired = false;\n\nfunction wireControllerReload(): void {\n    if (controllerReloadWired) return;\n    controllerReloadWired = true;\n    let refreshing = false;\n    navigator.serviceWorker.addEventListener(\"controllerchange\", () => {\n        if (refreshing) return;\n        refreshing = true;\n        window.location.reload();\n    });\n}\n\n/**\n * Register a service worker with consistent update-detection wiring.\n *\n * Skips silently when the runtime has no `serviceWorker` support. The host\n * app keeps full control over the SW file — this helper only handles the\n * boilerplate around `register()` and update detection.\n *\n * Two things can mean \"an update is ready\", and only one of them is an event.\n * `updatefound` covers the worker that installs while this tab is open. The\n * commoner case has no event at all: the user visited after a deploy, the new\n * worker installed and went to `waiting`, they closed the tab, and they are back\n * now. `install` already happened, so nothing fires — which is why `waiting` is\n * read directly once the registration resolves. Both routes go through the same\n * dedupe, so a worker is announced once even when both apply.\n *\n * Neither route fires without `navigator.serviceWorker.controller`: no\n * controller means this is the first install, which is `onReady` territory, not\n * an update the user should be prompted about.\n *\n * With `autoUpdate` enabled it additionally polls `registration.update()` on\n * an interval and (by default) reloads the page when a freshly activated worker\n * takes control — a framework-agnostic equivalent of `vite-plugin-pwa`'s\n * auto-update client, implemented directly on `navigator.serviceWorker`.\n *\n * @returns The registration when it succeeds, or `null` when unsupported.\n */\nexport async function registerServiceWorker(\n    options: RegisterServiceWorkerOptions,\n): Promise<ServiceWorkerRegistration | null> {\n    if (typeof navigator === \"undefined\" || !(\"serviceWorker\" in navigator)) {\n        return null;\n    }\n\n    try {\n        const registration = await navigator.serviceWorker.register(options.url, {\n            scope: options.scope,\n        });\n\n        if (registration.active) options.onReady?.(registration);\n\n        if (registration.waiting && navigator.serviceWorker.controller) {\n            announceUpdate(registration.waiting, registration, options);\n        }\n\n        registration.addEventListener(\"updatefound\", () => {\n            const installing = registration.installing;\n            if (!installing) return;\n            installing.addEventListener(\"statechange\", () => {\n                if (installing.state === \"installed\" && navigator.serviceWorker.controller) {\n                    announceUpdate(installing, registration, options);\n                }\n            });\n        });\n\n        if (options.autoUpdate) {\n            if (options.reloadOnActivate !== false) wireControllerReload();\n            const intervalMs = options.updateIntervalMs ?? DEFAULT_UPDATE_INTERVAL_MS;\n            window.setInterval(() => {\n                void registration.update();\n            }, intervalMs);\n        }\n\n        return registration;\n    } catch (error) {\n        options.onError?.(error);\n        return null;\n    }\n}\n\n/**\n * Tell a waiting worker to activate immediately. Pair with `onUpdate` to roll\n * out updates after the user confirms a reload prompt.\n */\nexport function skipWaiting(worker: ServiceWorker): void {\n    worker.postMessage({ type: \"SKIP_WAITING\" });\n}\n\n/**\n * Unregister all registered service workers for this origin.\n *\n * @returns Number of workers that were unregistered.\n */\nexport async function unregisterAllServiceWorkers(): Promise<number> {\n    if (typeof navigator === \"undefined\" || !(\"serviceWorker\" in navigator)) return 0;\n    const registrations = await navigator.serviceWorker.getRegistrations();\n    let count = 0;\n    for (const registration of registrations) {\n        const result = await registration.unregister();\n        if (result) count += 1;\n    }\n    return count;\n}\n"],"mappings":"AA0CA,IAeM,EAAmB,IAAI,QAS7B,SAAS,EACL,EACA,EACA,EACI,CACA,EAAiB,IAAI,CAAM,IAC/B,EAAiB,IAAI,CAAM,EAC3B,EAAQ,WAAW,EAAQ,CAAY,EAC3C,CAEA,IAAI,EAAwB,GAE5B,SAAS,GAA6B,CAClC,GAAI,EAAuB,OAC3B,EAAwB,GACxB,IAAI,EAAa,GACjB,UAAU,cAAc,iBAAiB,uBAA0B,CAC3D,IACJ,EAAa,GACb,OAAO,SAAS,OAAO,EAC3B,CAAC,CACL,CA4BA,eAAsB,EAClB,EACyC,CACzC,GAAI,OAAO,UAAc,KAAe,EAAE,kBAAmB,WACzD,OAAO,KAGX,GAAI,CACA,IAAM,EAAe,MAAM,UAAU,cAAc,SAAS,EAAQ,IAAK,CACrE,MAAO,EAAQ,KACnB,CAAC,EAkBD,GAhBI,EAAa,QAAQ,EAAQ,UAAU,CAAY,EAEnD,EAAa,SAAW,UAAU,cAAc,YAChD,EAAe,EAAa,QAAS,EAAc,CAAO,EAG9D,EAAa,iBAAiB,kBAAqB,CAC/C,IAAM,EAAa,EAAa,WAC3B,GACL,EAAW,iBAAiB,kBAAqB,CACzC,EAAW,QAAU,aAAe,UAAU,cAAc,YAC5D,EAAe,EAAY,EAAc,CAAO,CAExD,CAAC,CACL,CAAC,EAEG,EAAQ,WAAY,CAChB,EAAQ,mBAAqB,IAAO,EAAqB,EAC7D,IAAM,EAAa,EAAQ,kBAAoB,KAC/C,OAAO,gBAAkB,CACrB,EAAkB,OAAO,CAC7B,EAAG,CAAU,CACjB,CAEA,OAAO,CACX,OAAS,EAAO,CAEZ,OADA,EAAQ,UAAU,CAAK,EAChB,IACX,CACJ,CAMA,SAAgB,EAAY,EAA6B,CACrD,EAAO,YAAY,CAAE,KAAM,cAAe,CAAC,CAC/C,CAOA,eAAsB,GAA+C,CACjE,GAAI,OAAO,UAAc,KAAe,EAAE,kBAAmB,WAAY,MAAO,GAChF,IAAM,EAAgB,MAAM,UAAU,cAAc,iBAAiB,EACjE,EAAQ,EACZ,IAAK,IAAM,KAAgB,EAEnB,MADiB,EAAa,WAAW,IACjC,GAAS,GAEzB,OAAO,CACX"}
+{"version":3,"file":"register-service-worker.cjs","names":["announcedWorkers","announceUpdate","worker","options","registration","controllerReloadWired","wireControllerReload","refreshing","registerServiceWorker","installing","intervalMs","error","skipWaiting","unregisterAllServiceWorkers","registrations","count"],"sources":["../../src/sw/register-service-worker.ts"],"sourcesContent":["export interface RegisterServiceWorkerOptions {\n    /** Public URL of the compiled service worker file (e.g. `/sw.js`). */\n    url: string;\n    /** SW scope (default: SW directory). */\n    scope?: string;\n    /** Called once the registration is active. */\n    onReady?: (registration: ServiceWorkerRegistration) => void;\n    /**\n     * Called when a new worker has finished installing while another worker\n     * still controls the page. The host app typically prompts the user to\n     * reload and then calls {@link skipWaiting} on the returned worker.\n     *\n     * Fires for a worker that was already `waiting` when `register()` resolved\n     * — the state a user returning after a deploy actually finds — as well as\n     * for one that installs during this session, and at most once per worker.\n     */\n    onUpdate?: (waiting: ServiceWorker, registration: ServiceWorkerRegistration) => void;\n    /** Called on registration failure. */\n    onError?: (error: unknown) => void;\n    /**\n     * When `true`, poll the server for a fresh service worker on an interval\n     * (see {@link RegisterServiceWorkerOptions.updateIntervalMs}) and, unless\n     * {@link RegisterServiceWorkerOptions.reloadOnActivate} is disabled, reload\n     * the page as soon as a new worker takes control. Mirrors the auto-update\n     * behaviour of `vite-plugin-pwa` without depending on it. Default `false`.\n     */\n    autoUpdate?: boolean;\n    /**\n     * How often, in ms, to call `registration.update()` while `autoUpdate` is\n     * on. Browsers already re-check roughly every 24h; an hourly poll keeps\n     * long-lived sessions current without flooding the network. Default\n     * `3600000` (1 hour).\n     */\n    updateIntervalMs?: number;\n    /**\n     * When `autoUpdate` is on, reload the page once a new worker takes control\n     * (`controllerchange`), guarded against reload loops. Set to `false` to\n     * keep polling but leave the reload to the host app. Default `true`.\n     */\n    reloadOnActivate?: boolean;\n}\n\nconst DEFAULT_UPDATE_INTERVAL_MS = 60 * 60 * 1000;\n\n/**\n * Workers already handed to `onUpdate`, so no worker is announced twice.\n *\n * Two paths reach the same waiting worker and both are needed: `updatefound`\n * catches the worker that installs while the tab is open, and the `waiting`\n * read at registration catches the one that installed on an earlier visit. In\n * the session where a deploy lands *and* the tab stays open, both fire for the\n * same worker — without this the app prompts twice.\n *\n * Keyed by worker identity rather than by registration, so a second deploy in\n * the same session still announces: that is a different `ServiceWorker` object.\n * A `WeakSet` because the entry should die with the worker it names.\n */\nconst announcedWorkers = new WeakSet<ServiceWorker>();\n\n/**\n * Hand a waiting worker to `onUpdate`, at most once per worker.\n *\n * @param worker - The worker that finished installing.\n * @param registration - The registration it belongs to.\n * @param options - The caller's options, whose `onUpdate` is invoked.\n */\nfunction announceUpdate(\n    worker: ServiceWorker,\n    registration: ServiceWorkerRegistration,\n    options: RegisterServiceWorkerOptions,\n): void {\n    if (announcedWorkers.has(worker)) return;\n    announcedWorkers.add(worker);\n    options.onUpdate?.(worker, registration);\n}\n\nlet controllerReloadWired = false;\n\nfunction wireControllerReload(): void {\n    if (controllerReloadWired) return;\n    controllerReloadWired = true;\n    let refreshing = false;\n    navigator.serviceWorker.addEventListener(\"controllerchange\", () => {\n        if (refreshing) return;\n        refreshing = true;\n        window.location.reload();\n    });\n}\n\n/**\n * Register a service worker with consistent update-detection wiring.\n *\n * Skips silently when the runtime has no `serviceWorker` support. The host\n * app keeps full control over the SW file — this helper only handles the\n * boilerplate around `register()` and update detection.\n *\n * Two things can mean \"an update is ready\", and only one of them is an event.\n * `updatefound` covers the worker that installs while this tab is open. The\n * commoner case has no event at all: the user visited after a deploy, the new\n * worker installed and went to `waiting`, they closed the tab, and they are back\n * now. `install` already happened, so nothing fires — which is why `waiting` is\n * read directly once the registration resolves. Both routes go through the same\n * dedupe, so a worker is announced once even when both apply.\n *\n * Neither route fires without `navigator.serviceWorker.controller`: no\n * controller means this is the first install, which is `onReady` territory, not\n * an update the user should be prompted about.\n *\n * With `autoUpdate` enabled it additionally polls `registration.update()` on\n * an interval and (by default) reloads the page when a freshly activated worker\n * takes control — a framework-agnostic equivalent of `vite-plugin-pwa`'s\n * auto-update client, implemented directly on `navigator.serviceWorker`.\n *\n * @returns The registration when it succeeds, or `null` when unsupported.\n */\nexport async function registerServiceWorker(\n    options: RegisterServiceWorkerOptions,\n): Promise<ServiceWorkerRegistration | null> {\n    if (typeof navigator === \"undefined\" || !(\"serviceWorker\" in navigator)) {\n        return null;\n    }\n\n    try {\n        const registration = await navigator.serviceWorker.register(options.url, {\n            scope: options.scope,\n        });\n\n        if (registration.active) options.onReady?.(registration);\n\n        if (registration.waiting && navigator.serviceWorker.controller) {\n            announceUpdate(registration.waiting, registration, options);\n        }\n\n        registration.addEventListener(\"updatefound\", () => {\n            const installing = registration.installing;\n            if (!installing) return;\n            installing.addEventListener(\"statechange\", () => {\n                if (installing.state === \"installed\" && navigator.serviceWorker.controller) {\n                    announceUpdate(installing, registration, options);\n                }\n            });\n        });\n\n        if (options.autoUpdate) {\n            if (options.reloadOnActivate !== false) wireControllerReload();\n            const intervalMs = options.updateIntervalMs ?? DEFAULT_UPDATE_INTERVAL_MS;\n            window.setInterval(() => {\n                void registration.update();\n            }, intervalMs);\n        }\n\n        return registration;\n    } catch (error) {\n        options.onError?.(error);\n        return null;\n    }\n}\n\n/**\n * Tell a waiting worker to activate immediately. Pair with `onUpdate` to roll\n * out updates after the user confirms a reload prompt.\n */\nexport function skipWaiting(worker: ServiceWorker): void {\n    worker.postMessage({ type: \"SKIP_WAITING\" });\n}\n\n/**\n * Unregister all registered service workers for this origin.\n *\n * @returns Number of workers that were unregistered.\n */\nexport async function unregisterAllServiceWorkers(): Promise<number> {\n    if (typeof navigator === \"undefined\" || !(\"serviceWorker\" in navigator)) return 0;\n    const registrations = await navigator.serviceWorker.getRegistrations();\n    let count = 0;\n    for (const registration of registrations) {\n        const result = await registration.unregister();\n        if (result) count += 1;\n    }\n    return count;\n}\n"],"mappings":"AA0CA,IAeMA,EAAmB,IAAI,QAS7B,SAASC,EACL,EACA,EACA,EACI,CACAD,EAAiB,IAAIE,CAAM,IAC/BF,EAAiB,IAAIE,CAAM,EAC3BC,EAAQ,WAAWD,EAAQE,CAAY,EAC3C,CAEA,IAAIC,EAAwB,GAE5B,SAASC,GAA6B,CAClC,GAAID,EAAuB,OAC3B,EAAwB,GACxB,IAAIE,EAAa,GACjB,UAAU,cAAc,iBAAiB,uBAA0B,CAC3DA,IACJ,EAAa,GACb,OAAO,SAAS,OAAO,EAC3B,CAAC,CACL,CA4BA,eAAsBC,EAClB,EACyC,CACzC,GAAI,OAAO,UAAc,KAAe,EAAE,kBAAmB,WACzD,OAAO,KAGX,GAAI,CACA,IAAMJ,EAAe,MAAM,UAAU,cAAc,SAASD,EAAQ,IAAK,CACrE,MAAOA,EAAQ,KACnB,CAAC,EAkBD,GAhBIC,EAAa,QAAQD,EAAQ,UAAUC,CAAY,EAEnDA,EAAa,SAAW,UAAU,cAAc,YAChDH,EAAeG,EAAa,QAASA,EAAcD,CAAO,EAG9DC,EAAa,iBAAiB,kBAAqB,CAC/C,IAAMK,EAAaL,EAAa,WAC3BK,GACLA,EAAW,iBAAiB,kBAAqB,CACzCA,EAAW,QAAU,aAAe,UAAU,cAAc,YAC5DR,EAAeQ,EAAYL,EAAcD,CAAO,CAExD,CAAC,CACL,CAAC,EAEGA,EAAQ,WAAY,CAChBA,EAAQ,mBAAqB,IAAOG,EAAqB,EAC7D,IAAMI,EAAaP,EAAQ,kBAAoB,KAC/C,OAAO,gBAAkB,CACrBC,EAAkB,OAAO,CAC7B,EAAGM,CAAU,CACjB,CAEA,OAAON,CACX,OAASO,EAAO,CAEZ,OADAR,EAAQ,UAAUQ,CAAK,EAChB,IACX,CACJ,CAMA,SAAgBC,EAAY,EAA6B,CACrDV,EAAO,YAAY,CAAE,KAAM,cAAe,CAAC,CAC/C,CAOA,eAAsBW,GAA+C,CACjE,GAAI,OAAO,UAAc,KAAe,EAAE,kBAAmB,WAAY,MAAO,GAChF,IAAMC,EAAgB,MAAM,UAAU,cAAc,iBAAiB,EACjEC,EAAQ,EACZ,IAAK,IAAMX,KAAgBU,EAEnB,MADiBV,EAAa,WAAW,IACjC,GAAS,GAEzB,OAAOW,CACX,C"}

package/dist/sw/register-service-worker.js.map

@@ -1 +1 @@
-{"version":3,"file":"register-service-worker.js","names":[],"sources":["../../src/sw/register-service-worker.ts"],"sourcesContent":["export interface RegisterServiceWorkerOptions {\n    /** Public URL of the compiled service worker file (e.g. `/sw.js`). */\n    url: string;\n    /** SW scope (default: SW directory). */\n    scope?: string;\n    /** Called once the registration is active. */\n    onReady?: (registration: ServiceWorkerRegistration) => void;\n    /**\n     * Called when a new worker has finished installing while another worker\n     * still controls the page. The host app typically prompts the user to\n     * reload and then calls {@link skipWaiting} on the returned worker.\n     *\n     * Fires for a worker that was already `waiting` when `register()` resolved\n     * — the state a user returning after a deploy actually finds — as well as\n     * for one that installs during this session, and at most once per worker.\n     */\n    onUpdate?: (waiting: ServiceWorker, registration: ServiceWorkerRegistration) => void;\n    /** Called on registration failure. */\n    onError?: (error: unknown) => void;\n    /**\n     * When `true`, poll the server for a fresh service worker on an interval\n     * (see {@link RegisterServiceWorkerOptions.updateIntervalMs}) and, unless\n     * {@link RegisterServiceWorkerOptions.reloadOnActivate} is disabled, reload\n     * the page as soon as a new worker takes control. Mirrors the auto-update\n     * behaviour of `vite-plugin-pwa` without depending on it. Default `false`.\n     */\n    autoUpdate?: boolean;\n    /**\n     * How often, in ms, to call `registration.update()` while `autoUpdate` is\n     * on. Browsers already re-check roughly every 24h; an hourly poll keeps\n     * long-lived sessions current without flooding the network. Default\n     * `3600000` (1 hour).\n     */\n    updateIntervalMs?: number;\n    /**\n     * When `autoUpdate` is on, reload the page once a new worker takes control\n     * (`controllerchange`), guarded against reload loops. Set to `false` to\n     * keep polling but leave the reload to the host app. Default `true`.\n     */\n    reloadOnActivate?: boolean;\n}\n\nconst DEFAULT_UPDATE_INTERVAL_MS = 60 * 60 * 1000;\n\n/**\n * Workers already handed to `onUpdate`, so no worker is announced twice.\n *\n * Two paths reach the same waiting worker and both are needed: `updatefound`\n * catches the worker that installs while the tab is open, and the `waiting`\n * read at registration catches the one that installed on an earlier visit. In\n * the session where a deploy lands *and* the tab stays open, both fire for the\n * same worker — without this the app prompts twice.\n *\n * Keyed by worker identity rather than by registration, so a second deploy in\n * the same session still announces: that is a different `ServiceWorker` object.\n * A `WeakSet` because the entry should die with the worker it names.\n */\nconst announcedWorkers = new WeakSet<ServiceWorker>();\n\n/**\n * Hand a waiting worker to `onUpdate`, at most once per worker.\n *\n * @param worker - The worker that finished installing.\n * @param registration - The registration it belongs to.\n * @param options - The caller's options, whose `onUpdate` is invoked.\n */\nfunction announceUpdate(\n    worker: ServiceWorker,\n    registration: ServiceWorkerRegistration,\n    options: RegisterServiceWorkerOptions,\n): void {\n    if (announcedWorkers.has(worker)) return;\n    announcedWorkers.add(worker);\n    options.onUpdate?.(worker, registration);\n}\n\nlet controllerReloadWired = false;\n\nfunction wireControllerReload(): void {\n    if (controllerReloadWired) return;\n    controllerReloadWired = true;\n    let refreshing = false;\n    navigator.serviceWorker.addEventListener(\"controllerchange\", () => {\n        if (refreshing) return;\n        refreshing = true;\n        window.location.reload();\n    });\n}\n\n/**\n * Register a service worker with consistent update-detection wiring.\n *\n * Skips silently when the runtime has no `serviceWorker` support. The host\n * app keeps full control over the SW file — this helper only handles the\n * boilerplate around `register()` and update detection.\n *\n * Two things can mean \"an update is ready\", and only one of them is an event.\n * `updatefound` covers the worker that installs while this tab is open. The\n * commoner case has no event at all: the user visited after a deploy, the new\n * worker installed and went to `waiting`, they closed the tab, and they are back\n * now. `install` already happened, so nothing fires — which is why `waiting` is\n * read directly once the registration resolves. Both routes go through the same\n * dedupe, so a worker is announced once even when both apply.\n *\n * Neither route fires without `navigator.serviceWorker.controller`: no\n * controller means this is the first install, which is `onReady` territory, not\n * an update the user should be prompted about.\n *\n * With `autoUpdate` enabled it additionally polls `registration.update()` on\n * an interval and (by default) reloads the page when a freshly activated worker\n * takes control — a framework-agnostic equivalent of `vite-plugin-pwa`'s\n * auto-update client, implemented directly on `navigator.serviceWorker`.\n *\n * @returns The registration when it succeeds, or `null` when unsupported.\n */\nexport async function registerServiceWorker(\n    options: RegisterServiceWorkerOptions,\n): Promise<ServiceWorkerRegistration | null> {\n    if (typeof navigator === \"undefined\" || !(\"serviceWorker\" in navigator)) {\n        return null;\n    }\n\n    try {\n        const registration = await navigator.serviceWorker.register(options.url, {\n            scope: options.scope,\n        });\n\n        if (registration.active) options.onReady?.(registration);\n\n        if (registration.waiting && navigator.serviceWorker.controller) {\n            announceUpdate(registration.waiting, registration, options);\n        }\n\n        registration.addEventListener(\"updatefound\", () => {\n            const installing = registration.installing;\n            if (!installing) return;\n            installing.addEventListener(\"statechange\", () => {\n                if (installing.state === \"installed\" && navigator.serviceWorker.controller) {\n                    announceUpdate(installing, registration, options);\n                }\n            });\n        });\n\n        if (options.autoUpdate) {\n            if (options.reloadOnActivate !== false) wireControllerReload();\n            const intervalMs = options.updateIntervalMs ?? DEFAULT_UPDATE_INTERVAL_MS;\n            window.setInterval(() => {\n                void registration.update();\n            }, intervalMs);\n        }\n\n        return registration;\n    } catch (error) {\n        options.onError?.(error);\n        return null;\n    }\n}\n\n/**\n * Tell a waiting worker to activate immediately. Pair with `onUpdate` to roll\n * out updates after the user confirms a reload prompt.\n */\nexport function skipWaiting(worker: ServiceWorker): void {\n    worker.postMessage({ type: \"SKIP_WAITING\" });\n}\n\n/**\n * Unregister all registered service workers for this origin.\n *\n * @returns Number of workers that were unregistered.\n */\nexport async function unregisterAllServiceWorkers(): Promise<number> {\n    if (typeof navigator === \"undefined\" || !(\"serviceWorker\" in navigator)) return 0;\n    const registrations = await navigator.serviceWorker.getRegistrations();\n    let count = 0;\n    for (const registration of registrations) {\n        const result = await registration.unregister();\n        if (result) count += 1;\n    }\n    return count;\n}\n"],"mappings":";AA0CA,IAeM,oBAAmB,IAAI,QAAuB;AASpD,SAAS,EACL,GACA,GACA,GACI;CACA,EAAiB,IAAI,CAAM,MAC/B,EAAiB,IAAI,CAAM,GAC3B,EAAQ,WAAW,GAAQ,CAAY;AAC3C;AAEA,IAAI,IAAwB;AAE5B,SAAS,IAA6B;CAClC,IAAI,GAAuB;CAC3B,IAAwB;CACxB,IAAI,IAAa;CACjB,UAAU,cAAc,iBAAiB,0BAA0B;EAC3D,MACJ,IAAa,IACb,OAAO,SAAS,OAAO;CAC3B,CAAC;AACL;AA4BA,eAAsB,EAClB,GACyC;CACzC,IAAI,OAAO,YAAc,OAAe,EAAE,mBAAmB,YACzD,OAAO;CAGX,IAAI;EACA,IAAM,IAAe,MAAM,UAAU,cAAc,SAAS,EAAQ,KAAK,EACrE,OAAO,EAAQ,MACnB,CAAC;EAkBD,IAhBI,EAAa,UAAQ,EAAQ,UAAU,CAAY,GAEnD,EAAa,WAAW,UAAU,cAAc,cAChD,EAAe,EAAa,SAAS,GAAc,CAAO,GAG9D,EAAa,iBAAiB,qBAAqB;GAC/C,IAAM,IAAa,EAAa;GAC3B,KACL,EAAW,iBAAiB,qBAAqB;IAC7C,AAAI,EAAW,UAAU,eAAe,UAAU,cAAc,cAC5D,EAAe,GAAY,GAAc,CAAO;GAExD,CAAC;EACL,CAAC,GAEG,EAAQ,YAAY;GACpB,AAAI,EAAQ,qBAAqB,MAAO,EAAqB;GAC7D,IAAM,IAAa,EAAQ,oBAAoB;GAC/C,OAAO,kBAAkB;IACrB,EAAkB,OAAO;GAC7B,GAAG,CAAU;EACjB;EAEA,OAAO;CACX,SAAS,GAAO;EAEZ,OADA,EAAQ,UAAU,CAAK,GAChB;CACX;AACJ;AAMA,SAAgB,EAAY,GAA6B;CACrD,EAAO,YAAY,EAAE,MAAM,eAAe,CAAC;AAC/C;AAOA,eAAsB,IAA+C;CACjE,IAAI,OAAO,YAAc,OAAe,EAAE,mBAAmB,YAAY,OAAO;CAChF,IAAM,IAAgB,MAAM,UAAU,cAAc,iBAAiB,GACjE,IAAQ;CACZ,KAAK,IAAM,KAAgB,GAEvB,AAAI,MADiB,EAAa,WAAW,MACjC,KAAS;CAEzB,OAAO;AACX"}
+{"version":3,"file":"register-service-worker.js","names":["announcedWorkers","announceUpdate","worker","options","registration","controllerReloadWired","wireControllerReload","refreshing","registerServiceWorker","installing","intervalMs","error","skipWaiting","unregisterAllServiceWorkers","registrations","count"],"sources":["../../src/sw/register-service-worker.ts"],"sourcesContent":["export interface RegisterServiceWorkerOptions {\n    /** Public URL of the compiled service worker file (e.g. `/sw.js`). */\n    url: string;\n    /** SW scope (default: SW directory). */\n    scope?: string;\n    /** Called once the registration is active. */\n    onReady?: (registration: ServiceWorkerRegistration) => void;\n    /**\n     * Called when a new worker has finished installing while another worker\n     * still controls the page. The host app typically prompts the user to\n     * reload and then calls {@link skipWaiting} on the returned worker.\n     *\n     * Fires for a worker that was already `waiting` when `register()` resolved\n     * — the state a user returning after a deploy actually finds — as well as\n     * for one that installs during this session, and at most once per worker.\n     */\n    onUpdate?: (waiting: ServiceWorker, registration: ServiceWorkerRegistration) => void;\n    /** Called on registration failure. */\n    onError?: (error: unknown) => void;\n    /**\n     * When `true`, poll the server for a fresh service worker on an interval\n     * (see {@link RegisterServiceWorkerOptions.updateIntervalMs}) and, unless\n     * {@link RegisterServiceWorkerOptions.reloadOnActivate} is disabled, reload\n     * the page as soon as a new worker takes control. Mirrors the auto-update\n     * behaviour of `vite-plugin-pwa` without depending on it. Default `false`.\n     */\n    autoUpdate?: boolean;\n    /**\n     * How often, in ms, to call `registration.update()` while `autoUpdate` is\n     * on. Browsers already re-check roughly every 24h; an hourly poll keeps\n     * long-lived sessions current without flooding the network. Default\n     * `3600000` (1 hour).\n     */\n    updateIntervalMs?: number;\n    /**\n     * When `autoUpdate` is on, reload the page once a new worker takes control\n     * (`controllerchange`), guarded against reload loops. Set to `false` to\n     * keep polling but leave the reload to the host app. Default `true`.\n     */\n    reloadOnActivate?: boolean;\n}\n\nconst DEFAULT_UPDATE_INTERVAL_MS = 60 * 60 * 1000;\n\n/**\n * Workers already handed to `onUpdate`, so no worker is announced twice.\n *\n * Two paths reach the same waiting worker and both are needed: `updatefound`\n * catches the worker that installs while the tab is open, and the `waiting`\n * read at registration catches the one that installed on an earlier visit. In\n * the session where a deploy lands *and* the tab stays open, both fire for the\n * same worker — without this the app prompts twice.\n *\n * Keyed by worker identity rather than by registration, so a second deploy in\n * the same session still announces: that is a different `ServiceWorker` object.\n * A `WeakSet` because the entry should die with the worker it names.\n */\nconst announcedWorkers = new WeakSet<ServiceWorker>();\n\n/**\n * Hand a waiting worker to `onUpdate`, at most once per worker.\n *\n * @param worker - The worker that finished installing.\n * @param registration - The registration it belongs to.\n * @param options - The caller's options, whose `onUpdate` is invoked.\n */\nfunction announceUpdate(\n    worker: ServiceWorker,\n    registration: ServiceWorkerRegistration,\n    options: RegisterServiceWorkerOptions,\n): void {\n    if (announcedWorkers.has(worker)) return;\n    announcedWorkers.add(worker);\n    options.onUpdate?.(worker, registration);\n}\n\nlet controllerReloadWired = false;\n\nfunction wireControllerReload(): void {\n    if (controllerReloadWired) return;\n    controllerReloadWired = true;\n    let refreshing = false;\n    navigator.serviceWorker.addEventListener(\"controllerchange\", () => {\n        if (refreshing) return;\n        refreshing = true;\n        window.location.reload();\n    });\n}\n\n/**\n * Register a service worker with consistent update-detection wiring.\n *\n * Skips silently when the runtime has no `serviceWorker` support. The host\n * app keeps full control over the SW file — this helper only handles the\n * boilerplate around `register()` and update detection.\n *\n * Two things can mean \"an update is ready\", and only one of them is an event.\n * `updatefound` covers the worker that installs while this tab is open. The\n * commoner case has no event at all: the user visited after a deploy, the new\n * worker installed and went to `waiting`, they closed the tab, and they are back\n * now. `install` already happened, so nothing fires — which is why `waiting` is\n * read directly once the registration resolves. Both routes go through the same\n * dedupe, so a worker is announced once even when both apply.\n *\n * Neither route fires without `navigator.serviceWorker.controller`: no\n * controller means this is the first install, which is `onReady` territory, not\n * an update the user should be prompted about.\n *\n * With `autoUpdate` enabled it additionally polls `registration.update()` on\n * an interval and (by default) reloads the page when a freshly activated worker\n * takes control — a framework-agnostic equivalent of `vite-plugin-pwa`'s\n * auto-update client, implemented directly on `navigator.serviceWorker`.\n *\n * @returns The registration when it succeeds, or `null` when unsupported.\n */\nexport async function registerServiceWorker(\n    options: RegisterServiceWorkerOptions,\n): Promise<ServiceWorkerRegistration | null> {\n    if (typeof navigator === \"undefined\" || !(\"serviceWorker\" in navigator)) {\n        return null;\n    }\n\n    try {\n        const registration = await navigator.serviceWorker.register(options.url, {\n            scope: options.scope,\n        });\n\n        if (registration.active) options.onReady?.(registration);\n\n        if (registration.waiting && navigator.serviceWorker.controller) {\n            announceUpdate(registration.waiting, registration, options);\n        }\n\n        registration.addEventListener(\"updatefound\", () => {\n            const installing = registration.installing;\n            if (!installing) return;\n            installing.addEventListener(\"statechange\", () => {\n                if (installing.state === \"installed\" && navigator.serviceWorker.controller) {\n                    announceUpdate(installing, registration, options);\n                }\n            });\n        });\n\n        if (options.autoUpdate) {\n            if (options.reloadOnActivate !== false) wireControllerReload();\n            const intervalMs = options.updateIntervalMs ?? DEFAULT_UPDATE_INTERVAL_MS;\n            window.setInterval(() => {\n                void registration.update();\n            }, intervalMs);\n        }\n\n        return registration;\n    } catch (error) {\n        options.onError?.(error);\n        return null;\n    }\n}\n\n/**\n * Tell a waiting worker to activate immediately. Pair with `onUpdate` to roll\n * out updates after the user confirms a reload prompt.\n */\nexport function skipWaiting(worker: ServiceWorker): void {\n    worker.postMessage({ type: \"SKIP_WAITING\" });\n}\n\n/**\n * Unregister all registered service workers for this origin.\n *\n * @returns Number of workers that were unregistered.\n */\nexport async function unregisterAllServiceWorkers(): Promise<number> {\n    if (typeof navigator === \"undefined\" || !(\"serviceWorker\" in navigator)) return 0;\n    const registrations = await navigator.serviceWorker.getRegistrations();\n    let count = 0;\n    for (const registration of registrations) {\n        const result = await registration.unregister();\n        if (result) count += 1;\n    }\n    return count;\n}\n"],"mappings":";AA0CA,IAeMA,oBAAmB,IAAI,QAAuB;AASpD,SAASC,EACL,GACA,GACA,GACI;CACJ,AAAID,EAAiB,IAAIE,CAAM,MAC/BF,EAAiB,IAAIE,CAAM,GAC3BC,EAAQ,WAAWD,GAAQE,CAAY;AAC3C;AAEA,IAAIC,IAAwB;AAE5B,SAASC,IAA6B;CAClC,IAAID,GAAuB;CAC3B,IAAwB;CACxB,IAAIE,IAAa;CACjB,UAAU,cAAc,iBAAiB,0BAA0B;EAC/D,AAAIA,MACJ,IAAa,IACb,OAAO,SAAS,OAAO;CAC3B,CAAC;AACL;AA4BA,eAAsBC,EAClB,GACyC;CACzC,IAAI,OAAO,YAAc,OAAe,EAAE,mBAAmB,YACzD,OAAO;CAGX,IAAI;EACA,IAAMJ,IAAe,MAAM,UAAU,cAAc,SAASD,EAAQ,KAAK,EACrE,OAAOA,EAAQ,MACnB,CAAC;EAkBD,IAhBIC,EAAa,UAAQD,EAAQ,UAAUC,CAAY,GAEnDA,EAAa,WAAW,UAAU,cAAc,cAChDH,EAAeG,EAAa,SAASA,GAAcD,CAAO,GAG9DC,EAAa,iBAAiB,qBAAqB;GAC/C,IAAMK,IAAaL,EAAa;GAChC,AAAKK,KACLA,EAAW,iBAAiB,qBAAqB;IAC7C,AAAIA,EAAW,UAAU,eAAe,UAAU,cAAc,cAC5DR,EAAeQ,GAAYL,GAAcD,CAAO;GAExD,CAAC;EACL,CAAC,GAEGA,EAAQ,YAAY;GACpB,AAAIA,EAAQ,qBAAqB,MAAOG,EAAqB;GAC7D,IAAMI,IAAaP,EAAQ,oBAAoB;GAC/C,OAAO,kBAAkB;IACrB,EAAkB,OAAO;GAC7B,GAAGO,CAAU;EACjB;EAEA,OAAON;CACX,SAASO,GAAO;EAEZ,OADAR,EAAQ,UAAUQ,CAAK,GAChB;CACX;AACJ;AAMA,SAAgBC,EAAY,GAA6B;CACrD,EAAO,YAAY,EAAE,MAAM,eAAe,CAAC;AAC/C;AAOA,eAAsBC,IAA+C;CACjE,IAAI,OAAO,YAAc,OAAe,EAAE,mBAAmB,YAAY,OAAO;CAChF,IAAMC,IAAgB,MAAM,UAAU,cAAc,iBAAiB,GACjEC,IAAQ;CACZ,KAAK,IAAMX,KAAgBU,GAEvB,AAAI,MADiBV,EAAa,WAAW,MACjC,KAAS;CAEzB,OAAOW;AACX"}

package/dist/sw/session-data.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"session-data.cjs","names":[],"sources":["../../src/sw/session-data.ts"],"sourcesContent":["import { clearBackgroundSyncQueue } from \"./background-sync\";\nimport { clearCaches } from \"./cache-inspect\";\nimport type { CacheFilter } from \"./cache-inspect\";\n\n/** Options for {@link clearSessionData}. */\nexport interface ClearSessionDataOptions {\n    /**\n     * Which Cache Storage buckets hold session data. Default: every bucket except\n     * the app-shell precache (`tempest-precache-*`), so the app still launches\n     * offline after logout while no runtime entry — whatever its `cacheName` —\n     * survives into the next session.\n     */\n    caches?: CacheFilter;\n    /** The background-sync `queueName` to clear. Default `tempest-bg-sync`. */\n    queueName?: string;\n}\n\n/** What {@link clearSessionData} removed. */\nexport interface ClearSessionDataResult {\n    /** Names of the Cache Storage buckets deleted. */\n    caches: string[];\n    /** Whether the background-sync queue was emptied. */\n    queueCleared: boolean;\n}\n\n/** Default cache filter: everything but the versioned app-shell precache. */\nfunction isSessionCache(name: string): boolean {\n    return !name.startsWith(\"tempest-precache-\");\n}\n\n/**\n * Remove everything the service-worker helpers keep on behalf of the signed-in\n * user: the runtime caches filled by `installRuntimeCache` and the queue of\n * mutations waiting in `installBackgroundSync`. Call it on logout, from the page.\n *\n * Both stores outlive the session and are shared by every account that signs in\n * on the browser. Measured in Chromium 153 (11/10/2026), before this existed:\n * the documented `clearCaches(\"tempest-\")` deleted nothing because the recipe's\n * runtime cache was named `api`, the next account read the previous account's\n * `GET /api/me` offline, and a mutation queued by the previous account was\n * replayed with its stored bearer after logout. A prefix filter cannot know the\n * names a recipe chose, so the default here inverts it: every bucket goes except\n * the precache, which holds only the build's static assets.\n *\n * Cache Storage and IndexedDB are origin storage, readable from the window, so\n * this needs no message to the worker.\n *\n * @param options - Narrow the caches to delete, or name a custom queue.\n * @returns The caches deleted and whether the queue was cleared.\n *\n * @example\n * import { clearSessionData } from \"tempest-react-sdk/sw\";\n *\n * async function logout() {\n *     await clearSessionData();\n * }\n */\nexport async function clearSessionData(\n    options: ClearSessionDataOptions = {},\n): Promise<ClearSessionDataResult> {\n    const [caches, queueCleared] = await Promise.all([\n        clearCaches(options.caches ?? isSessionCache),\n        clearBackgroundSyncQueue(options.queueName),\n    ]);\n    return { caches, queueCleared };\n}\n"],"mappings":"0EA0BA,SAAS,EAAe,EAAuB,CAC3C,MAAO,CAAC,EAAK,WAAW,mBAAmB,CAC/C,CA6BA,eAAsB,EAClB,EAAmC,CAAC,EACL,CAC/B,GAAM,CAAC,EAAQ,GAAgB,MAAM,QAAQ,IAAI,CAC7C,EAAA,YAAY,EAAQ,QAAU,CAAc,EAC5C,EAAA,yBAAyB,EAAQ,SAAS,CAC9C,CAAC,EACD,MAAO,CAAE,SAAQ,cAAa,CAClC"}
+{"version":3,"file":"session-data.cjs","names":["clearCaches","clearBackgroundSyncQueue","require_background_sync","require_cache_inspect","isSessionCache","name","clearSessionData","caches","queueCleared","options"],"sources":["../../src/sw/session-data.ts"],"sourcesContent":["import { clearBackgroundSyncQueue } from \"./background-sync\";\nimport { clearCaches } from \"./cache-inspect\";\nimport type { CacheFilter } from \"./cache-inspect\";\n\n/** Options for {@link clearSessionData}. */\nexport interface ClearSessionDataOptions {\n    /**\n     * Which Cache Storage buckets hold session data. Default: every bucket except\n     * the app-shell precache (`tempest-precache-*`), so the app still launches\n     * offline after logout while no runtime entry — whatever its `cacheName` —\n     * survives into the next session.\n     */\n    caches?: CacheFilter;\n    /** The background-sync `queueName` to clear. Default `tempest-bg-sync`. */\n    queueName?: string;\n}\n\n/** What {@link clearSessionData} removed. */\nexport interface ClearSessionDataResult {\n    /** Names of the Cache Storage buckets deleted. */\n    caches: string[];\n    /** Whether the background-sync queue was emptied. */\n    queueCleared: boolean;\n}\n\n/** Default cache filter: everything but the versioned app-shell precache. */\nfunction isSessionCache(name: string): boolean {\n    return !name.startsWith(\"tempest-precache-\");\n}\n\n/**\n * Remove everything the service-worker helpers keep on behalf of the signed-in\n * user: the runtime caches filled by `installRuntimeCache` and the queue of\n * mutations waiting in `installBackgroundSync`. Call it on logout, from the page.\n *\n * Both stores outlive the session and are shared by every account that signs in\n * on the browser. Measured in Chromium 153 (11/10/2026), before this existed:\n * the documented `clearCaches(\"tempest-\")` deleted nothing because the recipe's\n * runtime cache was named `api`, the next account read the previous account's\n * `GET /api/me` offline, and a mutation queued by the previous account was\n * replayed with its stored bearer after logout. A prefix filter cannot know the\n * names a recipe chose, so the default here inverts it: every bucket goes except\n * the precache, which holds only the build's static assets.\n *\n * Cache Storage and IndexedDB are origin storage, readable from the window, so\n * this needs no message to the worker.\n *\n * @param options - Narrow the caches to delete, or name a custom queue.\n * @returns The caches deleted and whether the queue was cleared.\n *\n * @example\n * import { clearSessionData } from \"tempest-react-sdk/sw\";\n *\n * async function logout() {\n *     await clearSessionData();\n * }\n */\nexport async function clearSessionData(\n    options: ClearSessionDataOptions = {},\n): Promise<ClearSessionDataResult> {\n    const [caches, queueCleared] = await Promise.all([\n        clearCaches(options.caches ?? isSessionCache),\n        clearBackgroundSyncQueue(options.queueName),\n    ]);\n    return { caches, queueCleared };\n}\n"],"mappings":"A,0EA0BA,SAASI,EAAe,EAAuB,CAC3C,MAAO,CAACC,EAAK,WAAW,mBAAmB,CAC/C,CA6BA,eAAsBC,EAClB,EAAmC,CAAC,EACL,CAC/B,GAAM,CAACC,EAAQC,GAAgB,MAAM,QAAQ,IAAI,CAC7CR,EAAAA,YAAYS,EAAQ,QAAUL,CAAc,EAC5CH,EAAAA,yBAAyBQ,EAAQ,SAAS,CAC9C,CAAC,EACD,MAAO,CAAE,SAAQ,cAAa,CAClC,C"}

package/dist/sw/session-data.js.map

@@ -1 +1 @@
-{"version":3,"file":"session-data.js","names":[],"sources":["../../src/sw/session-data.ts"],"sourcesContent":["import { clearBackgroundSyncQueue } from \"./background-sync\";\nimport { clearCaches } from \"./cache-inspect\";\nimport type { CacheFilter } from \"./cache-inspect\";\n\n/** Options for {@link clearSessionData}. */\nexport interface ClearSessionDataOptions {\n    /**\n     * Which Cache Storage buckets hold session data. Default: every bucket except\n     * the app-shell precache (`tempest-precache-*`), so the app still launches\n     * offline after logout while no runtime entry — whatever its `cacheName` —\n     * survives into the next session.\n     */\n    caches?: CacheFilter;\n    /** The background-sync `queueName` to clear. Default `tempest-bg-sync`. */\n    queueName?: string;\n}\n\n/** What {@link clearSessionData} removed. */\nexport interface ClearSessionDataResult {\n    /** Names of the Cache Storage buckets deleted. */\n    caches: string[];\n    /** Whether the background-sync queue was emptied. */\n    queueCleared: boolean;\n}\n\n/** Default cache filter: everything but the versioned app-shell precache. */\nfunction isSessionCache(name: string): boolean {\n    return !name.startsWith(\"tempest-precache-\");\n}\n\n/**\n * Remove everything the service-worker helpers keep on behalf of the signed-in\n * user: the runtime caches filled by `installRuntimeCache` and the queue of\n * mutations waiting in `installBackgroundSync`. Call it on logout, from the page.\n *\n * Both stores outlive the session and are shared by every account that signs in\n * on the browser. Measured in Chromium 153 (11/10/2026), before this existed:\n * the documented `clearCaches(\"tempest-\")` deleted nothing because the recipe's\n * runtime cache was named `api`, the next account read the previous account's\n * `GET /api/me` offline, and a mutation queued by the previous account was\n * replayed with its stored bearer after logout. A prefix filter cannot know the\n * names a recipe chose, so the default here inverts it: every bucket goes except\n * the precache, which holds only the build's static assets.\n *\n * Cache Storage and IndexedDB are origin storage, readable from the window, so\n * this needs no message to the worker.\n *\n * @param options - Narrow the caches to delete, or name a custom queue.\n * @returns The caches deleted and whether the queue was cleared.\n *\n * @example\n * import { clearSessionData } from \"tempest-react-sdk/sw\";\n *\n * async function logout() {\n *     await clearSessionData();\n * }\n */\nexport async function clearSessionData(\n    options: ClearSessionDataOptions = {},\n): Promise<ClearSessionDataResult> {\n    const [caches, queueCleared] = await Promise.all([\n        clearCaches(options.caches ?? isSessionCache),\n        clearBackgroundSyncQueue(options.queueName),\n    ]);\n    return { caches, queueCleared };\n}\n"],"mappings":";;;AA0BA,SAAS,EAAe,GAAuB;CAC3C,OAAO,CAAC,EAAK,WAAW,mBAAmB;AAC/C;AA6BA,eAAsB,EAClB,IAAmC,CAAC,GACL;CAC/B,IAAM,CAAC,GAAQ,KAAgB,MAAM,QAAQ,IAAI,CAC7C,EAAY,EAAQ,UAAU,CAAc,GAC5C,EAAyB,EAAQ,SAAS,CAC9C,CAAC;CACD,OAAO;EAAE;EAAQ;CAAa;AAClC"}
+{"version":3,"file":"session-data.js","names":["isSessionCache","name","clearSessionData","caches","queueCleared","clearCaches","options","clearBackgroundSyncQueue"],"sources":["../../src/sw/session-data.ts"],"sourcesContent":["import { clearBackgroundSyncQueue } from \"./background-sync\";\nimport { clearCaches } from \"./cache-inspect\";\nimport type { CacheFilter } from \"./cache-inspect\";\n\n/** Options for {@link clearSessionData}. */\nexport interface ClearSessionDataOptions {\n    /**\n     * Which Cache Storage buckets hold session data. Default: every bucket except\n     * the app-shell precache (`tempest-precache-*`), so the app still launches\n     * offline after logout while no runtime entry — whatever its `cacheName` —\n     * survives into the next session.\n     */\n    caches?: CacheFilter;\n    /** The background-sync `queueName` to clear. Default `tempest-bg-sync`. */\n    queueName?: string;\n}\n\n/** What {@link clearSessionData} removed. */\nexport interface ClearSessionDataResult {\n    /** Names of the Cache Storage buckets deleted. */\n    caches: string[];\n    /** Whether the background-sync queue was emptied. */\n    queueCleared: boolean;\n}\n\n/** Default cache filter: everything but the versioned app-shell precache. */\nfunction isSessionCache(name: string): boolean {\n    return !name.startsWith(\"tempest-precache-\");\n}\n\n/**\n * Remove everything the service-worker helpers keep on behalf of the signed-in\n * user: the runtime caches filled by `installRuntimeCache` and the queue of\n * mutations waiting in `installBackgroundSync`. Call it on logout, from the page.\n *\n * Both stores outlive the session and are shared by every account that signs in\n * on the browser. Measured in Chromium 153 (11/10/2026), before this existed:\n * the documented `clearCaches(\"tempest-\")` deleted nothing because the recipe's\n * runtime cache was named `api`, the next account read the previous account's\n * `GET /api/me` offline, and a mutation queued by the previous account was\n * replayed with its stored bearer after logout. A prefix filter cannot know the\n * names a recipe chose, so the default here inverts it: every bucket goes except\n * the precache, which holds only the build's static assets.\n *\n * Cache Storage and IndexedDB are origin storage, readable from the window, so\n * this needs no message to the worker.\n *\n * @param options - Narrow the caches to delete, or name a custom queue.\n * @returns The caches deleted and whether the queue was cleared.\n *\n * @example\n * import { clearSessionData } from \"tempest-react-sdk/sw\";\n *\n * async function logout() {\n *     await clearSessionData();\n * }\n */\nexport async function clearSessionData(\n    options: ClearSessionDataOptions = {},\n): Promise<ClearSessionDataResult> {\n    const [caches, queueCleared] = await Promise.all([\n        clearCaches(options.caches ?? isSessionCache),\n        clearBackgroundSyncQueue(options.queueName),\n    ]);\n    return { caches, queueCleared };\n}\n"],"mappings":";;;AA0BA,SAASA,EAAe,GAAuB;CAC3C,OAAO,CAACC,EAAK,WAAW,mBAAmB;AAC/C;AA6BA,eAAsBC,EAClB,IAAmC,CAAC,GACL;CAC/B,IAAM,CAACC,GAAQC,KAAgB,MAAM,QAAQ,IAAI,CAC7CC,EAAYC,EAAQ,UAAUN,CAAc,GAC5CO,EAAyBD,EAAQ,SAAS,CAC9C,CAAC;CACD,OAAO;EAAE;EAAQ;CAAa;AAClC"}

package/dist/tabular/assets.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"assets.cjs","names":[],"sources":["../../src/tabular/assets.ts"],"sourcesContent":["/**\n * The runtime's own assets, which are the other half of working offline.\n *\n * ONNX Runtime Web does **not** embed its WebAssembly binary, not even in\n * the `.bundle` builds. Measured in Chromium: the default entry fetches\n * `ort-wasm-simd-threaded.jsep.wasm` at session creation, and serving the\n * app without that file fails with `Aborted(both async and sync fetching of\n * the wasm failed)` — an error that says nothing about the missing file.\n *\n * So an offline app has to ship those binaries and precache them. This\n * module names them and points the runtime at a local directory.\n *\n * It does **not** import `onnxruntime-web`. An app on the compact route\n * (`CompactPredictor`) has no runtime at all, and a module that imported\n * one at load time would force every consumer of this subpath to install\n * the peer — which is exactly the cost that route exists to avoid. The\n * configured path is remembered here and applied by the ONNX predictor,\n * which imports the runtime only when it actually loads a model.\n */\n\n/**\n * The WebAssembly binaries ONNX Runtime Web may request.\n *\n * Which one is fetched depends on the browser's threading and SIMD support,\n * so an app that must work everywhere ships all of them. Chromium with the\n * default entry point fetched the `jsep` build.\n */\nexport const ORT_WASM_ASSETS: readonly string[] = [\n    \"ort-wasm-simd-threaded.wasm\",\n    \"ort-wasm-simd-threaded.mjs\",\n    \"ort-wasm-simd-threaded.jsep.wasm\",\n    \"ort-wasm-simd-threaded.jsep.mjs\",\n];\n\nlet configuredPath: string | undefined;\n\n/**\n * Point ONNX Runtime Web at locally served WebAssembly binaries.\n *\n * Call once, before creating any predictor.\n *\n * @example\n * ```ts\n * configureOrtAssets(\"/ort/\");\n * const predictor = await TabularPredictor.create(\"/models/classifier.onnx\");\n * ```\n *\n * @param basePath Directory the binaries are served from, with a trailing\n *   slash. Copy them there at build time — for Vite, from\n *   `node_modules/onnxruntime-web/dist/`.\n */\nexport function configureOrtAssets(basePath: string): void {\n    configuredPath = basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n}\n\n/**\n * Where the runtime's binaries were said to live.\n *\n * Read by the ONNX predictor just before it creates a session, which is\n * the first moment the runtime exists to be configured.\n *\n * @returns The configured directory, or `undefined` when none was set.\n */\nexport function configuredOrtAssetPath(): string | undefined {\n    return configuredPath;\n}\n\n/**\n * The URLs a service worker should precache for offline inference.\n *\n * The model file is not included: it is cached by\n * {@link fetchModelBytes} on first use, under its own bucket.\n *\n * @example\n * ```ts\n * installPrecache([...ortAssetUrls(\"/ort/\"), \"/index.html\"]);\n * ```\n *\n * @param basePath Directory the binaries are served from.\n * @returns Absolute-from-root URLs for every runtime asset.\n */\nexport function ortAssetUrls(basePath: string): string[] {\n    const prefix = basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n    return ORT_WASM_ASSETS.map((asset) => `${prefix}${asset}`);\n}\n"],"mappings":"AA2BA,IAAa,EAAqC,CAC9C,8BACA,6BACA,mCACA,iCACJ,EAEI,EAiBJ,SAAgB,EAAmB,EAAwB,CACvD,EAAiB,EAAS,SAAS,GAAG,EAAI,EAAW,GAAG,EAAS,EACrE,CAUA,SAAgB,GAA6C,CACzD,OAAO,CACX,CAgBA,SAAgB,EAAa,EAA4B,CACrD,IAAM,EAAS,EAAS,SAAS,GAAG,EAAI,EAAW,GAAG,EAAS,GAC/D,OAAO,EAAgB,IAAK,GAAU,GAAG,IAAS,GAAO,CAC7D"}
+{"version":3,"file":"assets.cjs","names":["ORT_WASM_ASSETS","configuredPath","configureOrtAssets","basePath","configuredOrtAssetPath","ortAssetUrls","prefix","asset"],"sources":["../../src/tabular/assets.ts"],"sourcesContent":["/**\n * The runtime's own assets, which are the other half of working offline.\n *\n * ONNX Runtime Web does **not** embed its WebAssembly binary, not even in\n * the `.bundle` builds. Measured in Chromium: the default entry fetches\n * `ort-wasm-simd-threaded.jsep.wasm` at session creation, and serving the\n * app without that file fails with `Aborted(both async and sync fetching of\n * the wasm failed)` — an error that says nothing about the missing file.\n *\n * So an offline app has to ship those binaries and precache them. This\n * module names them and points the runtime at a local directory.\n *\n * It does **not** import `onnxruntime-web`. An app on the compact route\n * (`CompactPredictor`) has no runtime at all, and a module that imported\n * one at load time would force every consumer of this subpath to install\n * the peer — which is exactly the cost that route exists to avoid. The\n * configured path is remembered here and applied by the ONNX predictor,\n * which imports the runtime only when it actually loads a model.\n */\n\n/**\n * The WebAssembly binaries ONNX Runtime Web may request.\n *\n * Which one is fetched depends on the browser's threading and SIMD support,\n * so an app that must work everywhere ships all of them. Chromium with the\n * default entry point fetched the `jsep` build.\n */\nexport const ORT_WASM_ASSETS: readonly string[] = [\n    \"ort-wasm-simd-threaded.wasm\",\n    \"ort-wasm-simd-threaded.mjs\",\n    \"ort-wasm-simd-threaded.jsep.wasm\",\n    \"ort-wasm-simd-threaded.jsep.mjs\",\n];\n\nlet configuredPath: string | undefined;\n\n/**\n * Point ONNX Runtime Web at locally served WebAssembly binaries.\n *\n * Call once, before creating any predictor.\n *\n * @example\n * ```ts\n * configureOrtAssets(\"/ort/\");\n * const predictor = await TabularPredictor.create(\"/models/classifier.onnx\");\n * ```\n *\n * @param basePath Directory the binaries are served from, with a trailing\n *   slash. Copy them there at build time — for Vite, from\n *   `node_modules/onnxruntime-web/dist/`.\n */\nexport function configureOrtAssets(basePath: string): void {\n    configuredPath = basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n}\n\n/**\n * Where the runtime's binaries were said to live.\n *\n * Read by the ONNX predictor just before it creates a session, which is\n * the first moment the runtime exists to be configured.\n *\n * @returns The configured directory, or `undefined` when none was set.\n */\nexport function configuredOrtAssetPath(): string | undefined {\n    return configuredPath;\n}\n\n/**\n * The URLs a service worker should precache for offline inference.\n *\n * The model file is not included: it is cached by\n * {@link fetchModelBytes} on first use, under its own bucket.\n *\n * @example\n * ```ts\n * installPrecache([...ortAssetUrls(\"/ort/\"), \"/index.html\"]);\n * ```\n *\n * @param basePath Directory the binaries are served from.\n * @returns Absolute-from-root URLs for every runtime asset.\n */\nexport function ortAssetUrls(basePath: string): string[] {\n    const prefix = basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n    return ORT_WASM_ASSETS.map((asset) => `${prefix}${asset}`);\n}\n"],"mappings":"AA2BA,IAAaA,EAAqC,CAC9C,8BACA,6BACA,mCACA,iCACJ,EAEIC,EAiBJ,SAAgBC,EAAmB,EAAwB,CACvD,EAAiBC,EAAS,SAAS,GAAG,EAAIA,EAAW,GAAGA,EAAS,EACrE,CAUA,SAAgBC,GAA6C,CACzD,OAAOH,CACX,CAgBA,SAAgBI,EAAa,EAA4B,CACrD,IAAMC,EAASH,EAAS,SAAS,GAAG,EAAIA,EAAW,GAAGA,EAAS,GAC/D,OAAOH,EAAgB,IAAK,GAAU,GAAGM,IAASC,GAAO,CAC7D,C"}

package/dist/tabular/assets.js.map

@@ -1 +1 @@
-{"version":3,"file":"assets.js","names":[],"sources":["../../src/tabular/assets.ts"],"sourcesContent":["/**\n * The runtime's own assets, which are the other half of working offline.\n *\n * ONNX Runtime Web does **not** embed its WebAssembly binary, not even in\n * the `.bundle` builds. Measured in Chromium: the default entry fetches\n * `ort-wasm-simd-threaded.jsep.wasm` at session creation, and serving the\n * app without that file fails with `Aborted(both async and sync fetching of\n * the wasm failed)` — an error that says nothing about the missing file.\n *\n * So an offline app has to ship those binaries and precache them. This\n * module names them and points the runtime at a local directory.\n *\n * It does **not** import `onnxruntime-web`. An app on the compact route\n * (`CompactPredictor`) has no runtime at all, and a module that imported\n * one at load time would force every consumer of this subpath to install\n * the peer — which is exactly the cost that route exists to avoid. The\n * configured path is remembered here and applied by the ONNX predictor,\n * which imports the runtime only when it actually loads a model.\n */\n\n/**\n * The WebAssembly binaries ONNX Runtime Web may request.\n *\n * Which one is fetched depends on the browser's threading and SIMD support,\n * so an app that must work everywhere ships all of them. Chromium with the\n * default entry point fetched the `jsep` build.\n */\nexport const ORT_WASM_ASSETS: readonly string[] = [\n    \"ort-wasm-simd-threaded.wasm\",\n    \"ort-wasm-simd-threaded.mjs\",\n    \"ort-wasm-simd-threaded.jsep.wasm\",\n    \"ort-wasm-simd-threaded.jsep.mjs\",\n];\n\nlet configuredPath: string | undefined;\n\n/**\n * Point ONNX Runtime Web at locally served WebAssembly binaries.\n *\n * Call once, before creating any predictor.\n *\n * @example\n * ```ts\n * configureOrtAssets(\"/ort/\");\n * const predictor = await TabularPredictor.create(\"/models/classifier.onnx\");\n * ```\n *\n * @param basePath Directory the binaries are served from, with a trailing\n *   slash. Copy them there at build time — for Vite, from\n *   `node_modules/onnxruntime-web/dist/`.\n */\nexport function configureOrtAssets(basePath: string): void {\n    configuredPath = basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n}\n\n/**\n * Where the runtime's binaries were said to live.\n *\n * Read by the ONNX predictor just before it creates a session, which is\n * the first moment the runtime exists to be configured.\n *\n * @returns The configured directory, or `undefined` when none was set.\n */\nexport function configuredOrtAssetPath(): string | undefined {\n    return configuredPath;\n}\n\n/**\n * The URLs a service worker should precache for offline inference.\n *\n * The model file is not included: it is cached by\n * {@link fetchModelBytes} on first use, under its own bucket.\n *\n * @example\n * ```ts\n * installPrecache([...ortAssetUrls(\"/ort/\"), \"/index.html\"]);\n * ```\n *\n * @param basePath Directory the binaries are served from.\n * @returns Absolute-from-root URLs for every runtime asset.\n */\nexport function ortAssetUrls(basePath: string): string[] {\n    const prefix = basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n    return ORT_WASM_ASSETS.map((asset) => `${prefix}${asset}`);\n}\n"],"mappings":";AA2BA,IAAa,IAAqC;CAC9C;CACA;CACA;CACA;AACJ,GAEI;AAiBJ,SAAgB,EAAmB,GAAwB;CACvD,IAAiB,EAAS,SAAS,GAAG,IAAI,IAAW,GAAG,EAAS;AACrE;AAUA,SAAgB,IAA6C;CACzD,OAAO;AACX;AAgBA,SAAgB,EAAa,GAA4B;CACrD,IAAM,IAAS,EAAS,SAAS,GAAG,IAAI,IAAW,GAAG,EAAS;CAC/D,OAAO,EAAgB,KAAK,MAAU,GAAG,IAAS,GAAO;AAC7D"}
+{"version":3,"file":"assets.js","names":["ORT_WASM_ASSETS","configuredPath","configureOrtAssets","basePath","configuredOrtAssetPath","ortAssetUrls","prefix","asset"],"sources":["../../src/tabular/assets.ts"],"sourcesContent":["/**\n * The runtime's own assets, which are the other half of working offline.\n *\n * ONNX Runtime Web does **not** embed its WebAssembly binary, not even in\n * the `.bundle` builds. Measured in Chromium: the default entry fetches\n * `ort-wasm-simd-threaded.jsep.wasm` at session creation, and serving the\n * app without that file fails with `Aborted(both async and sync fetching of\n * the wasm failed)` — an error that says nothing about the missing file.\n *\n * So an offline app has to ship those binaries and precache them. This\n * module names them and points the runtime at a local directory.\n *\n * It does **not** import `onnxruntime-web`. An app on the compact route\n * (`CompactPredictor`) has no runtime at all, and a module that imported\n * one at load time would force every consumer of this subpath to install\n * the peer — which is exactly the cost that route exists to avoid. The\n * configured path is remembered here and applied by the ONNX predictor,\n * which imports the runtime only when it actually loads a model.\n */\n\n/**\n * The WebAssembly binaries ONNX Runtime Web may request.\n *\n * Which one is fetched depends on the browser's threading and SIMD support,\n * so an app that must work everywhere ships all of them. Chromium with the\n * default entry point fetched the `jsep` build.\n */\nexport const ORT_WASM_ASSETS: readonly string[] = [\n    \"ort-wasm-simd-threaded.wasm\",\n    \"ort-wasm-simd-threaded.mjs\",\n    \"ort-wasm-simd-threaded.jsep.wasm\",\n    \"ort-wasm-simd-threaded.jsep.mjs\",\n];\n\nlet configuredPath: string | undefined;\n\n/**\n * Point ONNX Runtime Web at locally served WebAssembly binaries.\n *\n * Call once, before creating any predictor.\n *\n * @example\n * ```ts\n * configureOrtAssets(\"/ort/\");\n * const predictor = await TabularPredictor.create(\"/models/classifier.onnx\");\n * ```\n *\n * @param basePath Directory the binaries are served from, with a trailing\n *   slash. Copy them there at build time — for Vite, from\n *   `node_modules/onnxruntime-web/dist/`.\n */\nexport function configureOrtAssets(basePath: string): void {\n    configuredPath = basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n}\n\n/**\n * Where the runtime's binaries were said to live.\n *\n * Read by the ONNX predictor just before it creates a session, which is\n * the first moment the runtime exists to be configured.\n *\n * @returns The configured directory, or `undefined` when none was set.\n */\nexport function configuredOrtAssetPath(): string | undefined {\n    return configuredPath;\n}\n\n/**\n * The URLs a service worker should precache for offline inference.\n *\n * The model file is not included: it is cached by\n * {@link fetchModelBytes} on first use, under its own bucket.\n *\n * @example\n * ```ts\n * installPrecache([...ortAssetUrls(\"/ort/\"), \"/index.html\"]);\n * ```\n *\n * @param basePath Directory the binaries are served from.\n * @returns Absolute-from-root URLs for every runtime asset.\n */\nexport function ortAssetUrls(basePath: string): string[] {\n    const prefix = basePath.endsWith(\"/\") ? basePath : `${basePath}/`;\n    return ORT_WASM_ASSETS.map((asset) => `${prefix}${asset}`);\n}\n"],"mappings":";AA2BA,IAAaA,IAAqC;CAC9C;CACA;CACA;CACA;AACJ,GAEIC;AAiBJ,SAAgBC,EAAmB,GAAwB;CACvD,IAAiBC,EAAS,SAAS,GAAG,IAAIA,IAAW,GAAGA,EAAS;AACrE;AAUA,SAAgBC,IAA6C;CACzD,OAAOH;AACX;AAgBA,SAAgBI,EAAa,GAA4B;CACrD,IAAMC,IAASH,EAAS,SAAS,GAAG,IAAIA,IAAW,GAAGA,EAAS;CAC/D,OAAOH,EAAgB,KAAK,MAAU,GAAGM,IAASC,GAAO;AAC7D"}

package/dist/tabular/cache.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"cache.cjs","names":[],"sources":["../../src/tabular/cache.ts"],"sourcesContent":["/**\n * Keeping model bytes on the device, so the second visit works offline.\n *\n * A prediction that needs the network is not offline inference. The model\n * file is the one asset the app cannot re-derive, so it goes into Cache\n * Storage on first load and is read from there afterwards.\n *\n * Cache-first, not network-first, and deliberately: a model file is\n * immutable for a given version, so revalidating it on every load spends a\n * round trip to learn nothing. Publish a new version under a new URL (or\n * pass `revalidate`) when the model changes.\n */\n\nimport { ModelFetchError } from \"./exceptions\";\n\n/** Cache Storage bucket used when the caller does not name one. */\nexport const DEFAULT_MODEL_CACHE = \"tempest-tabular-models\";\n\n/** Options for {@link fetchModelBytes}. */\nexport interface ModelCacheOptions {\n    /** Cache Storage bucket name. */\n    readonly cacheName?: string;\n    /**\n     * Go to the network first and fall back to the cache.\n     *\n     * For a URL that serves \"whatever is current\" rather than a pinned\n     * version. Costs a round trip on every load when online.\n     */\n    readonly revalidate?: boolean;\n    /** `fetch` options, e.g. credentials for a private model endpoint. */\n    readonly requestInit?: RequestInit;\n}\n\n/**\n * Whether Cache Storage is usable here.\n *\n * Absent in a non-secure context, in Node, and in some private-mode\n * browsers. The module degrades to a plain fetch rather than failing —\n * losing offline support is better than losing inference.\n *\n * @returns `true` when `caches` can be used.\n */\nfunction hasCacheStorage(): boolean {\n    return typeof globalThis.caches !== \"undefined\";\n}\n\n/**\n * Fetch the model bytes, preferring the on-device copy.\n *\n * @example\n * ```ts\n * const bytes = await fetchModelBytes(\"/models/classifier-v3.onnx\");\n * const predictor = await TabularPredictor.create(bytes);\n * ```\n *\n * @param url Where the model lives.\n * @param options Cache bucket, revalidation and `fetch` options.\n * @returns The model bytes.\n * @throws {@link ModelFetchError} when the model is neither cached nor\n *   reachable — which is the \"offline and never warmed\" case, and the\n *   message says so.\n */\nexport async function fetchModelBytes(\n    url: string,\n    options: ModelCacheOptions = {},\n): Promise<Uint8Array> {\n    const cacheName = options.cacheName ?? DEFAULT_MODEL_CACHE;\n\n    if (!hasCacheStorage()) {\n        return await downloadBytes(url, options.requestInit);\n    }\n\n    const cache = await globalThis.caches.open(cacheName);\n\n    if (options.revalidate !== true) {\n        const cached = await cache.match(url);\n        if (cached !== undefined) return new Uint8Array(await cached.arrayBuffer());\n    }\n\n    try {\n        const response = await fetch(url, options.requestInit);\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Failed to download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        await cache.put(url, response.clone());\n        return new Uint8Array(await response.arrayBuffer());\n    } catch (error) {\n        const cached = await cache.match(url);\n        if (cached !== undefined) return new Uint8Array(await cached.arrayBuffer());\n        if (error instanceof ModelFetchError) throw error;\n        throw new ModelFetchError(\n            `The model is not cached and could not be downloaded: ${url}. ` +\n                \"Warm the cache while online — prefetch it at install time, or \" +\n                \"precache it in the service worker.\",\n            { cause: error },\n        );\n    }\n}\n\n/**\n * Download without touching the cache.\n *\n * @param url Where the model lives.\n * @param requestInit `fetch` options.\n * @returns The model bytes.\n * @throws {@link ModelFetchError} when the request fails.\n */\nasync function downloadBytes(url: string, requestInit?: RequestInit): Promise<Uint8Array> {\n    try {\n        const response = await fetch(url, requestInit);\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Failed to download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        return new Uint8Array(await response.arrayBuffer());\n    } catch (error) {\n        if (error instanceof ModelFetchError) throw error;\n        throw new ModelFetchError(`Failed to download the model: ${url}`, { cause: error });\n    }\n}\n\n/**\n * Whether a model is already on the device.\n *\n * Useful for showing \"available offline\" in the UI, and for deciding\n * whether to prefetch on a metered connection.\n *\n * @param url The model URL.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when the bytes are cached.\n */\nexport async function isModelCached(\n    url: string,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    const cache = await globalThis.caches.open(cacheName);\n    return (await cache.match(url)) !== undefined;\n}\n\n/**\n * Store model bytes without downloading them.\n *\n * For an app that already has the bytes — from a file input, or from a\n * bundle it unpacked — and wants the next load to find them cached.\n *\n * @param url The URL to key the entry under.\n * @param bytes The model bytes.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when the entry was stored, `false` without Cache Storage.\n */\nexport async function cacheModelBytes(\n    url: string,\n    bytes: Uint8Array,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    const cache = await globalThis.caches.open(cacheName);\n    const body = new Uint8Array(bytes).buffer as ArrayBuffer;\n    await cache.put(\n        url,\n        new Response(body, {\n            headers: { \"content-type\": \"application/octet-stream\" },\n        }),\n    );\n    return true;\n}\n\n/**\n * Drop cached models.\n *\n * @param url A specific model to evict; omit to delete the whole bucket.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when something was deleted.\n */\nexport async function clearModelCache(\n    url?: string,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    if (url === undefined) return await globalThis.caches.delete(cacheName);\n    const cache = await globalThis.caches.open(cacheName);\n    return await cache.delete(url);\n}\n"],"mappings":"oCAgBA,IAAa,EAAsB,yBA0BnC,SAAS,GAA2B,CAChC,OAAc,WAAW,SAAW,MACxC,CAkBA,eAAsB,EAClB,EACA,EAA6B,CAAC,EACX,CACnB,IAAM,EAAY,EAAQ,WAAA,yBAE1B,GAAI,CAAC,EAAgB,EACjB,OAAO,MAAM,EAAc,EAAK,EAAQ,WAAW,EAGvD,IAAM,EAAQ,MAAM,WAAW,OAAO,KAAK,CAAS,EAEpD,GAAI,EAAQ,aAAe,GAAM,CAC7B,IAAM,EAAS,MAAM,EAAM,MAAM,CAAG,EACpC,GAAI,IAAW,IAAA,GAAW,OAAO,IAAI,WAAW,MAAM,EAAO,YAAY,CAAC,CAC9E,CAEA,GAAI,CACA,IAAM,EAAW,MAAM,MAAM,EAAK,EAAQ,WAAW,EACrD,GAAI,CAAC,EAAS,GACV,MAAM,IAAI,EAAA,gBACN,iCAAiC,EAAS,OAAO,GAAG,EAAS,YACjE,EAGJ,OADA,MAAM,EAAM,IAAI,EAAK,EAAS,MAAM,CAAC,EAC9B,IAAI,WAAW,MAAM,EAAS,YAAY,CAAC,CACtD,OAAS,EAAO,CACZ,IAAM,EAAS,MAAM,EAAM,MAAM,CAAG,EACpC,GAAI,IAAW,IAAA,GAAW,OAAO,IAAI,WAAW,MAAM,EAAO,YAAY,CAAC,EAE1E,MADI,aAAiB,EAAA,gBAAuB,EACtC,IAAI,EAAA,gBACN,wDAAwD,EAAI,oGAG5D,CAAE,MAAO,CAAM,CACnB,CACJ,CACJ,CAUA,eAAe,EAAc,EAAa,EAAgD,CACtF,GAAI,CACA,IAAM,EAAW,MAAM,MAAM,EAAK,CAAW,EAC7C,GAAI,CAAC,EAAS,GACV,MAAM,IAAI,EAAA,gBACN,iCAAiC,EAAS,OAAO,GAAG,EAAS,YACjE,EAEJ,OAAO,IAAI,WAAW,MAAM,EAAS,YAAY,CAAC,CACtD,OAAS,EAAO,CAEZ,MADI,aAAiB,EAAA,gBAAuB,EACtC,IAAI,EAAA,gBAAgB,iCAAiC,IAAO,CAAE,MAAO,CAAM,CAAC,CACtF,CACJ,CAYA,eAAsB,EAClB,EACA,EAAoB,EACJ,CAGhB,OAFK,EAAgB,EAEb,MAAM,MADM,WAAW,OAAO,KAAK,CAAS,EAAA,CAChC,MAAM,CAAG,IAAO,IAAA,GAFL,EAGnC,CAaA,eAAsB,EAClB,EACA,EACA,EAAoB,EACJ,CAChB,GAAI,CAAC,EAAgB,EAAG,MAAO,GAC/B,IAAM,EAAQ,MAAM,WAAW,OAAO,KAAK,CAAS,EAC9C,EAAO,IAAI,WAAW,CAAK,CAAC,CAAC,OAOnC,OANA,MAAM,EAAM,IACR,EACA,IAAI,SAAS,EAAM,CACf,QAAS,CAAE,eAAgB,0BAA2B,CAC1D,CAAC,CACL,EACO,EACX,CASA,eAAsB,EAClB,EACA,EAAoB,EACJ,CAIhB,OAHK,EAAgB,EACjB,IAAQ,IAAA,GAAkB,MAAM,WAAW,OAAO,OAAO,CAAS,EAE/D,MAAM,MADO,WAAW,OAAO,KAAK,CAAS,EAAA,CACjC,OAAO,CAAG,EAHE,EAInC"}
+{"version":3,"file":"cache.cjs","names":["ModelFetchError","require_exceptions","DEFAULT_MODEL_CACHE","hasCacheStorage","fetchModelBytes","cacheName","options","downloadBytes","url","cache","cached","response","error","requestInit","isModelCached","cacheModelBytes","body","bytes","clearModelCache"],"sources":["../../src/tabular/cache.ts"],"sourcesContent":["/**\n * Keeping model bytes on the device, so the second visit works offline.\n *\n * A prediction that needs the network is not offline inference. The model\n * file is the one asset the app cannot re-derive, so it goes into Cache\n * Storage on first load and is read from there afterwards.\n *\n * Cache-first, not network-first, and deliberately: a model file is\n * immutable for a given version, so revalidating it on every load spends a\n * round trip to learn nothing. Publish a new version under a new URL (or\n * pass `revalidate`) when the model changes.\n */\n\nimport { ModelFetchError } from \"./exceptions\";\n\n/** Cache Storage bucket used when the caller does not name one. */\nexport const DEFAULT_MODEL_CACHE = \"tempest-tabular-models\";\n\n/** Options for {@link fetchModelBytes}. */\nexport interface ModelCacheOptions {\n    /** Cache Storage bucket name. */\n    readonly cacheName?: string;\n    /**\n     * Go to the network first and fall back to the cache.\n     *\n     * For a URL that serves \"whatever is current\" rather than a pinned\n     * version. Costs a round trip on every load when online.\n     */\n    readonly revalidate?: boolean;\n    /** `fetch` options, e.g. credentials for a private model endpoint. */\n    readonly requestInit?: RequestInit;\n}\n\n/**\n * Whether Cache Storage is usable here.\n *\n * Absent in a non-secure context, in Node, and in some private-mode\n * browsers. The module degrades to a plain fetch rather than failing —\n * losing offline support is better than losing inference.\n *\n * @returns `true` when `caches` can be used.\n */\nfunction hasCacheStorage(): boolean {\n    return typeof globalThis.caches !== \"undefined\";\n}\n\n/**\n * Fetch the model bytes, preferring the on-device copy.\n *\n * @example\n * ```ts\n * const bytes = await fetchModelBytes(\"/models/classifier-v3.onnx\");\n * const predictor = await TabularPredictor.create(bytes);\n * ```\n *\n * @param url Where the model lives.\n * @param options Cache bucket, revalidation and `fetch` options.\n * @returns The model bytes.\n * @throws {@link ModelFetchError} when the model is neither cached nor\n *   reachable — which is the \"offline and never warmed\" case, and the\n *   message says so.\n */\nexport async function fetchModelBytes(\n    url: string,\n    options: ModelCacheOptions = {},\n): Promise<Uint8Array> {\n    const cacheName = options.cacheName ?? DEFAULT_MODEL_CACHE;\n\n    if (!hasCacheStorage()) {\n        return await downloadBytes(url, options.requestInit);\n    }\n\n    const cache = await globalThis.caches.open(cacheName);\n\n    if (options.revalidate !== true) {\n        const cached = await cache.match(url);\n        if (cached !== undefined) return new Uint8Array(await cached.arrayBuffer());\n    }\n\n    try {\n        const response = await fetch(url, options.requestInit);\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Failed to download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        await cache.put(url, response.clone());\n        return new Uint8Array(await response.arrayBuffer());\n    } catch (error) {\n        const cached = await cache.match(url);\n        if (cached !== undefined) return new Uint8Array(await cached.arrayBuffer());\n        if (error instanceof ModelFetchError) throw error;\n        throw new ModelFetchError(\n            `The model is not cached and could not be downloaded: ${url}. ` +\n                \"Warm the cache while online — prefetch it at install time, or \" +\n                \"precache it in the service worker.\",\n            { cause: error },\n        );\n    }\n}\n\n/**\n * Download without touching the cache.\n *\n * @param url Where the model lives.\n * @param requestInit `fetch` options.\n * @returns The model bytes.\n * @throws {@link ModelFetchError} when the request fails.\n */\nasync function downloadBytes(url: string, requestInit?: RequestInit): Promise<Uint8Array> {\n    try {\n        const response = await fetch(url, requestInit);\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Failed to download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        return new Uint8Array(await response.arrayBuffer());\n    } catch (error) {\n        if (error instanceof ModelFetchError) throw error;\n        throw new ModelFetchError(`Failed to download the model: ${url}`, { cause: error });\n    }\n}\n\n/**\n * Whether a model is already on the device.\n *\n * Useful for showing \"available offline\" in the UI, and for deciding\n * whether to prefetch on a metered connection.\n *\n * @param url The model URL.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when the bytes are cached.\n */\nexport async function isModelCached(\n    url: string,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    const cache = await globalThis.caches.open(cacheName);\n    return (await cache.match(url)) !== undefined;\n}\n\n/**\n * Store model bytes without downloading them.\n *\n * For an app that already has the bytes — from a file input, or from a\n * bundle it unpacked — and wants the next load to find them cached.\n *\n * @param url The URL to key the entry under.\n * @param bytes The model bytes.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when the entry was stored, `false` without Cache Storage.\n */\nexport async function cacheModelBytes(\n    url: string,\n    bytes: Uint8Array,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    const cache = await globalThis.caches.open(cacheName);\n    const body = new Uint8Array(bytes).buffer as ArrayBuffer;\n    await cache.put(\n        url,\n        new Response(body, {\n            headers: { \"content-type\": \"application/octet-stream\" },\n        }),\n    );\n    return true;\n}\n\n/**\n * Drop cached models.\n *\n * @param url A specific model to evict; omit to delete the whole bucket.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when something was deleted.\n */\nexport async function clearModelCache(\n    url?: string,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    if (url === undefined) return await globalThis.caches.delete(cacheName);\n    const cache = await globalThis.caches.open(cacheName);\n    return await cache.delete(url);\n}\n"],"mappings":"A,oCAgBA,IAAaE,EAAsB,yBA0BnC,SAASC,GAA2B,CAChC,OAAc,WAAW,SAAW,MACxC,CAkBA,eAAsBC,EAClB,EACA,EAA6B,CAAC,EACX,CACnB,IAAMC,EAAYC,EAAQ,WAAA,yBAE1B,GAAI,CAACH,EAAgB,EACjB,OAAO,MAAMI,EAAcC,EAAKF,EAAQ,WAAW,EAGvD,IAAMG,EAAQ,MAAM,WAAW,OAAO,KAAKJ,CAAS,EAEpD,GAAIC,EAAQ,aAAe,GAAM,CAC7B,IAAMI,EAAS,MAAMD,EAAM,MAAMD,CAAG,EACpC,GAAIE,IAAW,IAAA,GAAW,OAAO,IAAI,WAAW,MAAMA,EAAO,YAAY,CAAC,CAC9E,CAEA,GAAI,CACA,IAAMC,EAAW,MAAM,MAAMH,EAAKF,EAAQ,WAAW,EACrD,GAAI,CAACK,EAAS,GACV,MAAM,IAAIX,EAAAA,gBACN,iCAAiCW,EAAS,OAAO,GAAGA,EAAS,YACjE,EAGJ,OADA,MAAMF,EAAM,IAAID,EAAKG,EAAS,MAAM,CAAC,EAC9B,IAAI,WAAW,MAAMA,EAAS,YAAY,CAAC,CACtD,OAASC,EAAO,CACZ,IAAMF,EAAS,MAAMD,EAAM,MAAMD,CAAG,EACpC,GAAIE,IAAW,IAAA,GAAW,OAAO,IAAI,WAAW,MAAMA,EAAO,YAAY,CAAC,EAE1E,MADIE,aAAiBZ,EAAAA,gBAAuBY,EACtC,IAAIZ,EAAAA,gBACN,wDAAwDQ,EAAI,oGAG5D,CAAE,MAAOI,CAAM,CACnB,CACJ,CACJ,CAUA,eAAeL,EAAc,EAAa,EAAgD,CACtF,GAAI,CACA,IAAMI,EAAW,MAAM,MAAMH,EAAKK,CAAW,EAC7C,GAAI,CAACF,EAAS,GACV,MAAM,IAAIX,EAAAA,gBACN,iCAAiCW,EAAS,OAAO,GAAGA,EAAS,YACjE,EAEJ,OAAO,IAAI,WAAW,MAAMA,EAAS,YAAY,CAAC,CACtD,OAASC,EAAO,CAEZ,MADIA,aAAiBZ,EAAAA,gBAAuBY,EACtC,IAAIZ,EAAAA,gBAAgB,iCAAiCQ,IAAO,CAAE,MAAOI,CAAM,CAAC,CACtF,CACJ,CAYA,eAAsBE,EAClB,EACA,EAAoBZ,EACJ,CAGhB,OAFKC,EAAgB,EAEb,MAAM,MADM,WAAW,OAAO,KAAKE,CAAS,EAAA,CAChC,MAAMG,CAAG,IAAO,IAAA,GAFL,EAGnC,CAaA,eAAsBO,EAClB,EACA,EACA,EAAoBb,EACJ,CAChB,GAAI,CAACC,EAAgB,EAAG,MAAO,GAC/B,IAAMM,EAAQ,MAAM,WAAW,OAAO,KAAKJ,CAAS,EAC9CW,EAAO,IAAI,WAAWC,CAAK,CAAC,CAAC,OAOnC,OANA,MAAMR,EAAM,IACRD,EACA,IAAI,SAASQ,EAAM,CACf,QAAS,CAAE,eAAgB,0BAA2B,CAC1D,CAAC,CACL,EACO,EACX,CASA,eAAsBE,EAClB,EACA,EAAoBhB,EACJ,CAIhB,OAHKC,EAAgB,EACjBK,IAAQ,IAAA,GAAkB,MAAM,WAAW,OAAO,OAAOH,CAAS,EAE/D,MAAM,MADO,WAAW,OAAO,KAAKA,CAAS,EAAA,CACjC,OAAOG,CAAG,EAHE,EAInC,C"}

package/dist/tabular/cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"cache.js","names":[],"sources":["../../src/tabular/cache.ts"],"sourcesContent":["/**\n * Keeping model bytes on the device, so the second visit works offline.\n *\n * A prediction that needs the network is not offline inference. The model\n * file is the one asset the app cannot re-derive, so it goes into Cache\n * Storage on first load and is read from there afterwards.\n *\n * Cache-first, not network-first, and deliberately: a model file is\n * immutable for a given version, so revalidating it on every load spends a\n * round trip to learn nothing. Publish a new version under a new URL (or\n * pass `revalidate`) when the model changes.\n */\n\nimport { ModelFetchError } from \"./exceptions\";\n\n/** Cache Storage bucket used when the caller does not name one. */\nexport const DEFAULT_MODEL_CACHE = \"tempest-tabular-models\";\n\n/** Options for {@link fetchModelBytes}. */\nexport interface ModelCacheOptions {\n    /** Cache Storage bucket name. */\n    readonly cacheName?: string;\n    /**\n     * Go to the network first and fall back to the cache.\n     *\n     * For a URL that serves \"whatever is current\" rather than a pinned\n     * version. Costs a round trip on every load when online.\n     */\n    readonly revalidate?: boolean;\n    /** `fetch` options, e.g. credentials for a private model endpoint. */\n    readonly requestInit?: RequestInit;\n}\n\n/**\n * Whether Cache Storage is usable here.\n *\n * Absent in a non-secure context, in Node, and in some private-mode\n * browsers. The module degrades to a plain fetch rather than failing —\n * losing offline support is better than losing inference.\n *\n * @returns `true` when `caches` can be used.\n */\nfunction hasCacheStorage(): boolean {\n    return typeof globalThis.caches !== \"undefined\";\n}\n\n/**\n * Fetch the model bytes, preferring the on-device copy.\n *\n * @example\n * ```ts\n * const bytes = await fetchModelBytes(\"/models/classifier-v3.onnx\");\n * const predictor = await TabularPredictor.create(bytes);\n * ```\n *\n * @param url Where the model lives.\n * @param options Cache bucket, revalidation and `fetch` options.\n * @returns The model bytes.\n * @throws {@link ModelFetchError} when the model is neither cached nor\n *   reachable — which is the \"offline and never warmed\" case, and the\n *   message says so.\n */\nexport async function fetchModelBytes(\n    url: string,\n    options: ModelCacheOptions = {},\n): Promise<Uint8Array> {\n    const cacheName = options.cacheName ?? DEFAULT_MODEL_CACHE;\n\n    if (!hasCacheStorage()) {\n        return await downloadBytes(url, options.requestInit);\n    }\n\n    const cache = await globalThis.caches.open(cacheName);\n\n    if (options.revalidate !== true) {\n        const cached = await cache.match(url);\n        if (cached !== undefined) return new Uint8Array(await cached.arrayBuffer());\n    }\n\n    try {\n        const response = await fetch(url, options.requestInit);\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Failed to download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        await cache.put(url, response.clone());\n        return new Uint8Array(await response.arrayBuffer());\n    } catch (error) {\n        const cached = await cache.match(url);\n        if (cached !== undefined) return new Uint8Array(await cached.arrayBuffer());\n        if (error instanceof ModelFetchError) throw error;\n        throw new ModelFetchError(\n            `The model is not cached and could not be downloaded: ${url}. ` +\n                \"Warm the cache while online — prefetch it at install time, or \" +\n                \"precache it in the service worker.\",\n            { cause: error },\n        );\n    }\n}\n\n/**\n * Download without touching the cache.\n *\n * @param url Where the model lives.\n * @param requestInit `fetch` options.\n * @returns The model bytes.\n * @throws {@link ModelFetchError} when the request fails.\n */\nasync function downloadBytes(url: string, requestInit?: RequestInit): Promise<Uint8Array> {\n    try {\n        const response = await fetch(url, requestInit);\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Failed to download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        return new Uint8Array(await response.arrayBuffer());\n    } catch (error) {\n        if (error instanceof ModelFetchError) throw error;\n        throw new ModelFetchError(`Failed to download the model: ${url}`, { cause: error });\n    }\n}\n\n/**\n * Whether a model is already on the device.\n *\n * Useful for showing \"available offline\" in the UI, and for deciding\n * whether to prefetch on a metered connection.\n *\n * @param url The model URL.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when the bytes are cached.\n */\nexport async function isModelCached(\n    url: string,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    const cache = await globalThis.caches.open(cacheName);\n    return (await cache.match(url)) !== undefined;\n}\n\n/**\n * Store model bytes without downloading them.\n *\n * For an app that already has the bytes — from a file input, or from a\n * bundle it unpacked — and wants the next load to find them cached.\n *\n * @param url The URL to key the entry under.\n * @param bytes The model bytes.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when the entry was stored, `false` without Cache Storage.\n */\nexport async function cacheModelBytes(\n    url: string,\n    bytes: Uint8Array,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    const cache = await globalThis.caches.open(cacheName);\n    const body = new Uint8Array(bytes).buffer as ArrayBuffer;\n    await cache.put(\n        url,\n        new Response(body, {\n            headers: { \"content-type\": \"application/octet-stream\" },\n        }),\n    );\n    return true;\n}\n\n/**\n * Drop cached models.\n *\n * @param url A specific model to evict; omit to delete the whole bucket.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when something was deleted.\n */\nexport async function clearModelCache(\n    url?: string,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    if (url === undefined) return await globalThis.caches.delete(cacheName);\n    const cache = await globalThis.caches.open(cacheName);\n    return await cache.delete(url);\n}\n"],"mappings":";;AAgBA,IAAa,IAAsB;AA0BnC,SAAS,IAA2B;CAChC,OAAc,WAAW,WAAW;AACxC;AAkBA,eAAsB,EAClB,GACA,IAA6B,CAAC,GACX;CACnB,IAAM,IAAY,EAAQ,aAAA;CAE1B,IAAI,CAAC,EAAgB,GACjB,OAAO,MAAM,EAAc,GAAK,EAAQ,WAAW;CAGvD,IAAM,IAAQ,MAAM,WAAW,OAAO,KAAK,CAAS;CAEpD,IAAI,EAAQ,eAAe,IAAM;EAC7B,IAAM,IAAS,MAAM,EAAM,MAAM,CAAG;EACpC,IAAI,MAAW,KAAA,GAAW,OAAO,IAAI,WAAW,MAAM,EAAO,YAAY,CAAC;CAC9E;CAEA,IAAI;EACA,IAAM,IAAW,MAAM,MAAM,GAAK,EAAQ,WAAW;EACrD,IAAI,CAAC,EAAS,IACV,MAAM,IAAI,EACN,iCAAiC,EAAS,OAAO,GAAG,EAAS,YACjE;EAGJ,OADA,MAAM,EAAM,IAAI,GAAK,EAAS,MAAM,CAAC,GAC9B,IAAI,WAAW,MAAM,EAAS,YAAY,CAAC;CACtD,SAAS,GAAO;EACZ,IAAM,IAAS,MAAM,EAAM,MAAM,CAAG;EACpC,IAAI,MAAW,KAAA,GAAW,OAAO,IAAI,WAAW,MAAM,EAAO,YAAY,CAAC;EAE1E,MADI,aAAiB,IAAuB,IACtC,IAAI,EACN,wDAAwD,EAAI,qGAG5D,EAAE,OAAO,EAAM,CACnB;CACJ;AACJ;AAUA,eAAe,EAAc,GAAa,GAAgD;CACtF,IAAI;EACA,IAAM,IAAW,MAAM,MAAM,GAAK,CAAW;EAC7C,IAAI,CAAC,EAAS,IACV,MAAM,IAAI,EACN,iCAAiC,EAAS,OAAO,GAAG,EAAS,YACjE;EAEJ,OAAO,IAAI,WAAW,MAAM,EAAS,YAAY,CAAC;CACtD,SAAS,GAAO;EAEZ,MADI,aAAiB,IAAuB,IACtC,IAAI,EAAgB,iCAAiC,KAAO,EAAE,OAAO,EAAM,CAAC;CACtF;AACJ;AAYA,eAAsB,EAClB,GACA,IAAoB,GACJ;CAGhB,OAFK,EAAgB,IAEb,OAAM,MADM,WAAW,OAAO,KAAK,CAAS,EAAA,CAChC,MAAM,CAAG,MAAO,KAAA,IAFL;AAGnC;AAaA,eAAsB,EAClB,GACA,GACA,IAAoB,GACJ;CAChB,IAAI,CAAC,EAAgB,GAAG,OAAO;CAC/B,IAAM,IAAQ,MAAM,WAAW,OAAO,KAAK,CAAS,GAC9C,IAAO,IAAI,WAAW,CAAK,CAAC,CAAC;CAOnC,OANA,MAAM,EAAM,IACR,GACA,IAAI,SAAS,GAAM,EACf,SAAS,EAAE,gBAAgB,2BAA2B,EAC1D,CAAC,CACL,GACO;AACX;AASA,eAAsB,EAClB,GACA,IAAoB,GACJ;CAIhB,OAHK,EAAgB,IACjB,MAAQ,KAAA,IAAkB,MAAM,WAAW,OAAO,OAAO,CAAS,IAE/D,OAAM,MADO,WAAW,OAAO,KAAK,CAAS,EAAA,CACjC,OAAO,CAAG,IAHE;AAInC"}
+{"version":3,"file":"cache.js","names":["DEFAULT_MODEL_CACHE","hasCacheStorage","fetchModelBytes","cacheName","options","downloadBytes","url","cache","cached","response","ModelFetchError","error","requestInit","isModelCached","cacheModelBytes","body","bytes","clearModelCache"],"sources":["../../src/tabular/cache.ts"],"sourcesContent":["/**\n * Keeping model bytes on the device, so the second visit works offline.\n *\n * A prediction that needs the network is not offline inference. The model\n * file is the one asset the app cannot re-derive, so it goes into Cache\n * Storage on first load and is read from there afterwards.\n *\n * Cache-first, not network-first, and deliberately: a model file is\n * immutable for a given version, so revalidating it on every load spends a\n * round trip to learn nothing. Publish a new version under a new URL (or\n * pass `revalidate`) when the model changes.\n */\n\nimport { ModelFetchError } from \"./exceptions\";\n\n/** Cache Storage bucket used when the caller does not name one. */\nexport const DEFAULT_MODEL_CACHE = \"tempest-tabular-models\";\n\n/** Options for {@link fetchModelBytes}. */\nexport interface ModelCacheOptions {\n    /** Cache Storage bucket name. */\n    readonly cacheName?: string;\n    /**\n     * Go to the network first and fall back to the cache.\n     *\n     * For a URL that serves \"whatever is current\" rather than a pinned\n     * version. Costs a round trip on every load when online.\n     */\n    readonly revalidate?: boolean;\n    /** `fetch` options, e.g. credentials for a private model endpoint. */\n    readonly requestInit?: RequestInit;\n}\n\n/**\n * Whether Cache Storage is usable here.\n *\n * Absent in a non-secure context, in Node, and in some private-mode\n * browsers. The module degrades to a plain fetch rather than failing —\n * losing offline support is better than losing inference.\n *\n * @returns `true` when `caches` can be used.\n */\nfunction hasCacheStorage(): boolean {\n    return typeof globalThis.caches !== \"undefined\";\n}\n\n/**\n * Fetch the model bytes, preferring the on-device copy.\n *\n * @example\n * ```ts\n * const bytes = await fetchModelBytes(\"/models/classifier-v3.onnx\");\n * const predictor = await TabularPredictor.create(bytes);\n * ```\n *\n * @param url Where the model lives.\n * @param options Cache bucket, revalidation and `fetch` options.\n * @returns The model bytes.\n * @throws {@link ModelFetchError} when the model is neither cached nor\n *   reachable — which is the \"offline and never warmed\" case, and the\n *   message says so.\n */\nexport async function fetchModelBytes(\n    url: string,\n    options: ModelCacheOptions = {},\n): Promise<Uint8Array> {\n    const cacheName = options.cacheName ?? DEFAULT_MODEL_CACHE;\n\n    if (!hasCacheStorage()) {\n        return await downloadBytes(url, options.requestInit);\n    }\n\n    const cache = await globalThis.caches.open(cacheName);\n\n    if (options.revalidate !== true) {\n        const cached = await cache.match(url);\n        if (cached !== undefined) return new Uint8Array(await cached.arrayBuffer());\n    }\n\n    try {\n        const response = await fetch(url, options.requestInit);\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Failed to download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        await cache.put(url, response.clone());\n        return new Uint8Array(await response.arrayBuffer());\n    } catch (error) {\n        const cached = await cache.match(url);\n        if (cached !== undefined) return new Uint8Array(await cached.arrayBuffer());\n        if (error instanceof ModelFetchError) throw error;\n        throw new ModelFetchError(\n            `The model is not cached and could not be downloaded: ${url}. ` +\n                \"Warm the cache while online — prefetch it at install time, or \" +\n                \"precache it in the service worker.\",\n            { cause: error },\n        );\n    }\n}\n\n/**\n * Download without touching the cache.\n *\n * @param url Where the model lives.\n * @param requestInit `fetch` options.\n * @returns The model bytes.\n * @throws {@link ModelFetchError} when the request fails.\n */\nasync function downloadBytes(url: string, requestInit?: RequestInit): Promise<Uint8Array> {\n    try {\n        const response = await fetch(url, requestInit);\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Failed to download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        return new Uint8Array(await response.arrayBuffer());\n    } catch (error) {\n        if (error instanceof ModelFetchError) throw error;\n        throw new ModelFetchError(`Failed to download the model: ${url}`, { cause: error });\n    }\n}\n\n/**\n * Whether a model is already on the device.\n *\n * Useful for showing \"available offline\" in the UI, and for deciding\n * whether to prefetch on a metered connection.\n *\n * @param url The model URL.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when the bytes are cached.\n */\nexport async function isModelCached(\n    url: string,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    const cache = await globalThis.caches.open(cacheName);\n    return (await cache.match(url)) !== undefined;\n}\n\n/**\n * Store model bytes without downloading them.\n *\n * For an app that already has the bytes — from a file input, or from a\n * bundle it unpacked — and wants the next load to find them cached.\n *\n * @param url The URL to key the entry under.\n * @param bytes The model bytes.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when the entry was stored, `false` without Cache Storage.\n */\nexport async function cacheModelBytes(\n    url: string,\n    bytes: Uint8Array,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    const cache = await globalThis.caches.open(cacheName);\n    const body = new Uint8Array(bytes).buffer as ArrayBuffer;\n    await cache.put(\n        url,\n        new Response(body, {\n            headers: { \"content-type\": \"application/octet-stream\" },\n        }),\n    );\n    return true;\n}\n\n/**\n * Drop cached models.\n *\n * @param url A specific model to evict; omit to delete the whole bucket.\n * @param cacheName Cache Storage bucket name.\n * @returns `true` when something was deleted.\n */\nexport async function clearModelCache(\n    url?: string,\n    cacheName: string = DEFAULT_MODEL_CACHE,\n): Promise<boolean> {\n    if (!hasCacheStorage()) return false;\n    if (url === undefined) return await globalThis.caches.delete(cacheName);\n    const cache = await globalThis.caches.open(cacheName);\n    return await cache.delete(url);\n}\n"],"mappings":";;AAgBA,IAAaA,IAAsB;AA0BnC,SAASC,IAA2B;CAChC,OAAc,WAAW,WAAW;AACxC;AAkBA,eAAsBC,EAClB,GACA,IAA6B,CAAC,GACX;CACnB,IAAMC,IAAYC,EAAQ,aAAA;CAE1B,IAAI,CAACH,EAAgB,GACjB,OAAO,MAAMI,EAAcC,GAAKF,EAAQ,WAAW;CAGvD,IAAMG,IAAQ,MAAM,WAAW,OAAO,KAAKJ,CAAS;CAEpD,IAAIC,EAAQ,eAAe,IAAM;EAC7B,IAAMI,IAAS,MAAMD,EAAM,MAAMD,CAAG;EACpC,IAAIE,MAAW,KAAA,GAAW,OAAO,IAAI,WAAW,MAAMA,EAAO,YAAY,CAAC;CAC9E;CAEA,IAAI;EACA,IAAMC,IAAW,MAAM,MAAMH,GAAKF,EAAQ,WAAW;EACrD,IAAI,CAACK,EAAS,IACV,MAAM,IAAIC,EACN,iCAAiCD,EAAS,OAAO,GAAGA,EAAS,YACjE;EAGJ,OADA,MAAMF,EAAM,IAAID,GAAKG,EAAS,MAAM,CAAC,GAC9B,IAAI,WAAW,MAAMA,EAAS,YAAY,CAAC;CACtD,SAASE,GAAO;EACZ,IAAMH,IAAS,MAAMD,EAAM,MAAMD,CAAG;EACpC,IAAIE,MAAW,KAAA,GAAW,OAAO,IAAI,WAAW,MAAMA,EAAO,YAAY,CAAC;EAE1E,MADIG,aAAiBD,IAAuBC,IACtC,IAAID,EACN,wDAAwDJ,EAAI,qGAG5D,EAAE,OAAOK,EAAM,CACnB;CACJ;AACJ;AAUA,eAAeN,EAAc,GAAa,GAAgD;CACtF,IAAI;EACA,IAAMI,IAAW,MAAM,MAAMH,GAAKM,CAAW;EAC7C,IAAI,CAACH,EAAS,IACV,MAAM,IAAIC,EACN,iCAAiCD,EAAS,OAAO,GAAGA,EAAS,YACjE;EAEJ,OAAO,IAAI,WAAW,MAAMA,EAAS,YAAY,CAAC;CACtD,SAASE,GAAO;EAEZ,MADIA,aAAiBD,IAAuBC,IACtC,IAAID,EAAgB,iCAAiCJ,KAAO,EAAE,OAAOK,EAAM,CAAC;CACtF;AACJ;AAYA,eAAsBE,EAClB,GACA,IAAoBb,GACJ;CAGhB,OAFKC,EAAgB,IAEb,OAAM,MADM,WAAW,OAAO,KAAKE,CAAS,EAAA,CAChC,MAAMG,CAAG,MAAO,KAAA,IAFL;AAGnC;AAaA,eAAsBQ,EAClB,GACA,GACA,IAAoBd,GACJ;CAChB,IAAI,CAACC,EAAgB,GAAG,OAAO;CAC/B,IAAMM,IAAQ,MAAM,WAAW,OAAO,KAAKJ,CAAS,GAC9CY,IAAO,IAAI,WAAWC,CAAK,CAAC,CAAC;CAOnC,OANA,MAAMT,EAAM,IACRD,GACA,IAAI,SAASS,GAAM,EACf,SAAS,EAAE,gBAAgB,2BAA2B,EAC1D,CAAC,CACL,GACO;AACX;AASA,eAAsBE,EAClB,GACA,IAAoBjB,GACJ;CAIhB,OAHKC,EAAgB,IACjBK,MAAQ,KAAA,IAAkB,MAAM,WAAW,OAAO,OAAOH,CAAS,IAE/D,OAAM,MADO,WAAW,OAAO,KAAKA,CAAS,EAAA,CACjC,OAAOG,CAAG,IAHE;AAInC"}

package/dist/tabular/compact.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"compact.cjs","names":[],"sources":["../../src/tabular/compact.ts"],"sourcesContent":["/**\n * @tempest-limits file-lines — the compact model format: the header, the column\n * dictionary, the quantised weights and the decoder that reads them back. Writer and\n * reader in one file because a format whose two halves live apart drifts.\n */\n/**\n * Running a model with no inference runtime at all.\n *\n * ONNX in the browser costs a **25.6 MB WebAssembly runtime** (6.0 MB\n * gzipped) before the first prediction, while the model itself is a few\n * hundred kilobytes. For an app whose only model is tabular, that runtime\n * *is* the download — so this reader replaces it with 1.49 KB of\n * arithmetic (measured, brotli).\n *\n * A linear model is a dot product. A tree is a chain of comparisons. That\n * is the whole implementation; there is nothing here that a WebAssembly\n * kernel would do better at this size.\n *\n * The file it reads (`.tmc`, magic `TMC1`) is written by\n * `tempest-fastapi-sdk`'s `export_sklearn_to_compact`, which verifies the\n * bytes against scikit-learn's own predictions and refuses to write a file\n * that disagrees. **It is data, not code**: no `eval`, no generated\n * JavaScript, nothing a strict CSP forbids.\n *\n * The trade against {@link TabularPredictor}: ONNX covers every estimator,\n * this covers linear models and tree ensembles. Pick by what your app\n * already ships — a page that loads ONNX for vision pays nothing extra for\n * tabular ONNX.\n */\n\nimport { CompactFormatError, FeatureShapeError, ModelFetchError } from \"./exceptions\";\nimport type { FeatureRow, PredictedLabel, TabularPrediction } from \"./types\";\n\n/** Magic bytes opening every compact file. */\nconst MAGIC = \"TMC1\";\n\n/** Layout version this reader understands. */\nexport const SUPPORTED_COMPACT_SCHEMA = 1;\n\n/** What the file holds. */\nexport type CompactKind = \"linear\" | \"tree_ensemble\";\n\n/** How raw scores become probabilities. */\ntype CompactLink = \"softmax\" | \"sigmoid\" | \"normalize\" | \"identity\";\n\n/** One array stored after the header. */\ninterface CompactSection {\n    readonly name: string;\n    readonly dtype: \"float32\" | \"int32\";\n    readonly length: number;\n}\n\n/** The parsed header. */\ninterface CompactHeader {\n    readonly schema_version: number;\n    readonly kind: CompactKind;\n    readonly task: \"classification\" | \"regression\";\n    readonly link: CompactLink;\n    readonly classes: readonly string[];\n    /** How scikit-learn typed those labels: ``int``, ``float`` or ``str``. */\n    readonly class_type?: \"int\" | \"float\" | \"str\";\n    readonly n_features: number;\n    readonly n_outputs: number;\n    readonly n_trees?: number;\n    readonly estimator: string;\n    readonly feature_names: readonly string[];\n    readonly preprocess: { readonly offset: number[]; readonly scale: number[] } | null;\n    readonly sections: readonly CompactSection[];\n}\n\n/** What a loaded compact model is. */\nexport interface CompactPredictorInfo {\n    /** Which reader path the file uses. */\n    readonly kind: CompactKind;\n    /** Class labels in score-column order; empty for a regressor. */\n    readonly classes: readonly string[];\n    /** Values expected per row. */\n    readonly numFeatures: number;\n    /** Column order recorded at training time, when the export had one. */\n    readonly featureNames: readonly string[];\n    /** Trees in the ensemble; `0` for a linear model. */\n    readonly numTrees: number;\n    /** Whether the model produces class scores. */\n    readonly isClassifier: boolean;\n    /** Class name of the exported estimator. */\n    readonly estimator: string;\n}\n\n/**\n * A compact model, loaded and ready to answer.\n *\n * @example\n * ```ts\n * const predictor = await CompactPredictor.create(\"/models/risk.tmc\");\n * const { labels, probabilities } = await predictor.predict([[5.1, 3.5, 1.4, 0.2]]);\n * ```\n */\nexport class CompactPredictor {\n    private constructor(\n        private readonly header: CompactHeader,\n        private readonly arrays: Record<string, Float32Array | Int32Array>,\n        /** What is loaded. */\n        public readonly info: CompactPredictorInfo,\n    ) {}\n\n    /**\n     * Load a `.tmc` file.\n     *\n     * @param source A URL, or the bytes when the app already has them.\n     * @param requestInit `fetch` options, when `source` is a URL.\n     * @returns The loaded predictor.\n     * @throws {@link ModelFetchError} when a URL cannot be read.\n     * @throws {@link CompactFormatError} when the bytes are not a compact\n     *   model, or use a layout newer than this reader.\n     */\n    static async create(\n        source: string | ArrayBuffer | Uint8Array,\n        requestInit?: RequestInit,\n    ): Promise<CompactPredictor> {\n        const buffer = await toBuffer(source, requestInit);\n        const bytes = new Uint8Array(buffer);\n\n        if (String.fromCharCode(...bytes.subarray(0, 4)) !== MAGIC) {\n            throw new CompactFormatError(\n                \"This is not a compact model file: it does not start with \" +\n                    `\"${MAGIC}\". A .onnx file goes through TabularPredictor instead.`,\n            );\n        }\n\n        const view = new DataView(buffer);\n        const headerLength = view.getUint32(4, true);\n        const header = JSON.parse(\n            new TextDecoder().decode(bytes.subarray(8, 8 + headerLength)),\n        ) as CompactHeader;\n\n        if (header.schema_version > SUPPORTED_COMPACT_SCHEMA) {\n            throw new CompactFormatError(\n                `This file uses compact layout ${header.schema_version}, and this ` +\n                    `SDK understands ${SUPPORTED_COMPACT_SCHEMA}. Upgrade ` +\n                    \"tempest-react-sdk before serving it.\",\n            );\n        }\n\n        const arrays: Record<string, Float32Array | Int32Array> = {};\n        let cursor = 8 + headerLength;\n        for (const section of header.sections) {\n            arrays[section.name] =\n                section.dtype === \"float32\"\n                    ? new Float32Array(buffer, cursor, section.length)\n                    : new Int32Array(buffer, cursor, section.length);\n            cursor += section.length * 4;\n        }\n\n        return new CompactPredictor(header, arrays, {\n            kind: header.kind,\n            classes: header.classes,\n            numFeatures: header.n_features,\n            featureNames: header.feature_names,\n            numTrees: header.n_trees ?? 0,\n            isClassifier: header.task === \"classification\",\n            estimator: header.estimator,\n        });\n    }\n\n    /**\n     * Predict for a batch of rows.\n     *\n     * @param rows One array of feature values per row, in training column\n     *   order. A single row is still wrapped: `[[...]]`.\n     * @returns Labels, class scores when the model is a classifier, and the\n     *   call's duration.\n     * @throws {@link FeatureShapeError} when the batch is empty, ragged, or\n     *   the wrong width.\n     */\n    async predict(rows: readonly FeatureRow[]): Promise<TabularPrediction> {\n        const width = validateRows(rows, this.header.n_features);\n        const started = performance.now();\n\n        const scores: number[][] = [];\n        for (const row of rows) {\n            const prepared = this.preprocess(row, width);\n            scores.push(\n                this.header.kind === \"linear\"\n                    ? this.linearScores(prepared)\n                    : this.treeScores(prepared),\n            );\n        }\n\n        const { labels, probabilities } = this.finish(scores);\n        return {\n            labels,\n            probabilities,\n            numRows: rows.length,\n            ms: performance.now() - started,\n        };\n    }\n\n    /** Releasing nothing, so callers can swap predictors without branching. */\n    async dispose(): Promise<void> {\n        /* no runtime, nothing to release */\n    }\n\n    /**\n     * Apply the folded scaler, when the export had one.\n     *\n     * @param row The raw feature values.\n     * @param width How many there are.\n     * @returns The values the model was trained on.\n     */\n    private preprocess(row: FeatureRow, width: number): number[] {\n        const preprocess = this.header.preprocess;\n        if (preprocess === null) return row as number[];\n        const scaled = new Array<number>(width);\n        for (let index = 0; index < width; index += 1) {\n            scaled[index] =\n                ((row[index] as number) - (preprocess.offset[index] as number)) /\n                (preprocess.scale[index] as number);\n        }\n        return scaled;\n    }\n\n    /**\n     * Score one row against the coefficient matrix.\n     *\n     * @param row The prepared feature values.\n     * @returns One raw score per output.\n     */\n    private linearScores(row: readonly number[]): number[] {\n        const coef = this.arrays.coef as Float32Array;\n        const intercept = this.arrays.intercept as Float32Array;\n        const features = this.header.n_features;\n        const outputs = this.header.n_outputs;\n\n        const scores = new Array<number>(outputs);\n        for (let output = 0; output < outputs; output += 1) {\n            let total = intercept[output] as number;\n            const base = output * features;\n            for (let index = 0; index < features; index += 1) {\n                total += (coef[base + index] as number) * (row[index] as number);\n            }\n            scores[output] = total;\n        }\n        return scores;\n    }\n\n    /**\n     * Walk every tree and average what the leaves hold.\n     *\n     * A leaf is marked by a negative `feature` entry, which also carries\n     * its slot in the value array — so the walk needs no second lookup and\n     * the file stores values only for leaves.\n     *\n     * **The comparison runs in float32** (`Math.fround`), because that is\n     * what scikit-learn does: it casts its input to float32 before\n     * traversing, so a threshold like 5.099999904632568 — a float32 value\n     * widened for storage — and an input of 5.1 compare *equal* and go\n     * left. Comparing in float64 sends that row right instead, which on an\n     * iris forest changed one tree's vote and moved a probability by 0.05.\n     *\n     * @param row The prepared feature values.\n     * @returns One averaged score per output.\n     */\n    private treeScores(row: readonly number[]): number[] {\n        const feature = this.arrays.node_feature as Int32Array;\n        const threshold = this.arrays.node_threshold as Float32Array;\n        const left = this.arrays.node_left as Int32Array;\n        const right = this.arrays.node_right as Int32Array;\n        const leaf = this.arrays.leaf_value as Float32Array;\n        const offsets = this.arrays.tree_offset as Int32Array;\n        const outputs = this.header.n_outputs;\n        const trees = offsets.length - 1;\n\n        const totals = new Array<number>(outputs).fill(0);\n        for (let tree = 0; tree < trees; tree += 1) {\n            let node = offsets[tree] as number;\n            let column = feature[node] as number;\n            while (column >= 0) {\n                node =\n                    Math.fround(row[column] as number) <= (threshold[node] as number)\n                        ? (left[node] as number)\n                        : (right[node] as number);\n                column = feature[node] as number;\n            }\n            const slot = (-1 - column) * outputs;\n            for (let output = 0; output < outputs; output += 1) {\n                totals[output] += leaf[slot + output] as number;\n            }\n        }\n        for (let output = 0; output < outputs; output += 1) {\n            totals[output] = (totals[output] as number) / trees;\n        }\n        return totals;\n    }\n\n    /**\n     * Turn raw scores into labels and probabilities.\n     *\n     * @param scores One score array per row.\n     * @returns Labels and probabilities in the shape the ONNX route uses,\n     *   so an app can swap runtimes without touching its own code. That\n     *   includes the label's **type**: an integer class comes back as a\n     *   number here exactly as ONNX returns it, because two routes over one\n     *   model that disagree on `0` versus `\"0\"` break the day someone\n     *   switches.\n     */\n    private finish(scores: readonly number[][]): {\n        labels: PredictedLabel[];\n        probabilities: number[][];\n    } {\n        const link = this.header.link;\n        const classes = this.header.classes;\n\n        if (link === \"identity\") {\n            return { labels: scores.map((row) => row[0] as number), probabilities: [] };\n        }\n\n        const probabilities = scores.map((row) => {\n            if (link === \"sigmoid\") {\n                const positive = 1 / (1 + Math.exp(-(row[0] as number)));\n                return [1 - positive, positive];\n            }\n            if (link === \"softmax\") {\n                const highest = Math.max(...row);\n                const exponentiated = row.map((value) => Math.exp(value - highest));\n                const total = exponentiated.reduce((sum, value) => sum + value, 0);\n                return exponentiated.map((value) => value / total);\n            }\n            const total = row.reduce((sum, value) => sum + value, 0);\n            return total === 0 ? [...row] : row.map((value) => value / total);\n        });\n\n        const numeric = this.header.class_type !== \"str\";\n        const labels = probabilities.map((row) => {\n            let best = 0;\n            for (let index = 1; index < row.length; index += 1) {\n                if ((row[index] as number) > (row[best] as number)) best = index;\n            }\n            const label = classes[best];\n            if (label === undefined) return best;\n            return numeric ? Number(label) : label;\n        });\n\n        return { labels, probabilities };\n    }\n}\n\n/**\n * Read a source into an `ArrayBuffer`.\n *\n * @param source A URL or the bytes.\n * @param requestInit `fetch` options.\n * @returns The bytes.\n * @throws {@link ModelFetchError} when the URL cannot be read.\n */\nasync function toBuffer(\n    source: string | ArrayBuffer | Uint8Array,\n    requestInit?: RequestInit,\n): Promise<ArrayBuffer> {\n    if (typeof source === \"string\") {\n        let response: Response;\n        try {\n            response = await fetch(source, requestInit);\n        } catch (error) {\n            throw new ModelFetchError(`Could not download the model: ${source}`, {\n                cause: error,\n            });\n        }\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Could not download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        return await response.arrayBuffer();\n    }\n    if (source instanceof Uint8Array) {\n        return source.buffer.slice(\n            source.byteOffset,\n            source.byteOffset + source.byteLength,\n        ) as ArrayBuffer;\n    }\n    return source;\n}\n\n/**\n * Check a batch before predicting on it.\n *\n * @param rows The batch.\n * @param expected Features the model wants per row.\n * @returns The batch width.\n * @throws {@link FeatureShapeError} when the batch cannot be predicted on.\n */\nfunction validateRows(rows: readonly FeatureRow[], expected: number): number {\n    if (!Array.isArray(rows) || rows.length === 0) {\n        throw new FeatureShapeError(\"predict() needs at least one row, shaped [[f1, f2, ...]].\");\n    }\n    const width = rows[0]?.length ?? 0;\n    const ragged = rows.findIndex((row) => row.length !== width);\n    if (ragged !== -1) {\n        throw new FeatureShapeError(\n            `All rows must have the same width; row ${ragged} has ` +\n                `${rows[ragged]?.length} values, expected ${width}.`,\n        );\n    }\n    if (width !== expected) {\n        throw new FeatureShapeError(\n            `The model expects ${expected} features per row, got ${width}.`,\n        );\n    }\n    return width;\n}\n"],"mappings":"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"}
+{"version":3,"file":"compact.cjs","names":["CompactFormatError","ModelFetchError","FeatureShapeError","require_exceptions","MAGIC","CompactPredictor","header","arrays","info","buffer","toBuffer","source","requestInit","bytes","headerLength","cursor","section","width","validateRows","rows","started","scores","row","prepared","preprocess","scaled","index","coef","intercept","features","outputs","output","total","base","feature","threshold","left","right","leaf","offsets","trees","totals","tree","node","column","slot","link","classes","probabilities","positive","highest","exponentiated","value","sum","numeric","best","label","response","error","ragged","expected"],"sources":["../../src/tabular/compact.ts"],"sourcesContent":["/**\n * @tempest-limits file-lines — the compact model format: the header, the column\n * dictionary, the quantised weights and the decoder that reads them back. Writer and\n * reader in one file because a format whose two halves live apart drifts.\n */\n/**\n * Running a model with no inference runtime at all.\n *\n * ONNX in the browser costs a **25.6 MB WebAssembly runtime** (6.0 MB\n * gzipped) before the first prediction, while the model itself is a few\n * hundred kilobytes. For an app whose only model is tabular, that runtime\n * *is* the download — so this reader replaces it with 1.49 KB of\n * arithmetic (measured, brotli).\n *\n * A linear model is a dot product. A tree is a chain of comparisons. That\n * is the whole implementation; there is nothing here that a WebAssembly\n * kernel would do better at this size.\n *\n * The file it reads (`.tmc`, magic `TMC1`) is written by\n * `tempest-fastapi-sdk`'s `export_sklearn_to_compact`, which verifies the\n * bytes against scikit-learn's own predictions and refuses to write a file\n * that disagrees. **It is data, not code**: no `eval`, no generated\n * JavaScript, nothing a strict CSP forbids.\n *\n * The trade against {@link TabularPredictor}: ONNX covers every estimator,\n * this covers linear models and tree ensembles. Pick by what your app\n * already ships — a page that loads ONNX for vision pays nothing extra for\n * tabular ONNX.\n */\n\nimport { CompactFormatError, FeatureShapeError, ModelFetchError } from \"./exceptions\";\nimport type { FeatureRow, PredictedLabel, TabularPrediction } from \"./types\";\n\n/** Magic bytes opening every compact file. */\nconst MAGIC = \"TMC1\";\n\n/** Layout version this reader understands. */\nexport const SUPPORTED_COMPACT_SCHEMA = 1;\n\n/** What the file holds. */\nexport type CompactKind = \"linear\" | \"tree_ensemble\";\n\n/** How raw scores become probabilities. */\ntype CompactLink = \"softmax\" | \"sigmoid\" | \"normalize\" | \"identity\";\n\n/** One array stored after the header. */\ninterface CompactSection {\n    readonly name: string;\n    readonly dtype: \"float32\" | \"int32\";\n    readonly length: number;\n}\n\n/** The parsed header. */\ninterface CompactHeader {\n    readonly schema_version: number;\n    readonly kind: CompactKind;\n    readonly task: \"classification\" | \"regression\";\n    readonly link: CompactLink;\n    readonly classes: readonly string[];\n    /** How scikit-learn typed those labels: ``int``, ``float`` or ``str``. */\n    readonly class_type?: \"int\" | \"float\" | \"str\";\n    readonly n_features: number;\n    readonly n_outputs: number;\n    readonly n_trees?: number;\n    readonly estimator: string;\n    readonly feature_names: readonly string[];\n    readonly preprocess: { readonly offset: number[]; readonly scale: number[] } | null;\n    readonly sections: readonly CompactSection[];\n}\n\n/** What a loaded compact model is. */\nexport interface CompactPredictorInfo {\n    /** Which reader path the file uses. */\n    readonly kind: CompactKind;\n    /** Class labels in score-column order; empty for a regressor. */\n    readonly classes: readonly string[];\n    /** Values expected per row. */\n    readonly numFeatures: number;\n    /** Column order recorded at training time, when the export had one. */\n    readonly featureNames: readonly string[];\n    /** Trees in the ensemble; `0` for a linear model. */\n    readonly numTrees: number;\n    /** Whether the model produces class scores. */\n    readonly isClassifier: boolean;\n    /** Class name of the exported estimator. */\n    readonly estimator: string;\n}\n\n/**\n * A compact model, loaded and ready to answer.\n *\n * @example\n * ```ts\n * const predictor = await CompactPredictor.create(\"/models/risk.tmc\");\n * const { labels, probabilities } = await predictor.predict([[5.1, 3.5, 1.4, 0.2]]);\n * ```\n */\nexport class CompactPredictor {\n    private constructor(\n        private readonly header: CompactHeader,\n        private readonly arrays: Record<string, Float32Array | Int32Array>,\n        /** What is loaded. */\n        public readonly info: CompactPredictorInfo,\n    ) {}\n\n    /**\n     * Load a `.tmc` file.\n     *\n     * @param source A URL, or the bytes when the app already has them.\n     * @param requestInit `fetch` options, when `source` is a URL.\n     * @returns The loaded predictor.\n     * @throws {@link ModelFetchError} when a URL cannot be read.\n     * @throws {@link CompactFormatError} when the bytes are not a compact\n     *   model, or use a layout newer than this reader.\n     */\n    static async create(\n        source: string | ArrayBuffer | Uint8Array,\n        requestInit?: RequestInit,\n    ): Promise<CompactPredictor> {\n        const buffer = await toBuffer(source, requestInit);\n        const bytes = new Uint8Array(buffer);\n\n        if (String.fromCharCode(...bytes.subarray(0, 4)) !== MAGIC) {\n            throw new CompactFormatError(\n                \"This is not a compact model file: it does not start with \" +\n                    `\"${MAGIC}\". A .onnx file goes through TabularPredictor instead.`,\n            );\n        }\n\n        const view = new DataView(buffer);\n        const headerLength = view.getUint32(4, true);\n        const header = JSON.parse(\n            new TextDecoder().decode(bytes.subarray(8, 8 + headerLength)),\n        ) as CompactHeader;\n\n        if (header.schema_version > SUPPORTED_COMPACT_SCHEMA) {\n            throw new CompactFormatError(\n                `This file uses compact layout ${header.schema_version}, and this ` +\n                    `SDK understands ${SUPPORTED_COMPACT_SCHEMA}. Upgrade ` +\n                    \"tempest-react-sdk before serving it.\",\n            );\n        }\n\n        const arrays: Record<string, Float32Array | Int32Array> = {};\n        let cursor = 8 + headerLength;\n        for (const section of header.sections) {\n            arrays[section.name] =\n                section.dtype === \"float32\"\n                    ? new Float32Array(buffer, cursor, section.length)\n                    : new Int32Array(buffer, cursor, section.length);\n            cursor += section.length * 4;\n        }\n\n        return new CompactPredictor(header, arrays, {\n            kind: header.kind,\n            classes: header.classes,\n            numFeatures: header.n_features,\n            featureNames: header.feature_names,\n            numTrees: header.n_trees ?? 0,\n            isClassifier: header.task === \"classification\",\n            estimator: header.estimator,\n        });\n    }\n\n    /**\n     * Predict for a batch of rows.\n     *\n     * @param rows One array of feature values per row, in training column\n     *   order. A single row is still wrapped: `[[...]]`.\n     * @returns Labels, class scores when the model is a classifier, and the\n     *   call's duration.\n     * @throws {@link FeatureShapeError} when the batch is empty, ragged, or\n     *   the wrong width.\n     */\n    async predict(rows: readonly FeatureRow[]): Promise<TabularPrediction> {\n        const width = validateRows(rows, this.header.n_features);\n        const started = performance.now();\n\n        const scores: number[][] = [];\n        for (const row of rows) {\n            const prepared = this.preprocess(row, width);\n            scores.push(\n                this.header.kind === \"linear\"\n                    ? this.linearScores(prepared)\n                    : this.treeScores(prepared),\n            );\n        }\n\n        const { labels, probabilities } = this.finish(scores);\n        return {\n            labels,\n            probabilities,\n            numRows: rows.length,\n            ms: performance.now() - started,\n        };\n    }\n\n    /** Releasing nothing, so callers can swap predictors without branching. */\n    async dispose(): Promise<void> {\n        /* no runtime, nothing to release */\n    }\n\n    /**\n     * Apply the folded scaler, when the export had one.\n     *\n     * @param row The raw feature values.\n     * @param width How many there are.\n     * @returns The values the model was trained on.\n     */\n    private preprocess(row: FeatureRow, width: number): number[] {\n        const preprocess = this.header.preprocess;\n        if (preprocess === null) return row as number[];\n        const scaled = new Array<number>(width);\n        for (let index = 0; index < width; index += 1) {\n            scaled[index] =\n                ((row[index] as number) - (preprocess.offset[index] as number)) /\n                (preprocess.scale[index] as number);\n        }\n        return scaled;\n    }\n\n    /**\n     * Score one row against the coefficient matrix.\n     *\n     * @param row The prepared feature values.\n     * @returns One raw score per output.\n     */\n    private linearScores(row: readonly number[]): number[] {\n        const coef = this.arrays.coef as Float32Array;\n        const intercept = this.arrays.intercept as Float32Array;\n        const features = this.header.n_features;\n        const outputs = this.header.n_outputs;\n\n        const scores = new Array<number>(outputs);\n        for (let output = 0; output < outputs; output += 1) {\n            let total = intercept[output] as number;\n            const base = output * features;\n            for (let index = 0; index < features; index += 1) {\n                total += (coef[base + index] as number) * (row[index] as number);\n            }\n            scores[output] = total;\n        }\n        return scores;\n    }\n\n    /**\n     * Walk every tree and average what the leaves hold.\n     *\n     * A leaf is marked by a negative `feature` entry, which also carries\n     * its slot in the value array — so the walk needs no second lookup and\n     * the file stores values only for leaves.\n     *\n     * **The comparison runs in float32** (`Math.fround`), because that is\n     * what scikit-learn does: it casts its input to float32 before\n     * traversing, so a threshold like 5.099999904632568 — a float32 value\n     * widened for storage — and an input of 5.1 compare *equal* and go\n     * left. Comparing in float64 sends that row right instead, which on an\n     * iris forest changed one tree's vote and moved a probability by 0.05.\n     *\n     * @param row The prepared feature values.\n     * @returns One averaged score per output.\n     */\n    private treeScores(row: readonly number[]): number[] {\n        const feature = this.arrays.node_feature as Int32Array;\n        const threshold = this.arrays.node_threshold as Float32Array;\n        const left = this.arrays.node_left as Int32Array;\n        const right = this.arrays.node_right as Int32Array;\n        const leaf = this.arrays.leaf_value as Float32Array;\n        const offsets = this.arrays.tree_offset as Int32Array;\n        const outputs = this.header.n_outputs;\n        const trees = offsets.length - 1;\n\n        const totals = new Array<number>(outputs).fill(0);\n        for (let tree = 0; tree < trees; tree += 1) {\n            let node = offsets[tree] as number;\n            let column = feature[node] as number;\n            while (column >= 0) {\n                node =\n                    Math.fround(row[column] as number) <= (threshold[node] as number)\n                        ? (left[node] as number)\n                        : (right[node] as number);\n                column = feature[node] as number;\n            }\n            const slot = (-1 - column) * outputs;\n            for (let output = 0; output < outputs; output += 1) {\n                totals[output] += leaf[slot + output] as number;\n            }\n        }\n        for (let output = 0; output < outputs; output += 1) {\n            totals[output] = (totals[output] as number) / trees;\n        }\n        return totals;\n    }\n\n    /**\n     * Turn raw scores into labels and probabilities.\n     *\n     * @param scores One score array per row.\n     * @returns Labels and probabilities in the shape the ONNX route uses,\n     *   so an app can swap runtimes without touching its own code. That\n     *   includes the label's **type**: an integer class comes back as a\n     *   number here exactly as ONNX returns it, because two routes over one\n     *   model that disagree on `0` versus `\"0\"` break the day someone\n     *   switches.\n     */\n    private finish(scores: readonly number[][]): {\n        labels: PredictedLabel[];\n        probabilities: number[][];\n    } {\n        const link = this.header.link;\n        const classes = this.header.classes;\n\n        if (link === \"identity\") {\n            return { labels: scores.map((row) => row[0] as number), probabilities: [] };\n        }\n\n        const probabilities = scores.map((row) => {\n            if (link === \"sigmoid\") {\n                const positive = 1 / (1 + Math.exp(-(row[0] as number)));\n                return [1 - positive, positive];\n            }\n            if (link === \"softmax\") {\n                const highest = Math.max(...row);\n                const exponentiated = row.map((value) => Math.exp(value - highest));\n                const total = exponentiated.reduce((sum, value) => sum + value, 0);\n                return exponentiated.map((value) => value / total);\n            }\n            const total = row.reduce((sum, value) => sum + value, 0);\n            return total === 0 ? [...row] : row.map((value) => value / total);\n        });\n\n        const numeric = this.header.class_type !== \"str\";\n        const labels = probabilities.map((row) => {\n            let best = 0;\n            for (let index = 1; index < row.length; index += 1) {\n                if ((row[index] as number) > (row[best] as number)) best = index;\n            }\n            const label = classes[best];\n            if (label === undefined) return best;\n            return numeric ? Number(label) : label;\n        });\n\n        return { labels, probabilities };\n    }\n}\n\n/**\n * Read a source into an `ArrayBuffer`.\n *\n * @param source A URL or the bytes.\n * @param requestInit `fetch` options.\n * @returns The bytes.\n * @throws {@link ModelFetchError} when the URL cannot be read.\n */\nasync function toBuffer(\n    source: string | ArrayBuffer | Uint8Array,\n    requestInit?: RequestInit,\n): Promise<ArrayBuffer> {\n    if (typeof source === \"string\") {\n        let response: Response;\n        try {\n            response = await fetch(source, requestInit);\n        } catch (error) {\n            throw new ModelFetchError(`Could not download the model: ${source}`, {\n                cause: error,\n            });\n        }\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Could not download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        return await response.arrayBuffer();\n    }\n    if (source instanceof Uint8Array) {\n        return source.buffer.slice(\n            source.byteOffset,\n            source.byteOffset + source.byteLength,\n        ) as ArrayBuffer;\n    }\n    return source;\n}\n\n/**\n * Check a batch before predicting on it.\n *\n * @param rows The batch.\n * @param expected Features the model wants per row.\n * @returns The batch width.\n * @throws {@link FeatureShapeError} when the batch cannot be predicted on.\n */\nfunction validateRows(rows: readonly FeatureRow[], expected: number): number {\n    if (!Array.isArray(rows) || rows.length === 0) {\n        throw new FeatureShapeError(\"predict() needs at least one row, shaped [[f1, f2, ...]].\");\n    }\n    const width = rows[0]?.length ?? 0;\n    const ragged = rows.findIndex((row) => row.length !== width);\n    if (ragged !== -1) {\n        throw new FeatureShapeError(\n            `All rows must have the same width; row ${ragged} has ` +\n                `${rows[ragged]?.length} values, expected ${width}.`,\n        );\n    }\n    if (width !== expected) {\n        throw new FeatureShapeError(\n            `The model expects ${expected} features per row, got ${width}.`,\n        );\n    }\n    return width;\n}\n"],"mappings":"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"}

package/dist/tabular/compact.js.map

@@ -1 +1 @@
-{"version":3,"file":"compact.js","names":[],"sources":["../../src/tabular/compact.ts"],"sourcesContent":["/**\n * @tempest-limits file-lines — the compact model format: the header, the column\n * dictionary, the quantised weights and the decoder that reads them back. Writer and\n * reader in one file because a format whose two halves live apart drifts.\n */\n/**\n * Running a model with no inference runtime at all.\n *\n * ONNX in the browser costs a **25.6 MB WebAssembly runtime** (6.0 MB\n * gzipped) before the first prediction, while the model itself is a few\n * hundred kilobytes. For an app whose only model is tabular, that runtime\n * *is* the download — so this reader replaces it with 1.49 KB of\n * arithmetic (measured, brotli).\n *\n * A linear model is a dot product. A tree is a chain of comparisons. That\n * is the whole implementation; there is nothing here that a WebAssembly\n * kernel would do better at this size.\n *\n * The file it reads (`.tmc`, magic `TMC1`) is written by\n * `tempest-fastapi-sdk`'s `export_sklearn_to_compact`, which verifies the\n * bytes against scikit-learn's own predictions and refuses to write a file\n * that disagrees. **It is data, not code**: no `eval`, no generated\n * JavaScript, nothing a strict CSP forbids.\n *\n * The trade against {@link TabularPredictor}: ONNX covers every estimator,\n * this covers linear models and tree ensembles. Pick by what your app\n * already ships — a page that loads ONNX for vision pays nothing extra for\n * tabular ONNX.\n */\n\nimport { CompactFormatError, FeatureShapeError, ModelFetchError } from \"./exceptions\";\nimport type { FeatureRow, PredictedLabel, TabularPrediction } from \"./types\";\n\n/** Magic bytes opening every compact file. */\nconst MAGIC = \"TMC1\";\n\n/** Layout version this reader understands. */\nexport const SUPPORTED_COMPACT_SCHEMA = 1;\n\n/** What the file holds. */\nexport type CompactKind = \"linear\" | \"tree_ensemble\";\n\n/** How raw scores become probabilities. */\ntype CompactLink = \"softmax\" | \"sigmoid\" | \"normalize\" | \"identity\";\n\n/** One array stored after the header. */\ninterface CompactSection {\n    readonly name: string;\n    readonly dtype: \"float32\" | \"int32\";\n    readonly length: number;\n}\n\n/** The parsed header. */\ninterface CompactHeader {\n    readonly schema_version: number;\n    readonly kind: CompactKind;\n    readonly task: \"classification\" | \"regression\";\n    readonly link: CompactLink;\n    readonly classes: readonly string[];\n    /** How scikit-learn typed those labels: ``int``, ``float`` or ``str``. */\n    readonly class_type?: \"int\" | \"float\" | \"str\";\n    readonly n_features: number;\n    readonly n_outputs: number;\n    readonly n_trees?: number;\n    readonly estimator: string;\n    readonly feature_names: readonly string[];\n    readonly preprocess: { readonly offset: number[]; readonly scale: number[] } | null;\n    readonly sections: readonly CompactSection[];\n}\n\n/** What a loaded compact model is. */\nexport interface CompactPredictorInfo {\n    /** Which reader path the file uses. */\n    readonly kind: CompactKind;\n    /** Class labels in score-column order; empty for a regressor. */\n    readonly classes: readonly string[];\n    /** Values expected per row. */\n    readonly numFeatures: number;\n    /** Column order recorded at training time, when the export had one. */\n    readonly featureNames: readonly string[];\n    /** Trees in the ensemble; `0` for a linear model. */\n    readonly numTrees: number;\n    /** Whether the model produces class scores. */\n    readonly isClassifier: boolean;\n    /** Class name of the exported estimator. */\n    readonly estimator: string;\n}\n\n/**\n * A compact model, loaded and ready to answer.\n *\n * @example\n * ```ts\n * const predictor = await CompactPredictor.create(\"/models/risk.tmc\");\n * const { labels, probabilities } = await predictor.predict([[5.1, 3.5, 1.4, 0.2]]);\n * ```\n */\nexport class CompactPredictor {\n    private constructor(\n        private readonly header: CompactHeader,\n        private readonly arrays: Record<string, Float32Array | Int32Array>,\n        /** What is loaded. */\n        public readonly info: CompactPredictorInfo,\n    ) {}\n\n    /**\n     * Load a `.tmc` file.\n     *\n     * @param source A URL, or the bytes when the app already has them.\n     * @param requestInit `fetch` options, when `source` is a URL.\n     * @returns The loaded predictor.\n     * @throws {@link ModelFetchError} when a URL cannot be read.\n     * @throws {@link CompactFormatError} when the bytes are not a compact\n     *   model, or use a layout newer than this reader.\n     */\n    static async create(\n        source: string | ArrayBuffer | Uint8Array,\n        requestInit?: RequestInit,\n    ): Promise<CompactPredictor> {\n        const buffer = await toBuffer(source, requestInit);\n        const bytes = new Uint8Array(buffer);\n\n        if (String.fromCharCode(...bytes.subarray(0, 4)) !== MAGIC) {\n            throw new CompactFormatError(\n                \"This is not a compact model file: it does not start with \" +\n                    `\"${MAGIC}\". A .onnx file goes through TabularPredictor instead.`,\n            );\n        }\n\n        const view = new DataView(buffer);\n        const headerLength = view.getUint32(4, true);\n        const header = JSON.parse(\n            new TextDecoder().decode(bytes.subarray(8, 8 + headerLength)),\n        ) as CompactHeader;\n\n        if (header.schema_version > SUPPORTED_COMPACT_SCHEMA) {\n            throw new CompactFormatError(\n                `This file uses compact layout ${header.schema_version}, and this ` +\n                    `SDK understands ${SUPPORTED_COMPACT_SCHEMA}. Upgrade ` +\n                    \"tempest-react-sdk before serving it.\",\n            );\n        }\n\n        const arrays: Record<string, Float32Array | Int32Array> = {};\n        let cursor = 8 + headerLength;\n        for (const section of header.sections) {\n            arrays[section.name] =\n                section.dtype === \"float32\"\n                    ? new Float32Array(buffer, cursor, section.length)\n                    : new Int32Array(buffer, cursor, section.length);\n            cursor += section.length * 4;\n        }\n\n        return new CompactPredictor(header, arrays, {\n            kind: header.kind,\n            classes: header.classes,\n            numFeatures: header.n_features,\n            featureNames: header.feature_names,\n            numTrees: header.n_trees ?? 0,\n            isClassifier: header.task === \"classification\",\n            estimator: header.estimator,\n        });\n    }\n\n    /**\n     * Predict for a batch of rows.\n     *\n     * @param rows One array of feature values per row, in training column\n     *   order. A single row is still wrapped: `[[...]]`.\n     * @returns Labels, class scores when the model is a classifier, and the\n     *   call's duration.\n     * @throws {@link FeatureShapeError} when the batch is empty, ragged, or\n     *   the wrong width.\n     */\n    async predict(rows: readonly FeatureRow[]): Promise<TabularPrediction> {\n        const width = validateRows(rows, this.header.n_features);\n        const started = performance.now();\n\n        const scores: number[][] = [];\n        for (const row of rows) {\n            const prepared = this.preprocess(row, width);\n            scores.push(\n                this.header.kind === \"linear\"\n                    ? this.linearScores(prepared)\n                    : this.treeScores(prepared),\n            );\n        }\n\n        const { labels, probabilities } = this.finish(scores);\n        return {\n            labels,\n            probabilities,\n            numRows: rows.length,\n            ms: performance.now() - started,\n        };\n    }\n\n    /** Releasing nothing, so callers can swap predictors without branching. */\n    async dispose(): Promise<void> {\n        /* no runtime, nothing to release */\n    }\n\n    /**\n     * Apply the folded scaler, when the export had one.\n     *\n     * @param row The raw feature values.\n     * @param width How many there are.\n     * @returns The values the model was trained on.\n     */\n    private preprocess(row: FeatureRow, width: number): number[] {\n        const preprocess = this.header.preprocess;\n        if (preprocess === null) return row as number[];\n        const scaled = new Array<number>(width);\n        for (let index = 0; index < width; index += 1) {\n            scaled[index] =\n                ((row[index] as number) - (preprocess.offset[index] as number)) /\n                (preprocess.scale[index] as number);\n        }\n        return scaled;\n    }\n\n    /**\n     * Score one row against the coefficient matrix.\n     *\n     * @param row The prepared feature values.\n     * @returns One raw score per output.\n     */\n    private linearScores(row: readonly number[]): number[] {\n        const coef = this.arrays.coef as Float32Array;\n        const intercept = this.arrays.intercept as Float32Array;\n        const features = this.header.n_features;\n        const outputs = this.header.n_outputs;\n\n        const scores = new Array<number>(outputs);\n        for (let output = 0; output < outputs; output += 1) {\n            let total = intercept[output] as number;\n            const base = output * features;\n            for (let index = 0; index < features; index += 1) {\n                total += (coef[base + index] as number) * (row[index] as number);\n            }\n            scores[output] = total;\n        }\n        return scores;\n    }\n\n    /**\n     * Walk every tree and average what the leaves hold.\n     *\n     * A leaf is marked by a negative `feature` entry, which also carries\n     * its slot in the value array — so the walk needs no second lookup and\n     * the file stores values only for leaves.\n     *\n     * **The comparison runs in float32** (`Math.fround`), because that is\n     * what scikit-learn does: it casts its input to float32 before\n     * traversing, so a threshold like 5.099999904632568 — a float32 value\n     * widened for storage — and an input of 5.1 compare *equal* and go\n     * left. Comparing in float64 sends that row right instead, which on an\n     * iris forest changed one tree's vote and moved a probability by 0.05.\n     *\n     * @param row The prepared feature values.\n     * @returns One averaged score per output.\n     */\n    private treeScores(row: readonly number[]): number[] {\n        const feature = this.arrays.node_feature as Int32Array;\n        const threshold = this.arrays.node_threshold as Float32Array;\n        const left = this.arrays.node_left as Int32Array;\n        const right = this.arrays.node_right as Int32Array;\n        const leaf = this.arrays.leaf_value as Float32Array;\n        const offsets = this.arrays.tree_offset as Int32Array;\n        const outputs = this.header.n_outputs;\n        const trees = offsets.length - 1;\n\n        const totals = new Array<number>(outputs).fill(0);\n        for (let tree = 0; tree < trees; tree += 1) {\n            let node = offsets[tree] as number;\n            let column = feature[node] as number;\n            while (column >= 0) {\n                node =\n                    Math.fround(row[column] as number) <= (threshold[node] as number)\n                        ? (left[node] as number)\n                        : (right[node] as number);\n                column = feature[node] as number;\n            }\n            const slot = (-1 - column) * outputs;\n            for (let output = 0; output < outputs; output += 1) {\n                totals[output] += leaf[slot + output] as number;\n            }\n        }\n        for (let output = 0; output < outputs; output += 1) {\n            totals[output] = (totals[output] as number) / trees;\n        }\n        return totals;\n    }\n\n    /**\n     * Turn raw scores into labels and probabilities.\n     *\n     * @param scores One score array per row.\n     * @returns Labels and probabilities in the shape the ONNX route uses,\n     *   so an app can swap runtimes without touching its own code. That\n     *   includes the label's **type**: an integer class comes back as a\n     *   number here exactly as ONNX returns it, because two routes over one\n     *   model that disagree on `0` versus `\"0\"` break the day someone\n     *   switches.\n     */\n    private finish(scores: readonly number[][]): {\n        labels: PredictedLabel[];\n        probabilities: number[][];\n    } {\n        const link = this.header.link;\n        const classes = this.header.classes;\n\n        if (link === \"identity\") {\n            return { labels: scores.map((row) => row[0] as number), probabilities: [] };\n        }\n\n        const probabilities = scores.map((row) => {\n            if (link === \"sigmoid\") {\n                const positive = 1 / (1 + Math.exp(-(row[0] as number)));\n                return [1 - positive, positive];\n            }\n            if (link === \"softmax\") {\n                const highest = Math.max(...row);\n                const exponentiated = row.map((value) => Math.exp(value - highest));\n                const total = exponentiated.reduce((sum, value) => sum + value, 0);\n                return exponentiated.map((value) => value / total);\n            }\n            const total = row.reduce((sum, value) => sum + value, 0);\n            return total === 0 ? [...row] : row.map((value) => value / total);\n        });\n\n        const numeric = this.header.class_type !== \"str\";\n        const labels = probabilities.map((row) => {\n            let best = 0;\n            for (let index = 1; index < row.length; index += 1) {\n                if ((row[index] as number) > (row[best] as number)) best = index;\n            }\n            const label = classes[best];\n            if (label === undefined) return best;\n            return numeric ? Number(label) : label;\n        });\n\n        return { labels, probabilities };\n    }\n}\n\n/**\n * Read a source into an `ArrayBuffer`.\n *\n * @param source A URL or the bytes.\n * @param requestInit `fetch` options.\n * @returns The bytes.\n * @throws {@link ModelFetchError} when the URL cannot be read.\n */\nasync function toBuffer(\n    source: string | ArrayBuffer | Uint8Array,\n    requestInit?: RequestInit,\n): Promise<ArrayBuffer> {\n    if (typeof source === \"string\") {\n        let response: Response;\n        try {\n            response = await fetch(source, requestInit);\n        } catch (error) {\n            throw new ModelFetchError(`Could not download the model: ${source}`, {\n                cause: error,\n            });\n        }\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Could not download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        return await response.arrayBuffer();\n    }\n    if (source instanceof Uint8Array) {\n        return source.buffer.slice(\n            source.byteOffset,\n            source.byteOffset + source.byteLength,\n        ) as ArrayBuffer;\n    }\n    return source;\n}\n\n/**\n * Check a batch before predicting on it.\n *\n * @param rows The batch.\n * @param expected Features the model wants per row.\n * @returns The batch width.\n * @throws {@link FeatureShapeError} when the batch cannot be predicted on.\n */\nfunction validateRows(rows: readonly FeatureRow[], expected: number): number {\n    if (!Array.isArray(rows) || rows.length === 0) {\n        throw new FeatureShapeError(\"predict() needs at least one row, shaped [[f1, f2, ...]].\");\n    }\n    const width = rows[0]?.length ?? 0;\n    const ragged = rows.findIndex((row) => row.length !== width);\n    if (ragged !== -1) {\n        throw new FeatureShapeError(\n            `All rows must have the same width; row ${ragged} has ` +\n                `${rows[ragged]?.length} values, expected ${width}.`,\n        );\n    }\n    if (width !== expected) {\n        throw new FeatureShapeError(\n            `The model expects ${expected} features per row, got ${width}.`,\n        );\n    }\n    return width;\n}\n"],"mappings":"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"}
+{"version":3,"file":"compact.js","names":["MAGIC","CompactPredictor","header","arrays","info","buffer","toBuffer","source","requestInit","bytes","CompactFormatError","headerLength","cursor","section","width","validateRows","rows","started","scores","row","prepared","preprocess","scaled","index","coef","intercept","features","outputs","output","total","base","feature","threshold","left","right","leaf","offsets","trees","totals","tree","node","column","slot","link","classes","probabilities","positive","highest","exponentiated","value","sum","numeric","best","label","response","error","ModelFetchError","FeatureShapeError","ragged","expected"],"sources":["../../src/tabular/compact.ts"],"sourcesContent":["/**\n * @tempest-limits file-lines — the compact model format: the header, the column\n * dictionary, the quantised weights and the decoder that reads them back. Writer and\n * reader in one file because a format whose two halves live apart drifts.\n */\n/**\n * Running a model with no inference runtime at all.\n *\n * ONNX in the browser costs a **25.6 MB WebAssembly runtime** (6.0 MB\n * gzipped) before the first prediction, while the model itself is a few\n * hundred kilobytes. For an app whose only model is tabular, that runtime\n * *is* the download — so this reader replaces it with 1.49 KB of\n * arithmetic (measured, brotli).\n *\n * A linear model is a dot product. A tree is a chain of comparisons. That\n * is the whole implementation; there is nothing here that a WebAssembly\n * kernel would do better at this size.\n *\n * The file it reads (`.tmc`, magic `TMC1`) is written by\n * `tempest-fastapi-sdk`'s `export_sklearn_to_compact`, which verifies the\n * bytes against scikit-learn's own predictions and refuses to write a file\n * that disagrees. **It is data, not code**: no `eval`, no generated\n * JavaScript, nothing a strict CSP forbids.\n *\n * The trade against {@link TabularPredictor}: ONNX covers every estimator,\n * this covers linear models and tree ensembles. Pick by what your app\n * already ships — a page that loads ONNX for vision pays nothing extra for\n * tabular ONNX.\n */\n\nimport { CompactFormatError, FeatureShapeError, ModelFetchError } from \"./exceptions\";\nimport type { FeatureRow, PredictedLabel, TabularPrediction } from \"./types\";\n\n/** Magic bytes opening every compact file. */\nconst MAGIC = \"TMC1\";\n\n/** Layout version this reader understands. */\nexport const SUPPORTED_COMPACT_SCHEMA = 1;\n\n/** What the file holds. */\nexport type CompactKind = \"linear\" | \"tree_ensemble\";\n\n/** How raw scores become probabilities. */\ntype CompactLink = \"softmax\" | \"sigmoid\" | \"normalize\" | \"identity\";\n\n/** One array stored after the header. */\ninterface CompactSection {\n    readonly name: string;\n    readonly dtype: \"float32\" | \"int32\";\n    readonly length: number;\n}\n\n/** The parsed header. */\ninterface CompactHeader {\n    readonly schema_version: number;\n    readonly kind: CompactKind;\n    readonly task: \"classification\" | \"regression\";\n    readonly link: CompactLink;\n    readonly classes: readonly string[];\n    /** How scikit-learn typed those labels: ``int``, ``float`` or ``str``. */\n    readonly class_type?: \"int\" | \"float\" | \"str\";\n    readonly n_features: number;\n    readonly n_outputs: number;\n    readonly n_trees?: number;\n    readonly estimator: string;\n    readonly feature_names: readonly string[];\n    readonly preprocess: { readonly offset: number[]; readonly scale: number[] } | null;\n    readonly sections: readonly CompactSection[];\n}\n\n/** What a loaded compact model is. */\nexport interface CompactPredictorInfo {\n    /** Which reader path the file uses. */\n    readonly kind: CompactKind;\n    /** Class labels in score-column order; empty for a regressor. */\n    readonly classes: readonly string[];\n    /** Values expected per row. */\n    readonly numFeatures: number;\n    /** Column order recorded at training time, when the export had one. */\n    readonly featureNames: readonly string[];\n    /** Trees in the ensemble; `0` for a linear model. */\n    readonly numTrees: number;\n    /** Whether the model produces class scores. */\n    readonly isClassifier: boolean;\n    /** Class name of the exported estimator. */\n    readonly estimator: string;\n}\n\n/**\n * A compact model, loaded and ready to answer.\n *\n * @example\n * ```ts\n * const predictor = await CompactPredictor.create(\"/models/risk.tmc\");\n * const { labels, probabilities } = await predictor.predict([[5.1, 3.5, 1.4, 0.2]]);\n * ```\n */\nexport class CompactPredictor {\n    private constructor(\n        private readonly header: CompactHeader,\n        private readonly arrays: Record<string, Float32Array | Int32Array>,\n        /** What is loaded. */\n        public readonly info: CompactPredictorInfo,\n    ) {}\n\n    /**\n     * Load a `.tmc` file.\n     *\n     * @param source A URL, or the bytes when the app already has them.\n     * @param requestInit `fetch` options, when `source` is a URL.\n     * @returns The loaded predictor.\n     * @throws {@link ModelFetchError} when a URL cannot be read.\n     * @throws {@link CompactFormatError} when the bytes are not a compact\n     *   model, or use a layout newer than this reader.\n     */\n    static async create(\n        source: string | ArrayBuffer | Uint8Array,\n        requestInit?: RequestInit,\n    ): Promise<CompactPredictor> {\n        const buffer = await toBuffer(source, requestInit);\n        const bytes = new Uint8Array(buffer);\n\n        if (String.fromCharCode(...bytes.subarray(0, 4)) !== MAGIC) {\n            throw new CompactFormatError(\n                \"This is not a compact model file: it does not start with \" +\n                    `\"${MAGIC}\". A .onnx file goes through TabularPredictor instead.`,\n            );\n        }\n\n        const view = new DataView(buffer);\n        const headerLength = view.getUint32(4, true);\n        const header = JSON.parse(\n            new TextDecoder().decode(bytes.subarray(8, 8 + headerLength)),\n        ) as CompactHeader;\n\n        if (header.schema_version > SUPPORTED_COMPACT_SCHEMA) {\n            throw new CompactFormatError(\n                `This file uses compact layout ${header.schema_version}, and this ` +\n                    `SDK understands ${SUPPORTED_COMPACT_SCHEMA}. Upgrade ` +\n                    \"tempest-react-sdk before serving it.\",\n            );\n        }\n\n        const arrays: Record<string, Float32Array | Int32Array> = {};\n        let cursor = 8 + headerLength;\n        for (const section of header.sections) {\n            arrays[section.name] =\n                section.dtype === \"float32\"\n                    ? new Float32Array(buffer, cursor, section.length)\n                    : new Int32Array(buffer, cursor, section.length);\n            cursor += section.length * 4;\n        }\n\n        return new CompactPredictor(header, arrays, {\n            kind: header.kind,\n            classes: header.classes,\n            numFeatures: header.n_features,\n            featureNames: header.feature_names,\n            numTrees: header.n_trees ?? 0,\n            isClassifier: header.task === \"classification\",\n            estimator: header.estimator,\n        });\n    }\n\n    /**\n     * Predict for a batch of rows.\n     *\n     * @param rows One array of feature values per row, in training column\n     *   order. A single row is still wrapped: `[[...]]`.\n     * @returns Labels, class scores when the model is a classifier, and the\n     *   call's duration.\n     * @throws {@link FeatureShapeError} when the batch is empty, ragged, or\n     *   the wrong width.\n     */\n    async predict(rows: readonly FeatureRow[]): Promise<TabularPrediction> {\n        const width = validateRows(rows, this.header.n_features);\n        const started = performance.now();\n\n        const scores: number[][] = [];\n        for (const row of rows) {\n            const prepared = this.preprocess(row, width);\n            scores.push(\n                this.header.kind === \"linear\"\n                    ? this.linearScores(prepared)\n                    : this.treeScores(prepared),\n            );\n        }\n\n        const { labels, probabilities } = this.finish(scores);\n        return {\n            labels,\n            probabilities,\n            numRows: rows.length,\n            ms: performance.now() - started,\n        };\n    }\n\n    /** Releasing nothing, so callers can swap predictors without branching. */\n    async dispose(): Promise<void> {\n        /* no runtime, nothing to release */\n    }\n\n    /**\n     * Apply the folded scaler, when the export had one.\n     *\n     * @param row The raw feature values.\n     * @param width How many there are.\n     * @returns The values the model was trained on.\n     */\n    private preprocess(row: FeatureRow, width: number): number[] {\n        const preprocess = this.header.preprocess;\n        if (preprocess === null) return row as number[];\n        const scaled = new Array<number>(width);\n        for (let index = 0; index < width; index += 1) {\n            scaled[index] =\n                ((row[index] as number) - (preprocess.offset[index] as number)) /\n                (preprocess.scale[index] as number);\n        }\n        return scaled;\n    }\n\n    /**\n     * Score one row against the coefficient matrix.\n     *\n     * @param row The prepared feature values.\n     * @returns One raw score per output.\n     */\n    private linearScores(row: readonly number[]): number[] {\n        const coef = this.arrays.coef as Float32Array;\n        const intercept = this.arrays.intercept as Float32Array;\n        const features = this.header.n_features;\n        const outputs = this.header.n_outputs;\n\n        const scores = new Array<number>(outputs);\n        for (let output = 0; output < outputs; output += 1) {\n            let total = intercept[output] as number;\n            const base = output * features;\n            for (let index = 0; index < features; index += 1) {\n                total += (coef[base + index] as number) * (row[index] as number);\n            }\n            scores[output] = total;\n        }\n        return scores;\n    }\n\n    /**\n     * Walk every tree and average what the leaves hold.\n     *\n     * A leaf is marked by a negative `feature` entry, which also carries\n     * its slot in the value array — so the walk needs no second lookup and\n     * the file stores values only for leaves.\n     *\n     * **The comparison runs in float32** (`Math.fround`), because that is\n     * what scikit-learn does: it casts its input to float32 before\n     * traversing, so a threshold like 5.099999904632568 — a float32 value\n     * widened for storage — and an input of 5.1 compare *equal* and go\n     * left. Comparing in float64 sends that row right instead, which on an\n     * iris forest changed one tree's vote and moved a probability by 0.05.\n     *\n     * @param row The prepared feature values.\n     * @returns One averaged score per output.\n     */\n    private treeScores(row: readonly number[]): number[] {\n        const feature = this.arrays.node_feature as Int32Array;\n        const threshold = this.arrays.node_threshold as Float32Array;\n        const left = this.arrays.node_left as Int32Array;\n        const right = this.arrays.node_right as Int32Array;\n        const leaf = this.arrays.leaf_value as Float32Array;\n        const offsets = this.arrays.tree_offset as Int32Array;\n        const outputs = this.header.n_outputs;\n        const trees = offsets.length - 1;\n\n        const totals = new Array<number>(outputs).fill(0);\n        for (let tree = 0; tree < trees; tree += 1) {\n            let node = offsets[tree] as number;\n            let column = feature[node] as number;\n            while (column >= 0) {\n                node =\n                    Math.fround(row[column] as number) <= (threshold[node] as number)\n                        ? (left[node] as number)\n                        : (right[node] as number);\n                column = feature[node] as number;\n            }\n            const slot = (-1 - column) * outputs;\n            for (let output = 0; output < outputs; output += 1) {\n                totals[output] += leaf[slot + output] as number;\n            }\n        }\n        for (let output = 0; output < outputs; output += 1) {\n            totals[output] = (totals[output] as number) / trees;\n        }\n        return totals;\n    }\n\n    /**\n     * Turn raw scores into labels and probabilities.\n     *\n     * @param scores One score array per row.\n     * @returns Labels and probabilities in the shape the ONNX route uses,\n     *   so an app can swap runtimes without touching its own code. That\n     *   includes the label's **type**: an integer class comes back as a\n     *   number here exactly as ONNX returns it, because two routes over one\n     *   model that disagree on `0` versus `\"0\"` break the day someone\n     *   switches.\n     */\n    private finish(scores: readonly number[][]): {\n        labels: PredictedLabel[];\n        probabilities: number[][];\n    } {\n        const link = this.header.link;\n        const classes = this.header.classes;\n\n        if (link === \"identity\") {\n            return { labels: scores.map((row) => row[0] as number), probabilities: [] };\n        }\n\n        const probabilities = scores.map((row) => {\n            if (link === \"sigmoid\") {\n                const positive = 1 / (1 + Math.exp(-(row[0] as number)));\n                return [1 - positive, positive];\n            }\n            if (link === \"softmax\") {\n                const highest = Math.max(...row);\n                const exponentiated = row.map((value) => Math.exp(value - highest));\n                const total = exponentiated.reduce((sum, value) => sum + value, 0);\n                return exponentiated.map((value) => value / total);\n            }\n            const total = row.reduce((sum, value) => sum + value, 0);\n            return total === 0 ? [...row] : row.map((value) => value / total);\n        });\n\n        const numeric = this.header.class_type !== \"str\";\n        const labels = probabilities.map((row) => {\n            let best = 0;\n            for (let index = 1; index < row.length; index += 1) {\n                if ((row[index] as number) > (row[best] as number)) best = index;\n            }\n            const label = classes[best];\n            if (label === undefined) return best;\n            return numeric ? Number(label) : label;\n        });\n\n        return { labels, probabilities };\n    }\n}\n\n/**\n * Read a source into an `ArrayBuffer`.\n *\n * @param source A URL or the bytes.\n * @param requestInit `fetch` options.\n * @returns The bytes.\n * @throws {@link ModelFetchError} when the URL cannot be read.\n */\nasync function toBuffer(\n    source: string | ArrayBuffer | Uint8Array,\n    requestInit?: RequestInit,\n): Promise<ArrayBuffer> {\n    if (typeof source === \"string\") {\n        let response: Response;\n        try {\n            response = await fetch(source, requestInit);\n        } catch (error) {\n            throw new ModelFetchError(`Could not download the model: ${source}`, {\n                cause: error,\n            });\n        }\n        if (!response.ok) {\n            throw new ModelFetchError(\n                `Could not download the model: ${response.status} ${response.statusText}`,\n            );\n        }\n        return await response.arrayBuffer();\n    }\n    if (source instanceof Uint8Array) {\n        return source.buffer.slice(\n            source.byteOffset,\n            source.byteOffset + source.byteLength,\n        ) as ArrayBuffer;\n    }\n    return source;\n}\n\n/**\n * Check a batch before predicting on it.\n *\n * @param rows The batch.\n * @param expected Features the model wants per row.\n * @returns The batch width.\n * @throws {@link FeatureShapeError} when the batch cannot be predicted on.\n */\nfunction validateRows(rows: readonly FeatureRow[], expected: number): number {\n    if (!Array.isArray(rows) || rows.length === 0) {\n        throw new FeatureShapeError(\"predict() needs at least one row, shaped [[f1, f2, ...]].\");\n    }\n    const width = rows[0]?.length ?? 0;\n    const ragged = rows.findIndex((row) => row.length !== width);\n    if (ragged !== -1) {\n        throw new FeatureShapeError(\n            `All rows must have the same width; row ${ragged} has ` +\n                `${rows[ragged]?.length} values, expected ${width}.`,\n        );\n    }\n    if (width !== expected) {\n        throw new FeatureShapeError(\n            `The model expects ${expected} features per row, got ${width}.`,\n        );\n    }\n    return width;\n}\n"],"mappings":"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"}

package/dist/tabular/exceptions.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"exceptions.cjs","names":[],"sources":["../../src/tabular/exceptions.ts"],"sourcesContent":["/**\n * Errors thrown by the tabular inference module.\n *\n * Each one exists because the underlying failure is unreadable on its own:\n * ONNX Runtime reports a missing operator registration, and the actual cause\n * is an import path chosen three files away.\n *\n * Every subclass sets `name` to a **literal** string rather than to\n * `new.target.name`. Measured in a real build: the minifier renames the\n * class, so the derived form ships as `error.name === \"t\"` — useless in a\n * log and in any consumer that branches on the name.\n */\n\n/** Base class for every error this module throws. */\nexport class TabularError extends Error {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"TabularError\";\n    }\n}\n\n/** The model bytes could not be loaded into a session. */\nexport class ModelLoadError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"ModelLoadError\";\n    }\n}\n\n/**\n * The runtime has no kernels for this graph's operators.\n *\n * Measured, and the reason this class exists: importing\n * `onnxruntime-web/webgpu` loads a WebAssembly build without the\n * `ai.onnx.ml` domain, so creating a session over any scikit-learn export\n * fails with `No Op registered for TreeEnsembleClassifier`. The message\n * names the fix, because the raw error points at the model instead of at\n * the import.\n */\nexport class UnsupportedGraphError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"UnsupportedGraphError\";\n    }\n}\n\n/**\n * The bytes are not a compact model, or use a newer layout.\n *\n * Separate from {@link ModelLoadError} because the fix is different: a\n * `.onnx` file handed to the compact reader is a wiring mistake, not a\n * broken model.\n */\nexport class CompactFormatError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"CompactFormatError\";\n    }\n}\n\n/** The rows do not match what the model expects. */\nexport class FeatureShapeError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"FeatureShapeError\";\n    }\n}\n\n/** The session ran but its outputs could not be read. */\nexport class InferenceError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"InferenceError\";\n    }\n}\n\n/**\n * The model bytes could not be fetched or read from the cache.\n *\n * Distinct from {@link ModelLoadError}: this one means the app is offline\n * and nothing was cached, which is a deployment problem, not a model\n * problem.\n */\nexport class ModelFetchError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"ModelFetchError\";\n    }\n}\n"],"mappings":"AAcA,IAAa,EAAb,cAAkC,KAAM,CACpC,YAAY,EAAiB,EAAwB,CACjD,MAAM,EAAS,CAAO,EACtB,KAAK,KAAO,cAChB,CACJ,EAGa,EAAb,cAAoC,CAAa,CAC7C,YAAY,EAAiB,EAAwB,CACjD,MAAM,EAAS,CAAO,EACtB,KAAK,KAAO,gBAChB,CACJ,EAYa,EAAb,cAA2C,CAAa,CACpD,YAAY,EAAiB,EAAwB,CACjD,MAAM,EAAS,CAAO,EACtB,KAAK,KAAO,uBAChB,CACJ,EASa,EAAb,cAAwC,CAAa,CACjD,YAAY,EAAiB,EAAwB,CACjD,MAAM,EAAS,CAAO,EACtB,KAAK,KAAO,oBAChB,CACJ,EAGa,EAAb,cAAuC,CAAa,CAChD,YAAY,EAAiB,EAAwB,CACjD,MAAM,EAAS,CAAO,EACtB,KAAK,KAAO,mBAChB,CACJ,EAGa,EAAb,cAAoC,CAAa,CAC7C,YAAY,EAAiB,EAAwB,CACjD,MAAM,EAAS,CAAO,EACtB,KAAK,KAAO,gBAChB,CACJ,EASa,EAAb,cAAqC,CAAa,CAC9C,YAAY,EAAiB,EAAwB,CACjD,MAAM,EAAS,CAAO,EACtB,KAAK,KAAO,iBAChB,CACJ"}
+{"version":3,"file":"exceptions.cjs","names":["TabularError","message","options","ModelLoadError","UnsupportedGraphError","CompactFormatError","FeatureShapeError","InferenceError","ModelFetchError"],"sources":["../../src/tabular/exceptions.ts"],"sourcesContent":["/**\n * Errors thrown by the tabular inference module.\n *\n * Each one exists because the underlying failure is unreadable on its own:\n * ONNX Runtime reports a missing operator registration, and the actual cause\n * is an import path chosen three files away.\n *\n * Every subclass sets `name` to a **literal** string rather than to\n * `new.target.name`. Measured in a real build: the minifier renames the\n * class, so the derived form ships as `error.name === \"t\"` — useless in a\n * log and in any consumer that branches on the name.\n */\n\n/** Base class for every error this module throws. */\nexport class TabularError extends Error {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"TabularError\";\n    }\n}\n\n/** The model bytes could not be loaded into a session. */\nexport class ModelLoadError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"ModelLoadError\";\n    }\n}\n\n/**\n * The runtime has no kernels for this graph's operators.\n *\n * Measured, and the reason this class exists: importing\n * `onnxruntime-web/webgpu` loads a WebAssembly build without the\n * `ai.onnx.ml` domain, so creating a session over any scikit-learn export\n * fails with `No Op registered for TreeEnsembleClassifier`. The message\n * names the fix, because the raw error points at the model instead of at\n * the import.\n */\nexport class UnsupportedGraphError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"UnsupportedGraphError\";\n    }\n}\n\n/**\n * The bytes are not a compact model, or use a newer layout.\n *\n * Separate from {@link ModelLoadError} because the fix is different: a\n * `.onnx` file handed to the compact reader is a wiring mistake, not a\n * broken model.\n */\nexport class CompactFormatError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"CompactFormatError\";\n    }\n}\n\n/** The rows do not match what the model expects. */\nexport class FeatureShapeError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"FeatureShapeError\";\n    }\n}\n\n/** The session ran but its outputs could not be read. */\nexport class InferenceError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"InferenceError\";\n    }\n}\n\n/**\n * The model bytes could not be fetched or read from the cache.\n *\n * Distinct from {@link ModelLoadError}: this one means the app is offline\n * and nothing was cached, which is a deployment problem, not a model\n * problem.\n */\nexport class ModelFetchError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"ModelFetchError\";\n    }\n}\n"],"mappings":"AAcA,IAAaA,EAAb,cAAkC,KAAM,CACpC,YAAY,EAAiB,EAAwB,CACjD,MAAMC,EAASC,CAAO,EACtB,KAAK,KAAO,cAChB,CACJ,EAGaC,EAAb,cAAoCH,CAAa,CAC7C,YAAY,EAAiB,EAAwB,CACjD,MAAMC,EAASC,CAAO,EACtB,KAAK,KAAO,gBAChB,CACJ,EAYaE,EAAb,cAA2CJ,CAAa,CACpD,YAAY,EAAiB,EAAwB,CACjD,MAAMC,EAASC,CAAO,EACtB,KAAK,KAAO,uBAChB,CACJ,EASaG,EAAb,cAAwCL,CAAa,CACjD,YAAY,EAAiB,EAAwB,CACjD,MAAMC,EAASC,CAAO,EACtB,KAAK,KAAO,oBAChB,CACJ,EAGaI,EAAb,cAAuCN,CAAa,CAChD,YAAY,EAAiB,EAAwB,CACjD,MAAMC,EAASC,CAAO,EACtB,KAAK,KAAO,mBAChB,CACJ,EAGaK,EAAb,cAAoCP,CAAa,CAC7C,YAAY,EAAiB,EAAwB,CACjD,MAAMC,EAASC,CAAO,EACtB,KAAK,KAAO,gBAChB,CACJ,EASaM,EAAb,cAAqCR,CAAa,CAC9C,YAAY,EAAiB,EAAwB,CACjD,MAAMC,EAASC,CAAO,EACtB,KAAK,KAAO,iBAChB,CACJ,E"}

package/dist/tabular/exceptions.js.map

@@ -1 +1 @@
-{"version":3,"file":"exceptions.js","names":[],"sources":["../../src/tabular/exceptions.ts"],"sourcesContent":["/**\n * Errors thrown by the tabular inference module.\n *\n * Each one exists because the underlying failure is unreadable on its own:\n * ONNX Runtime reports a missing operator registration, and the actual cause\n * is an import path chosen three files away.\n *\n * Every subclass sets `name` to a **literal** string rather than to\n * `new.target.name`. Measured in a real build: the minifier renames the\n * class, so the derived form ships as `error.name === \"t\"` — useless in a\n * log and in any consumer that branches on the name.\n */\n\n/** Base class for every error this module throws. */\nexport class TabularError extends Error {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"TabularError\";\n    }\n}\n\n/** The model bytes could not be loaded into a session. */\nexport class ModelLoadError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"ModelLoadError\";\n    }\n}\n\n/**\n * The runtime has no kernels for this graph's operators.\n *\n * Measured, and the reason this class exists: importing\n * `onnxruntime-web/webgpu` loads a WebAssembly build without the\n * `ai.onnx.ml` domain, so creating a session over any scikit-learn export\n * fails with `No Op registered for TreeEnsembleClassifier`. The message\n * names the fix, because the raw error points at the model instead of at\n * the import.\n */\nexport class UnsupportedGraphError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"UnsupportedGraphError\";\n    }\n}\n\n/**\n * The bytes are not a compact model, or use a newer layout.\n *\n * Separate from {@link ModelLoadError} because the fix is different: a\n * `.onnx` file handed to the compact reader is a wiring mistake, not a\n * broken model.\n */\nexport class CompactFormatError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"CompactFormatError\";\n    }\n}\n\n/** The rows do not match what the model expects. */\nexport class FeatureShapeError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"FeatureShapeError\";\n    }\n}\n\n/** The session ran but its outputs could not be read. */\nexport class InferenceError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"InferenceError\";\n    }\n}\n\n/**\n * The model bytes could not be fetched or read from the cache.\n *\n * Distinct from {@link ModelLoadError}: this one means the app is offline\n * and nothing was cached, which is a deployment problem, not a model\n * problem.\n */\nexport class ModelFetchError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"ModelFetchError\";\n    }\n}\n"],"mappings":";AAcA,IAAa,IAAb,cAAkC,MAAM;CACpC,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAM,GAAS,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GAGa,IAAb,cAAoC,EAAa;CAC7C,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAM,GAAS,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GAYa,IAAb,cAA2C,EAAa;CACpD,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAM,GAAS,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GASa,IAAb,cAAwC,EAAa;CACjD,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAM,GAAS,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GAGa,IAAb,cAAuC,EAAa;CAChD,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAM,GAAS,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GAGa,IAAb,cAAoC,EAAa;CAC7C,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAM,GAAS,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GASa,IAAb,cAAqC,EAAa;CAC9C,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAM,GAAS,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ"}
+{"version":3,"file":"exceptions.js","names":["TabularError","message","options","ModelLoadError","UnsupportedGraphError","CompactFormatError","FeatureShapeError","InferenceError","ModelFetchError"],"sources":["../../src/tabular/exceptions.ts"],"sourcesContent":["/**\n * Errors thrown by the tabular inference module.\n *\n * Each one exists because the underlying failure is unreadable on its own:\n * ONNX Runtime reports a missing operator registration, and the actual cause\n * is an import path chosen three files away.\n *\n * Every subclass sets `name` to a **literal** string rather than to\n * `new.target.name`. Measured in a real build: the minifier renames the\n * class, so the derived form ships as `error.name === \"t\"` — useless in a\n * log and in any consumer that branches on the name.\n */\n\n/** Base class for every error this module throws. */\nexport class TabularError extends Error {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"TabularError\";\n    }\n}\n\n/** The model bytes could not be loaded into a session. */\nexport class ModelLoadError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"ModelLoadError\";\n    }\n}\n\n/**\n * The runtime has no kernels for this graph's operators.\n *\n * Measured, and the reason this class exists: importing\n * `onnxruntime-web/webgpu` loads a WebAssembly build without the\n * `ai.onnx.ml` domain, so creating a session over any scikit-learn export\n * fails with `No Op registered for TreeEnsembleClassifier`. The message\n * names the fix, because the raw error points at the model instead of at\n * the import.\n */\nexport class UnsupportedGraphError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"UnsupportedGraphError\";\n    }\n}\n\n/**\n * The bytes are not a compact model, or use a newer layout.\n *\n * Separate from {@link ModelLoadError} because the fix is different: a\n * `.onnx` file handed to the compact reader is a wiring mistake, not a\n * broken model.\n */\nexport class CompactFormatError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"CompactFormatError\";\n    }\n}\n\n/** The rows do not match what the model expects. */\nexport class FeatureShapeError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"FeatureShapeError\";\n    }\n}\n\n/** The session ran but its outputs could not be read. */\nexport class InferenceError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"InferenceError\";\n    }\n}\n\n/**\n * The model bytes could not be fetched or read from the cache.\n *\n * Distinct from {@link ModelLoadError}: this one means the app is offline\n * and nothing was cached, which is a deployment problem, not a model\n * problem.\n */\nexport class ModelFetchError extends TabularError {\n    constructor(message: string, options?: ErrorOptions) {\n        super(message, options);\n        this.name = \"ModelFetchError\";\n    }\n}\n"],"mappings":";AAcA,IAAaA,IAAb,cAAkC,MAAM;CACpC,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAMC,GAASC,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GAGaC,IAAb,cAAoCH,EAAa;CAC7C,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAMC,GAASC,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GAYaE,IAAb,cAA2CJ,EAAa;CACpD,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAMC,GAASC,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GASaG,IAAb,cAAwCL,EAAa;CACjD,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAMC,GAASC,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GAGaI,IAAb,cAAuCN,EAAa;CAChD,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAMC,GAASC,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GAGaK,IAAb,cAAoCP,EAAa;CAC7C,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAMC,GAASC,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ,GASaM,IAAb,cAAqCR,EAAa;CAC9C,YAAY,GAAiB,GAAwB;EAEjD,AADA,MAAMC,GAASC,CAAO,GACtB,KAAK,OAAO;CAChB;AACJ"}