intor 2.3.26 → 2.3.28

package/dist/core/export/index.js

@@ -4,8 +4,8 @@ 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';
+import 'p-limit';
 export { isValidMessages } from '../src/core/messages/utils/is-valid-messages.js';
-export { clearMessagesPool } from '../src/core/messages/global-messages-pool.js';
 export { mergeMessages } from '../src/core/messages/merge-messages.js';
 export { INTOR_MESSAGES_KIND, INTOR_MESSAGES_KIND_KEY, INTOR_PREFIX, getMessagesKind } from '../src/core/messages/internal-metadata.js';
 export { defineIntorConfig } from '../src/config/define-intor-config.js';

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

@@ -1,6 +1,10 @@
 export { intor } from '../../src/server/intor/intor.js';
 export { loadMessages } from '../../src/server/messages/load-messages.js';
-import 'intor-translator';
+import 'node:path';
+import 'p-limit';
+import '../../src/core/error/intor-error.js';
 import 'logry';
+export { clearMessagesPool } from '../../src/server/messages/load-local-messages/cache/messages-pool.js';
+import 'node:fs/promises';
+import 'intor-translator';
 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/cookie.js

@@ -1,6 +1,5 @@
 // Default cookie options
 const DEFAULT_COOKIE_OPTIONS = {
-    enabled: true,
     persist: true,
     name: "intor.locale",
     domain: undefined,

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

@@ -1,5 +1,6 @@
 import '../../core/error/intor-error.js';
 import { getLogger } from '../../core/logger/get-logger.js';
+import 'p-limit';
 
 /**
  * Resolves fallbackLocales into a runtime-safe mapping.

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

@@ -1,6 +1,7 @@
 import '../../core/error/intor-error.js';
 import { deepMerge } from '../../core/utils/deep-merge.js';
 import 'logry';
+import 'p-limit';
 import { DEFAULT_ROUTING_OPTIONS } from '../constants/routing.js';
 import '../constants/cookie.js';
 

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

@@ -1,5 +1,6 @@
 import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
 import 'logry';
+import 'p-limit';
 
 /**
  * Validates that the configured defaultLocale is supported.

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

@@ -1,5 +1,6 @@
 import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
 import 'logry';
+import 'p-limit';
 
 /**
  * Validates that the given id is a non-empty string.

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

@@ -1,5 +1,6 @@
 import { IntorError, IntorErrorCode } from '../../core/error/intor-error.js';
 import 'logry';
+import 'p-limit';
 
 /**
  * Validates that supportedLocales is provided and non-empty.

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

@@ -16,8 +16,6 @@ var IntorErrorCode;
     IntorErrorCode["INVALID_CONFIG_ID"] = "INTOR_INVALID_CONFIG_ID";
     IntorErrorCode["MISSING_SUPPORTED_LOCALES"] = "INTOR_MISSING_SUPPORTED_LOCALES";
     IntorErrorCode["UNSUPPORTED_DEFAULT_LOCALE"] = "INTOR_UNSUPPORTED_DEFAULT_LOCALE";
-    // runtime
-    IntorErrorCode["RUNTIME_NOT_INITIALIZED"] = "INTOR_RUNTIME_NOT_INITIALIZED";
 })(IntorErrorCode || (IntorErrorCode = {}));
 
 export { IntorError, IntorErrorCode };

package/dist/core/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/core/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({ 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 };

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

@@ -1,18 +1,24 @@
+import pLimit from 'p-limit';
 import { getLogger } from '../../logger/get-logger.js';
-import { fetchLocaleMessages } from './fetch-locale-messages/fetch-locale-messages.js';
+import { collectRemoteResources } from './collect-remote-resources.js';
+import { fetchRemoteResource } from './fetch-remote-resource.js';
+import { resolveRemoteResources } from './resolve-remote-resources.js';
 
 /**
- * Load locale messages from a remote API.
+ * Load locale messages from a remote source.
  *
  * This function serves as the orchestration layer for remote message loading.
  * It coordinates:
  *
  * - Locale resolution with fallbacks
- * - Respecting abort signals across the entire async flow
+ * - Concurrency control for network requests
+ * - Remote resource fetching and message merging
  *
- * Network fetching and data validation are delegated to lower-level utilities.
+ * Remote messages are fetched on demand and are not memoized at the process level.
+ *
+ * Network requests and response validation are delegated to lower-level utilities.
  */
-const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir, url, headers, signal, loggerOptions, }) => {
+const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurrency, 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
@@ -21,33 +27,45 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
         return;
     }
     const start = performance.now();
-    logger.debug("Loading remote messages.", { url });
-    // ---------------------------------------------------------------------------
+    logger.debug("Loading remote messages.", { baseUrl });
+    // ----------------------------------------------------------------
     // Resolve locale messages with ordered fallback strategy
-    // ---------------------------------------------------------------------------
+    // ----------------------------------------------------------------
+    const limit = concurrency ? pLimit(concurrency) : undefined;
     const candidateLocales = [locale, ...(fallbackLocales || [])];
     let messages;
     for (let i = 0; i < candidateLocales.length; i++) {
         const candidateLocale = candidateLocales[i];
         const isLast = i === candidateLocales.length - 1;
         try {
-            const fetched = await fetchLocaleMessages({
+            // -----------------------------------------------------------------
+            // Collect remote message resources for the locale
+            // -----------------------------------------------------------------
+            const resources = collectRemoteResources({
                 locale: candidateLocale,
+                baseUrl,
                 namespaces,
-                rootDir,
-                url,
-                headers,
-                signal,
-                extraOptions: { loggerOptions },
             });
-            // Stop at the first locale that yields non-empty messages
-            if (fetched && Object.values(fetched[candidateLocale] || {}).length > 0) {
-                messages = fetched;
-                break;
-            }
+            // -----------------------------------------------------------------
+            // Fetch all message chunks in parallel
+            // -----------------------------------------------------------------
+            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions });
+            const results = await Promise.all(resources.map(({ url }) => limit ? limit(() => fetchUrl(url)) : fetchUrl(url)));
+            // Guard: no valid remote resources
+            if (!results.some(Boolean))
+                continue;
+            // -----------------------------------------------------------------
+            // Resolve and merge remote message resources
+            // -----------------------------------------------------------------
+            const resolved = resolveRemoteResources(resources.map((res, i) => ({ path: res.path, data: results[i] })));
+            // -----------------------------------------------------------------
+            // Wrap resolved messages into locale-scoped LocaleMessages
+            // -----------------------------------------------------------------
+            messages = { [candidateLocale]: resolved };
+            break;
         }
-        catch (error) {
-            if (error instanceof Error && error.name === "AbortError") {
+        catch {
+            if (signal?.aborted) {
                 logger.debug("Remote message loading aborted.");
                 return;
             }
@@ -58,18 +76,14 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, rootDir
                 });
             }
             else {
-                logger.warn(`Failed to fetch locale messages for "${candidateLocale}", trying next fallback.`);
+                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
             }
-            logger.trace("Remote fetch error detail.", {
-                locale: candidateLocale,
-                error,
-            });
         }
     }
     // Final success log with resolved locale and timing
     if (messages) {
         logger.trace("Finished loading remote messages.", {
-            loadedLocale: messages ? Object.keys(messages)[0] : undefined,
+            loadedLocale: Object.keys(messages)[0],
             duration: `${Math.round(performance.now() - start)} ms`,
         });
     }

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

@@ -0,0 +1,24 @@
+import { deepMerge } from '../../utils/deep-merge.js';
+import { nestObjectFromPath } from '../utils/nest-object-from-path.js';
+
+/**
+ * Resolve remote message resources into a single MessageObject.
+ *
+ * - Applies semantic nesting based on resource path
+ * - Merges all resolved message chunks
+ *
+ * Always returns a MessageObject.
+ * An empty object represents an empty translation domain.
+ */
+function resolveRemoteResources(resources) {
+    let result = {};
+    for (const { path, data } of resources) {
+        if (!data)
+            continue;
+        const resolved = path.length > 0 ? nestObjectFromPath(path, data) : data;
+        result = deepMerge(result, resolved);
+    }
+    return result;
+}
+
+export { resolveRemoteResources };

package/dist/core/src/routing/pathname/canonicalize-pathname.js

@@ -1,6 +1,7 @@
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
+import 'p-limit';
 
 /**
  * Returns a canonical, locale-agnostic pathname.

package/dist/core/src/routing/pathname/materialize-pathname.js

@@ -2,6 +2,7 @@ import { PREFIX_PLACEHOLDER } from '../../core/constants/prefix-placeholder.js';
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
+import 'p-limit';
 
 /**
  * Materializes a standardized pathname by applying

package/dist/core/src/routing/pathname/standardize-pathname.js

@@ -2,6 +2,7 @@ import { PREFIX_PLACEHOLDER } from '../../core/constants/prefix-placeholder.js';
 import '../../core/error/intor-error.js';
 import { normalizePathname } from '../../core/utils/normalizers/normalize-pathname.js';
 import 'logry';
+import 'p-limit';
 
 /**
  * Standardizes a canonical pathname into an internal routing template

package/dist/core/src/server/helpers/get-translator.js

@@ -1,24 +1,20 @@
-import { createIntorRuntime } from '../runtime/create-intor-runtime.js';
+import { initTranslator } from '../translator/init-translator.js';
 
 // Implementation
 async function getTranslator(config, params) {
     const { readers, allowCacheWrite, preKey, handlers, plugins } = params;
     const locale = params.locale;
-    // Create runtime (request-scoped, no cache write)
-    const runtime = createIntorRuntime(config, {
+    // Initialize a locale-bound translator snapshot with messages loaded
+    const translator = await initTranslator(config, locale, {
         readers,
         allowCacheWrite,
-    });
-    // Ensure messages & create translator snapshot
-    await runtime.ensureMessages(locale);
-    const translator = runtime.translator(locale, {
         preKey,
         plugins,
         handlers,
     });
     return {
         messages: translator.messages,
-        locale,
+        locale: translator.locale,
         hasKey: translator.hasKey,
         t: translator.t,
     };

package/dist/core/src/server/intor/intor.js

@@ -1,6 +1,7 @@
 import '../../core/error/intor-error.js';
 import { getLogger } from '../../core/logger/get-logger.js';
-import { createIntorRuntime } from '../runtime/create-intor-runtime.js';
+import 'p-limit';
+import { initTranslator } from '../translator/init-translator.js';
 
 /**
  * Initializes Intor for the current execution context.
@@ -12,8 +13,6 @@ async function intor(config, localeOrResolver, options) {
     const baseLogger = getLogger(config.logger);
     const logger = baseLogger.child({ scope: "intor" });
     logger.info("Start Intor initialization.");
-    // Create runtime (request-scoped)
-    const runtime = createIntorRuntime(config, options);
     // Resolve locale
     const isLocaleFunction = typeof localeOrResolver === "function";
     const locale = isLocaleFunction
@@ -21,13 +20,15 @@ async function intor(config, localeOrResolver, options) {
         : localeOrResolver || config.defaultLocale;
     const source = typeof localeOrResolver === "function" ? "resolver" : "static";
     logger.debug(`Initial locale resolved as "${locale}" via "${source}".`);
-    // Ensure messages & create translator snapshot
-    await runtime.ensureMessages(locale);
-    const translator = runtime.translator(locale);
+    // Initialize a locale-bound translator snapshot with messages loaded
+    const translator = await initTranslator(config, locale, {
+        readers: options?.readers,
+        allowCacheWrite: options?.allowCacheWrite,
+    });
     logger.info("Intor initialized.");
     return {
         config,
-        locale,
+        locale: translator.locale,
         messages: translator.messages,
     };
 }

package/dist/core/src/server/messages/load-local-messages/cache/messages-pool.js

@@ -0,0 +1,17 @@
+/**
+ * Get the messages pool.
+ */
+function getMessagesPool() {
+    if (!globalThis.__INTOR_MESSAGES_POOL__) {
+        globalThis.__INTOR_MESSAGES_POOL__ = new Map();
+    }
+    return globalThis.__INTOR_MESSAGES_POOL__;
+}
+/**
+ * Clear all cached messages.
+ */
+function clearMessagesPool() {
+    getMessagesPool().clear();
+}
+
+export { clearMessagesPool, getMessagesPool };

package/dist/core/src/server/messages/load-local-messages/load-local-messages.js

@@ -3,7 +3,7 @@ import pLimit from 'p-limit';
 import '../../../core/error/intor-error.js';
 import { normalizeCacheKey } from '../../../core/utils/normalizers/normalize-cache-key.js';
 import { getLogger } from '../../../core/logger/get-logger.js';
-import { getGlobalMessagesPool } from '../../../core/messages/global-messages-pool.js';
+import { getMessagesPool } from './cache/messages-pool.js';
 import { readLocaleMessages } from './read-locale-messages/read-locale-messages.js';
 
 /**
@@ -21,7 +21,7 @@ import { readLocaleMessages } from './read-locale-messages/read-locale-messages.
  *
  * File traversal, parsing, and validation are delegated to lower-level utilities.
  */
-const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readers, pool = getGlobalMessagesPool(), allowCacheWrite = false, loggerOptions, }) => {
+const loadLocalMessages = async ({ id, locale, fallbackLocales, namespaces, rootDir = "messages", concurrency = 10, readers, pool = getMessagesPool(), allowCacheWrite = false, loggerOptions, }) => {
     const baseLogger = getLogger(loggerOptions);
     const logger = baseLogger.child({ scope: "load-local-messages" });
     const start = performance.now();

package/dist/core/src/server/messages/load-local-messages/read-locale-messages/collect-file-entries/collect-file-entries.js

@@ -2,6 +2,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import '../../../../../core/error/intor-error.js';
 import { getLogger } from '../../../../../core/logger/get-logger.js';
+import 'p-limit';
 
 /**
  * Recursively collects message file metadata under a given locale root.

package/dist/core/src/server/messages/load-local-messages/read-locale-messages/parse-file-entries/parse-file-entries.js

@@ -2,9 +2,10 @@ import path from 'node:path';
 import '../../../../../core/error/intor-error.js';
 import { deepMerge } from '../../../../../core/utils/deep-merge.js';
 import { getLogger } from '../../../../../core/logger/get-logger.js';
+import 'p-limit';
 import { isValidMessages } from '../../../../../core/messages/utils/is-valid-messages.js';
+import { nestObjectFromPath } from '../../../../../core/messages/utils/nest-object-from-path.js';
 import { jsonReader } from './utils/json-reader.js';
-import { nestObjectFromPath } from './utils/nest-object-from-path.js';
 
 /**
  * Parse locale message files into a unified Messages object (single-locale).
@@ -40,7 +41,7 @@ async function parseFileEntries({ fileEntries, limit, readers, loggerOptions, })
     const logger = baseLogger.child({ scope: "parse-file-entries" });
     // Read and parse all file entries
     const parsedFileEntries = [];
-    const tasks = fileEntries.map(({ namespace, segments, basename, fullPath, relativePath }) => limit(async () => {
+    const tasks = fileEntries.map(({ namespace, segments, basename, fullPath }) => limit(async () => {
         try {
             // -------------------------------------------------------------------
             // Read and validate file content
@@ -73,10 +74,9 @@ async function parseFileEntries({ fileEntries, limit, readers, loggerOptions, })
             // Nest the parsed content based on the path segments
             const nestedMessages = nestObjectFromPath(keyPath, raw);
             parsedFileEntries.push({ namespace, messages: nestedMessages });
-            logger.trace(`Parsed message file: ${relativePath}`);
         }
         catch (error) {
-            logger.error("Failed to read or parse file.", {
+            logger.warn("Failed to read or parse file.", {
                 path: fullPath,
                 error,
             });

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

@@ -28,12 +28,12 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
         logger.warn("No loader options have been configured in the current config.");
         return;
     }
-    const { type, namespaces, rootDir } = loader;
+    const { type, namespaces, concurrency } = loader;
     const fallbackLocales = config.fallbackLocales[locale] || [];
     logger.info(`Loading messages for locale "${locale}".`);
     logger.trace("Starting to load messages with runtime context.", {
         loaderType: type,
-        rootDir,
+        ...(type === "local" ? { rootDir: loader.rootDir } : {}),
         locale,
         fallbackLocales: fallbackLocales.join(", "),
         namespaces: namespaces && namespaces.length > 0 ? [...namespaces] : "*",
@@ -48,8 +48,8 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
             locale,
             fallbackLocales,
             namespaces,
-            rootDir,
-            concurrency: loader.concurrency,
+            rootDir: loader.rootDir,
+            concurrency,
             readers,
             allowCacheWrite,
             loggerOptions: config.logger,
@@ -60,7 +60,7 @@ const loadMessages = async ({ config, locale, readers, allowCacheWrite = false,
             locale,
             fallbackLocales,
             namespaces,
-            rootDir,
+            concurrency,
             url: loader.url,
             headers: loader.headers,
             loggerOptions: config.logger,

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

@@ -0,0 +1,36 @@
+import '../../core/error/intor-error.js';
+import { resolveLoaderOptions } from '../../core/utils/resolve-loader-options.js';
+import 'logry';
+import 'p-limit';
+import { loadMessages } from '../messages/load-messages.js';
+import 'node:path';
+import 'node:fs/promises';
+import { createTranslator } from './create-translator.js';
+
+/**
+ * Initializes a server-side translator for a specific locale.
+ *
+ * - Performs message loading during initialization.
+ * - Returns an immutable translator snapshot.
+ */
+async function initTranslator(config, locale, options) {
+    const { readers, allowCacheWrite = false, preKey, handlers, plugins, } = options || {};
+    const loader = resolveLoaderOptions(config, "server");
+    // Load messages
+    let messages = {};
+    if (loader) {
+        messages =
+            (await loadMessages({ config, locale, readers, allowCacheWrite })) || {};
+    }
+    // Create immutable translator snapshot
+    return createTranslator({
+        config,
+        locale,
+        messages,
+        preKey,
+        handlers,
+        plugins,
+    });
+}
+
+export { initTranslator };

package/dist/express/export/express/index.js

@@ -1,2 +1,2 @@
-export { createIntor } from '../../src/adapters/express/middleware/create-intor.js';
+export { createIntorMiddleware } from '../../src/adapters/express/middleware/create-intor-middleware.js';
 export { getTranslator } from '../../src/adapters/express/helpers/get-translator.js';

package/dist/express/src/adapters/express/helpers/get-translator.js

@@ -1,7 +1,7 @@
 import '../../../core/error/intor-error.js';
 import 'logry';
-import 'node:path';
 import 'p-limit';
+import 'node:path';
 import 'node:fs/promises';
 import 'intor-translator';
 import { getTranslator as getTranslator$1 } from '../../../server/helpers/get-translator.js';

package/dist/express/src/adapters/express/middleware/{create-intor.js → create-intor-middleware.js}

@@ -2,13 +2,14 @@ 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';
 import 'node:path';
-import 'p-limit';
 import 'node:fs/promises';
 import 'intor-translator';
 import { getTranslator } from '../../../server/helpers/get-translator.js';
+import { parseCookieHeader } from '../../../server/shared/utils/parse-cookie-header.js';
 
 /**
  * Resolves locale-aware routing for the current execution context.
@@ -20,7 +21,7 @@ import { getTranslator } from '../../../server/helpers/get-translator.js';
  *
  * @platform Express
  */
-function createIntor(config, options) {
+function createIntorMiddleware(config, options) {
     return async function intorMiddleware(req, _res, next) {
         // locale from accept-language header
         const acceptLanguage = req.headers["accept-language"];
@@ -31,7 +32,7 @@ function createIntor(config, options) {
         const { locale, localeSource, pathname } = await resolveInbound(config, req.path, false, {
             host: req.hostname,
             query: normalizeQuery(req.query),
-            cookie: req.cookies?.[config.cookie.name],
+            cookie: parseCookieHeader(req.headers.cookie)[config.cookie.name],
             detected: localeFromAcceptLanguage || config.defaultLocale,
         });
         // --------------------------------------------------
@@ -59,4 +60,4 @@ function createIntor(config, options) {
     };
 }
 
-export { createIntor };
+export { createIntorMiddleware };

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

@@ -1,23 +1,9 @@
-class IntorError extends Error {
-    code;
-    id;
-    constructor({ message, code, id }) {
-        const fullMessage = id ? `[${id}] ${message}` : message;
-        super(fullMessage);
-        this.name = "IntorError";
-        this.id = id;
-        this.code = code;
-        Object.setPrototypeOf(this, new.target.prototype); // Fix prototype
-    }
-}
 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";
-    // runtime
-    IntorErrorCode["RUNTIME_NOT_INITIALIZED"] = "INTOR_RUNTIME_NOT_INITIALIZED";
 })(IntorErrorCode || (IntorErrorCode = {}));
 
-export { IntorError, IntorErrorCode };
+export { IntorErrorCode };