intor 2.4.17 → 2.5.0

package/dist/vue/src/client/vue/provider/effects/use-locale-effects.js

@@ -1,6 +1,5 @@
 import { watch } from 'vue';
 import { shouldPersistOnFirstVisit } from '../../../../policies/should-persist-on-first-visit.js';
-import '../../../../core/error/intor-error.js';
 import 'logry';
 import 'p-limit';
 import 'intor-translator';

package/dist/vue/src/client/vue/provider/effects/use-messages-effects.js

@@ -23,13 +23,8 @@ function useMessagesEffects(config, locale, runtimeMessages, internalIsLoading)
         },
     });
     // Refetch messages when locale changes (except initial render).
-    let isInitial = true;
     watch(locale, (newLocale) => {
-        if (isInitial) {
-            isInitial = false;
-            return;
-        }
-        refetchMessages(newLocale);
+        void refetchMessages(newLocale);
     });
 }
 

package/dist/vue/src/client/vue/provider/{inject.js → inject-intor-context.js}

@@ -1,11 +1,11 @@
 import { inject } from 'vue';
 import { IntorContextKey } from './intor-provider.js';
 
-function injectIntor() {
+function injectIntorContext() {
     const context = inject(IntorContextKey);
     if (!context)
-        throw new Error("injectIntor must be used within IntorProvider");
+        throw new Error("injectIntorContext must be used within IntorProvider");
     return context;
 }
 
-export { injectIntor };
+export { injectIntorContext };

package/dist/vue/src/client/vue/provider/intor-provider.js

@@ -1,9 +1,15 @@
 import { Translator } from 'intor-translator';
 import { defineComponent, ref, computed, watch, provide } from 'vue';
+import { resolveEffectiveIsLoading, resolveEffectiveMessages } from '../../shared/provider/effective-state.js';
 import { useLocaleEffects } from './effects/use-locale-effects.js';
 import { useMessagesEffects } from './effects/use-messages-effects.js';
 
 const IntorContextKey = Symbol("IntorContext");
+/**
+ * Vue provider for Intor.
+ *
+ * @public
+ */
 const IntorProvider = defineComponent({
     name: "IntorProvider",
     props: { value: { type: Object, required: true } },
@@ -18,35 +24,32 @@ const IntorProvider = defineComponent({
         // Locale transition
         // ---------------------------------------------------------------------------
         /** Request a locale change. */
-        const setLocale = async (newLocale) => {
+        const setLocale = (newLocale) => {
             if (newLocale === locale.value)
                 return;
             locale.value = newLocale;
-            props.value.onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
+            void props.value.onLocaleChange?.(newLocale); // Notify external listener (fire-and-forget)
         };
         // ---------------------------------------------------------------------------
         // Effective state
         // ---------------------------------------------------------------------------
-        // external > internal
-        const effectiveIsLoading = computed(() => !!props.value.isLoading?.value || internalIsLoading.value);
-        // runtime (client refetch) > initial > config (static)
-        const effectiveMessages = computed(() => runtimeMessages.value ||
-            props.value.messages?.value ||
-            props.value.config.messages ||
-            {});
+        const effectiveIsLoading = computed(() => resolveEffectiveIsLoading(!!props.value.isLoading?.value, internalIsLoading.value));
+        const effectiveMessages = computed(() => resolveEffectiveMessages(runtimeMessages.value, props.value.messages?.value, props.value.config.messages));
         // ---------------------------------------------------------------------------
         // Translator
         // ---------------------------------------------------------------------------
+        const { loadingMessage, missingMessage } = props.value.config.translator ?? {};
+        const { handlers, hooks } = props.value;
         const translator = computed(() => {
             return new Translator({
                 messages: effectiveMessages.value,
                 locale: locale.value,
                 isLoading: effectiveIsLoading.value,
                 fallbackLocales: props.value.config.fallbackLocales,
-                loadingMessage: props.value.config.translator?.loadingMessage,
-                missingMessage: props.value.config.translator?.missingMessage,
-                handlers: props.value.handlers,
-                plugins: props.value.plugins,
+                ...(loadingMessage !== undefined ? { loadingMessage } : {}),
+                ...(missingMessage !== undefined ? { missingMessage } : {}),
+                ...(handlers !== undefined ? { handlers } : {}),
+                ...(hooks !== undefined ? { hooks } : {}),
             });
         });
         // -------------------------------------------------------------------------
@@ -66,7 +69,7 @@ const IntorProvider = defineComponent({
             translator,
         }));
         provide(IntorContextKey, contextValue);
-        return () => slots.default?.();
+        return () => slots["default"]?.();
     },
 });
 

package/dist/vue/src/client/vue/translator/trans.js

@@ -2,9 +2,11 @@ import { defineComponent, h, Fragment } from 'vue';
 import { useTranslator } from './use-translator.js';
 
 /**
- * `<Trans />` is a lightweight Vue component for rendering rich translations.
+ * Vue component for rendering rich translations.
  *
- * It is a thin adapter around `translator.tRich` and introduces no additional logic.
+ * A thin wrapper around `tRich`.
+ *
+ * @public
  */
 const Trans = defineComponent({
     name: "Trans",

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

@@ -1,15 +1,15 @@
 import { computed } from 'vue';
 import '../provider/intor-provider.js';
-import { injectIntor } from '../provider/inject.js';
+import { injectIntorContext } from '../provider/inject-intor-context.js';
 import { createTRich } from './create-t-rich.js';
 
 /**
  * Vue composable for accessing the active, scope-aware translator instance.
  *
- * @platform Vue
+ * @public
  */
 function useTranslator(preKey) {
-    const intor = injectIntor();
+    const intor = injectIntorContext();
     const translator = intor.value.translator;
     const scoped = computed(() => translator.value.scoped(preKey));
     return {

package/dist/vue/src/core/logger/get-logger.js

@@ -5,7 +5,6 @@ const DEFAULT_FORMAT_CONFIG = {
     timestamp: { withDate: false },
 };
 const DEFAULT_RENDER_CONFIG = {
-    timestamp: {},
     id: { visible: true, prefix: "<", suffix: ">" },
     meta: { lineBreaksAfter: 1 },
 };
@@ -14,23 +13,27 @@ const DEFAULT_RENDER_CONFIG = {
  * - Safe across hot reloads
  * - Prevents unbounded memory usage via soft LRU
  */
-function getLogger({ id = "default", formatConfig, renderConfig, preset, ...options }) {
+function getLogger({ id = "default", 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);
+    const existing = pool.get(id);
+    if (existing)
+        return existing;
+    const baseConfig = preset === undefined
+        ? {
+            formatConfig: DEFAULT_FORMAT_CONFIG,
+            renderConfig: DEFAULT_RENDER_CONFIG,
+        }
+        : { preset };
+    const logger = logry({
+        id,
+        ...baseConfig,
+        ...options,
+    });
+    pool.set(id, logger);
+    // Soft LRU: keep pool size under control
+    if (pool.size > 1000) {
+        for (const key of [...pool.keys()].slice(0, 200)) {
+            pool.delete(key);
         }
     }
     return logger;

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

@@ -21,13 +21,13 @@ async function fetchRemoteResource({ fetch, url, headers, signal, loggerOptions,
             method: "GET",
             headers: { "Content-Type": "application/json", ...headers },
             cache: "no-store",
-            signal,
+            ...(signal !== undefined ? { signal } : {}),
         });
         if (!response.ok) {
             throw new Error(`HTTP ${response.status} ${response.statusText}`);
         }
         // Parse JSON body
-        const data = await response.json();
+        const data = (await response.json());
         // Validate messages structure
         if (!isValidMessages(data)) {
             throw new Error("Invalid messages structure");

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

@@ -34,9 +34,8 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
     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;
+    for (const candidateLocale of candidateLocales) {
+        const isLast = candidateLocale === candidateLocales[candidateLocales.length - 1];
         try {
             // -----------------------------------------------------------------
             // Collect remote message resources for the locale
@@ -44,12 +43,18 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             const resources = collectRemoteResources({
                 locale: candidateLocale,
                 baseUrl,
-                namespaces,
+                ...(namespaces !== undefined ? { namespaces } : {}),
             });
             // -----------------------------------------------------------------
             // Fetch all message chunks in parallel
             // -----------------------------------------------------------------
-            const fetchUrl = (url) => fetchRemoteResource({ url, headers, signal, loggerOptions, fetch });
+            const fetchUrl = (url) => fetchRemoteResource({
+                url,
+                ...(headers !== undefined ? { headers } : {}),
+                ...(signal !== undefined ? { 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))
@@ -57,7 +62,10 @@ const loadRemoteMessages = async ({ locale, fallbackLocales, namespaces, concurr
             // -----------------------------------------------------------------
             // Resolve and merge remote message resources
             // -----------------------------------------------------------------
-            const resolved = resolveRemoteResources(resources.map((res, i) => ({ path: res.path, data: results[i] })));
+            const resolved = resolveRemoteResources(resources.map((res, i) => {
+                const data = results[i];
+                return { path: res.path, ...(data !== undefined ? { data } : {}) };
+            }));
             // -----------------------------------------------------------------
             // Wrap resolved messages into locale-scoped LocaleMessages
             // -----------------------------------------------------------------

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

@@ -6,6 +6,8 @@ import { deepMerge } from '../utils/deep-merge.js';
  *
  * - Only merges messages under the given locale
  * - Emits debug logs for add / override events
+ *
+ * @public
  */
 function mergeMessages(a, b, { config, locale, onEvent }) {
     const baseLogger = getLogger({ ...config.logger, id: config.id });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intor",
-  "version": "2.4.17",
+  "version": "2.5.0",
   "description": "The i18n library for modern JavaScript",
   "author": "Yiming Liao",
   "homepage": "https://intor.dev",
@@ -51,6 +51,10 @@
       "types": "./dist/types/export/react/index.d.ts",
       "import": "./dist/react/export/react/index.js"
     },
+    "./react/internal": {
+      "types": "./dist/types/export/react/internal/index.d.ts",
+      "import": "./dist/react/export/react/internal/index.js"
+    },
     "./vue": {
       "types": "./dist/types/export/vue/index.d.ts",
       "import": "./dist/vue/export/vue/index.js"
@@ -59,6 +63,10 @@
       "types": "./dist/types/export/svelte/index.d.ts",
       "import": "./dist/svelte/export/svelte/index.js"
     },
+    "./svelte/internal": {
+      "types": "./dist/types/export/svelte/internal/index.d.ts",
+      "import": "./dist/svelte/export/svelte/internal/index.js"
+    },
     "./next": {
       "types": "./dist/types/export/next/index.d.ts",
       "import": "./dist/next/export/next/index.js"
@@ -96,22 +104,27 @@
     "node": ">=20"
   },
   "scripts": {
-    "type": "tsc --noEmit",
+    "type": "tsc -p tsconfig.json --noEmit",
     "lint": "eslint",
-    "lint:debug": "eslint --debug",
     "test": "vitest",
     "test:types": "tsx scripts/test-types.ts",
     "test:check": "tsx scripts/check-test-structure.ts",
     "knip": "knip --config .config/knip.config.ts",
+    "clean": "rm -rf dist",
     "build": "tsx scripts/build.ts",
-    "prepublishOnly": "yarn build"
+    "build:types": "tsc -p tsconfig.build.json && tsc-alias tsconfig.build.json --outDir dist/types",
+    "build:release": "yarn clean && yarn build && yarn build:types && yarn api:build",
+    "api:build": "tsx scripts/api-extractor/build.ts",
+    "api:check": "tsx scripts/api-extractor/check.ts",
+    "prepublishOnly": "yarn build:release"
   },
   "dependencies": {
-    "intor-translator": "^1.4.15",
+    "intor-translator": "^1.5.0",
     "logry": "2.1.6",
     "p-limit": "7.2.0"
   },
   "devDependencies": {
+    "@microsoft/api-extractor": "^7.57.6",
     "@rollup/plugin-alias": "6.0.0",
     "@rollup/plugin-typescript": "12.3.0",
     "@rollup/pluginutils": "5.3.0",
@@ -119,13 +132,13 @@
     "@testing-library/dom": "10.4.1",
     "@testing-library/jest-dom": "6.9.1",
     "@testing-library/react": "16.3.1",
-    "@testing-library/user-event": "14.6.1",
     "@types/express": "5.0.6",
     "@types/node": "24.10.1",
     "@types/react": "19.0.0",
     "@types/react-dom": "19.0.0",
     "@vitejs/plugin-react": "5.1.2",
     "@vitest/coverage-v8": "4.0.16",
+    "@vue/test-utils": "^2.4.6",
     "eslint": "9.39.2",
     "eslint-config-prettier": "10.1.8",
     "eslint-import-resolver-typescript": "4.4.4",
@@ -154,7 +167,7 @@
     "tsd": "0.33.0",
     "tsx": "^4.21.0",
     "typescript": "5.8.3",
-    "typescript-eslint": "8.32.1",
+    "typescript-eslint": "^8.56.1",
     "vite": "7.3.0",
     "vite-tsconfig-paths": "6.0.3",
     "vitest": "4.0.16",

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

@@ -1,9 +0,0 @@
-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/express/src/core/logger/get-logger.js

@@ -1,39 +0,0 @@
-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/express/src/core/logger/global-logger-pool.js

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

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

@@ -1,25 +0,0 @@
-/**
- * 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/express/src/core/messages/load-remote-messages/fetch-remote-resource.js

@@ -1,47 +0,0 @@
-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 };

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

@@ -1,93 +0,0 @@
-import pLimit from 'p-limit';
-import { getLogger } from '../../logger/get-logger.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 source.
- *
- * This function serves as the orchestration layer for remote message loading.
- * It coordinates:
- *
- * - Locale resolution with fallbacks
- * - Concurrency control for network requests
- * - Remote resource fetching and message merging
- *
- * 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, 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
-    if (signal?.aborted) {
-        logger.debug("Remote message loading aborted before fetch.");
-        return;
-    }
-    const start = performance.now();
-    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 {
-            // -----------------------------------------------------------------
-            // Collect remote message resources for the locale
-            // -----------------------------------------------------------------
-            const resources = collectRemoteResources({
-                locale: candidateLocale,
-                baseUrl,
-                namespaces,
-            });
-            // -----------------------------------------------------------------
-            // Fetch all message chunks in parallel
-            // -----------------------------------------------------------------
-            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))
-                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 {
-            if (signal?.aborted) {
-                logger.debug("Remote message loading aborted.");
-                return;
-            }
-            if (isLast) {
-                logger.warn("Failed to load messages for all candidate locales.", {
-                    locale,
-                    fallbackLocales,
-                });
-            }
-            else {
-                logger.warn(`Failed to load locale messages for "${candidateLocale}", trying next fallback.`);
-            }
-        }
-    }
-    // Final success log with resolved locale and timing
-    if (messages) {
-        logger.trace("Finished loading remote messages.", {
-            loadedLocale: Object.keys(messages)[0],
-            duration: `${Math.round(performance.now() - start)} ms`,
-        });
-    }
-    return messages;
-};
-
-export { loadRemoteMessages };

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

@@ -1,24 +0,0 @@
-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/express/src/core/messages/merge-messages.js

@@ -1,33 +0,0 @@
-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 };