intor 2.3.9 → 2.3.11

package/README.md

@@ -15,9 +15,3 @@ Fast to start, easy to extend, and free from the usual i18n heaviness.
 [![License](https://img.shields.io/npm/l/intor?style=flat&colorA=000000&colorB=000000)](LICENSE)
 
 </div>
-
-<div align="center">
-
-#### 🍳 Cooking the Intor v2 docs, crafting them to perfection...
-
-</div>

package/dist/core/export/index.js

@@ -1,10 +1,12 @@
 export { PREFIX_PLACEHOLDER } from '../src/core/constants/prefix-placeholder.js';
 export { IntorError, IntorErrorCode } from '../src/core/error/intor-error.js';
 export { deepMerge } from '../src/core/utils/deep-merge.js';
+export { resolveLoaderOptions } from '../src/core/utils/resolve-loader-options.js';
 import 'logry';
 export { clearLoggerPool } from '../src/core/logger/global-logger-pool.js';
 export { isValidMessages } from '../src/core/messages/utils/is-valid-messages.js';
 export { clearMessagesPool, setGlobalMessagesPool } from '../src/core/messages/global-messages-pool.js';
+export { mergeMessages } from '../src/core/messages/merge-messages.js';
 export { defineIntorConfig } from '../src/config/define-intor-config.js';
 import '../src/config/constants/cookie.js';
 import '../src/config/constants/cache.js';

package/dist/core/export/server/index.js

@@ -1,8 +1,6 @@
 export { intor } from '../../src/server/intor/intor.js';
 export { loadMessages } from '../../src/server/messages/load-messages.js';
 import 'intor-translator';
-import '../../src/core/error/intor-error.js';
 import 'logry';
-import 'keyv';
 export { getTranslator } from '../../src/server/helpers/get-translator.js';
 export { loadMessagesFromUrl } from '../../src/server/helpers/local-messages-from-url.js';

package/dist/core/src/config/constants/routing.js

@@ -1,22 +1,18 @@
 // Default routing options
 const DEFAULT_ROUTING_OPTIONS = {
-    locale: {
-        sources: ["path", "query", "cookie", "detected"],
-        query: { key: "locale" },
-    },
-    navigation: {
-        carrier: "path",
-        path: { prefix: "none" },
-        query: { key: "locale" },
-        host: { map: {} },
+    basePath: "/",
+    localePrefix: "none",
+    inbound: {
+        localeSources: ["path", "query", "cookie", "detected"],
+        queryKey: "locale",
+        firstVisit: { localeSource: "browser", persist: true, redirect: true },
     },
-    firstVisit: {
-        localeSource: "browser",
-        redirect: true,
-        persist: true,
+    outbound: {
+        localeCarrier: "path",
+        queryKey: "locale",
+        host: { map: {}, default: undefined },
+        forceFullReload: false,
     },
-    basePath: "/",
-    forceFullReload: false,
 };
 
 export { DEFAULT_ROUTING_OPTIONS };

package/dist/core/src/config/define-intor-config.js

@@ -3,34 +3,34 @@ import { resolveCookieOptions } from './resolvers/resolve-cookie-options.js';
 import { resolveFallbackLocales } from './resolvers/resolve-fallback-locales.js';
 import { resolveRoutingOptions } from './resolvers/resolve-routing-options.js';
 import { validateDefaultLocale } from './validators/validate-default-locale.js';
+import { validateId } from './validators/validate-id.js';
 import { validateSupportedLocales } from './validators/validate-supported-locales.js';
 
 /**
- * Defines and resolves an Intor configuration.
+ * Defines the canonical Intor configuration.
  *
- * This is the canonical entry point for transforming a raw configuration
- * into a fully validated and resolved Intor config.
+ * Transforms a raw config into a validated and runtime-ready form by:
+ * - enforcing required invariants
+ * - resolving derived options
+ * - applying stable defaults
  *
- * Responsibilities:
- * - Validate required invariants
- * - Resolve and normalize derived options
- * - Apply stable defaults
- *
- * This function is purely declarative and side-effect free.
- * It does not create runtime instances or attach dynamic behavior.
- *
- * Intended to run once during application initialization.
+ * This function is declarative and side-effect free.
  */
 const defineIntorConfig = (config) => {
+    // -----------------------------------------------------------------------------
     // Validators
-    const supportedLocales = validateSupportedLocales(config);
-    const defaultLocale = validateDefaultLocale(config, supportedLocales);
+    // -----------------------------------------------------------------------------
+    const id = validateId(config.id ?? "default");
+    const supportedLocales = validateSupportedLocales(id, config.supportedLocales);
+    const supportedSet = new Set(supportedLocales);
+    const defaultLocale = validateDefaultLocale(id, config.defaultLocale, supportedSet);
+    // -----------------------------------------------------------------------------
     // Resolvers
-    const fallbackLocales = resolveFallbackLocales(config, supportedLocales);
+    // -----------------------------------------------------------------------------
+    const fallbackLocales = resolveFallbackLocales(config, id, supportedSet);
     const cookie = resolveCookieOptions(config.cookie);
     const routing = resolveRoutingOptions(config.routing);
     const cache = resolveCacheOptions(config.cache);
-    const id = config.id ?? "default";
     return {
         id,
         messages: config.messages,

package/dist/core/src/config/resolvers/resolve-fallback-locales.js

@@ -1,50 +1,60 @@
+import '../../core/error/intor-error.js';
+import { getLogger } from '../../core/logger/get-logger.js';
+import 'keyv';
+
 /**
- * Resolves and normalizes fallback locale mappings.
- *
- * This utility validates the user-defined `fallbackLocales` configuration
- * against the provided `supportedLocales` list and the configured `defaultLocale`.
- *
- * Resolution rules:
- * - Only locales listed in `supportedLocales` are considered valid fallbacks.
- * - The literal value `"default"` is always allowed and represents the configured default locale.
- * - Fallback entries matching `defaultLocale` are treated as valid.
- * - Invalid fallback locales are ignored and reported via warnings.
+ * Resolves fallbackLocales into a runtime-safe mapping.
  *
- * Notes:
- * - This function is purely defensive and does not throw on invalid input.
- * - Only validated fallback mappings are included in the returned result.
- * - Logging is used for diagnostics only and does not affect the output.
+ * Invalid entries are ignored and reported via warnings.
  */
-const resolveFallbackLocales = (config, supportedLocales) => {
+const resolveFallbackLocales = (config, id, supportedSet) => {
     const { defaultLocale, fallbackLocales } = config;
+    // Fast exit: no fallback configuration provided
     if (!fallbackLocales || typeof fallbackLocales !== "object") {
         return {};
     }
-    const supportedSet = new Set(supportedLocales);
-    const validMap = {}; // Collected valid fallbacks
-    const invalidFallbackMap = new Map(); // Track invalid ones
+    const logger = getLogger({ id }).child({
+        scope: "resolve-fallback-locales",
+    });
+    const resolvedMap = {};
+    const invalidMap = new Map();
+    // ---------------------------------------------------------------------------
+    // Normalize each fallback rule
+    // ---------------------------------------------------------------------------
     for (const [locale, fallbacks] of Object.entries(fallbackLocales)) {
-        const fallbackArray = Array.isArray(fallbacks) ? fallbacks : [];
-        // Valid: in supported list, matches default, or literal "default"
-        const validFallbacks = fallbackArray.filter((fallback) => fallback === "default" ||
-            supportedSet.has(fallback) ||
-            fallback === defaultLocale);
-        // Invalid: not "default", not supported, and not defaultLocale
-        const invalidFallbacks = fallbackArray.filter((fallback) => fallback !== "default" &&
-            !supportedSet.has(fallback) &&
-            fallback !== defaultLocale);
-        if (invalidFallbacks.length > 0) {
-            invalidFallbackMap.set(locale, invalidFallbacks);
+        // Guard: fallback rules for unreachable locales are ignored.
+        if (!supportedSet.has(locale) && locale !== defaultLocale) {
+            logger.warn(`Fallback locale "${locale}" is not listed in supportedLocales.`);
+            continue;
         }
-        if (validFallbacks.length > 0) {
-            validMap[locale] = validFallbacks;
+        const fallbackArray = Array.isArray(fallbacks) ? fallbacks : [];
+        const validFallbacks = [];
+        const invalidFallbacks = [];
+        for (const fallback of fallbackArray) {
+            // A fallback target is considered valid if:
+            // - It exists in `supportedLocales`
+            // - It is the literal value "default"
+            if (fallback === "default" || supportedSet.has(fallback)) {
+                validFallbacks.push(fallback);
+            }
+            else {
+                invalidFallbacks.push(fallback);
+            }
         }
+        if (invalidFallbacks.length > 0)
+            invalidMap.set(locale, invalidFallbacks);
+        if (validFallbacks.length > 0)
+            resolvedMap[locale] = validFallbacks;
     }
-    // Log out invalid fallback locales
-    for (const [locale, invalids] of invalidFallbackMap.entries()) {
-        console.warn(`Invalid fallback locales for "${locale}"`, { invalids: [...invalids] }, { scope: "resolveFallbackLocales" });
+    // ---------------------------------------------------------------------------
+    // Diagnostics: report ignored fallback entries
+    // ---------------------------------------------------------------------------
+    for (const [locale, invalids] of invalidMap.entries()) {
+        logger.warn(`Invalid fallback locales for "${locale}".`, {
+            invalids: invalids.join(", "),
+        });
     }
-    return validMap;
+    return resolvedMap;
 };
 
 export { resolveFallbackLocales };

package/dist/core/src/config/resolvers/resolve-routing-options.js

@@ -1,45 +1,65 @@
 import '../../core/error/intor-error.js';
-import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
+import { deepMerge } from '../../core/utils/deep-merge.js';
 import 'logry';
 import 'keyv';
 import { DEFAULT_ROUTING_OPTIONS } from '../constants/routing.js';
 import '../constants/cookie.js';
 import '../constants/cache.js';
 
-const resolveRoutingOptions = (routing = {}) => {
-    return {
-        ...DEFAULT_ROUTING_OPTIONS,
-        ...routing,
-        locale: {
-            ...DEFAULT_ROUTING_OPTIONS.locale,
-            ...routing.locale,
-            query: {
-                ...DEFAULT_ROUTING_OPTIONS.locale.query,
-                ...routing.locale?.query,
-            },
-        },
-        navigation: {
-            ...DEFAULT_ROUTING_OPTIONS.navigation,
-            ...routing.navigation,
-            path: {
-                ...DEFAULT_ROUTING_OPTIONS.navigation.path,
-                ...routing.navigation?.path,
-            },
-            query: {
-                ...DEFAULT_ROUTING_OPTIONS.navigation.query,
-                ...routing.navigation?.query,
-            },
-            host: {
-                ...DEFAULT_ROUTING_OPTIONS.navigation.host,
-                ...routing.navigation?.host,
-            },
-        },
-        firstVisit: {
-            ...DEFAULT_ROUTING_OPTIONS.firstVisit,
-            ...routing.firstVisit,
-        },
-        basePath: normalizePathname(routing?.basePath || ""),
-    };
-};
+/**
+ * Resolves routing configuration into a fully normalized form.
+ *
+ * - Flat shortcuts are projected into structured options.
+ * - Structured options override projected values.
+ * - Defaults are applied last.
+ */
+function resolveRoutingOptions(raw) {
+    if (!raw)
+        return DEFAULT_ROUTING_OPTIONS;
+    const projectedFromFlat = projectFlatToStructured(raw);
+    const structuredOverrides = stripFlatShortcuts(raw);
+    const defined = deepMerge(projectedFromFlat, structuredOverrides);
+    return deepMerge(DEFAULT_ROUTING_OPTIONS, defined);
+}
+/** Assigns a value to the target only if it is explicitly defined. */
+function assignIfDefined(target, key, value) {
+    if (value !== undefined)
+        target[key] = value;
+}
+/** Projects flat routing shortcuts into structured options. */
+function projectFlatToStructured(flat) {
+    const structured = {};
+    assignIfDefined(structured, "basePath", flat.basePath);
+    assignIfDefined(structured, "localePrefix", flat.localePrefix);
+    // inbound
+    const inbound = {};
+    assignIfDefined(inbound, "localeSources", flat.localeSources);
+    assignIfDefined(inbound, "queryKey", flat.queryKey);
+    assignIfDefined(inbound, "firstVisit", flat.firstVisit);
+    if (Object.keys(inbound).length > 0)
+        structured.inbound = inbound;
+    // outbound
+    const outbound = {};
+    assignIfDefined(outbound, "localeCarrier", flat.localeCarrier);
+    assignIfDefined(outbound, "queryKey", flat.queryKey);
+    assignIfDefined(outbound, "host", flat.host);
+    assignIfDefined(outbound, "forceFullReload", flat.forceFullReload);
+    if (Object.keys(outbound).length > 0)
+        structured.outbound = outbound;
+    return structured;
+}
+/** Removes flat shortcuts, preserving structured overrides only. */
+function stripFlatShortcuts(raw) {
+    const structured = {};
+    if ("basePath" in raw)
+        structured.basePath = raw.basePath;
+    if ("localePrefix" in raw)
+        structured.localePrefix = raw.localePrefix;
+    if ("inbound" in raw)
+        structured.inbound = raw.inbound;
+    if ("outbound" in raw)
+        structured.outbound = raw.outbound;
+    return structured;
+}
 
 export { resolveRoutingOptions };

package/dist/core/src/config/validators/validate-default-locale.js

@@ -3,30 +3,16 @@ import 'logry';
 import 'keyv';
 
 /**
- * Validates the configured default locale.
+ * Validates that the configured defaultLocale is supported.
  *
- * - Ensures that `defaultLocale` is explicitly defined.
- * - Ensures that `defaultLocale` is included in `supportedLocales`.
- *
- * This validation is part of the configuration initialization phase
- * and is expected to fail fast when misconfigured.
+ * Fails fast if `defaultLocale` is not included in `supportedLocales`.
  */
-const validateDefaultLocale = (config, supportedLocales) => {
-    const { id, defaultLocale } = config;
-    // Throw error if defaultLocale is undefined
-    if (!defaultLocale) {
-        throw new IntorError({
-            id,
-            code: IntorErrorCode.MISSING_DEFAULT_LOCALE,
-            message: `The defaultLocale is undefined`,
-        });
-    }
-    // Throw error if defaultLocale is not listed in supportedLocales
-    if (!supportedLocales.includes(defaultLocale)) {
+const validateDefaultLocale = (id, defaultLocale, supportedSet) => {
+    if (!supportedSet.has(defaultLocale)) {
         throw new IntorError({
             id,
             code: IntorErrorCode.UNSUPPORTED_DEFAULT_LOCALE,
-            message: `The defaultLocale "${defaultLocale}" is not included in the supportedLocales.`,
+            message: `"defaultLocale" must be included in "supportedLocales".`,
         });
     }
     return defaultLocale;

package/dist/core/src/config/validators/validate-id.js

@@ -0,0 +1,21 @@
+import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
+import 'logry';
+import 'keyv';
+
+/**
+ * Validates that the given id is a non-empty string.
+ *
+ * Fails fast if the id is empty or whitespace-only.
+ */
+const validateId = (id) => {
+    if (id.trim() === "") {
+        throw new IntorError({
+            id,
+            code: IntorErrorCode.INVALID_CONFIG_ID,
+            message: `"id" must be a non-empty string.`,
+        });
+    }
+    return id;
+};
+
+export { validateId };

package/dist/core/src/config/validators/validate-supported-locales.js

@@ -3,29 +3,19 @@ import 'logry';
 import 'keyv';
 
 /**
- * Validates and resolves the list of supported locales.
+ * Validates that supportedLocales is provided and non-empty.
  *
- * - Ensures `supportedLocales` is explicitly provided when a loader is used.
- * - Falls back to inferring locales from static message keys when no loader
- *   is configured.
- *
- * This validation runs during configuration initialization and is expected
- * to fail fast when required inputs are missing.
+ * Fails fast when missing.
  */
-const validateSupportedLocales = (config) => {
-    const { id, supportedLocales } = config;
-    const hasAnyLoader = !!config.loader || !!config.server?.loader || !!config.client?.loader;
-    // Ensure supportedLocales is set when using loader
-    if (hasAnyLoader && !supportedLocales) {
+const validateSupportedLocales = (id, supportedLocales) => {
+    if (!supportedLocales || supportedLocales.length === 0) {
         throw new IntorError({
             id,
             code: IntorErrorCode.MISSING_SUPPORTED_LOCALES,
-            message: `"supportedLocales" is required when using message loaders. 
-                 Please specify all supported locales explicitly.`,
+            message: `"supportedLocales" must be specified.`,
         });
     }
-    // Return supportedLocales or infer from message keys
-    return supportedLocales || Object.keys(config.messages || {});
+    return supportedLocales;
 };
 
 export { validateSupportedLocales };

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

@@ -13,8 +13,8 @@ class IntorError extends Error {
 var IntorErrorCode;
 (function (IntorErrorCode) {
     // config
+    IntorErrorCode["INVALID_CONFIG_ID"] = "INTOR_INVALID_CONFIG_ID";
     IntorErrorCode["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
-    IntorErrorCode["MISSING_DEFAULT_LOCALE"] = "INTOR_MISSING_DEFAULT_LOCALE";
     IntorErrorCode["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
     // runtime
     IntorErrorCode["RUNTIME_NOT_INITIALIZED"] = "INTOR_RUNTIME_NOT_INITIALIZED";

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

@@ -5,16 +5,16 @@ import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messag
 /**
  * Load locale messages from a remote API.
  *
- * This function acts as the orchestration layer for remote message loading.
- * It is responsible for:
+ * This function serves as the orchestration layer for remote message loading.
+ * It coordinates:
  *
- * - Resolving fallback locales in order
- * - Coordinating cache read / write behavior
+ * - Locale resolution with fallbacks
+ * - Cache read / write behavior
  * - Respecting abort signals across the entire async flow
  *
  * Network fetching and data validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
+const loadRemoteMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir, url, headers, signal, pool, cacheOptions, allowCacheWrite = false, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-remote-messages" });
     // Abort early if the request has already been cancelled
@@ -24,16 +24,20 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
     }
     const start = performance.now();
     logger.debug("Loading remote messages.", { url });
-    // --- Cache key ---
+    // ---------------------------------------------------------------------------
+    // Cache key resolution
+    // ---------------------------------------------------------------------------
     const cacheKey = normalizeCacheKey([
-        loggerOptions.id,
+        id,
         "loaderType:remote",
         rootDir,
         locale,
-        (fallbackLocales ?? []).toSorted().join(","),
-        (namespaces ?? []).toSorted().join(","),
+        (fallbackLocales || []).toSorted().join(","),
+        (namespaces || []).toSorted().join(","),
     ]);
-    // --- Cache read ---
+    // ---------------------------------------------------------------------------
+    // Cache read
+    // ---------------------------------------------------------------------------
     if (cacheOptions.enabled && cacheKey) {
         const cached = await pool?.get(cacheKey);
         if (signal?.aborted) {
@@ -45,9 +49,11 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
             return cached;
         }
     }
+    // ---------------------------------------------------------------------------
+    // Resolve locale messages with ordered fallback strategy
+    // ---------------------------------------------------------------------------
     const candidateLocales = [locale, ...(fallbackLocales || [])];
     let messages;
-    // Try each candidate locale in order and stop at the first successful result
     for (let i = 0; i < candidateLocales.length; i++) {
         const candidateLocale = candidateLocales[i];
         const isLast = i === candidateLocales.length - 1;
@@ -87,13 +93,17 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
             });
         }
     }
-    // --- Cache write ---
-    if (cacheOptions.enabled && allowCacheWrite && cacheKey && messages) {
+    // ---------------------------------------------------------------------------
+    // Cache write (explicitly permitted)
+    // ---------------------------------------------------------------------------
+    if (cacheOptions.enabled && allowCacheWrite) {
         if (signal?.aborted) {
             logger.debug("Remote message loading aborted before cache write.");
             return;
         }
-        await pool?.set(cacheKey, messages, cacheOptions.ttl);
+        if (cacheKey && messages) {
+            await pool?.set(cacheKey, messages, cacheOptions.ttl);
+        }
     }
     // Final success log with resolved locale and timing
     if (messages) {

package/dist/core/src/core/messages/merge-messages.js

@@ -0,0 +1,33 @@
+import { getLogger } from '../logger/get-logger.js';
+import { deepMerge } from '../utils/deep-merge.js';
+
+/**
+ * Merge locale-specific messages with runtime overrides.
+ *
+ * - Only merges messages under the given locale
+ * - Emits debug logs for add / override events
+ */
+function mergeMessages(a, b, { config, locale, onEvent }) {
+    const baseLogger = getLogger({ ...config.logger, id: config.id });
+    const logger = baseLogger.child({ scope: "merge-messages" });
+    // Merge messages for the active locale only
+    const merged = deepMerge(a?.[locale] ?? {}, b?.[locale] ?? {}, {
+        onOverride: (event) => {
+            if (onEvent) {
+                onEvent(event);
+                return;
+            }
+            const { kind, path, next, prev } = event;
+            if (kind === "add")
+                return;
+            logger.debug(`Override | ${locale}: "${path}"`, { prev, next });
+        },
+    });
+    // Preserve other locales, update only the target one
+    return {
+        ...a,
+        [locale]: merged,
+    };
+}
+
+export { mergeMessages };

package/dist/core/src/core/utils/deep-merge.js

@@ -1,28 +1,44 @@
 /**
- * Deeply merges two objects.
+ * Deeply merges two plain objects.
  *
- * - Nested objects → merged recursively
- * - Array / primitive → b overwrites a
+ * - Nested plain objects → merged recursively
+ * - Arrays / primitives → `b` overwrites `a`
  *
- * This function always returns a plain object.
+ * Debug behavior (optional):
+ * - Emits override events via `onOverride`
+ * - Zero overhead when no options are provided
+ *
+ * This function always returns a new plain object.
  */
-const deepMerge = (a = {}, b = {}) => {
+const deepMerge = (a = {}, b = {}, options) => {
     const result = { ...a };
+    const basePath = options?._path ?? [];
+    // Iterate only over b's own enumerable properties
     for (const key in b) {
-        if (Object.prototype.hasOwnProperty.call(b, key)) {
-            const av = a[key];
-            const bv = b[key];
-            if (av &&
-                bv &&
-                typeof av === "object" &&
-                typeof bv === "object" &&
-                !Array.isArray(av) &&
-                !Array.isArray(bv)) {
-                result[key] = deepMerge(av, bv);
-            }
-            else {
-                result[key] = bv;
-            }
+        if (!Object.prototype.hasOwnProperty.call(b, key))
+            continue;
+        const aValue = a[key];
+        const bValue = b[key];
+        const nextPath = [...basePath, key];
+        // Recursively merge when both sides are plain objects
+        if (aValue &&
+            bValue &&
+            typeof aValue === "object" &&
+            typeof bValue === "object" &&
+            !Array.isArray(aValue) &&
+            !Array.isArray(bValue)) {
+            result[key] = deepMerge(aValue, bValue, options ? { ...options, _path: nextPath } : undefined);
+        }
+        else {
+            // Emit override event only when debugging is enabled
+            const isAdd = aValue === undefined;
+            options?.onOverride?.({
+                path: nextPath.join("."),
+                prev: aValue,
+                next: bValue,
+                kind: isAdd ? "add" : "override",
+            });
+            result[key] = bValue;
         }
     }
     return result;

package/dist/core/src/core/utils/resolve-loader-options.js

@@ -18,6 +18,15 @@
  *   for the given runtime.
  */
 const resolveLoaderOptions = (config, runtime) => {
+    // --- runtime: client ---
+    if (runtime === "client") {
+        const client = config.client?.loader;
+        if (client) {
+            // Client loader is always remote by design
+            return { type: "remote", ...client };
+        }
+        return config.server?.loader ?? config.loader;
+    }
     // --- runtime: server ---
     return config.server?.loader ?? config.loader;
 };