@dokebi/template-inertia 0.4.2 → 0.4.5

package/dist/boot-fallback.js

@@ -0,0 +1,134 @@
+// The first HTML's text while the app loads (Studio v2, 10-31): a page whose entry script cannot be
+// fetched (a dev restart, a deploy in progress) stayed blank, and no line of the app ran to say so.
+// The root holds "loading" until the app mounts (Vue's mount empties it); after `timeoutMs` the text
+// turns to "could not load — reload" by CSS alone (an animation delay, so a CSP that blocks inline
+// scripts still gets it). A small inline script shows it at once when the entry script fails to
+// load. A server-rendered page has its markup instead and gets neither.
+// The built-in look is a centered spinner (the text stays for screen readers) and a reload button;
+// `stylesheet` links an app's own look right after it, so it shows before any script of the app
+// runs: also under dokebi dev, where the app's CSS only comes with its scripts.
+import { createHash } from 'node:crypto';
+const LANGUAGE_TAG = /^[A-Za-z]{2,8}(?:-[A-Za-z0-9]{1,8})*$/;
+const MAX_TEXT = 200;
+const BUILT_IN = Object.freeze({
+    en: { loading: 'Loading…', failed: 'The app could not be loaded.', reload: 'Reload' },
+    // docs-check: hangul-begin
+    ko: { loading: '불러오는 중…', failed: '앱을 불러오지 못했어요.', reload: '다시 불러오기' },
+    // docs-check: hangul-end
+});
+/** Checked and filled; undefined when the input is not a valid setting. */
+export function normalizeBootFallback(input) {
+    if (input === false)
+        return Object.freeze({ enabled: false, timeoutMs: 10_000, messages: {} });
+    const value = input ?? {};
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    if (Object.keys(value).some((key) => !['enabled', 'timeoutMs', 'messages', 'stylesheet', 'logo'].includes(key)))
+        return undefined;
+    const { stylesheet, logo } = value;
+    if (stylesheet !== undefined && !localUrl(stylesheet))
+        return undefined;
+    if (logo !== undefined && !localUrl(logo))
+        return undefined;
+    const enabled = value.enabled ?? true;
+    const timeoutMs = value.timeoutMs ?? 10_000;
+    if (typeof enabled !== 'boolean' ||
+        !Number.isSafeInteger(timeoutMs) ||
+        timeoutMs < 1000 ||
+        timeoutMs > 120_000)
+        return undefined;
+    const messages = {};
+    const given = value.messages ?? {};
+    if (given === null || typeof given !== 'object' || Array.isArray(given))
+        return undefined;
+    for (const [tag, texts] of Object.entries(given)) {
+        if (!LANGUAGE_TAG.test(tag) || texts === null || typeof texts !== 'object')
+            return undefined;
+        const kept = {};
+        for (const [key, text] of Object.entries(texts)) {
+            if (!['loading', 'failed', 'reload'].includes(key))
+                return undefined;
+            if (typeof text !== 'string' || text.length === 0 || text.length > MAX_TEXT)
+                return undefined;
+            kept[key] = text;
+        }
+        messages[tag.toLowerCase()] = Object.freeze(kept);
+    }
+    return Object.freeze({
+        enabled,
+        timeoutMs,
+        messages: Object.freeze(messages),
+        ...(stylesheet === undefined ? {} : { stylesheet }),
+        ...(logo === undefined ? {} : { logo }),
+    });
+}
+/** `/x`, not `//host`, without backslash, quote, angle bracket, space or control character. */
+function localUrl(value) {
+    return (typeof value === 'string' &&
+        value.length <= 2048 &&
+        value.startsWith('/') &&
+        !value.startsWith('//') &&
+        ![...value].some((char) => '\\"\'<>'.includes(char) || char.charCodeAt(0) <= 32));
+}
+const escapeHtml = (value) => value
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+/** The texts for `language` (`<html lang>`): exact tag, its primary subtag, then English. */
+function textsFor(settings, language) {
+    const tag = (language ?? '').toLowerCase();
+    const primary = tag.split('-')[0] ?? '';
+    // Own keys only: Content-Language is any text the app set (`constructor`, `__proto__` named
+    // Object.prototype members and left the texts undefined: the page answered 500).
+    const own = (table, key) => Object.hasOwn(table, key) ? table[key] : undefined;
+    const builtIn = own(BUILT_IN, primary) ?? BUILT_IN.en;
+    return {
+        ...builtIn,
+        ...own(settings.messages, primary),
+        ...own(settings.messages, tag),
+    };
+}
+/**
+ * The head part (a style and a script, before the module scripts so a failed load is heard) and
+ * the root's content. The head part depends on the root id and the timeout only, so its hashes are
+ * fixed for a scope (logged at debug for a CSP that lists hashes).
+ */
+export function bootMarkup(settings, rootId, language) {
+    const texts = textsFor(settings, language);
+    return {
+        head: bootHead(rootId, settings.timeoutMs) +
+            (settings.stylesheet
+                ? `<link rel="stylesheet" href="${escapeHtml(settings.stylesheet)}">`
+                : ''),
+        root: `<div data-dokebi-boot role="status" aria-live="polite">${settings.logo ? `<img data-dokebi-boot-logo src="${escapeHtml(settings.logo)}" alt="">` : ''}<p data-dokebi-boot-loading>${escapeHtml(texts.loading)}</p><p data-dokebi-boot-failed>${escapeHtml(texts.failed)} <a href="">${escapeHtml(texts.reload)}</a></p></div>`,
+    };
+}
+/** The style and the script of the head (fixed per root id and timeout). */
+export function bootHead(rootId, timeoutMs) {
+    return `<style>${bootStyle(timeoutMs)}</style><script>${bootScript(rootId)}</script>`;
+}
+/**
+ * "Loading" turns to "could not load" after the delay, or at once once the script marks it. The
+ * look: the box fills the window and centers its line; "loading" is a spinner (its text, at size 0,
+ * is still read out), "could not load" its text over a reload button, a `logo` above both. Neutral
+ * greys; a dark colour scheme gets a dark box (the page behind it is white without the app's CSS),
+ * and reduced motion a spinner that stands still (Studio v2 Z1). An app restyles it with
+ * `stylesheet`.
+ */
+export function bootStyle(timeoutMs) {
+    return `@keyframes dokebi-boot-hide{from{visibility:visible;position:static}to{visibility:hidden;position:absolute}}@keyframes dokebi-boot-show{from{visibility:hidden;position:absolute}to{visibility:visible;position:static}}@keyframes dokebi-boot-spin{to{transform:rotate(360deg)}}[data-dokebi-boot]{position:fixed;inset:0;display:flex;flex-direction:column;align-items:center;justify-content:center;gap:16px;padding:24px;font:15px/1.5 system-ui,-apple-system,"Segoe UI",sans-serif;color:#71717a;text-align:center}[data-dokebi-boot] p{margin:0}[data-dokebi-boot-loading]{width:32px;height:32px;font-size:0;color:transparent;animation:dokebi-boot-hide 0s linear ${timeoutMs}ms both}[data-dokebi-boot-loading]::before{content:"";display:block;box-sizing:border-box;width:100%;height:100%;border:3px solid rgba(113,113,122,.25);border-top-color:#71717a;border-radius:50%;animation:dokebi-boot-spin .8s linear infinite}[data-dokebi-boot-failed]{display:flex;flex-direction:column;align-items:center;gap:12px;max-width:320px;animation:dokebi-boot-show 0s linear ${timeoutMs}ms both}[data-dokebi-boot-failed] a{padding:8px 16px;border-radius:8px;background:#52525b;color:#fff;font-size:14px;font-weight:600;text-decoration:none}[data-dokebi-boot=failed] [data-dokebi-boot-loading],[data-dokebi-boot=failed] [data-dokebi-boot-failed]{animation-delay:0s}[data-dokebi-boot-logo]{display:block;max-width:160px;max-height:64px}@media (prefers-color-scheme:dark){[data-dokebi-boot]{color-scheme:dark;background:#18181b;color:#a1a1aa}[data-dokebi-boot-loading]::before{border-color:rgba(161,161,170,.25);border-top-color:#a1a1aa}[data-dokebi-boot-failed] a{background:#e4e4e7;color:#18181b}}@media (prefers-reduced-motion:reduce){[data-dokebi-boot-loading]::before{animation:none;border-color:rgba(113,113,122,.6)}}`;
+}
+/** A module script of the page that fails to load marks the boot text failed (capture phase). */
+export function bootScript(rootId) {
+    return `(function(){var id=${JSON.stringify(rootId)};function fail(){var r=document.getElementById(id),b=r&&r.querySelector("[data-dokebi-boot]");if(b)b.setAttribute("data-dokebi-boot","failed")}addEventListener("error",function(e){var t=e.target;if(t&&t.tagName==="SCRIPT"&&t.type==="module"){if(document.readyState==="loading")document.addEventListener("DOMContentLoaded",fail);else fail()}},true)})();`;
+}
+/**
+ * The CSP sources of the head's style and script (`'sha256-…'`), for an app whose CSP has no
+ * 'unsafe-inline': add them to style-src and script-src, or turn bootFallback off.
+ */
+export function bootHashes(rootId, timeoutMs) {
+    const hash = (text) => `'sha256-${createHash('sha256').update(text).digest('base64')}'`;
+    return { style: hash(bootStyle(timeoutMs)), script: hash(bootScript(rootId)) };
+}

package/dist/built-files.d.ts

@@ -0,0 +1,9 @@
+/** A content-hashed name (`app-3fa8c1d2.js`, `app-BXk2_9aQ.css`): kept by browsers for a year. */
+export declare const HASHED: RegExp;
+/**
+ * The file a request names under a served build folder, or undefined (404): segments of
+ * `BUILT_SEGMENT` only (no `..`, no hidden name, no backslash, no encoded separator), no source
+ * map, and a regular file (no symbolic link, no folder) inside that folder, also after resolving
+ * links of the folders on the way (a linked subfolder pointing elsewhere is not followed out).
+ */
+export declare function builtFolderFile(folder: string, rest: string): Promise<string | undefined>;

package/dist/built-files.js

@@ -0,0 +1,44 @@
+import { lstat, realpath } from 'node:fs/promises';
+import { join, sep } from 'node:path';
+/*
+ * The hashed files of a build folder (rolling deploys, audit 2026-10-25): a worker serves every
+ * file of the folders its manifest's files sit in, not only those files, so the chunks of the
+ * build that another worker generation renders stay loadable.
+ */
+/** One path segment of a built file: Vite's `[name]-[hash].[ext]` characters, never hidden. */
+const BUILT_SEGMENT = /^[\w@~+-][\w.@~+-]{0,254}$/;
+/**
+ * Source maps are never served from a folder: the manifest names none (they were never served
+ * before), and `build.sourcemap: 'hidden'` writes them beside the chunks for error tracking only,
+ * so serving them would publish the original sources.
+ */
+const SOURCE_MAP = /\.map$/i;
+/** A content-hashed name (`app-3fa8c1d2.js`, `app-BXk2_9aQ.css`): kept by browsers for a year. */
+export const HASHED = /[-.][A-Za-z0-9_-]{8,}\.[A-Za-z0-9]{1,16}$/;
+/**
+ * The file a request names under a served build folder, or undefined (404): segments of
+ * `BUILT_SEGMENT` only (no `..`, no hidden name, no backslash, no encoded separator), no source
+ * map, and a regular file (no symbolic link, no folder) inside that folder, also after resolving
+ * links of the folders on the way (a linked subfolder pointing elsewhere is not followed out).
+ */
+export async function builtFolderFile(folder, rest) {
+    if (typeof rest !== 'string' || !rest || rest.length > 1024)
+        return undefined;
+    const segments = rest.split('/');
+    if (!segments.every((segment) => BUILT_SEGMENT.test(segment)))
+        return undefined;
+    if (SOURCE_MAP.test(rest))
+        return undefined;
+    const file = join(folder, ...segments);
+    if (!file.startsWith(folder + sep))
+        return undefined;
+    const info = await lstat(file).catch((error) => {
+        if (error.code === 'ENOENT' || error.code === 'ENOTDIR')
+            return undefined;
+        throw error;
+    });
+    if (!info?.isFile())
+        return undefined;
+    const [real, root] = await Promise.all([realpath(file), realpath(folder)]);
+    return real.startsWith(root + sep) ? file : undefined;
+}

package/dist/errors.d.ts

@@ -1,8 +1,8 @@
 import { DokebiError, type DokebiErrorOptions } from '@dokebi/core';
 /** Codes of `InertiaError` (failures of setup, files and the page flow). */
-export type InertiaErrorCode = 'SSR_BUNDLE_MISSING' | 'SSR_BUNDLE_INVALID' | 'SSR_ENTRY_MISSING' | 'VITE_MANIFEST_MISSING' | 'VITE_MANIFEST_INVALID' | 'VITE_DEV_MISSING' | 'VITE_DEV_UNAVAILABLE' | 'SEAL_SSR_CONFLICT' | 'METHOD_NOT_ALLOWED' | 'CLOSED';
+export type InertiaErrorCode = 'SSR_BUNDLE_MISSING' | 'SSR_BUNDLE_INVALID' | 'SSR_ENTRY_MISSING' | 'SSR_TIMEOUT' | 'VITE_MANIFEST_MISSING' | 'VITE_MANIFEST_INVALID' | 'VITE_DEV_MISSING' | 'VITE_DEV_UNAVAILABLE' | 'SEAL_SSR_CONFLICT' | 'METHOD_NOT_ALLOWED' | 'CLOSED';
 /** Codes of `InertiaUsageError` (a wrong argument: a TypeError, as before 0.4.0). */
-export type InertiaUsageErrorCode = 'INVALID_ENTRY' | 'INVALID_SCOPE' | 'INVALID_RENDER' | 'INVALID_PROPS' | 'INVALID_URL' | 'INVALID_PROP_HELPER' | 'SSR_INVALID_RESULT';
+export type InertiaUsageErrorCode = 'INVALID_ENTRY' | 'INVALID_SCOPE' | 'INVALID_RENDER' | 'INVALID_PROPS' | 'INVALID_URL' | 'INVALID_PROP_HELPER' | 'SSR_INVALID_RESULT' | 'INVALID_PRUNE';
 /** Failures of @dokebi/template-inertia; compare `code`, not the class. */
 export declare class InertiaError extends DokebiError<InertiaErrorCode> {
     constructor(code: InertiaErrorCode, message: string, options?: DokebiErrorOptions);

package/dist/errors.js

@@ -4,8 +4,9 @@ const FIX = {
     SSR_BUNDLE_MISSING: 'Build the views first (npm run build), or correct ssr.bundle.',
     SSR_BUNDLE_INVALID: 'The SSR bundle must be a file that exports render(page).',
     SSR_ENTRY_MISSING: 'Set ssr.entry (the source module of the SSR bundle, e.g. src/apps/<app>/views/ssr.js) for development, or put ssr.js beside vite.entry.',
+    SSR_TIMEOUT: 'Find what the page render waits for (a fetch, a slow store) and move it into props, or raise ssr.timeoutMs above the slowest render.',
     VITE_MANIFEST_MISSING: 'Build the views first (npm run build), or correct vite.manifest.',
-    VITE_MANIFEST_INVALID: 'Point vite.manifest at .vite/manifest.json of a Vite build (at most 4 MB) and vite.entry at one of its entries.',
+    VITE_MANIFEST_INVALID: 'Point vite.manifest at .vite/manifest.json of a Vite build (at most viteManifestMaxBytes, 4 MiB by default) and vite.entry at one of its entries.',
     VITE_DEV_MISSING: 'npm install --save-dev vite (DOKEBI_VITE_DEV=1 serves the views through it).',
     VITE_DEV_UNAVAILABLE: 'Run the app with dokebi dev, which starts one Vite dev host and sets DOKEBI_VITE_DEV_URL and DOKEBI_VITE_DEV_KEY; or unset both to start Vite in this process.',
     SEAL_SSR_CONFLICT: 'Set inertia.ssr: false for the app of a seal host, or remove seal: true from its domains (D-0062).',
@@ -18,6 +19,7 @@ const FIX = {
     INVALID_URL: 'Use a local absolute URL such as /posts/1 (not //host, no backslash or spaces).',
     INVALID_PROP_HELPER: 'defer(fn, { group? }), merge(value, { deep?, matchOn? }), once(value, { key? }): a JSON value or a function, with the documented options.',
     SSR_INVALID_RESULT: 'The SSR render(page) must return { head: string[], body: string } whose body has the root element (rootId).',
+    INVALID_PRUNE: "pruneBuildFiles({ manifest: 'dist/.vite/manifest.json', olderThanMs?, dryRun?, maxManifestBytes?, now? }): a manifest path, and whole non-negative numbers.",
 };
 /** Failures of @dokebi/template-inertia; compare `code`, not the class. */
 export class InertiaError extends DokebiError {

package/dist/i18n-store.d.ts

@@ -0,0 +1,64 @@
+/** Messages of one bundle: { source locale → { flat key → message } } (as the server joins them). */
+export type StoredMessages = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+/** The limits of `settings.cache` (dokebi-i18n http.pageCache). */
+export interface StoreLimits {
+    readonly cookie: string;
+    readonly maxCookieBytes: number;
+    readonly maxAgeSeconds: number;
+    readonly maxBundles: number;
+    readonly maxStoreCharacters: number;
+}
+/** The log of the runtime (PageI18nLogger of i18n.ts). */
+export interface StoreLogger {
+    isEnabled?(level: 'debug' | 'warn' | 'error'): boolean;
+    log(level: 'debug' | 'warn' | 'error', message: string, fields?: Record<string, unknown>): void;
+}
+/** The browser objects the store uses; tests pass their own. */
+export interface StoreHost {
+    readonly storage: Pick<Storage, 'length' | 'key' | 'getItem' | 'setItem' | 'removeItem'>;
+    readonly document?: {
+        cookie: string;
+    };
+    readonly secure?: boolean;
+    /** Runs work when the page is idle (requestIdleCallback, else a timer). */
+    readonly later?: (work: () => void) => void;
+}
+/** One kept bundle, read from its key alone. */
+export interface Kept {
+    readonly key: string;
+    readonly locale: string;
+    readonly namespace: string;
+    readonly token: string;
+    readonly characters: number;
+    readonly written: number;
+}
+export declare class BundleStore {
+    #private;
+    constructor(host: StoreHost, limits: StoreLimits, logger?: StoreLogger);
+    set limits(limits: StoreLimits);
+    get limits(): StoreLimits;
+    get usable(): boolean;
+    /** Every kept bundle (from the keys; no value is read). */
+    index(): Kept[];
+    /**
+     * The messages of a kept bundle: the one with `token`, or (no token: a page from history) the
+     * newest of `locale`/`namespace`. An item that is not valid JSON messages is removed.
+     */
+    read(locale: string, namespace: string, token?: string, index?: readonly Kept[]): {
+        token: string;
+        messages: StoredMessages;
+    } | undefined;
+    /** Keeps a bundle the server sent (written when the page is idle). */
+    keep(locale: string, namespace: string, token: string, messages: StoredMessages): void;
+    /** The locale the page shows: its bundles come first in the cookie. */
+    show(locale: string): void;
+    /** Work for an idle moment after the pending writes (the runtime's preload). */
+    whenIdle(work: () => void): void;
+    /**
+     * Writes the pending bundles, keeps the limits and rewrites the cookie. Runs when idle; a test
+     * calls it directly.
+     */
+    flush(): void;
+    /** The cookie from what is kept (an empty claim deletes it). */
+    writeCookie(index?: readonly Kept[]): void;
+}

package/dist/i18n-store.js

@@ -0,0 +1,368 @@
+/*
+ * D-0126: the message bundles a browser keeps between page loads, for the runtime of
+ * `@dokebi/template-inertia/i18n`. One localStorage item per bundle (page locale × namespace, one
+ * version each), its key carrying everything an index needs, so tabs never share a mutable index:
+ *
+ *   dokebi-i18n:1:<locale>:<namespace>:<token>:<characters>:<written, base 36>  →  JSON messages
+ *
+ * The cookie (http.pageCache.cookieName of @dokebi/i18n) names the kept bundles by token, newest
+ * of the current locale first, so a full page load leaves them out of the HTML. Everything here
+ * is best effort: a browser that refuses storage, a full quota or an item someone changed only
+ * means the server sends those messages again. Each such case is logged at debug.
+ */
+const PREFIX = 'dokebi-i18n:1:';
+const TOKEN = 8;
+const TOKENS = /^[A-Za-z0-9_-]+$/;
+const PART = /^[A-Za-z0-9_-]{1,128}$/;
+function describe(error) {
+    return error instanceof Error
+        ? { name: error.name, message: error.message, stack: error.stack }
+        : { message: String(error) };
+}
+export class BundleStore {
+    #limits;
+    #host;
+    #logger;
+    #pending = new Map();
+    #idle = [];
+    #scheduled = false;
+    /** The locale whose bundles the cookie names first. */
+    #locale = '';
+    #cookieValue;
+    /** Set when the storage itself failed (blocked, gone): nothing is read or written again. */
+    #broken = false;
+    constructor(host, limits, logger) {
+        this.#host = host;
+        this.#limits = limits;
+        this.#logger = logger;
+    }
+    set limits(limits) {
+        this.#limits = limits;
+    }
+    get limits() {
+        return this.#limits;
+    }
+    get usable() {
+        return !this.#broken;
+    }
+    /** Every kept bundle (from the keys; no value is read). */
+    index() {
+        if (this.#broken)
+            return [];
+        const kept = [];
+        try {
+            const storage = this.#host.storage;
+            for (let index = 0; index < storage.length; index++) {
+                const key = storage.key(index);
+                if (!key?.startsWith(PREFIX))
+                    continue;
+                const parts = key.slice(PREFIX.length).split(':');
+                const [locale, namespace, token, characters, written] = parts;
+                if (parts.length !== 5 ||
+                    !PART.test(locale) ||
+                    !PART.test(namespace) ||
+                    token.length !== TOKEN ||
+                    !TOKENS.test(token))
+                    continue;
+                kept.push({
+                    key,
+                    locale: locale,
+                    namespace: namespace,
+                    token: token,
+                    characters: Number.parseInt(characters, 10) || 0,
+                    written: Number.parseInt(written, 36) || 0,
+                });
+            }
+        }
+        catch (error) {
+            this.#fail('index', error);
+            return [];
+        }
+        return kept;
+    }
+    /**
+     * The messages of a kept bundle: the one with `token`, or (no token: a page from history) the
+     * newest of `locale`/`namespace`. An item that is not valid JSON messages is removed.
+     */
+    read(locale, namespace, token, index = this.index()) {
+        let best;
+        for (const kept of index)
+            if (kept.locale === locale &&
+                kept.namespace === namespace &&
+                (token === undefined || kept.token === token) &&
+                (!best || kept.written > best.written))
+                best = kept;
+        if (!best)
+            return undefined;
+        let text;
+        try {
+            text = this.#host.storage.getItem(best.key);
+        }
+        catch (error) {
+            this.#fail('read', error);
+            return undefined;
+        }
+        if (text === null)
+            return undefined;
+        let messages;
+        try {
+            messages = JSON.parse(text);
+        }
+        catch (error) {
+            this.#debug('Kept page bundle is not JSON; removed', {
+                code: 'I18N_STORE_INVALID',
+                locale,
+                namespace,
+                error: describe(error),
+            });
+            this.#remove(best.key);
+            return undefined;
+        }
+        if (!valid(messages)) {
+            this.#debug('Kept page bundle has another shape; removed', {
+                code: 'I18N_STORE_INVALID',
+                locale,
+                namespace,
+            });
+            this.#remove(best.key);
+            return undefined;
+        }
+        return { token: best.token, messages };
+    }
+    /** Keeps a bundle the server sent (written when the page is idle). */
+    keep(locale, namespace, token, messages) {
+        if (this.#broken || !PART.test(locale) || !PART.test(namespace) || !TOKENS.test(token))
+            return;
+        this.#pending.set(`${locale}:${namespace}`, { locale, namespace, token, messages });
+        this.#schedule();
+    }
+    /** The locale the page shows: its bundles come first in the cookie. */
+    show(locale) {
+        if (locale === this.#locale)
+            return;
+        this.#locale = locale;
+        this.#schedule();
+    }
+    /** Work for an idle moment after the pending writes (the runtime's preload). */
+    whenIdle(work) {
+        this.#idle.push(work);
+        this.#schedule();
+    }
+    /**
+     * Writes the pending bundles, keeps the limits and rewrites the cookie. Runs when idle; a test
+     * calls it directly.
+     */
+    flush() {
+        this.#scheduled = false;
+        const pending = [...this.#pending.values()];
+        this.#pending.clear();
+        let index = this.index();
+        for (const bundle of pending)
+            index = this.#write(bundle, index);
+        index = this.#trim(index);
+        this.writeCookie(index);
+        for (const work of this.#idle.splice(0))
+            work();
+    }
+    /** The cookie from what is kept (an empty claim deletes it). */
+    writeCookie(index = this.index()) {
+        const document = this.#host.document;
+        if (!document)
+            return;
+        const room = Math.floor(this.#limits.maxCookieBytes / TOKEN);
+        const order = [...index].sort((a, b) => Number(b.locale === this.#locale) - Number(a.locale === this.#locale) ||
+            b.written - a.written);
+        const value = order
+            .slice(0, room)
+            .map((kept) => kept.token)
+            .join('');
+        if (value === this.#cookieValue)
+            return;
+        this.#cookieValue = value;
+        const name = this.#limits.cookie;
+        document.cookie = value
+            ? `${name}=${value}; Path=/; Max-Age=${this.#limits.maxAgeSeconds}; SameSite=Lax${this.#host.secure ? '; Secure' : ''}`
+            : `${name}=; Path=/; Max-Age=0; SameSite=Lax${this.#host.secure ? '; Secure' : ''}`;
+        this.#debug('Page bundle cookie written', {
+            code: 'I18N_STORE_COOKIE',
+            bundles: value.length / TOKEN,
+            kept: index.length,
+        });
+    }
+    #write(bundle, index) {
+        let text;
+        try {
+            text = JSON.stringify(bundle.messages);
+        }
+        catch (error) {
+            this.#debug('Page bundle could not be serialized; not kept', {
+                code: 'I18N_STORE_SKIPPED',
+                locale: bundle.locale,
+                namespace: bundle.namespace,
+                error: describe(error),
+            });
+            return index;
+        }
+        const written = Date.now();
+        const key = `${PREFIX}${bundle.locale}:${bundle.namespace}:${bundle.token}:${text.length}:${written.toString(36)}`;
+        // One version per locale and namespace: the others go first.
+        const rest = [];
+        for (const kept of index)
+            if (kept.locale === bundle.locale && kept.namespace === bundle.namespace)
+                this.#remove(kept.key);
+            else
+                rest.push(kept);
+        if (text.length + key.length > this.#limits.maxStoreCharacters) {
+            this.#debug('Page bundle larger than the store; not kept', {
+                code: 'I18N_STORE_SKIPPED',
+                locale: bundle.locale,
+                namespace: bundle.namespace,
+                characters: text.length,
+            });
+            return rest;
+        }
+        const entry = {
+            key,
+            locale: bundle.locale,
+            namespace: bundle.namespace,
+            token: bundle.token,
+            characters: text.length,
+            written,
+        };
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                this.#host.storage.setItem(key, text);
+                rest.push(entry);
+                return rest;
+            }
+            catch (error) {
+                if (attempt === 0 && quota(error)) {
+                    // Room for this one: the oldest bundles of other locales first.
+                    this.#debug('Page bundle store is full; oldest bundles removed', {
+                        code: 'I18N_STORE_FULL',
+                        characters: text.length,
+                    });
+                    let freed = 0;
+                    for (const kept of this.#evictionOrder(rest)) {
+                        if (freed >= text.length + key.length)
+                            break;
+                        this.#remove(kept.key);
+                        freed += kept.characters + kept.key.length;
+                        rest.splice(rest.indexOf(kept), 1);
+                    }
+                    continue;
+                }
+                if (quota(error)) {
+                    this.#debug('Page bundle store is full; bundle not kept', {
+                        code: 'I18N_STORE_SKIPPED',
+                        locale: bundle.locale,
+                        namespace: bundle.namespace,
+                        error: describe(error),
+                    });
+                    return rest;
+                }
+                this.#fail('write', error);
+                return rest;
+            }
+        }
+        return rest;
+    }
+    /** maxBundles and maxStoreCharacters: the oldest bundles of other locales go first. */
+    #trim(index) {
+        let characters = 0;
+        for (const kept of index)
+            characters += kept.characters + kept.key.length;
+        if (index.length <= this.#limits.maxBundles && characters <= this.#limits.maxStoreCharacters)
+            return index;
+        const rest = [...index];
+        let removed = 0;
+        for (const kept of this.#evictionOrder(index)) {
+            if (rest.length <= this.#limits.maxBundles && characters <= this.#limits.maxStoreCharacters)
+                break;
+            this.#remove(kept.key);
+            characters -= kept.characters + kept.key.length;
+            rest.splice(rest.indexOf(kept), 1);
+            removed++;
+        }
+        this.#debug('Page bundle store trimmed to its limits', {
+            code: 'I18N_STORE_TRIMMED',
+            removed,
+            kept: rest.length,
+        });
+        return rest;
+    }
+    #evictionOrder(index) {
+        return [...index].sort((a, b) => Number(a.locale === this.#locale) - Number(b.locale === this.#locale) ||
+            a.written - b.written);
+    }
+    #remove(key) {
+        try {
+            this.#host.storage.removeItem(key);
+        }
+        catch (error) {
+            this.#fail('remove', error);
+        }
+    }
+    #schedule() {
+        if (this.#scheduled || this.#broken)
+            return;
+        this.#scheduled = true;
+        const later = this.#host.later ?? ((work) => setTimeout(work, 0));
+        later(() => {
+            try {
+                this.flush();
+            }
+            catch (error) {
+                // A timer callback has no caller: the failure is logged here, and the store stops.
+                this.#fail('flush', error);
+            }
+        });
+    }
+    /** The storage refused an operation (blocked, removed): the store stops, the claim is dropped. */
+    #fail(operation, error) {
+        if (!this.#broken)
+            this.#debug('Page bundle store unavailable; bundles are not kept', {
+                code: 'I18N_STORE_UNAVAILABLE',
+                operation,
+                error: describe(error),
+            });
+        this.#broken = true;
+        this.#pending.clear();
+        const document = this.#host.document;
+        if (document && this.#cookieValue !== '') {
+            this.#cookieValue = '';
+            document.cookie = `${this.#limits.cookie}=; Path=/; Max-Age=0; SameSite=Lax${this.#host.secure ? '; Secure' : ''}`;
+        }
+    }
+    #debug(message, fields) {
+        const logger = this.#logger;
+        if (logger && (logger.isEnabled?.('debug') ?? true))
+            logger.log('debug', message, fields);
+    }
+}
+function quota(error) {
+    const name = error?.name;
+    return name === 'QuotaExceededError' || name === 'NS_ERROR_DOM_QUOTA_REACHED';
+}
+function plain(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** { locale → { key → string | { other: string, … } } }: what the server sends, nothing else. */
+function valid(messages) {
+    if (!plain(messages))
+        return false;
+    for (const byKey of Object.values(messages)) {
+        if (!plain(byKey))
+            return false;
+        for (const message of Object.values(byKey)) {
+            if (typeof message === 'string')
+                continue;
+            if (!plain(message) || typeof message.other !== 'string')
+                return false;
+            for (const branch of Object.values(message))
+                if (typeof branch !== 'string')
+                    return false;
+        }
+    }
+    return true;
+}