@sveltekit-i18n/base 3.0.0 → 3.1.0-next.0

package/dist/I18n.svelte.js

@@ -1,28 +1,96 @@
-import { fetchTranslations, hasOwn, mergeTranslations, read, resolveLoaders, sanitizerFactory, sanitizeTranslationLocales, testRoute, toDotNotation, translate } from './utils.js';
+import { untrack } from 'svelte';
+import { capturesParams, fetchTranslation, hasOwn, loaderName, mergeFetched, mergeTranslations, omitProtoKeys, paramsSignature, read, resolveLoaders, routeParams, sanitizerFactory, sanitizeTranslationLocales, serialize, servedLocales, toDotNotation, translate, unique, withoutBasePath } from './utils.js';
 import { logError, logger, loggerFactory, setLogger } from './logger.js';
 const defaultCache = Number.POSITIVE_INFINITY;
+/**
+ * A top-level key holding part of `namespace` — the namespace itself or a key
+ * flattened out of it. Keys are strings, so an off-contract namespace that is
+ * not one holds none of them.
+ */
+const isNamespaceKey = (key, namespace) => typeof namespace === 'string' && (key === namespace || key.startsWith(`${namespace}.`));
 class I18nCore {
     // -- reactive state ---------------------------------------------------------
-    #config = $state(undefined);
+    /**
+     * Raw, as are the tables: each is replaced whole, never changed in place,
+     * and deep state would hand back proxies of what it holds in the browser —
+     * loaders no key of `#deliveries` or the records matches, and tables a
+     * structured clone rejects.
+     */
+    #config = $state.raw(undefined);
     /** The ACTIVE locale — advances only after its translations resolved. */
     #locale = $state(undefined);
-    /** The locale most recently asked for; loads fire once a route exists too. */
+    /**
+     * The locale the next trigger loads: the one most recently asked for, unless
+     * control flow failed that call and put back what it replaced. Loads fire
+     * once a route exists too.
+     */
     #requestedLocale = $state(undefined);
     #route = $state(undefined);
-    #rawTranslations = $state({});
-    #translations = $state({});
+    #rawTranslations = $state.raw({});
+    #translations = $state.raw({});
     /** Replaced immutably on every change so `loading` recomputes. */
     #pending = $state(new Set());
     /** Locale normalization, as `config.sanitizeLocales` asks for it. */
     #sanitize = $derived(sanitizerFactory(this.#config?.sanitizeLocales));
     // -- plain internal state ---------------------------------------------------
+    // Load records keep a loader from running twice. A loader's own record holds
+    // the params signature it last delivered for; a namespace record stands for
+    // a namespace a plain hand-off delivered, and keeps its loaders from fetching
+    // it again unless their params ask for other data. Seeded data records
+    // nothing.
+    #loaderRecords = new Map();
     // Null prototype: these tables are indexed by user-supplied locales, and a
     // plain object would resolve a '__proto__' assignment via the setter.
-    #loadedKeys = Object.create(null);
+    #namespaceRecords = Object.create(null);
+    // What each source last put into a namespace, so a loader whose params
+    // changed can replace its own part and leave its siblings' in place. Kept
+    // apart from the records: invalidation drops those, not what is displayed,
+    // and a reconfiguration hands them on to the loaders with the same id.
+    #deliveries = new Map();
+    #externalTranslations = {};
+    // The params signature the next trigger asks each loader for:
+    // the one the most recent call asked for, unless a failed call put an
+    // earlier one's back, and `null` for a loader its route does not select.
+    // Loads settle out of order, and a delivery for params the route no longer
+    // asks for must not replace what it displays; a warm load asks for nothing.
+    #wanted = new Map();
+    // The latest delivery of each loader for params nothing wanted yet — a warm
+    // load of another route's params, typically a preload — so the trigger that
+    // wants them applies it instead of fetching again. One per loader, as a
+    // router keeps one preload. It starts its locale's `cache` window, and
+    // invalidation drops it with the records.
+    #parked = new Map();
+    // What a hand-off delivered for the loaders with `cache: false`, whose
+    // records keep no trigger that selects them from running them. It serves the
+    // pass it arrived with: until an activating trigger asks for another locale
+    // or route than the hand-off named, or than the first activating trigger
+    // after it where the hand-off named none.
+    #handedOff = new Map();
+    #handOffPass = {};
     /** When each locale first received data — drives the `cache` expiry. */
     #loadedAt = Object.create(null);
-    /** In-flight loads keyed by locale and route; duplicate triggers share the promise. */
-    #inflight = new Map();
+    /**
+     * Loads in flight, each under the key of what its trigger selected; a
+     * trigger with the same key shares the promise of one that delivers all it
+     * has to fetch. `calls` holds the activating calls that share it, so a
+     * warm load joined by one activates when it settles, or fails them as an
+     * activating load does. `unparked` holds the parked deliveries its calls
+     * claimed, which it applies when it settles. `severed` holds the loaders, of
+     * either kind, an invalidation cut off while the load was in flight.
+     */
+    #inflight = new Set();
+    // The loaders' fetches in flight, which loads from the same route share
+    // wherever their selections differ.
+    #fetches = new Set();
+    // The control flow of a shared fetch already reported: every load it
+    // rejects gets it, and it was thrown once.
+    #reported = new WeakSet();
+    /**
+     * The activating calls since the last one whose load resolved without
+     * failing, oldest first. A failed call is undone while it is the last, so a
+     * call that came later and has not failed keeps what it asked for.
+     */
+    #calls = [];
     #destroyed = false;
     constructor(config) {
         if (config)
@@ -37,7 +105,9 @@ class I18nCore {
     /**
      * The active locale. Reading it is reactive; assigning it is a shorthand for
      * a fire-and-forget `setLocale()` — the value therefore updates once the
-     * locale's translations resolved, not synchronously on assignment.
+     * locale's translations resolved, not synchronously on assignment. It does
+     * not advance when a loader throws SvelteKit's `redirect()` or an `error()`
+     * below 500, which an assignment only logs.
      */
     get locale() {
         return this.#locale;
@@ -56,13 +126,10 @@ class I18nCore {
     locales = $derived.by(() => {
         if (!this.#config)
             return [];
-        const { loaders = [] } = this.#config;
-        const loaderLocales = loaders.map(({ locale }) => locale);
-        const translationLocales = Object.keys(this.#translations);
-        return Array.from(new Set([
-            ...this.#sanitize(...loaderLocales),
-            ...this.#sanitize(...translationLocales),
-        ]));
+        // Loader locales are sanitized once, when the config resolves them, and
+        // table locales once, when their data arrives; a custom `sanitizeLocales`
+        // need not be idempotent.
+        return servedLocales(this.#config.loaders ?? [], this.#translations);
     });
     initialized = $derived(this.#locale !== undefined && this.#route !== undefined && Object.keys(this.#translations).length > 0);
     /**
@@ -88,11 +155,11 @@ class I18nCore {
         };
     });
     // -- configuration ----------------------------------------------------------
-    /** Applies a config. The public entry is `loadConfig`. */
-    async #configLoader(config) {
+    /** Applies a config and returns the `initLocale` load. The public entry is `loadConfig`. */
+    #configLoader(config) {
         if (!config) {
             logger.error('No config provided!');
-            return;
+            return Promise.resolve();
         }
         // `extensions` is a construction-time directive, not configuration state —
         // it is consumed by the constructor and must not land in `#config`.
@@ -102,7 +169,7 @@ class I18nCore {
         const sanitize = sanitizerFactory(rest.sanitizeLocales);
         const [sanitizedInitLocale] = sanitize(initLocale);
         const [sanitizedFallbackLocale] = sanitize(fallbackLocale);
-        const loaders = resolveLoaders(rest.loaders);
+        const loaders = resolveLoaders(rest.loaders, rest.sanitizeLocales);
         logger.debug('Setting config.');
         this.#config = {
             initLocale: sanitizedInitLocale,
@@ -112,147 +179,327 @@ class I18nCore {
             loaders,
         };
         // Report-only: the loader still runs, but `.` is the dot-notation
-        // separator, so a dotted key collides with the flattened namespace.
+        // separator, so a dotted namespace collides with the flattened one.
         // `String` rather than a template literal — interpolating a Symbol throws,
         // and a config-time report must not abort the rest of the config load.
-        loaders.forEach(({ key }) => {
-            const name = key == null ? '' : String(key);
+        loaders.forEach(({ namespace }) => {
+            const name = namespace == null ? '' : String(namespace);
             if (name.includes('.')) {
-                logger.error(`Invalid '${name}' loader key. It shouldn't include the '.' character.`);
+                logger.error(`Invalid '${name}' loader namespace. It shouldn't include the '.' character.`);
             }
         });
         // A reconfiguration can swap loaders or cache policy — bookkeeping from
         // the previous config must not suppress the new loaders.
         this.invalidate();
+        this.#wanted.clear();
+        this.#handOnDeliveries(loaders);
         if (translations)
             this.addTranslations(translations);
-        if (sanitizedInitLocale)
-            await this.loadTranslations(sanitizedInitLocale);
+        return sanitizedInitLocale ? this.loadTranslations(initLocale) : Promise.resolve();
     }
     /**
-     * Public entry for (re)configuration. The failure is reported here and the
-     * promise marked handled, so a fire-and-forget call cannot become an
-     * unhandled rejection; an awaiting caller still receives it.
+     * Public entry for (re)configuration. It returns the promise of the
+     * `initLocale` load, which reports its own failure; a config that fails to
+     * apply is reported here. Either way the promise is marked handled, so a
+     * fire-and-forget call cannot become an unhandled rejection; an awaiting
+     * caller still receives it.
      */
-    loadConfig = (config) => {
+    loadConfig = (config) => untrack(() => {
         if (this.#inert('loadConfig'))
             return Promise.resolve();
-        const promise = this.#configLoader(config);
-        promise.catch((error) => logError('Failed to load the i18n config.', error));
-        return promise;
-    };
+        // Not async: the `initLocale` load's own promise is returned as it is, and
+        // a config that throws is caught here instead of escaping the constructor.
+        try {
+            return this.#configLoader(config);
+        }
+        catch (error) {
+            logError('Failed to load the i18n config.', error);
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- passed on as thrown
+            const promise = Promise.reject(error);
+            promise.catch(() => undefined);
+            return promise;
+        }
+    });
     // -- loading ----------------------------------------------------------------
-    setLocale = (locale) => {
-        if (!locale || this.#inert('setLocale'))
+    // The loading calls — these, `loadNamespace()` and `loadConfig()` — and
+    // `addTranslations()` and `hydrate()` read the state they write, untracked:
+    // called from an effect, they must not make it depend on that state, or the
+    // effect runs them again whenever a later call, a load or an undo changes it.
+    setLocale = (locale) => untrack(() => {
+        if (!locale || this.#inert('setLocale') || this.#unserved(locale))
             return Promise.resolve();
+        const call = this.#ask();
         if (locale !== this.#requestedLocale) {
             logger.debug(`Setting '${locale}' locale.`);
             this.#requestedLocale = locale;
         }
         // Delegated even for a repeated value — the caller awaits "this locale is
         // loaded", which may mean joining a load already in flight.
-        if (this.#route !== undefined)
-            return this.#load(locale, this.#route);
-        return Promise.resolve();
-    };
-    setRoute = (route) => {
+        return this.#stand(call, this.#route !== undefined ? this.#load(locale, this.#route, call) : Promise.resolve());
+    });
+    setRoute = (input) => untrack(() => {
         if (this.#inert('setRoute'))
             return Promise.resolve();
+        const route = withoutBasePath(input, this.#config?.basePath);
+        const call = this.#ask();
         if (route !== this.#route) {
             logger.debug(`Setting '${route}' route.`);
             this.#route = route;
         }
-        if (this.#requestedLocale !== undefined)
-            return this.#load(this.#requestedLocale, route);
-        return Promise.resolve();
-    };
-    loadTranslations = (locale, route = this.#route ?? '') => {
-        if (!locale || this.#inert('loadTranslations'))
+        return this.#stand(call, this.#requestedLocale !== undefined ? this.#load(this.#requestedLocale, route, call) : Promise.resolve());
+    });
+    /**
+     * `{ activate: false }` only fills the tables: it leaves the requested
+     * locale, the route and `locale` untouched and does not count towards
+     * `loading` — what is rendered does not change: data of a loader whose route
+     * params differ from the ones the current route asks for is kept aside, the
+     * latest per loader, and the activating trigger that asks for them applies
+     * it. It
+     * leaves `cache` expiry to the next activating trigger. A loader's
+     * `redirect()` or `error()` below 500 rejects it all the same.
+     */
+    loadTranslations = (locale, route, { activate = true } = {}) => untrack(() => {
+        if (!locale || this.#inert('loadTranslations') || this.#unserved(locale))
             return Promise.resolve();
+        const target = route === undefined ? this.#route ?? '' : withoutBasePath(route, this.#config?.basePath);
+        if (!activate)
+            return this.#load(locale, target);
+        const call = this.#ask();
         this.#requestedLocale = locale;
-        this.#route = route;
-        return this.#load(locale, route);
-    };
+        this.#route = target;
+        return this.#stand(call, this.#load(locale, target, call));
+    });
     /**
-     * Marks loaded translations stale — for one locale, or all of them. Loaders
-     * run again on the NEXT load trigger; the call itself starts no load and
-     * keeps the currently displayed translations in place. A load still in
-     * flight for an invalidated locale is severed: it settles, but its data is
-     * discarded — it predates the invalidation.
+     * Loads one namespace for the active locale (or `locale`), whatever the
+     * routes of its loaders say — for what an interaction needs rather than a
+     * route: a modal, a panel, an editor. Warm, like `{ activate: false }`: it
+     * changes neither the locale nor `loading`, and it leaves `cache` expiry to
+     * the next activating trigger. It honours the load records, so calling it
+     * on every interaction fetches once — a loader with `cache: false` runs each
+     * time on its routes — and what it loads stays loaded across routes. A
+     * loader's `redirect()` or `error()` below 500 rejects it.
      */
-    invalidate = (locale) => {
+    loadNamespace = (namespace, locale) => untrack(() => {
+        if (this.#inert('loadNamespace'))
+            return Promise.resolve();
+        const target = locale ?? this.#locale;
+        if (!target)
+            return Promise.resolve();
+        return this.#load(target, this.#route ?? '', undefined, namespace);
+    });
+    /**
+     * Marks loaded translations stale — for one locale or all of them, and for
+     * one namespace or all of them. Loaders run again on the NEXT load trigger;
+     * the call itself starts no load and keeps the currently displayed
+     * translations in place. A loader still in flight for what was invalidated
+     * is severed: its load settles, but what it returns or throws is discarded —
+     * it predates the invalidation — and an activating trigger fetches it again,
+     * once, before its locale activates. It leaves it to the next trigger when
+     * another loader of its load threw SvelteKit's control flow that still
+     * counts, which rejects the trigger, and when the refetch is severed too. A
+     * namespace invalidation leaves the locale's `cache` window where it was.
+     */
+    invalidate = (locale, namespace) => {
         if (this.#inert('invalidate'))
             return;
-        if (locale !== undefined) {
-            const [sanitized] = this.#sanitize(locale);
-            if (sanitized !== undefined) {
-                delete this.#loadedKeys[sanitized];
-                delete this.#loadedAt[sanitized];
-                // Sever matching in-flight loads — applying their pre-invalidation
-                // data would resurrect the bookkeeping dropped above, permanently
-                // suppressing the promised refetch.
-                this.#inflight.forEach((_, key) => {
-                    if (key.startsWith(`${sanitized}\u0000`))
-                        this.#inflight.delete(key);
-                });
-            }
+        const [sanitized] = locale === undefined ? [] : this.#sanitize(locale);
+        if (locale !== undefined && sanitized === undefined)
             return;
-        }
-        this.#loadedKeys = Object.create(null);
-        this.#loadedAt = Object.create(null);
-        this.#inflight.clear();
+        this.#invalidate(sanitized, namespace);
     };
-    addTranslations = (translations) => {
+    addTranslations = (translations) => untrack(() => {
         if (this.#inert('addTranslations'))
             return;
         this.#addTranslations(translations);
-    };
+    });
+    /**
+     * Drops the bookkeeping `invalidate()` names and severs its loaders in
+     * flight. `config.cache` does not cover a loader with `cache: false`, so
+     * expiry leaves it alone.
+     */
+    #invalidate(sanitized, namespace, { expiry = false } = {}) {
+        const locales = sanitized === undefined ? Object.keys(this.#namespaceRecords) : [sanitized];
+        locales.forEach((recorded) => {
+            if (namespace === undefined)
+                delete this.#namespaceRecords[recorded];
+            else
+                this.#namespaceRecords[recorded] = (read(this.#namespaceRecords, recorded) || []).filter((name) => name !== namespace);
+        });
+        if (namespace === undefined) {
+            if (sanitized === undefined)
+                this.#loadedAt = Object.create(null);
+            else
+                delete this.#loadedAt[sanitized];
+        }
+        const covers = (loader) => !(expiry && loader.cache === false)
+            && (sanitized === undefined || loader.locale === sanitized)
+            && (namespace === undefined || loader.namespace === namespace);
+        this.#loaderRecords.forEach((_, loader) => {
+            if (covers(loader))
+                this.#loaderRecords.delete(loader);
+        });
+        this.#handedOff.forEach((_, loader) => {
+            if (covers(loader))
+                this.#handedOff.delete(loader);
+        });
+        this.#parked.forEach((_, loader) => {
+            if (covers(loader))
+                this.#parked.delete(loader);
+        });
+        // Applying their pre-invalidation data would resurrect the bookkeeping
+        // dropped above, permanently suppressing the promised refetch.
+        this.#sever(covers);
+    }
+    /**
+     * Restores the state `snapshot({ records: true })` captured on another
+     * instance: its data, its load records, the active locale and the route.
+     * A loader named by a record does not run again for the same params — one
+     * with `cache: false` only for the pass the envelope arrived with; data no
+     * record names is displayed but keeps no loader from running. An envelope
+     * without `records` is a plain hand-off instead: every namespace its data
+     * names keeps its loaders without params from running, and holds one with
+     * `cache: false` back for that pass. Nothing
+     * happens for `undefined`, so a load whose server half sent nothing can call
+     * it unconditionally.
+     */
+    hydrate = (envelope) => untrack(() => {
+        if (!envelope || this.#inert('hydrate'))
+            return;
+        // Typically `initLocale`: the constructor started its load before the
+        // records could keep the loaders from running.
+        if (this.#inflight.size)
+            logger.warn('Hydrating after a load started: its loaders ran regardless of the hand-off.');
+        const { translations = {}, records, seeds = {}, locale, route } = envelope;
+        if (records)
+            this.#hydrateRecords(translations, records, seeds);
+        else
+            this.#hydratePlain(translations);
+        this.#handOffPass = { locale, route };
+        // A hand-off stands: no call before it is put back.
+        this.#calls = [];
+        if (route !== undefined)
+            this.#route = route;
+        if (locale !== undefined) {
+            this.#requestedLocale = locale;
+            this.#locale = locale;
+        }
+        const resolved = this.#resolveLocale(locale);
+        if (resolved !== undefined && route !== undefined)
+            this.#want(this.#matchLoaders(resolved, route));
+    });
     /**
      * Serializes what this instance holds for the active locale and the fallback
-     * locale, narrowed to the current route: a key owned only by loaders that do
-     * not match the route is left out. The result is shaped like
-     * `config.translations`, so a client hydrates by handing it back to the
-     * constructor — the bookkeeping derived from it then keeps the matching
-     * loaders from fetching the same data again.
+     * locale. The result is shaped like `config.translations`, and a client
+     * hands it over with `hydrate({ translations })`: a plain hand-off, whose
+     * namespace records keep the matching loaders without params from fetching
+     * it again and hold one with `cache: false` back for that pass. Passed to
+     * `addTranslations()` or assigned to `config.translations` it only seeds,
+     * and every loader runs again.
+     * A namespace plain data cannot hand over is left out, for the client to
+     * load: one fed by several loaders, whose record would suppress a part the
+     * payload lacks; one whose loader's routes can capture params, whose data a
+     * plain hand-off keeps as data no loader delivered, so the next params could
+     * not replace it; and one none of whose loaders delivered here and no
+     * hand-off named, whose seeded data would keep the client's loaders from
+     * ever running.
+     * A literal `__proto__` key is left out too, and with records its
+     * namespace's loaders are, and a namespace whose loader captures params,
+     * without them a namespace a loader serves, so the client loads it whole: the serializer SvelteKit hands load data to refuses an
+     * object that carries one. A locale
+     * named `__proto__` is left out altogether.
+     *
+     * `{ records: true }` returns an envelope for `hydrate()` instead: the same
+     * data, the loaders that delivered it, the active locale and the route. The
+     * records name each loader, so a namespace fed by several loaders is handed
+     * over too, and so is one a loader delivered for route params while its
+     * record says so — not a namespace with both, whose data the client could
+     * not split between them. What was seeded into the namespace of a loader
+     * whose routes capture params travels apart as `seeds`, so it outlives new
+     * params there, and reaches the client where the namespace is left out.
      */
-    snapshot = () => {
-        const { fallbackLocale } = this.#config ?? {};
-        const route = this.#route ?? '';
-        // `#locale` is already sanitized; the fallback is normalized the same way
-        // the loaders key their data.
-        const locales = [this.#locale, ...this.#sanitize(fallbackLocale)].filter((locale) => !!locale);
-        return locales.reduce((acc, locale) => {
-            if (hasOwn(acc, locale))
-                return acc;
+    snapshot = ((options) => {
+        const withRecords = options?.records === true;
+        const { fallbackLocale, loaders = [] } = this.#config ?? {};
+        // Both are held sanitized, the way the loaders key their data.
+        const locales = unique([this.#locale, fallbackLocale].filter((locale) => !!locale));
+        const omitted = new Map(locales.map((locale) => [locale, this.#unsnapshottable(locale, withRecords)]));
+        const isOmitted = (locale, key) => (omitted.get(locale) ?? []).some((namespace) => isNamespaceKey(key, namespace));
+        // The top-level keys each locale lost a literal `__proto__` key under: a
+        // record of their namespace would suppress the part the payload lacks.
+        const stripped = new Map();
+        const translations = locales.reduce((acc, locale) => {
             const data = read(this.#rawTranslations, locale);
             if (!data)
                 return acc;
-            const offRoute = this.#offRouteKeys(locale, route);
-            const relevant = Object.keys(data)
-                .filter((key) => !offRoute.has(key))
-                .reduce((keep, key) => ({ ...keep, [key]: read(data, key) }), {});
+            if (locale === '__proto__') {
+                logger.warn('Leaving the \'__proto__\' locale out of the snapshot: load data cannot carry it.');
+                return acc;
+            }
+            const handable = Object.fromEntries(Object.entries(data).filter(([key]) => !isOmitted(locale, key)));
+            const relevant = omitProtoKeys(handable);
+            let kept = relevant;
+            if (relevant !== handable) {
+                logger.warn(`Leaving a '__proto__' key of locale '${locale}' out of the snapshot: load data cannot carry it.`);
+                const lost = Object.keys(handable).filter((key) => !hasOwn(relevant, key) || relevant[key] !== handable[key]);
+                stripped.set(locale, lost);
+                // The namespace goes without its record, whole: data plain or unrecorded
+                // is kept on the client as data no loader delivered, which a plain
+                // hand-off marks loaded and new params could not replace. It goes for
+                // the client to load instead — with records, only where params can
+                // change. One no loader serves keeps the rest.
+                const served = loaders
+                    .filter((loader) => loader.locale === locale && (!withRecords || capturesParams(loader.routes)))
+                    .filter((loader) => lost.some((key) => isNamespaceKey(key, loader.namespace)))
+                    .map(({ namespace }) => namespace);
+                kept = Object.fromEntries(Object.entries(relevant).filter(([key]) => !served.some((namespace) => isNamespaceKey(key, namespace))));
+            }
             // An empty entry would still stamp the locale's freshness on the client,
             // starting its `cache` window on data it never received.
-            if (!Object.keys(relevant).length)
+            if (!Object.keys(kept).length)
                 return acc;
-            return { ...acc, [locale]: relevant };
+            return { ...acc, [locale]: kept };
         }, {});
-    };
+        if (!withRecords)
+            return translations;
+        // A loader without an id cannot be named off-process: its data travels as
+        // data alone, and the client runs it again.
+        const records = loaders.flatMap((loader) => {
+            const { id, locale, namespace } = loader;
+            const signature = this.#loaderRecords.get(loader);
+            if (id === null || signature === undefined || !omitted.has(locale) || locale === '__proto__' || isOmitted(locale, namespace))
+                return [];
+            if ((stripped.get(locale) ?? []).some((key) => isNamespaceKey(key, namespace)))
+                return [];
+            return [signature ? { id, signature } : { id }];
+        });
+        // Where params can change, the client takes a recorded namespace whole as
+        // its loader's delivery and loads one left out itself, so what was seeded
+        // into it travels apart: the seed has to outlive the delivery new params
+        // replace there as it does here.
+        const seeds = omitProtoKeys(this.#externalOf(loaders.filter(({ locale, routes }) => omitted.has(locale) && locale !== '__proto__' && capturesParams(routes))));
+        return {
+            translations,
+            records,
+            ...(Object.keys(seeds).length ? { seeds } : {}),
+            ...(this.#locale === undefined ? {} : { locale: this.#locale }),
+            ...(this.#route === undefined ? {} : { route: this.#route }),
+        };
+    });
     /**
      * Detaches the instance from its loading lifecycle: in-flight loads settle
-     * with their data discarded, `loading` drops to `false`, and every further
-     * load or mutation call is ignored with a warning. Reads (`t`, `l`, `locale`,
-     * `translations`, `snapshot`) keep working, so a component still tearing down
-     * renders its last state instead of breaking. Idempotent.
+     * with whatever their loaders return or throw discarded, `loading` drops to
+     * `false`, and every further load or mutation call is ignored with a warning.
+     * Reads (`t`, `l`, `locale`, `translations`, `snapshot`) keep working, so a
+     * component still tearing down renders its last state instead of breaking.
+     * Idempotent.
      */
     destroy = () => {
         if (this.#destroyed)
             return;
         logger.debug('Destroying the i18n instance.');
         this.#destroyed = true;
-        // Severed rather than awaited — the identity guard in `#load` makes a
-        // settled load apply nothing once its entry is gone.
-        this.#inflight.clear();
+        // Severed rather than awaited: a settled load then applies nothing.
+        this.#sever(() => true);
         this.#pending = new Set();
     };
     // -- internals --------------------------------------------------------------
@@ -269,77 +516,259 @@ class I18nCore {
         });
     }
     /**
-     * Resolves loader data for a locale and route WITHOUT applying it. Returns
-     * `[]` when there is nothing to load. The `cache` expiry is evaluated by
-     * load triggers, not here.
+     * The fetches of `requests` from `route`, WITHOUT applying their data: each
+     * joins the one in flight for the same loader, params and route, and `run`
+     * starts the rest. Those are registered before `run` calls any loader, so a
+     * loader that starts a load of its own route joins its own fetch instead of
+     * running again. A fetch that delivered stays in the table until a load
+     * waiting on it has applied or parked the delivery; any other, and one of a
+     * loader with `cache: false`, leaves it with its outcome, so the next load
+     * runs the loader again. The `cache` expiry is evaluated by load triggers,
+     * not here.
      */
-    async #getTranslationProps(locale, route) {
-        if (!this.#config || !locale)
-            return [];
-        const [sanitizedLocale] = this.#sanitize(locale);
-        const filteredLoaders = this.#filterLoaders(sanitizedLocale, route);
-        if (!filteredLoaders.length)
-            return [];
-        logger.debug('Fetching translations...');
-        const rawTranslations = await fetchTranslations(filteredLoaders, route);
-        const loadedKeys = Object.entries(rawTranslations).reduce((acc, [translationLocale, data]) => ({ ...acc, [translationLocale]: Object.keys(data ?? {}) }), {});
-        const keys = filteredLoaders
-            .filter(({ key, locale: loaderLocale }) => (read(loadedKeys, loaderLocale) || []).some(
-        // Exact or namespaced match only — `navbar` data must not mark a
-        // sibling `nav` loader as loaded.
-        (loadedKey) => `${loadedKey}` === key || `${loadedKey}`.startsWith(`${key}.`)))
-            .reduce((acc, { key, locale: loaderLocale }) => ({
+    #fetch(requests, route) {
+        const started = [];
+        const fetches = requests.map((request) => {
+            const shared = Array.from(this.#fetches).find((fetch) => fetch.route === route
+                && fetch.request.loader === request.loader
+                && fetch.request.signature === request.signature);
+            if (shared)
+                return shared;
+            let outcome;
+            const fetch = { request, route, outcome: new Promise((resolve, reject) => { outcome = { resolve, reject }; }) };
+            this.#fetches.add(fetch);
+            started.push({ fetch, outcome });
+            return fetch;
+        });
+        const run = () => {
+            if (started.length)
+                logger.debug('Fetching translations...');
+            started.forEach(({ fetch, outcome }) => {
+                const release = (fetched) => {
+                    if (!fetched?.deliveries.length || fetch.request.loader.cache === false)
+                        this.#fetches.delete(fetch);
+                };
+                fetchTranslation(fetch.request, route).then((fetched) => {
+                    release(fetched);
+                    outcome.resolve(fetched);
+                }, (reason) => {
+                    release();
+                    outcome.reject(reason);
+                });
+            });
+        };
+        return { fetches, run };
+    }
+    /**
+     * Gives each delivery of the previous config to the loader of the new one
+     * with the same id, so its params can still replace it. What no loader can
+     * take over is kept as data supplied without a loader, so a namespace rebuilt
+     * later keeps it rather than losing it.
+     */
+    #handOnDeliveries(loaders) {
+        const takers = new Map(loaders.flatMap((loader) => (loader.id === null ? [] : [[loader.id, loader]])));
+        const deliveries = Array.from(this.#deliveries.values());
+        const orphaned = deliveries.filter(({ loader }) => loader.id === null || !takers.has(loader.id));
+        this.#deliveries = new Map(deliveries.flatMap((delivery) => {
+            const taker = delivery.loader.id === null ? undefined : takers.get(delivery.loader.id);
+            return taker ? [[taker, { ...delivery, loader: taker }]] : [];
+        }));
+        this.#keepExternal(serialize(orphaned.map(({ loader, data }) => ({ ...loader, data }))));
+    }
+    /**
+     * Applies what loaders delivered and records them as loaded. A loader whose
+     * params changed replaces the part of its namespace it delivered before:
+     * the namespace is rebuilt from the data supplied without a loader and from
+     * what each of its loaders last delivered, so no key of the previous params
+     * survives and a sibling's part stays in place. The preprocessed table of a
+     * locale that lost data is derived again from the raw one, since a custom
+     * `preprocess` may have renamed the keys that would have to go. Both tables
+     * are computed before anything is written, so a `preprocess` that throws
+     * records no loader and the next trigger fetches it again.
+     */
+    #applyDeliveries(deliveries) {
+        const replaced = deliveries
+            .filter(({ loader, signature }) => {
+            const previous = this.#deliveries.get(loader);
+            return previous !== undefined && previous.signature !== signature;
+        })
+            .map(({ loader }) => loader);
+        const delivered = new Map(deliveries.map((delivery) => [delivery.loader, delivery]));
+        const isReplaced = ({ locale, namespace }) => replaced.some((loader) => loader.locale === locale && loader.namespace === namespace);
+        const { loaders = [] } = this.#config ?? {};
+        const rebuilt = loaders
+            .filter(isReplaced)
+            .map((loader) => delivered.get(loader) ?? this.#deliveries.get(loader))
+            .filter((delivery) => delivery !== undefined);
+        const raw = replaced.reduce((acc, { locale, namespace }) => ({
             ...acc,
-            [loaderLocale]: [...(read(acc, loaderLocale) || []), key],
-        }), {});
-        return [rawTranslations, keys];
+            [locale]: Object.fromEntries(Object.entries(read(acc, locale) ?? {}).filter(([key]) => !isNamespaceKey(key, namespace))),
+        }), this.#rawTranslations);
+        const seeded = this.#merged({ raw, translations: this.#translations }, this.#externalOf(replaced));
+        const merged = this.#merged(seeded, serialize([
+            ...deliveries.filter(({ loader }) => !isReplaced(loader)),
+            ...rebuilt,
+        ].map(({ loader, data }) => ({ ...loader, data }))));
+        const translations = unique(replaced.map(({ locale }) => locale)).reduce((acc, locale) => ({ ...acc, [locale]: this.#preprocess(read(merged.raw, locale)) }), merged.translations);
+        deliveries.forEach((delivery) => this.#record(delivery));
+        this.#rawTranslations = merged.raw;
+        this.#translations = translations;
+        this.#stamp(deliveries.filter(({ loader }) => loader.cache !== false).map(({ loader }) => loader.locale));
     }
     /**
-     * Merges translations into the tables and registers their bookkeeping.
-     * `keys` carries the exact loader keys of a load; without it (the public
-     * `addTranslations` path) loaded keys derive from the data's top-level keys.
+     * Merges seeded data. It records no namespace, so the namespace's loaders
+     * still run and merge into it, and it starts no `cache` window. It is kept to
+     * rebuild a namespace a loader later replaces its part of.
      */
-    #addTranslations(translations, keys) {
+    #addTranslations(translations) {
         if (!translations)
             return;
-        const { preprocess } = this.#config ?? {};
-        logger.debug('Adding translations...');
         const sanitized = sanitizeTranslationLocales(translations, this.#sanitize);
-        const translationLocales = Object.keys(sanitized);
-        this.#rawTranslations = translationLocales.reduce((acc, locale) => ({
+        this.#addSanitized(sanitized);
+    }
+    #addSanitized(sanitized) {
+        this.#mergeTranslations(sanitized);
+        this.#keepExternal(sanitized);
+    }
+    /**
+     * Applies plain hand-off data. It records every namespace the data names,
+     * which keeps its loaders without params from running, and a loader with
+     * `cache: false` is served by its namespace for the pass the data arrived
+     * with.
+     */
+    #hydratePlain(translations) {
+        const { loaders = [] } = this.#config ?? {};
+        const served = loaders.filter((loader) => loader.cache === false
+            && Object.keys(read(translations, loader.locale) ?? {}).some((key) => isNamespaceKey(key, loader.namespace)));
+        this.#addSanitized(translations);
+        Object.keys(translations).forEach((locale) => {
+            // A `null` payload for a locale must not take the whole call down —
+            // every step of the merge tolerates it, so this bookkeeping does too.
+            const data = read(translations, locale) ?? {};
+            this.#namespaceRecords[locale] = Array.from(new Set([
+                ...(read(this.#namespaceRecords, locale) || []),
+                ...Object.keys(data).map((key) => `${key}`.split('.')[0]),
+            ]));
+        });
+        served.forEach((loader) => this.#handedOff.set(loader, ''));
+        this.#stampHandOff(translations);
+    }
+    /**
+     * Applies hand-off data with the records of the loaders that delivered it.
+     * A recorded loader's namespace is kept as that loader's delivery, so params
+     * that change later replace it; the rest is kept as data supplied without a
+     * loader and, like a seed, records no namespace — the hand-off says which loaders it
+     * covers, and anything else loads again rather than going missing. `seeds`
+     * is what was seeded where params can change, displayed and kept as a seed
+     * so that it outlives a delivery. A record naming no loader of this config
+     * is dropped, and its loader runs again.
+     */
+    #hydrateRecords(translations, records, seeds) {
+        const { loaders = [] } = this.#config ?? {};
+        const named = new Map(loaders.flatMap((loader) => (loader.id === null ? [] : [[loader.id, loader]])));
+        const deliveries = records.flatMap(({ id, signature = '' }) => {
+            const loader = named.get(id);
+            if (!loader) {
+                logger.debug(`No loader is named '${id}'. It loads again.`);
+                return [];
+            }
+            return [{ loader, signature, data: read(read(translations, loader.locale), loader.namespace) ?? {} }];
+        });
+        // Under the data: it holds the seeds of the namespaces it carries already.
+        this.#mergeTranslations(seeds);
+        this.#mergeTranslations(translations);
+        deliveries.forEach((delivery) => {
+            this.#record(delivery);
+            if (delivery.loader.cache === false)
+                this.#handedOff.set(delivery.loader, delivery.signature);
+        });
+        const external = Object.keys(translations).reduce((acc, locale) => {
+            const rest = Object.fromEntries(Object.entries(read(translations, locale) ?? {}).filter(([key]) => !deliveries.some(({ loader }) => loader.locale === locale && loader.namespace === key)));
+            return Object.keys(rest).length ? { ...acc, [locale]: rest } : acc;
+        }, {});
+        this.#keepExternal(external);
+        this.#keepExternal(seeds);
+        this.#stampHandOff(translations);
+    }
+    /** Records `delivery` as its loader's; what was parked for its params is older. */
+    #record(delivery) {
+        this.#deliveries.set(delivery.loader, delivery);
+        this.#loaderRecords.set(delivery.loader, delivery.signature);
+        if (this.#parked.get(delivery.loader)?.signature === delivery.signature)
+            this.#parked.delete(delivery.loader);
+    }
+    /** The data held without a loader in the namespaces of `loaders`. */
+    #externalOf(loaders) {
+        return loaders.reduce((acc, { locale, namespace }) => {
+            const data = read(this.#externalTranslations, locale) ?? {};
+            const own = Object.fromEntries(Object.entries(data).filter(([key]) => isNamespaceKey(key, namespace)));
+            if (!Object.keys(own).length)
+                return acc;
+            return { ...acc, [locale]: { ...read(acc, locale), ...own } };
+        }, {});
+    }
+    /** Keeps data held without a loader, to rebuild a namespace from. */
+    #keepExternal(sanitized) {
+        this.#externalTranslations = Object.keys(sanitized).reduce((acc, locale) => ({
             ...acc,
             [locale]: mergeTranslations(read(acc, locale) || {}, read(sanitized, locale) ?? {}, locale),
-        }), this.#rawTranslations);
-        this.#translations = translationLocales.reduce((acc, locale) => {
-            let dotnotate = true;
-            let input = read(sanitized, locale);
-            if (typeof preprocess === 'function') {
-                input = preprocess(input);
-            }
-            if (typeof preprocess === 'function' || preprocess === 'none') {
-                dotnotate = false;
-            }
-            return ({
+        }), this.#externalTranslations);
+    }
+    /** A locale's table as `config.preprocess` asks for it. */
+    #preprocess(input) {
+        const { preprocess } = this.#config ?? {};
+        if (typeof preprocess === 'function')
+            return preprocess(input) ?? {};
+        if (preprocess === 'none')
+            return input ?? {};
+        return toDotNotation(input, preprocess === 'preserveArrays') ?? {};
+    }
+    /** Merges data keyed by sanitized locales into both tables. */
+    #mergeTranslations(sanitized) {
+        const { raw, translations } = this.#merged({ raw: this.#rawTranslations, translations: this.#translations }, sanitized);
+        this.#rawTranslations = raw;
+        this.#translations = translations;
+    }
+    /**
+     * Both tables with data keyed by sanitized locales merged in. Pure, so a
+     * caller that writes only once both are computed keeps them consistent when
+     * a `preprocess` throws.
+     */
+    #merged(tables, sanitized) {
+        logger.debug('Adding translations...');
+        const translationLocales = Object.keys(sanitized);
+        return {
+            raw: translationLocales.reduce((acc, locale) => ({
                 ...acc,
-                [locale]: mergeTranslations(read(acc, locale) || {}, (dotnotate ? toDotNotation(input, preprocess === 'preserveArrays') : input) ?? {}, locale),
-            });
-        }, this.#translations);
-        translationLocales.forEach((locale) => {
-            // A `null` payload for a locale must not take the whole call down —
-            // every step above tolerates it, so this bookkeeping does too.
-            let localeKeys = Object.keys(read(sanitized, locale) ?? {}).map((key) => `${key}`.split('.')[0]);
-            if (keys)
-                localeKeys = read(keys, locale);
-            this.#loadedKeys[locale] = Array.from(new Set([
-                ...(read(this.#loadedKeys, locale) || []),
-                ...(localeKeys || []),
-            ]));
-            // Freshness is measured from the locale's FIRST data — later partial
-            // loads (other routes) must not extend the window.
+                [locale]: mergeTranslations(read(acc, locale) || {}, read(sanitized, locale) ?? {}, locale),
+            }), tables.raw),
+            translations: translationLocales.reduce((acc, locale) => ({
+                ...acc,
+                [locale]: mergeTranslations(read(acc, locale) || {}, this.#preprocess(read(sanitized, locale)), locale),
+            }), tables.translations),
+        };
+    }
+    /**
+     * Starts the `cache` window of each locale that has none. Freshness is
+     * measured from the locale's FIRST data — later partial loads (other
+     * routes) must not extend the window.
+     */
+    #stamp(locales) {
+        locales.forEach((locale) => {
             if (read(this.#loadedAt, locale) === undefined)
                 this.#loadedAt[locale] = Date.now();
         });
     }
+    /**
+     * Stamps each locale hand-off data holds something for that a caching
+     * loader feeds: seeded data and a namespace only loaders with `cache: false`
+     * feed start no window.
+     */
+    #stampHandOff(translations) {
+        const { loaders = [] } = this.#config ?? {};
+        const cached = (locale, key) => loaders.some((loader) => loader.locale === locale && loader.cache !== false && isNamespaceKey(key, loader.namespace));
+        this.#stamp(Object.keys(translations).filter((locale) => Object.keys(read(translations, locale) ?? {}).some((key) => cached(locale, key))));
+    }
     /** Reports a call on a destroyed instance; `true` means "ignore the call". */
     #inert(action) {
         if (!this.#destroyed)
@@ -349,23 +778,33 @@ class I18nCore {
     }
     #resolveLocale(inputLocale) {
         const { fallbackLocale } = this.#config ?? {};
-        const locale = inputLocale || fallbackLocale;
-        if (!locale)
+        if (!inputLocale && !fallbackLocale)
             return undefined;
         const all = this.locales;
         // Nothing to match against yet; sanitizing here would only emit a
         // non-standard warning for a lookup that cannot succeed anyway.
         if (!all.length)
             return undefined;
-        // Sanitized once per lookup rather than once per candidate locale.
-        const sanitized = this.#sanitize(locale);
-        const match = all.find((known) => sanitized.includes(known));
-        if (match || !fallbackLocale || fallbackLocale === locale)
-            return match;
-        // Evaluated lazily: the fallback (and any non-standard warning it emits)
-        // must not run when the requested locale resolves directly.
-        const sanitizedFallback = this.#sanitize(fallbackLocale);
-        return all.find((known) => sanitizedFallback.includes(known));
+        if (inputLocale) {
+            // Sanitized once per lookup rather than once per candidate locale.
+            const sanitized = this.#sanitize(inputLocale);
+            const match = all.find((known) => sanitized.includes(known));
+            if (match)
+                return match;
+        }
+        // The fallback is held sanitized.
+        return fallbackLocale && all.includes(fallbackLocale) ? fallbackLocale : undefined;
+    }
+    /**
+     * Whether nothing serves `locale` — no loader, no translations and no
+     * `fallbackLocale` — so a request for it changes nothing. Until a locale is
+     * known, any request is kept: a config loaded later may serve it.
+     */
+    #unserved(locale) {
+        if (!this.locales.length || this.#resolveLocale(locale) !== undefined)
+            return false;
+        logger.debug(`Ignoring '${locale}' locale — nothing serves it.`);
+        return true;
     }
     #cacheValue() {
         const { cache = defaultCache } = this.#config ?? {};
@@ -380,103 +819,554 @@ class I18nCore {
             const loadedAt = read(this.#loadedAt, locale);
             if (loadedAt !== undefined && Date.now() >= loadedAt + cacheValue) {
                 logger.debug(`'${locale}' translations expired. Loaders will run again.`);
-                this.invalidate(locale);
+                this.#invalidate(locale, undefined, { expiry: true });
             }
         });
     }
-    /** Activates `locale` unless another request superseded its load meanwhile. */
-    #activate(locale) {
+    /**
+     * Whether the locale the next trigger loads is other than `locale`: a later
+     * request asked for another, or a failed one put an earlier back.
+     */
+    #superseded(locale) {
         const requested = this.#resolveLocale(this.#requestedLocale);
         // An unresolvable most-recent request supersedes nothing — it must not
         // block a completed load from activating.
-        if (requested !== undefined && requested !== locale)
+        return requested !== undefined && requested !== locale;
+    }
+    /** Activates `locale` unless another request superseded its load meanwhile. */
+    #activate(locale) {
+        if (this.#superseded(locale))
             return;
         if (this.#locale !== locale)
             this.#locale = locale;
     }
+    /** The namespaces of `sanitizedLocale` `snapshot()` leaves out — see there. */
+    #unsnapshottable(sanitizedLocale, withRecords) {
+        const { loaders = [] } = this.#config ?? {};
+        const own = loaders.filter(({ locale }) => locale === sanitizedLocale);
+        return unique(own.map(({ namespace }) => namespace)).filter((namespace) => {
+            const feeding = own.filter((loader) => loader.namespace === namespace);
+            const several = feeding.length > 1;
+            const params = feeding.some(({ routes }) => capturesParams(routes));
+            // Seeded data alone would keep the client's loaders from ever running.
+            const delivered = feeding.some((loader) => this.#loaderRecords.has(loader))
+                || (read(this.#namespaceRecords, sanitizedLocale) || []).includes(namespace);
+            if (!withRecords)
+                return several || params || !delivered;
+            // Only a record lets the client replace the data once the params change.
+            return params && (several || feeding.some((loader) => loader.id === null || !this.#loaderRecords.has(loader)));
+        });
+    }
+    /**
+     * The loaders of `sanitizedLocale` (and the fallback locale) whose routes
+     * match `route`, with the params the route yields for each.
+     */
+    #matchLoaders(sanitizedLocale, route) {
+        const { loaders = [], fallbackLocale } = this.#config ?? {};
+        return loaders.flatMap((loader) => {
+            if (loader.locale !== sanitizedLocale && loader.locale !== fallbackLocale)
+                return [];
+            const params = routeParams(loader.routes, route);
+            return params ? [{ loader, params, signature: paramsSignature(params) }] : [];
+        });
+    }
+    /**
+     * The loaders of `namespace` for `sanitizedLocale` (and the fallback
+     * locale), whatever their routes. A loader whose routes match `route` gets
+     * the params they yield. Any other has no params to ask for, so whatever it
+     * delivered last serves; only a loader with no record is asked, for none.
+     */
+    #matchNamespace(sanitizedLocale, namespace, route) {
+        const { loaders = [], fallbackLocale } = this.#config ?? {};
+        return loaders.flatMap((loader) => {
+            if (loader.namespace !== namespace)
+                return [];
+            if (loader.locale !== sanitizedLocale && loader.locale !== fallbackLocale)
+                return [];
+            const params = routeParams(loader.routes, route);
+            if (params)
+                return [{ loader, params, signature: paramsSignature(params) }];
+            return this.#loaderRecords.has(loader) ? [] : [{ loader, params: {}, signature: '' }];
+        });
+    }
+    /**
+     * Cuts the loaders `covers` matches off the loads in flight: a load running
+     * one discards that loader's data when it settles while the rest of it
+     * lands, and no trigger that has to fetch that loader joins it.
+     */
+    #sever(covers) {
+        this.#inflight.forEach(({ loaders, unparked, severed }) => {
+            [...loaders, ...unparked.map(({ request }) => request.loader)].filter(covers).forEach((loader) => severed.add(loader));
+        });
+        this.#fetches.forEach((fetch) => {
+            if (covers(fetch.request.loader))
+                this.#fetches.delete(fetch);
+        });
+    }
+    /**
+     * Ends the pass a hand-off serves once an activating trigger asks for
+     * another locale or route; the first trigger after a hand-off that named
+     * neither settles them.
+     */
+    #passHandOff(locale, route) {
+        if (!this.#handedOff.size)
+            return;
+        const { locale: passLocale = locale, route: passRoute = route } = this.#handOffPass;
+        if (passLocale === locale && passRoute === route)
+            this.#handOffPass = { locale, route };
+        else
+            this.#handedOff.clear();
+    }
     /**
-     * Loader keys of `sanitizedLocale` that only ever load on OTHER routes. A key
-     * claimed by a route-matching loader — or by no loader at all — is not
-     * attributable to another route and is therefore absent here.
+     * Records the params the current route asks each matching loader for, and
+     * none of every other loader: a loader of a locale the request left must not
+     * keep params its route asked for. Returns what it replaced.
      */
-    #offRouteKeys(sanitizedLocale, route) {
+    #want(matching) {
         const { loaders = [] } = this.#config ?? {};
-        const offRoute = new Set();
-        const onRoute = new Set();
-        loaders.forEach(({ key, locale, routes }) => {
-            if (this.#sanitize(locale)[0] !== sanitizedLocale)
+        const wants = new Map([
+            ...loaders.map((loader) => [loader, null]),
+            ...matching.map(({ loader, signature }) => [loader, signature]),
+        ]);
+        const replaced = new Map(Array.from(wants.keys(), (loader) => [loader, this.#wanted.get(loader)]));
+        wants.forEach((signature, loader) => this.#wanted.set(loader, signature));
+        return replaced;
+    }
+    /**
+     * Starts an activating call: keeps the requested locale and the route it is
+     * about to replace — with the params `#load` adds, what is put back should
+     * it fail.
+     */
+    #ask() {
+        const call = { replaced: { requestedLocale: this.#requestedLocale, route: this.#route, wanted: new Map() }, failed: false, threw: [], resumed: false };
+        this.#calls = [...this.#calls, call];
+        return call;
+    }
+    /**
+     * Lets a call whose load resolved without failing stand, with every call
+     * before it. Dropping them only bounds the chain: a later call that has not
+     * failed keeps them from being undone either way.
+     */
+    #stand(call, promise) {
+        call.settled = promise.then(() => {
+            if (!call.failed)
+                this.#calls = this.#calls.slice(this.#calls.indexOf(call) + 1);
+        }, () => undefined);
+        return promise;
+    }
+    /**
+     * Marks the calls a load failed for, then undoes and drops failed calls from
+     * the end of the chain: a failed call behind one that has not failed stays,
+     * and stays applied, until that one fails too. Returns whether the undo put
+     * another request back, with the control flow of the calls it undid and of
+     * this load, or `undefined` when it undid nothing.
+     */
+    #fail(calls, thrown) {
+        calls.forEach((call) => {
+            call.failed = true;
+            call.threw = [...call.threw, ...thrown];
+        });
+        const before = { locale: this.#requestedLocale, route: this.#route };
+        let threw;
+        for (let last = this.#calls.at(-1); last?.failed; last = this.#calls.at(-1)) {
+            this.#undo(last);
+            this.#calls = this.#calls.slice(0, -1);
+            threw = [...threw ?? [], ...last.threw];
+        }
+        if (!threw)
+            return undefined;
+        this.#rewant();
+        const changed = before.locale !== this.#requestedLocale || before.route !== this.#route;
+        if (changed) {
+            const onRoute = this.#route ? ` on '${this.#route}' route` : '';
+            logger.debug(`Undoing the failed calls: the request is back to '${this.#requestedLocale}' locale${onRoute}.`);
+        }
+        return { changed, threw: [...threw, ...thrown] };
+    }
+    /**
+     * Puts back what a failed call replaced. Whichever of the locale and the
+     * route was not asked for before it stands: it is all there is for the next
+     * trigger to load.
+     */
+    #undo({ replaced: { requestedLocale, route, wanted } }) {
+        if (requestedLocale !== undefined)
+            this.#requestedLocale = requestedLocale;
+        if (route !== undefined)
+            this.#route = route;
+        wanted.forEach((signature, loader) => {
+            if (signature === undefined)
+                this.#wanted.delete(loader);
+            else
+                this.#wanted.set(loader, signature);
+        });
+    }
+    /**
+     * The loaders the request an undo left in place selects: wanted for the
+     * params its route yields, and no longer recorded as loaded for others —
+     * whatever another load delivered for them meanwhile stays displayed until
+     * the request loads them again. Runs before the failed load applies what
+     * its other loaders delivered, so that is filtered by what is wanted now.
+     */
+    #rewant() {
+        const locale = this.#resolveLocale(this.#requestedLocale);
+        if (!locale || this.#route === undefined)
+            return;
+        const matching = this.#matchLoaders(locale, this.#route);
+        this.#want(matching);
+        matching.forEach(({ loader, signature }) => {
+            if (this.#loaderRecords.has(loader) && this.#loaderRecords.get(loader) !== signature)
+                this.#loaderRecords.delete(loader);
+        });
+    }
+    /**
+     * Once the failed load has applied what its other loaders delivered, the
+     * request the undo put back activates if its data is there — a loader with
+     * `cache: false` counts once its record holds the params — unless an
+     * activating load of it is in flight that activates it or fails. It is
+     * loaded otherwise, by an activating call nobody awaits: the load that would
+     * have activated it may have resolved without activating while it was
+     * replaced, and a load still waiting to resume joins this one. It loads
+     * nothing when the undo put back the request that failed, or when that
+     * request needs a loader for the params an undone call's load, or this one,
+     * threw control flow for: a failure never runs again by itself.
+     */
+    #settleUndo({ changed, threw: controlFlow }) {
+        const locale = this.#resolveLocale(this.#requestedLocale);
+        const route = this.#route;
+        if (!locale || route === undefined)
+            return;
+        const matching = this.#matchLoaders(locale, route);
+        const missing = this.#unloaded(matching).filter(({ loader, signature }) => loader.cache !== false || this.#loaderRecords.get(loader) !== signature);
+        if (!missing.length) {
+            const key = this.#inflightKey(locale, route, matching);
+            // A severed load, or one of a replaced config, activates nothing when
+            // it settles.
+            const activating = Array.from(this.#inflight).some((entry) => entry.key === key && entry.calls.length && !entry.severed.size && entry.config === this.#config);
+            if (activating)
                 return;
-            (routes && !routes.some(testRoute(route)) ? offRoute : onRoute).add(key);
+            this.#applyWanted(this.#claimParked(matching).map(({ delivery }) => delivery));
+            this.#activate(locale);
+            return;
+        }
+        const threw = missing.some(({ loader, signature }) => controlFlow.some((flow) => flow.loader === loader && flow.signature === signature));
+        if (!changed || threw)
+            return;
+        const call = this.#ask();
+        void this.#stand(call, this.#load(locale, route, call));
+    }
+    /**
+     * The matching loaders a load has to run: all but those whose own record
+     * holds the params the route yields now. A namespace a plain hand-off
+     * delivered stands in for the record of a loader without params that has
+     * none.
+     * A loader with `cache: false` runs unless a hand-off serves it: its record
+     * only names what it delivered.
+     */
+    #unloaded(matching) {
+        return matching.filter(({ loader, signature }) => {
+            if (loader.cache === false)
+                return this.#handedOff.get(loader) !== signature;
+            if (this.#parked.get(loader)?.signature === signature)
+                return false;
+            if (this.#loaderRecords.has(loader))
+                return this.#loaderRecords.get(loader) !== signature;
+            return signature !== '' || !(read(this.#namespaceRecords, loader.locale) || []).includes(loader.namespace);
         });
-        onRoute.forEach((key) => offRoute.delete(key));
-        return offRoute;
-    }
-    #filterLoaders(sanitizedLocale, route) {
-        const { loaders, fallbackLocale = '' } = this.#config ?? {};
-        const [sanitizedFallbackLocale] = this.#sanitize(fallbackLocale);
-        const translationForLocale = read(this.#translations, sanitizedLocale);
-        const translationForFallbackLocale = read(this.#translations, sanitizedFallbackLocale);
-        return (loaders || [])
-            .map(({ locale, ...rest }) => ({ ...rest, locale: this.#sanitize(locale)[0] }))
-            .filter(({ routes }) => !routes || (routes || []).some(testRoute(route)))
-            .filter(({ key, locale }) => (locale === sanitizedLocale && (!translationForLocale || !(read(this.#loadedKeys, sanitizedLocale) || []).includes(key))) || (fallbackLocale && locale === sanitizedFallbackLocale && (!translationForFallbackLocale
-            || !(read(this.#loadedKeys, sanitizedFallbackLocale) || []).includes(key))));
-    }
-    /**
-     * Starts (or joins) a load. A load already in flight for the same locale
-     * and route is returned as-is, so concurrent duplicate triggers share one
-     * fetch. The pending entry is registered synchronously, so `loading` is
-     * observable right after the triggering call; a load with nothing to fetch
-     * never registers at all, so cache-served navigations do not flicker the flag.
-     */
-    #load(requestedLocale, route) {
+    }
+    /**
+     * Starts (or joins) a load. A load already in flight for the same locale and
+     * route that selected the same loaders for the same params is returned as-is
+     * while it delivers everything the trigger has to fetch, so concurrent
+     * duplicate triggers share one fetch — whether they selected by route or by
+     * `namespace`. The pending entry is registered
+     * synchronously, so `loading` is observable right after the triggering call;
+     * a load with nothing to fetch never registers at all, so cache-served
+     * navigations do not flicker the flag. A warm load — one without an
+     * activating `call` — never registers either, until an activating trigger
+     * joins it.
+     */
+    #load(requestedLocale, route, call, namespace) {
         const locale = this.#resolveLocale(requestedLocale);
         if (!locale)
             return Promise.resolve();
-        // Expiry is evaluated per load trigger, BEFORE the in-flight check. That
-        // order is safe: a locale is stamped only once its data arrived, so a
-        // shared in-flight load cannot be invalidated by its own duplicates.
-        this.#invalidateExpired(locale, this.#sanitize(this.#config?.fallbackLocale)[0]);
-        // NUL never appears in a sanitized locale, so the key is unambiguous.
-        const inflightKey = `${locale}\u0000${route}`;
-        const inflight = this.#inflight.get(inflightKey);
-        if (inflight)
-            return inflight;
-        if (!this.#filterLoaders(locale, route).length) {
+        // Expiry is evaluated per activating trigger, BEFORE the in-flight check.
+        // That order is safe: a locale is stamped only once its data arrived, so a
+        // shared in-flight load cannot be invalidated by its own duplicates. A
+        // warm trigger fills the tables and leaves their freshness to the next
+        // activating one.
+        if (call)
+            this.#invalidateExpired(locale, this.#config?.fallbackLocale);
+        const matching = namespace === undefined ? this.#matchLoaders(locale, route) : this.#matchNamespace(locale, namespace, route);
+        // Recorded before the in-flight check, so a trigger joining a load, or one
+        // served from the records, still decides which params the route shows.
+        if (call) {
+            call.replaced.wanted = this.#want(matching);
+            this.#passHandOff(locale, route);
+        }
+        return this.#loadSelection(locale, route, this.#inflightKey(locale, route, matching), matching, call ? [call] : []);
+    }
+    /**
+     * The key of a load in flight: what the trigger selected and the route it
+     * came from. A loader receives the route, so a load for another route may
+     * deliver, or throw, what does not fit this one — and one awaiting a
+     * navigation to it would wait on itself.
+     */
+    #inflightKey(locale, route, matching) {
+        const { loaders = [] } = this.#config ?? {};
+        return JSON.stringify([locale, route, ...matching.map(({ loader, signature }) => [loaders.indexOf(loader), signature])]);
+    }
+    /** Joins the load in flight under `key` that delivers what `selected` lacks, or starts one. */
+    #loadSelection(locale, route, key, selected, calls) {
+        const requests = this.#unloaded(selected);
+        const unparked = calls.length ? this.#claimParked(selected) : [];
+        if (!requests.length) {
             // Nothing to fetch — the locale still becomes active (its data is
-            // already present or it has no loaders).
-            this.#activate(locale);
+            // already present, parked or it has no loaders).
+            if (calls.length) {
+                this.#applyWanted(unparked.map(({ delivery }) => delivery));
+                this.#activate(locale);
+            }
             return Promise.resolve();
         }
-        const promise = this.#getTranslationProps(locale, route).then((props) => {
-            // An `invalidate()` — explicit, via expiry, or via reconfiguration —
-            // that raced this load severed it from `#inflight`. Its data predates
-            // the invalidation: applying it would resurrect the dropped bookkeeping
-            // and permanently suppress the promised refetch.
-            if (this.#inflight.get(inflightKey) !== promise)
-                return;
-            if (props.length)
-                this.#addTranslations(...props);
-            this.#activate(locale);
+        // What is parked lands with the load, so a call it fails puts it back.
+        const inflight = this.#joinable(key, requests);
+        if (inflight)
+            return this.#join(inflight, calls, unparked);
+        return this.#start(locale, route, key, requests, calls, unparked);
+    }
+    /** The load in flight under `key` that delivers every one of `requests`. */
+    #joinable(key, requests) {
+        return Array.from(this.#inflight).find(({ key: inflightKey, loaders, severed }) => inflightKey === key
+            && requests.every(({ loader }) => loaders.includes(loader) && !severed.has(loader)));
+    }
+    /**
+     * Joins a load in flight. The activating calls that join make it activate,
+     * and fail with it when a loader of it throws control flow that was not
+     * severed.
+     */
+    #join(entry, calls, unparked) {
+        if (!calls.length)
+            return entry.promise;
+        if (!entry.calls.length)
+            this.#pending = new Set(this.#pending).add(entry.promise);
+        entry.calls = [...entry.calls, ...calls];
+        entry.unparked = [...entry.unparked, ...unparked];
+        return entry.promise;
+    }
+    /**
+     * Whether the next trigger asks `loader` for `signature`: the params its
+     * route yields, none while the route does not select the loader, or any
+     * before a trigger asked.
+     */
+    #isWanted({ loader, signature }) {
+        const wanted = this.#wanted.get(loader);
+        if (wanted === undefined)
+            return true;
+        return (wanted ?? '') === signature;
+    }
+    /**
+     * Applies the deliveries of the params the next trigger asks for, and parks
+     * the rest. A loader no trigger asked for params keeps what it delivered for
+     * others: a warm load parks what would replace it, unless it asks for no
+     * params — `loadNamespace()` off the loader's routes. What an activating load
+     * counts on stays parked until it settles. A loader with `cache: false` runs
+     * on every trigger that selects it, so nothing of it is parked.
+     */
+    #applyWanted(deliveries) {
+        const wanted = deliveries.filter(({ loader, signature }) => {
+            const wanted = this.#wanted.get(loader);
+            if (typeof wanted === 'string')
+                return wanted === signature;
+            const previous = this.#deliveries.get(loader);
+            return !previous || previous.signature === signature || signature === '';
+        });
+        const parked = deliveries.filter((delivery) => !wanted.includes(delivery)
+            && delivery.loader.cache !== false
+            && !this.#claimed(delivery.loader));
+        parked.forEach((delivery) => this.#parked.set(delivery.loader, delivery));
+        this.#stamp(parked.map(({ loader }) => loader.locale));
+        if (wanted.length)
+            this.#applyDeliveries(wanted);
+    }
+    /** Takes the fetches `entry` waited on out of the table, once what they delivered is applied or parked. */
+    #release({ fetches }) {
+        fetches.forEach((fetch) => this.#fetches.delete(fetch));
+    }
+    /** What is parked for `requests`, for the load that applies it once it settles. */
+    #claimParked(requests) {
+        return requests.flatMap((request) => {
+            const delivery = this.#parked.get(request.loader);
+            return delivery?.signature === request.signature ? [{ request, delivery }] : [];
+        });
+    }
+    /** Whether a load in flight counts on what is parked for `loader`. */
+    #claimed(loader) {
+        const delivery = this.#parked.get(loader);
+        return delivery !== undefined && Array.from(this.#inflight).some(({ unparked }) => unparked.some((claim) => claim.delivery === delivery));
+    }
+    /**
+     * The control flow a settled load rejects with: the first its locale's
+     * loaders threw, in `loaders` order, then the fallback locale's. What a
+     * severed loader threw predates the invalidation, and an activating load
+     * counts control flow only while it serves the request the next trigger
+     * loads — not once another locale or other params of that loader were asked
+     * for.
+     */
+    #rejection({ severed, calls }, locale, controlFlow) {
+        const discarded = (flow) => {
+            if (severed.has(flow.loader))
+                return 'an invalidation or destroy() severed it';
+            if (!calls.length)
+                return undefined;
+            if (this.#superseded(locale))
+                return 'another locale was asked for';
+            return this.#isWanted(flow) ? undefined : 'other params were asked for';
+        };
+        const counted = controlFlow.filter((flow) => {
+            const reason = discarded(flow);
+            if (reason)
+                logger.debug(`Discarding what the ${loaderName(flow.loader)} loader threw: ${reason}.`, flow.value);
+            return !reason;
+        });
+        const [first, ...rest] = [
+            ...counted.filter(({ loader }) => loader.locale === locale),
+            ...counted.filter(({ loader }) => loader.locale !== locale),
+        ];
+        if (!first)
+            return undefined;
+        rest.forEach(({ loader, value }) => logger.debug(`Discarding what the ${loaderName(loader)} loader threw: the load rejects with what the ${loaderName(first.loader)} loader threw.`, value));
+        return first;
+    }
+    /** Fetches `requests` as a load in flight under `key`, and settles it. */
+    #start(locale, route, key, requests, calls, unparked) {
+        const onRoute = route ? ` and '${route}' route` : '';
+        let rejection;
+        let outcome;
+        const promise = new Promise((resolve, reject) => { outcome = { resolve, reject }; });
+        const { fetches, run } = this.#fetch(requests, route);
+        const entry = { key, config: this.#config, promise, loaders: requests.map(({ loader }) => loader), fetches, severed: new Set(), calls, unparked };
+        // Registered before any loader is called, so one that invalidates or
+        // destroys the instance before its first `await` severs its own load too.
+        this.#inflight.add(entry);
+        if (calls.length)
+            this.#pending = new Set(this.#pending).add(promise);
+        run();
+        const settled = Promise.all(fetches.map(({ outcome }) => outcome)).then(mergeFetched).then(({ deliveries, controlFlow }) => {
+            // Released before the load settles: a trigger arriving in between must
+            // not join a load whose activation step has already run — it finds the
+            // data recorded and activates at once.
+            this.#inflight.delete(entry);
+            // An `invalidate()` — explicit, via expiry, via reconfiguration or via
+            // `destroy()` — that raced this load severed some of its loaders. Their
+            // data predates the invalidation: applying it would resurrect the
+            // dropped bookkeeping and permanently suppress the promised refetch.
+            const current = deliveries.filter(({ loader }) => !entry.severed.has(loader));
+            // What it counts on applies while still parked: a newer record of the
+            // same params dropped it, and an invalidation severed it.
+            const held = entry.unparked
+                .filter(({ request, delivery }) => !entry.severed.has(request.loader) && this.#parked.get(request.loader) === delivery)
+                .map(({ delivery }) => delivery);
+            const served = [...requests, ...entry.unparked.map(({ request }) => request)];
+            rejection = this.#rejection(entry, locale, controlFlow);
+            // The calls that share the load failed, whether its control flow rejects
+            // them or a later call superseded it: the locale does not advance, and
+            // what they replaced is put back unless a later call that has not failed
+            // came since.
+            const thrown = controlFlow.filter(({ loader }) => !entry.severed.has(loader));
+            const undone = thrown.length ? this.#fail(entry.calls, thrown) : undefined;
+            // With control flow, what the other loaders delivered lands as a warm
+            // load's does. Should applying it fail, that is only logged: the caller
+            // gets the control flow.
+            let failure;
+            try {
+                this.#applyWanted([...held, ...current]);
+            }
+            catch (error) {
+                if (rejection)
+                    logError(`Failed to load translations for '${locale}' locale${onRoute}.`, error);
+                else
+                    failure = { error };
+            }
+            this.#release(entry);
+            if (undone)
+                this.#settleUndo(undone);
+            if (failure)
+                throw failure.error;
+            if (rejection)
+                throw rejection.value;
+            // A load of params the route no longer asks for, whatever it returned,
+            // leaves the activation to the load of the params it asks for. One whose
+            // control flow a later call superseded failed: an undo that puts its
+            // request back loads it, unless that control flow still covers it.
+            const replaced = served.some((request) => !this.#isWanted(request));
+            if (!entry.calls.length || replaced || thrown.length)
+                return [];
+            if (!entry.severed.size)
+                this.#activate(locale);
+            return served.filter(({ loader }) => entry.severed.has(loader));
         });
-        this.#inflight.set(inflightKey, promise);
-        this.#pending = new Set(this.#pending).add(promise);
+        // Reported here so a load nobody awaits is still visible. What a resume
+        // adopts is a load of its own, which reports itself; control flow a
+        // shared fetch threw is reported by the first load it rejects.
+        settled.catch((error) => {
+            if (rejection) {
+                if (this.#reported.has(rejection))
+                    return;
+                this.#reported.add(rejection);
+            }
+            logError(rejection
+                ? `Rejecting the load of '${locale}' locale${onRoute} with what the ${loaderName(rejection.loader)} loader threw.`
+                : `Failed to load translations for '${locale}' locale${onRoute}.`, error);
+        });
+        // Resumed once per call: a loader that invalidates what it loads each time
+        // it runs would otherwise be fetched again for as long as it keeps doing
+        // so, while a call that joined a resumed load still gets its own.
+        settled
+            .then((severed) => (severed.length && entry.calls.some(({ resumed }) => !resumed) ? this.#resume(entry, locale, route, severed) : undefined))
+            .then(outcome.resolve, outcome.reject);
         const settle = () => {
-            // Guarded by identity — a later load under the same key must not be
-            // evicted by this one settling.
-            if (this.#inflight.get(inflightKey) === promise)
-                this.#inflight.delete(inflightKey);
+            // Only a settle step that threw before its release skipped the one above.
+            this.#inflight.delete(entry);
+            this.#release(entry);
+            if (!this.#pending.has(promise))
+                return;
             const next = new Set(this.#pending);
             next.delete(promise);
             this.#pending = next;
         };
+        // Also marks the load handled, so one nobody awaits cannot terminate the
+        // process; an awaiting caller still receives the rejection.
         promise.then(settle, settle);
-        // Reported here so a discarded load is still visible, and marked handled so
-        // it cannot terminate the process; an awaiting caller still receives the
-        // rejection from the same promise.
-        promise.catch((error) => logError(`Failed to load translations for '${locale}' locale and '${route}' route.`, error));
         return promise;
     }
+    /**
+     * Finishes an activating load an invalidation cut `severed` off: it fetches
+     * them again, so a trigger's promise that resolves still means its locale
+     * is loaded, and control flow the refetch throws rejects it as any load's
+     * does. It runs once per call: what severs the refetch of every call it
+     * serves is left to the next trigger, as is the locale when the instance
+     * was destroyed or reconfigured. Once a
+     * later call asked for another locale or route, it waits for the calls since
+     * its own to settle: it stands down should the request stay replaced, and
+     * resumes should an undo put it back. A load whose params a later request
+     * replaced, or whose control flow it superseded, does not get here: an undo
+     * that puts it back loads it itself.
+     */
+    #resume(entry, locale, route, severed) {
+        if (this.#destroyed || entry.config !== this.#config)
+            return undefined;
+        if (this.#superseded(locale) || this.#route !== route) {
+            // A resumed call joins a load after the calls it started, so the latest
+            // of them is found by its place in the chain, not in the load.
+            const last = Math.max(-1, ...entry.calls.map((call) => this.#calls.indexOf(call)));
+            const later = last === -1 ? [] : this.#calls.slice(last + 1);
+            if (!later.length)
+                return undefined;
+            return Promise.all(later.flatMap(({ settled }) => settled ?? [])).then(() => this.#resume(entry, locale, route, severed));
+        }
+        entry.calls.forEach((call) => { call.resumed = true; });
+        return this.#loadSelection(locale, route, entry.key, severed, entry.calls);
+    }
 }
 // The raw class is deliberately not exported — every consumer constructs
 // through the extension-aware signature. The exported name carries both