intor 2.3.29 → 2.3.30

package/dist/next/src/server/messages/load-messages.js

@@ -17,7 +17,7 @@ import { loadLocalMessages } from './load-local-messages/load-local-messages.js'
  * Message traversal, parsing, fallback resolution, and caching logic
  * are delegated to the selected loader.
  */
-const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, }) => {
+const loadMessages = async ({ config, locale, readers, allowCacheWrite = false, fetch, }) => {
     const baseLogger = getLogger(config.logger);
     const logger = baseLogger.child({ scope: "load-messages" });
     // ---------------------------------------------------------------------------
@@ -61,6 +61,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
             fallbackLocales,
             namespaces,
             concurrency,
+            fetch,
             url: loader.url,
             headers: loader.headers,
             loggerOptions: config.logger,

package/dist/next/src/server/translator/init-translator.js

@@ -14,13 +14,19 @@ import { createTranslator } from './create-translator.js';
  * - Returns an immutable translator snapshot.
  */
 async function initTranslator(config, locale, options) {
-    const { readers, allowCacheWrite = false, preKey, handlers, plugins, } = options || {};
+    const { readers, allowCacheWrite = false, fetch, preKey, handlers, plugins, } = options;
     const loader = resolveLoaderOptions(config, "server");
     // Load messages
     let messages = {};
     if (loader) {
-        messages =
-            (await loadMessages({ config, locale, readers, allowCacheWrite })) || {};
+        const loaded = await loadMessages({
+            config,
+            locale,
+            readers,
+            allowCacheWrite,
+            fetch,
+        });
+        messages = loaded || {};
     }
     // Create immutable translator snapshot
     return createTranslator({

package/dist/react/export/react/index.js

@@ -2,7 +2,5 @@ export { IntorProvider } from '../../src/client/react/provider/intor-provider.js
 export { useIntorContext } from '../../src/client/react/provider/use-intor-context.js';
 export { useTranslator } from '../../src/client/react/translator/use-translator.js';
 export { Trans } from '../../src/client/react/translator/trans.js';
-export { useResolveNavigation } from '../../src/client/react/navigation/use-resolve-navigation.js';
-export { useExecuteNavigation } from '../../src/client/react/navigation/use-execute-navigation.js';
 export { useIntor } from '../../src/client/react/helpers/use-intor.js';
 export { getClientLocale } from '../../src/client/shared/helpers/get-client-locale.js';

package/dist/react/src/client/shared/messages/create-refetch-messages.js

@@ -30,6 +30,7 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
                 fallbackLocales: config.fallbackLocales[newLocale] || [],
                 namespaces: loader.namespaces,
                 concurrency: loader.concurrency,
+                fetch: globalThis.fetch,
                 url: loader.url,
                 headers: loader.headers,
                 signal: currentController.signal,

package/dist/react/src/core/messages/load-remote-messages/fetch-remote-resource.js

@@ -12,7 +12,7 @@ import { isValidMessages } from '../utils/is-valid-messages.js';
  * - Validating the returned message structure
  * - Handling abort and network errors
  */
-async function fetchRemoteResource({ url, headers, signal, loggerOptions, }) {
+async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions, }) {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "fetch-locale-messages" });
     try {

package/dist/react/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -18,7 +18,7 @@ import { resolveRemoteResources } from './resolve-remote-resources.js';
  *
  * Network requests and response validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, url: baseUrl, headers, signal, loggerOptions, }) => {
+const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, fetch, url: baseUrl, headers, signal, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
@@ -49,7 +49,7 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             // -----------------------------------------------------------------
             // Fetch all message chunks in parallel
             // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions });
+            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions, fetch });
             const results = await Promise.all(resources.map(({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)));
             // Guard: no valid remote resources
             if (!results.some(Boolean))

package/dist/svelte/export/svelte/index.js

@@ -1,3 +1,5 @@
-export { createIntorStore } from '../../src/client/svelte/store/create-intor-store.js';
-export { createIntor } from '../../src/client/svelte/helpers/create-intor.js';
+export { createIntorStore } from '../../src/client/svelte/provider/create-intor-store.js';
+export { default as IntorProvider } from '../../src/client/svelte/provider/intor-provider.svelte';
+export { useIntorContext } from '../../src/client/svelte/provider/use-intor-context.js';
+export { useTranslator } from '../../src/client/svelte/translator/use-translator.js';
 export { getClientLocale } from '../../src/client/shared/helpers/get-client-locale.js';

package/dist/svelte/src/client/shared/messages/create-refetch-messages.js

@@ -30,6 +30,7 @@ const createRefetchMessages = ({ config, onLoadingStart, onLoadingEnd, onMessage
                 fallbackLocales: config.fallbackLocales[newLocale] || [],
                 namespaces: loader.namespaces,
                 concurrency: loader.concurrency,
+                fetch: globalThis.fetch,
                 url: loader.url,
                 headers: loader.headers,
                 signal: currentController.signal,

package/dist/svelte/src/client/svelte/{store → provider}/create-intor-store.js

@@ -1,9 +1,10 @@
 import { Translator } from 'intor-translator';
+import { setContext } from 'svelte';
 import { writable, readable, derived, get } from 'svelte/store';
-import { createTranslatorBindings } from './create-translator-bindings.js';
 import { attachLocaleEffects } from './effects/locale-effects.js';
 import { attachMessagesEffects } from './effects/messages-effects.js';
 
+const INTOR_CONTEXT_KEY = Symbol("intor:svelte");
 function createIntorStore({ config, locale: initialLocale, messages, handlers, plugins, onLocaleChange, isLoading: externalIsLoading, }) {
     // ---------------------------------------------------------------------------
     // Internal state
@@ -25,11 +26,12 @@ function createIntorStore({ config, locale: initialLocale, messages, handlers, p
     // ---------------------------------------------------------------------------
     // Effective state
     // ---------------------------------------------------------------------------
-    const externalIsLoadingStore = externalIsLoading ?? readable(false);
+    const externalIsLoadingStore = readable(!!externalIsLoading);
     // external > internal
     const effectiveIsLoading = derived([externalIsLoadingStore, internalIsLoading], ([$external, $internal]) => $external || $internal);
     // runtime (client refetch) > initial > config (static)
-    const effectiveMessages = derived([runtimeMessages, messages ?? readable(undefined)], ([$runtime, $initial]) => $runtime || $initial || config.messages || {});
+    const initialMessagesStore = readable(messages || config.messages || {});
+    const effectiveMessages = derived([runtimeMessages, initialMessagesStore], ([$runtime, $initial]) => $runtime || $initial);
     // ---------------------------------------------------------------------------
     // Translator
     // ---------------------------------------------------------------------------
@@ -48,16 +50,7 @@ function createIntorStore({ config, locale: initialLocale, messages, handlers, p
     // ---------------------------------------------------------------------------
     attachLocaleEffects(locale, config);
     attachMessagesEffects({ config, locale, runtimeMessages, internalIsLoading });
-    const { scoped, t, tRich } = createTranslatorBindings(translator);
-    return {
-        messages: effectiveMessages,
-        locale,
-        isLoading: effectiveIsLoading,
-        setLocale,
-        scoped,
-        t,
-        tRich,
-    };
+    setContext(INTOR_CONTEXT_KEY, { config, locale, setLocale, translator });
 }
 
-export { createIntorStore };
+export { INTOR_CONTEXT_KEY, createIntorStore };

package/dist/svelte/src/client/svelte/provider/intor-provider.svelte

@@ -0,0 +1,7 @@
+<script lang="ts">
+  import { createIntorStore } from "./create-intor-store";
+  export let value;
+  createIntorStore(value);
+</script>
+
+<slot />

package/dist/svelte/src/client/svelte/provider/use-intor-context.js

@@ -0,0 +1,11 @@
+import { getContext } from 'svelte';
+import { INTOR_CONTEXT_KEY } from './create-intor-store.js';
+
+function useIntorContext() {
+    const context = getContext(INTOR_CONTEXT_KEY);
+    if (!context)
+        throw new Error("useIntorContext must be used within IntorProvider");
+    return context;
+}
+
+export { useIntorContext };

package/dist/svelte/src/client/svelte/render/create-svelte-renderer.js

@@ -18,12 +18,11 @@ const createSvelteRenderer = (options) => {
         },
         /** Render semantic tag nodes */
         tag(name, attributes, children) {
-            const renderer = tagRenderers?.[name];
-            // Custom tag renderer
-            if (renderer) {
-                return typeof renderer === "function"
-                    ? renderer(children, attributes)
-                    : renderer;
+            const tagRenderer = tagRenderers?.[name];
+            if (tagRenderer) {
+                return typeof tagRenderer === "function"
+                    ? tagRenderer(children)
+                    : tagRenderer;
             }
             // Default behavior: render as native HTML tag
             return `<${name}${renderAttributes(attributes)}>${children.join("")}</${name}>`;

package/dist/svelte/src/client/svelte/translator/create-t-rich.js

@@ -0,0 +1,23 @@
+import { renderRichMessageSvelte } from '../render/render-rich-message-svelte.js';
+
+/**
+ * Create a Svelte-specific rich translation function.
+ *
+ * This adapter bridges the core Translator with the Svelte rich
+ * message rendering flow.
+ *
+ * - Resolves translated messages via `translator.t`
+ * - Renders semantic tags using Svelte renderers
+ * - Supports optional scoped keys via `preKey`
+ *
+ * Intended for Svelte client usage only.
+ */
+const createTRich = (translator, preKey) => {
+    const t = preKey ? translator.scoped(preKey).t : translator.t;
+    return (key, tagRenderers, replacements) => {
+        const message = t(key, replacements);
+        return renderRichMessageSvelte(message, tagRenderers);
+    };
+};
+
+export { createTRich };

package/dist/svelte/src/client/svelte/translator/use-translator.js

@@ -0,0 +1,32 @@
+import { derived } from 'svelte/store';
+import 'intor-translator';
+import 'svelte';
+import '../../../core/error/intor-error.js';
+import 'logry';
+import 'p-limit';
+import '../provider/intor-provider.svelte';
+import { useIntorContext } from '../provider/use-intor-context.js';
+import { createTRich } from './create-t-rich.js';
+
+// Implementation
+function useTranslator(preKey) {
+    const { translator, locale, setLocale } = useIntorContext();
+    const scoped = preKey
+        ? derived(translator, ($t) => $t.scoped(preKey))
+        : translator;
+    return {
+        messages: derived(translator, ($t) => $t.messages),
+        locale,
+        isLoading: derived(translator, ($t) => $t.isLoading),
+        setLocale,
+        hasKey: derived(scoped, ($t) => $t.hasKey),
+        t: derived(scoped, ($t) => $t.t),
+        tRich: derived(translator, ($t) => createTRich($t, preKey)),
+        // NOTE:
+        // The runtime implementation is intentionally erased.
+        // Type safety is guaranteed by public type contracts.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    };
+}
+
+export { useTranslator };

package/dist/svelte/src/core/messages/load-remote-messages/fetch-remote-resource.js

@@ -12,7 +12,7 @@ import { isValidMessages } from '../utils/is-valid-messages.js';
  * - Validating the returned message structure
  * - Handling abort and network errors
  */
-async function fetchRemoteResource({ url, headers, signal, loggerOptions, }) {
+async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions, }) {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "fetch-locale-messages" });
     try {

package/dist/svelte/src/core/messages/load-remote-messages/load-remote-messages.js

@@ -18,7 +18,7 @@ import { resolveRemoteResources } from './resolve-remote-resources.js';
  *
  * Network requests and response validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, url: baseUrl, headers, signal, loggerOptions, }) => {
+const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, fetch, url: baseUrl, headers, signal, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
@@ -49,7 +49,7 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             // -----------------------------------------------------------------
             // Fetch all message chunks in parallel
             // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions });
+            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions, fetch });
             const results = await Promise.all(resources.map(({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)));
             // Guard: no valid remote resources
             if (!results.some(Boolean))

package/dist/svelte-kit/export/svelte-kit/index.js

@@ -0,0 +1 @@
+export { useNavigation } from '../../src/adapters/svelte-kit/navigation/use-navigation.js';

package/dist/svelte-kit/export/svelte-kit/server/index.js

@@ -0,0 +1,2 @@
+export { createIntorHandle } from '../../../src/adapters/svelte-kit/server/create-intor-handle.js';
+export { intor } from '../../../src/adapters/svelte-kit/server/intor.js';

package/dist/svelte-kit/src/adapters/svelte-kit/navigation/use-navigation.js

@@ -0,0 +1,36 @@
+import { get } from 'svelte/store';
+import { executeNavigation } from '../../../client/shared/navigation/execute-navigation.js';
+import { useIntorContext } from 'intor/svelte';
+import '../../../core/error/intor-error.js';
+import 'logry';
+import 'p-limit';
+import { resolveNavigation } from '../../../routing/navigation/resolve-navigation.js';
+import { goto } from '$app/navigation';
+import { page } from '$app/state';
+
+/**
+ * Locale-aware navigation utilities for SvelteKit.
+ *
+ * Provides imperative navigation helpers that integrate
+ * Intor's locale-aware routing and side effects.
+ *
+ * @platform SvelteKit
+ */
+function useNavigation() {
+    const { config, locale: currentLocale, setLocale } = useIntorContext();
+    async function goto$1(url, opts) {
+        const { locale, ...rest } = opts || {};
+        const navigationResult = resolveNavigation(config, get(currentLocale), page.url.pathname, { destination: url, locale });
+        executeNavigation(navigationResult, {
+            config,
+            currentLocale: get(currentLocale),
+            setLocale,
+        });
+        return goto(navigationResult.destination, rest);
+    }
+    return {
+        goto: goto$1,
+    };
+}
+
+export { useNavigation };

package/dist/svelte-kit/src/adapters/svelte-kit/server/create-intor-handle.js

@@ -0,0 +1,58 @@
+import { redirect } from '@sveltejs/kit';
+import { INTOR_HEADERS } from '../../../core/constants/headers.js';
+import '../../../core/error/intor-error.js';
+import { normalizeQuery } from '../../../core/utils/normalizers/normalize-query.js';
+import 'logry';
+import 'p-limit';
+import { resolveInbound } from '../../../routing/inbound/resolve-inbound.js';
+import { getLocaleFromAcceptLanguage } from '../../../routing/locale/get-locale-from-accept-language.js';
+
+/**
+ * Resolves locale-aware routing for the current execution context.
+ *
+ * The resolved routing state is exposed via response headers.
+ *
+ * - Acts as the canonical routing authority within the SvelteKit request lifecycle.
+ *
+ * @platform SvelteKit
+ */
+function createIntorHandle(config) {
+    return async ({ event, resolve }) => {
+        // ----------------------------------------------------------
+        // Locale from Accept-Language header
+        // ----------------------------------------------------------
+        const acceptLanguage = event.request.headers.get("accept-language");
+        const localeFromAcceptLanguage = getLocaleFromAcceptLanguage(acceptLanguage, config.supportedLocales);
+        // ----------------------------------------------------------
+        // Resolve inbound routing decision (pure computation)
+        // ----------------------------------------------------------
+        const { locale, localeSource, pathname, shouldRedirect } = await resolveInbound(config, event.url.pathname, false, {
+            host: event.url.host,
+            query: normalizeQuery(Object.fromEntries(event.url.searchParams.entries())),
+            cookie: event.cookies.get(config.cookie.name),
+            detected: localeFromAcceptLanguage || config.defaultLocale,
+        });
+        // ----------------------------------------------------------
+        // Redirect if needed
+        // ----------------------------------------------------------
+        if (shouldRedirect) {
+            throw redirect(307, pathname);
+        }
+        // ----------------------------------------------------------
+        // Attach routing metadata
+        // ----------------------------------------------------------
+        // @ts-expect-error - App.Locals must be extended by user
+        event.locals.intor = {
+            locale,
+            localeSource,
+            pathname,
+        };
+        const response = await resolve(event);
+        response.headers.set(INTOR_HEADERS.LOCALE, locale);
+        response.headers.set(INTOR_HEADERS.LOCALE_SOURCE, localeSource);
+        response.headers.set(INTOR_HEADERS.PATHNAME, pathname);
+        return response;
+    };
+}
+
+export { createIntorHandle };

package/dist/svelte-kit/src/adapters/svelte-kit/server/intor.js

@@ -0,0 +1,24 @@
+import '../../../core/error/intor-error.js';
+import 'logry';
+import 'p-limit';
+import { intor as intor$1 } from '../../../server/intor/intor.js';
+import 'node:path';
+import 'node:fs/promises';
+import 'intor-translator';
+
+/**
+ * Initializes Intor for the current execution context.
+ *
+ * - Uses the locale resolved by the SvelteKit request lifecycle.
+ * - Permits cache writes during server execution.
+ * @platform SvelteKit
+ */
+async function intor(config, locale, fetch, options) {
+    return await intor$1(config, locale, {
+        readers: options?.readers,
+        allowCacheWrite: options?.allowCacheWrite ?? true,
+        fetch,
+    });
+}
+
+export { intor };

package/dist/svelte-kit/src/client/shared/navigation/execute-navigation.js

@@ -0,0 +1,49 @@
+import '../../../core/error/intor-error.js';
+import 'logry';
+import 'p-limit';
+import { shouldSyncLocale } from '../../../policies/should-sync-locale.js';
+import { setLocaleCookie } from '../utils/locale/set-locale-cookie.js';
+
+/**
+ * Executes a resolved navigation result.
+ *
+ * Applies all imperative side effects required to complete navigation,
+ * including locale synchronization, cookie persistence, and full reloads.
+ *
+ * This function must be called after `resolveNavigation`.
+ */
+function executeNavigation(navigationResult, context, e) {
+    const { config, currentLocale, setLocale } = context;
+    const { cookie } = config;
+    const { destination, kind, locale } = navigationResult;
+    // ------------------------------------------------------
+    // External navigation: let browser handle it
+    // ------------------------------------------------------
+    if (kind === "external") {
+        return;
+    }
+    // ------------------------------------------------------
+    // Full reload: commit locale side effects, then perform document reload
+    // ------------------------------------------------------
+    if (kind === "reload") {
+        if (shouldSyncLocale(locale, currentLocale)) {
+            if (cookie.persist) {
+                setLocaleCookie(cookie, locale);
+            }
+        }
+        globalThis.location.href = destination;
+        return;
+    }
+    // ------------------------------------------------------
+    // Client-side navigation only
+    // ------------------------------------------------------
+    if (shouldSyncLocale(locale, currentLocale)) {
+        // Eagerly persist locale to avoid stale cookie during client-side navigation.
+        if (cookie.persist) {
+            setLocaleCookie(cookie, locale);
+        }
+        setLocale(locale);
+    }
+}
+
+export { executeNavigation };

package/dist/svelte-kit/src/client/shared/utils/build-cookie-string.js

@@ -0,0 +1,30 @@
+/**
+ * Build a serialized cookie string.
+ */
+const buildCookieString = (cookieOptions, value) => {
+    const { name, maxAge, path, domain, sameSite, secure } = cookieOptions;
+    // Cookie name and encoded value
+    const parts = [`${name}=${encodeURIComponent(value)}`];
+    // Add expiration and max-age if provided
+    if (maxAge) {
+        const expires = new Date(Date.now() + maxAge * 1000).toUTCString();
+        parts.push(`expires=${expires}`, `max-age=${maxAge}`);
+    }
+    // Set path (default to "/")
+    parts.push(`path=${path ?? "/"}`);
+    // Add domain if specified
+    if (domain) {
+        parts.push(`domain=${domain}`);
+    }
+    // Add SameSite policy (e.g., Lax, Strict)
+    if (sameSite) {
+        parts.push(`SameSite=${sameSite[0].toUpperCase()}${sameSite.slice(1).toLowerCase()}`);
+    }
+    // Add Secure flag if not explicitly disabled
+    if (secure !== false) {
+        parts.push(`Secure`);
+    }
+    return parts.join("; ");
+};
+
+export { buildCookieString };

package/dist/svelte-kit/src/client/shared/utils/locale/set-locale-cookie.js

@@ -0,0 +1,15 @@
+import { buildCookieString } from '../build-cookie-string.js';
+
+/**
+ * Persist locale to a cookie.
+ *
+ * This function relies on `document.cookie`.
+ */
+const setLocaleCookie = (cookieOptions, locale) => {
+    if (typeof document === "undefined")
+        return;
+    // Build and apply the cookie string
+    document.cookie = buildCookieString(cookieOptions, locale);
+};
+
+export { setLocaleCookie };

package/dist/svelte-kit/src/core/constants/headers.js

@@ -0,0 +1,6 @@
+const INTOR_HEADERS = {
+    LOCALE: "x-intor-locale",
+    LOCALE_SOURCE: "x-intor-locale-source",
+    PATHNAME: "x-intor-pathname"};
+
+export { INTOR_HEADERS };

package/dist/svelte-kit/src/core/error/intor-error.js

@@ -0,0 +1,9 @@
+var IntorErrorCode;
+(function (IntorErrorCode) {
+    // config
+    IntorErrorCode["INVALID_CONFIG_ID"] = "INTOR_INVALID_CONFIG_ID";
+    IntorErrorCode["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
+    IntorErrorCode["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
+})(IntorErrorCode || (IntorErrorCode = {}));
+
+export { IntorErrorCode };

package/dist/svelte-kit/src/core/logger/get-logger.js

@@ -0,0 +1,39 @@
+import { logry } from 'logry';
+import { getGlobalLoggerPool } from './global-logger-pool.js';
+
+const DEFAULT_FORMAT_CONFIG = {
+    timestamp: { withDate: false },
+};
+const DEFAULT_RENDER_CONFIG = {
+    timestamp: {},
+    id: { visible: true, prefix: "<", suffix: ">" },
+    meta: { lineBreaksAfter: 1 },
+};
+/**
+ * Get a shared logger instance by id.
+ * - Safe across hot reloads
+ * - Prevents unbounded memory usage via soft LRU
+ */
+function getLogger({ id = "default", formatConfig, renderConfig, preset, ...options }) {
+    const pool = getGlobalLoggerPool();
+    let logger = pool.get(id);
+    if (!logger) {
+        logger = logry({
+            id,
+            formatConfig: !formatConfig && !preset ? DEFAULT_FORMAT_CONFIG : formatConfig,
+            renderConfig: !renderConfig && !preset ? DEFAULT_RENDER_CONFIG : renderConfig,
+            preset,
+            ...options,
+        });
+        pool.set(id, logger);
+        // Soft LRU: keep pool size under control
+        if (pool.size > 1000) {
+            const keys = [...pool.keys()];
+            for (const key of keys.slice(0, 200))
+                pool.delete(key);
+        }
+    }
+    return logger;
+}
+
+export { getLogger };

package/dist/svelte-kit/src/core/logger/global-logger-pool.js

@@ -0,0 +1,8 @@
+function getGlobalLoggerPool() {
+    if (!globalThis.__INTOR_LOGGER_POOL__) {
+        globalThis.__INTOR_LOGGER_POOL__ = new Map();
+    }
+    return globalThis.__INTOR_LOGGER_POOL__;
+}
+
+export { getGlobalLoggerPool };

package/dist/svelte-kit/src/core/messages/load-remote-messages/collect-remote-resources.js

@@ -0,0 +1,25 @@
+/**
+ * Collect remote message resources for a given locale.
+ *
+ * - Always includes the root `index.json`
+ * - Optionally includes namespace-specific resources
+ * - Produces semantic paths for later message nesting
+ *
+ * This function performs no I/O and does not validate resource existence.
+ */
+function collectRemoteResources({ locale, baseUrl, namespaces, }) {
+    const basePath = `${baseUrl}/${locale}`;
+    // Root translation resource (always loaded)
+    const indexResource = { url: `${basePath}/index.json`, path: [] };
+    // When no namespaces are provided, the locale domain consists of index only
+    if (!namespaces || namespaces.length === 0)
+        return [indexResource];
+    // Namespace-specific resources are nested under their namespace key
+    const nsResources = namespaces.map((ns) => ({
+        url: `${basePath}/${ns}.json`,
+        path: [ns],
+    }));
+    return [indexResource, ...nsResources];
+}
+
+export { collectRemoteResources };

package/dist/svelte-kit/src/core/messages/load-remote-messages/fetch-remote-resource.js

@@ -0,0 +1,47 @@
+import { getLogger } from '../../logger/get-logger.js';
+import { isValidMessages } from '../utils/is-valid-messages.js';
+
+/**
+ * Fetch a single remote messages resource.
+ *
+ * This function performs a single HTTP request to retrieve
+ * a remote translation messages payload.
+ *
+ * It is responsible for:
+ * - Issuing the network request
+ * - Validating the returned message structure
+ * - Handling abort and network errors
+ */
+async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions, }) {
+    const baseLogger = getLogger(loggerOptions);
+    const logger = baseLogger.child({ scope: "fetch-locale-messages" });
+    try {
+        // Fetch
+        const response = await fetch(url, {
+            method: "GET",
+            headers: { "Content-Type": "application/json", ...headers },
+            cache: "no-store",
+            signal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} ${response.statusText}`);
+        }
+        // Parse JSON body
+        const data = await response.json();
+        // Validate messages structure
+        if (!isValidMessages(data)) {
+            throw new Error("Invalid messages structure");
+        }
+        return data;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            logger.debug("Remote fetch aborted.", { url });
+            return;
+        }
+        logger.warn("Failed to fetch remote messages.", { url, error });
+        return;
+    }
+}
+
+export { fetchRemoteResource };