langie 1.11.1 → 1.12.0

package/dist/components/InterfaceLanguageSelect.vue.d.ts

@@ -55,11 +55,11 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
 }>, {
     translatorHost: string;
+    apiKey: string;
     languages: TranslatorLanguage[];
     placeholder: string;
     disabled: boolean;
     isDark: boolean;
-    apiKey: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/index.cjs

@@ -1,5 +1,5 @@
 /**
- * langie v1.11.1
+ * langie v1.12.0
  * (c) 2026 nlit
  * @license Apache-2.0
  *
@@ -589,6 +589,12 @@ function applyLanguageAlias(term = "") {
   return { primary, suggestions: Array.from(suggestions) };
 }
 
+// src/utils/displayNative.ts
+var TRAILING_PAREN = /\s*[（(][^（）()]*[）)]\s*$/;
+function displayNative(name = "", native = "") {
+  return name !== native && TRAILING_PAREN.test(name) && TRAILING_PAREN.test(native) ? native.replace(TRAILING_PAREN, "") : native;
+}
+
 // src/constants/colors.ts
 var COLORS = {
   // Primary colors
@@ -928,7 +934,7 @@ var LanguageSelect_default = /* @__PURE__ */ (0, import_vue.defineComponent)({
                   value.native_name && value.native_name !== value.name ? ((0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)(
                     "span",
                     _hoisted_4,
-                    "(" + (0, import_vue2.toDisplayString)(value.native_name) + ")",
+                    "(" + (0, import_vue2.toDisplayString)((0, import_vue2.unref)(displayNative)(value.name, value.native_name)) + ")",
                     1
                     /* TEXT */
                   )) : (0, import_vue2.createCommentVNode)("v-if", true)
@@ -956,7 +962,7 @@ var LanguageSelect_default = /* @__PURE__ */ (0, import_vue.defineComponent)({
                   option.native_name && option.native_name !== option.name ? ((0, import_vue2.openBlock)(), (0, import_vue2.createElementBlock)(
                     "span",
                     _hoisted_8,
-                    "(" + (0, import_vue2.toDisplayString)(option.native_name) + ")",
+                    "(" + (0, import_vue2.toDisplayString)((0, import_vue2.unref)(displayNative)(option.name, option.native_name)) + ")",
                     1
                     /* TEXT */
                   )) : (0, import_vue2.createCommentVNode)("v-if", true)
@@ -1019,9 +1025,6 @@ var import_vue8 = require("vue");
 // src/useLangie.ts
 var import_vue5 = require("vue");
 
-// src/composables/useLangie-core.ts
-var import_vue4 = require("vue");
-
 // src/constants.ts
 var DEFAULT_API_HOST = "https://api.langie.uk/v1";
 var API_FIELD_TEXT = "t";
@@ -1032,6 +1035,153 @@ var API_FIELD_TRANSLATIONS = "translations";
 var API_FIELD_ERROR = "error";
 var API_FIELD_TURNSTILE = "turnstileToken";
 
+// src/core.ts
+var DEFAULT_TRANSLATOR_HOST = "http://localhost:8081";
+var DEFAULT_API_KEY_ENV = "TRANSLATOR_API_KEY";
+function resolveApiKey(options) {
+  if (options.apiKey) return options.apiKey;
+  const env = typeof process !== "undefined" ? process.env : void 0;
+  if (!env) return void 0;
+  return env[options.apiKeyEnv || DEFAULT_API_KEY_ENV];
+}
+var translationCache = /* @__PURE__ */ new Map();
+function getTranslationCacheKey(serviceTranslations, options) {
+  return JSON.stringify({
+    translations: serviceTranslations.map((t) => ({
+      [API_FIELD_TEXT]: t[API_FIELD_TEXT],
+      [API_FIELD_FROM]: t[API_FIELD_FROM],
+      [API_FIELD_TO]: t[API_FIELD_TO],
+      [API_FIELD_CTX]: t[API_FIELD_CTX] || options[API_FIELD_CTX] || "ui"
+    })),
+    host: options.translatorHost || DEFAULT_TRANSLATOR_HOST,
+    context: options[API_FIELD_CTX] || "ui"
+  });
+}
+async function translateBatch(translations2 = [], options = {}) {
+  if (!Array.isArray(translations2) || translations2.length === 0) {
+    throw new Error("translations must be a non-empty array");
+  }
+  const translatorHost = options.translatorHost || DEFAULT_TRANSLATOR_HOST;
+  const apiKey = resolveApiKey(options);
+  const serviceTranslations = [];
+  const indexMap = [];
+  translations2.forEach((tr, idx) => {
+    const from = (tr[API_FIELD_FROM] || "").toLowerCase();
+    const to = (tr[API_FIELD_TO] || "").toLowerCase();
+    if (from === to) {
+      return;
+    }
+    serviceTranslations.push(tr);
+    indexMap.push(idx);
+  });
+  let serviceResults = [];
+  if (serviceTranslations.length > 0) {
+    const cacheKey = getTranslationCacheKey(serviceTranslations, options);
+    if (translationCache.has(cacheKey)) {
+      serviceResults = await translationCache.get(cacheKey);
+    } else {
+      const translationPromise = (async () => {
+        try {
+          const turnstileToken = options.getTurnstileToken ? await options.getTurnstileToken() : void 0;
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), 5e3);
+          const resp = await fetch(`${translatorHost}/translate`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              ...apiKey ? { Authorization: `Bearer ${apiKey}`, "X-Api-Key": apiKey } : {}
+            },
+            body: JSON.stringify({
+              [API_FIELD_TRANSLATIONS]: serviceTranslations.map((t) => ({
+                [API_FIELD_TEXT]: t[API_FIELD_TEXT],
+                [API_FIELD_FROM]: t[API_FIELD_FROM],
+                [API_FIELD_TO]: t[API_FIELD_TO],
+                [API_FIELD_CTX]: t[API_FIELD_CTX] || options[API_FIELD_CTX] || "ui"
+              })),
+              [API_FIELD_CTX]: options[API_FIELD_CTX] || "ui",
+              ...turnstileToken ? { [API_FIELD_TURNSTILE]: turnstileToken } : {}
+            }),
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (!resp.ok) {
+            console.error(
+              "[translator-sdk] Translator error response:",
+              resp.status,
+              resp.statusText
+            );
+            throw new Error(`Translator service error: ${resp.status} ${resp.statusText}`);
+          }
+          let parsed;
+          try {
+            parsed = await resp.clone().json();
+          } catch (jsonErr) {
+            console.error("[translator-sdk] Failed to parse JSON response:", jsonErr);
+            throw new Error(`Failed to parse JSON response: ${jsonErr}`);
+          }
+          const data = parsed || {};
+          if (data[API_FIELD_ERROR]) {
+            console.warn(`[translator-sdk] Top-level API error:`, data[API_FIELD_ERROR]);
+            return serviceTranslations.map((translation) => ({
+              [API_FIELD_TEXT]: translation[API_FIELD_TEXT],
+              [API_FIELD_ERROR]: data[API_FIELD_ERROR]
+            }));
+          }
+          const results = Array.isArray(data[API_FIELD_TRANSLATIONS]) ? data[API_FIELD_TRANSLATIONS].map((translation, index) => {
+            const originalText = serviceTranslations[index]?.[API_FIELD_TEXT] || "";
+            if (translation[API_FIELD_ERROR]) {
+              console.warn(
+                `[translator-sdk] Translation error for "${originalText}":`,
+                translation[API_FIELD_ERROR]
+              );
+              return {
+                [API_FIELD_TEXT]: originalText,
+                // Return original text on error
+                [API_FIELD_ERROR]: translation[API_FIELD_ERROR]
+              };
+            }
+            if (translation[API_FIELD_FROM] && !translation[API_FIELD_TEXT]) {
+              return {
+                [API_FIELD_TEXT]: originalText,
+                // For detection, return original text
+                [API_FIELD_FROM]: translation[API_FIELD_FROM]
+              };
+            }
+            return {
+              [API_FIELD_TEXT]: translation[API_FIELD_TEXT] || originalText
+            };
+          }) : data[API_FIELD_TEXT] ? [{ [API_FIELD_TEXT]: data[API_FIELD_TEXT] }] : [];
+          return results;
+        } catch (error) {
+          translationCache.delete(cacheKey);
+          if (error instanceof Error && error.name === "AbortError") {
+            const message2 = `Translator request to ${translatorHost} timed out after 5 seconds.`;
+            console.error(message2);
+            throw new Error(message2);
+          }
+          const message = `Failed to connect to translator at ${translatorHost}. Is the service running?`;
+          console.error(message);
+          throw new Error(message);
+        }
+      })();
+      translationCache.set(cacheKey, translationPromise);
+      serviceResults = await translationPromise;
+    }
+  }
+  const final = translations2.map((tr, idx) => {
+    const from = (tr[API_FIELD_FROM] || "").toLowerCase();
+    const to = (tr[API_FIELD_TO] || "").toLowerCase();
+    if (from === to) return { [API_FIELD_TEXT]: tr[API_FIELD_TEXT] };
+    const svcIdx = indexMap.indexOf(idx);
+    if (svcIdx !== -1) return serviceResults[svcIdx] || { [API_FIELD_TEXT]: tr[API_FIELD_TEXT] };
+    return { [API_FIELD_TEXT]: tr[API_FIELD_TEXT] };
+  });
+  return final;
+}
+
+// src/composables/useLangie-core.ts
+var import_vue4 = require("vue");
+
 // src/utils/debug.ts
 var import_meta = {};
 function devDebug(...args) {
@@ -1276,143 +1426,6 @@ var clearCache = (pattern) => {
   return cacheManager.clear(pattern);
 };
 
-// src/core.ts
-var DEFAULT_TRANSLATOR_HOST = "http://localhost:8081";
-var translationCache = /* @__PURE__ */ new Map();
-function getTranslationCacheKey(serviceTranslations, options) {
-  return JSON.stringify({
-    translations: serviceTranslations.map((t) => ({
-      [API_FIELD_TEXT]: t[API_FIELD_TEXT],
-      [API_FIELD_FROM]: t[API_FIELD_FROM],
-      [API_FIELD_TO]: t[API_FIELD_TO],
-      [API_FIELD_CTX]: t[API_FIELD_CTX] || options[API_FIELD_CTX] || "ui"
-    })),
-    host: options.translatorHost || DEFAULT_TRANSLATOR_HOST,
-    context: options[API_FIELD_CTX] || "ui"
-  });
-}
-async function translateBatch(translations2 = [], options = {}) {
-  if (!Array.isArray(translations2) || translations2.length === 0) {
-    throw new Error("translations must be a non-empty array");
-  }
-  const translatorHost = options.translatorHost || DEFAULT_TRANSLATOR_HOST;
-  const apiKey = options.apiKey || process.env.TRANSLATOR_API_KEY;
-  const serviceTranslations = [];
-  const indexMap = [];
-  translations2.forEach((tr, idx) => {
-    const from = (tr[API_FIELD_FROM] || "").toLowerCase();
-    const to = (tr[API_FIELD_TO] || "").toLowerCase();
-    if (from === to) {
-      return;
-    }
-    serviceTranslations.push(tr);
-    indexMap.push(idx);
-  });
-  let serviceResults = [];
-  if (serviceTranslations.length > 0) {
-    const cacheKey = getTranslationCacheKey(serviceTranslations, options);
-    if (translationCache.has(cacheKey)) {
-      serviceResults = await translationCache.get(cacheKey);
-    } else {
-      const translationPromise = (async () => {
-        try {
-          const turnstileToken = options.getTurnstileToken ? await options.getTurnstileToken() : void 0;
-          const controller = new AbortController();
-          const timeoutId = setTimeout(() => controller.abort(), 5e3);
-          const resp = await fetch(`${translatorHost}/translate`, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              ...apiKey ? { Authorization: `Bearer ${apiKey}`, "X-Api-Key": apiKey } : {}
-            },
-            body: JSON.stringify({
-              [API_FIELD_TRANSLATIONS]: serviceTranslations.map((t) => ({
-                [API_FIELD_TEXT]: t[API_FIELD_TEXT],
-                [API_FIELD_FROM]: t[API_FIELD_FROM],
-                [API_FIELD_TO]: t[API_FIELD_TO],
-                [API_FIELD_CTX]: t[API_FIELD_CTX] || options[API_FIELD_CTX] || "ui"
-              })),
-              [API_FIELD_CTX]: options[API_FIELD_CTX] || "ui",
-              ...turnstileToken ? { [API_FIELD_TURNSTILE]: turnstileToken } : {}
-            }),
-            signal: controller.signal
-          });
-          clearTimeout(timeoutId);
-          if (!resp.ok) {
-            console.error(
-              "[translator-sdk] Translator error response:",
-              resp.status,
-              resp.statusText
-            );
-            throw new Error(`Translator service error: ${resp.status} ${resp.statusText}`);
-          }
-          let parsed;
-          try {
-            parsed = await resp.clone().json();
-          } catch (jsonErr) {
-            console.error("[translator-sdk] Failed to parse JSON response:", jsonErr);
-            throw new Error(`Failed to parse JSON response: ${jsonErr}`);
-          }
-          const data = parsed || {};
-          if (data[API_FIELD_ERROR]) {
-            console.warn(`[translator-sdk] Top-level API error:`, data[API_FIELD_ERROR]);
-            return serviceTranslations.map((translation) => ({
-              [API_FIELD_TEXT]: translation[API_FIELD_TEXT],
-              [API_FIELD_ERROR]: data[API_FIELD_ERROR]
-            }));
-          }
-          const results = Array.isArray(data[API_FIELD_TRANSLATIONS]) ? data[API_FIELD_TRANSLATIONS].map((translation, index) => {
-            const originalText = serviceTranslations[index]?.[API_FIELD_TEXT] || "";
-            if (translation[API_FIELD_ERROR]) {
-              console.warn(
-                `[translator-sdk] Translation error for "${originalText}":`,
-                translation[API_FIELD_ERROR]
-              );
-              return {
-                [API_FIELD_TEXT]: originalText,
-                // Return original text on error
-                [API_FIELD_ERROR]: translation[API_FIELD_ERROR]
-              };
-            }
-            if (translation[API_FIELD_FROM] && !translation[API_FIELD_TEXT]) {
-              return {
-                [API_FIELD_TEXT]: originalText,
-                // For detection, return original text
-                [API_FIELD_FROM]: translation[API_FIELD_FROM]
-              };
-            }
-            return {
-              [API_FIELD_TEXT]: translation[API_FIELD_TEXT] || originalText
-            };
-          }) : data[API_FIELD_TEXT] ? [{ [API_FIELD_TEXT]: data[API_FIELD_TEXT] }] : [];
-          return results;
-        } catch (error) {
-          translationCache.delete(cacheKey);
-          if (error instanceof Error && error.name === "AbortError") {
-            const message2 = `Translator request to ${translatorHost} timed out after 5 seconds.`;
-            console.error(message2);
-            throw new Error(message2);
-          }
-          const message = `Failed to connect to translator at ${translatorHost}. Is the service running?`;
-          console.error(message);
-          throw new Error(message);
-        }
-      })();
-      translationCache.set(cacheKey, translationPromise);
-      serviceResults = await translationPromise;
-    }
-  }
-  const final = translations2.map((tr, idx) => {
-    const from = (tr[API_FIELD_FROM] || "").toLowerCase();
-    const to = (tr[API_FIELD_TO] || "").toLowerCase();
-    if (from === to) return { [API_FIELD_TEXT]: tr[API_FIELD_TEXT] };
-    const svcIdx = indexMap.indexOf(idx);
-    if (svcIdx !== -1) return serviceResults[svcIdx] || { [API_FIELD_TEXT]: tr[API_FIELD_TEXT] };
-    return { [API_FIELD_TEXT]: tr[API_FIELD_TEXT] };
-  });
-  return final;
-}
-
 // src/utils/localizeLanguageNames.ts
 var CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var NAME_CTX = "language name";
@@ -1459,7 +1472,9 @@ var currentLanguage = (0, import_vue4.ref)("en");
 var _translatorHost = DEFAULT_API_HOST;
 var _autoSelected = false;
 var _languagesCache = null;
+var _languagesCacheAt = 0;
 var _languagesPromise = null;
+var LANGUAGES_CACHE_KEY = "langie_languages_cache";
 function useLangieCore(options = {}) {
   if (options.translatorHost) {
     _translatorHost = options.translatorHost;
@@ -1477,7 +1492,7 @@ function useLangieCore(options = {}) {
     }
   }
   if (typeof window !== "undefined") {
-    const cachedLanguages = getCache("langie_languages_cache");
+    const cachedLanguages = getCache(LANGUAGES_CACHE_KEY);
     if (cachedLanguages && availableLanguages.value.length === 0) {
       availableLanguages.value = cachedLanguages;
       devDebug("[useLangie] Seeded languages from cache (will revalidate):", cachedLanguages.length);
@@ -1510,15 +1525,18 @@ function useLangieCore(options = {}) {
     applyLocalizedNames(lang);
   };
   const fetchLanguages = async (opts = {}) => {
-    const { force = false, country: explicitCountry } = opts;
+    const { force = false, country: explicitCountry, maxAgeMs } = opts;
+    const cacheFresh = !!_languagesCache && (maxAgeMs === void 0 || Date.now() - _languagesCacheAt < maxAgeMs);
     devDebug("[useLangie] fetchLanguages called:", {
       force,
+      maxAgeMs,
+      cacheFresh,
       hasCache: !!_languagesCache,
       hasPromise: !!_languagesPromise,
       availableLanguagesLength: availableLanguages.value.length
     });
     if (!force) {
-      if (_languagesCache) {
+      if (cacheFresh) {
         devDebug("[useLangie] Returning cached languages:", _languagesCache.length);
         return _languagesCache;
       }
@@ -1576,7 +1594,7 @@ function useLangieCore(options = {}) {
       availableLanguages.value = filtered;
       devDebug("[useLangie] Set availableLanguages:", filtered.length);
       if (typeof window !== "undefined") {
-        const saved = setCache("langie_languages_cache", filtered, 7 * 24 * 60 * 60 * 1e3);
+        const saved = setCache(LANGUAGES_CACHE_KEY, filtered, 7 * 24 * 60 * 60 * 1e3);
         devDebug(
           "[useLangie] Saved languages to cache:",
           saved ? "success" : "failed",
@@ -1607,6 +1625,7 @@ function useLangieCore(options = {}) {
         _autoSelected = true;
       }
       _languagesCache = filtered;
+      _languagesCacheAt = Date.now();
       _languagesPromise = null;
       applyLocalizedNames(currentLanguage.value);
       return filtered;
@@ -1615,6 +1634,14 @@ function useLangieCore(options = {}) {
       return [];
     }
   };
+  const invalidateLanguages = () => {
+    _languagesCache = null;
+    _languagesCacheAt = 0;
+    _languagesPromise = null;
+    if (typeof window !== "undefined") {
+      clearCache(LANGUAGES_CACHE_KEY);
+    }
+  };
   const clearTranslations = () => {
     Object.keys(translations).forEach((key) => delete translations[key]);
     Object.keys(uiTranslations).forEach((key) => delete uiTranslations[key]);
@@ -1631,6 +1658,7 @@ function useLangieCore(options = {}) {
     isLoading,
     setLanguage,
     fetchLanguages,
+    invalidateLanguages,
     clearTranslations,
     translatorHost
   };
@@ -1948,6 +1976,7 @@ function createLangieInstance(options = {}) {
     isLoading,
     setLanguage,
     fetchLanguages,
+    invalidateLanguages,
     translatorHost,
     clearTranslations
   } = core;
@@ -1959,9 +1988,17 @@ function createLangieInstance(options = {}) {
     Object.assign(ltDefaults, defaults);
   };
   const getLtDefaults = () => ({ ...ltDefaults });
+  const seed = {};
+  if (options.ssrTranslations) seedTranslations(options.ssrTranslations);
+  function seedTranslations(entries) {
+    for (const lang of Object.keys(entries)) {
+      seed[lang] = { ...seed[lang] || {}, ...entries[lang] };
+    }
+  }
+  const getSeed = (lang, text, ctx) => seed[lang]?.[`${text}|${ctx}`];
   const CACHE_KEY = "langie_translations_cache";
   const UI_CACHE_KEY = "langie_ui_translations_cache";
-  const LANGUAGES_CACHE_KEY = "langie_languages_cache";
+  const LANGUAGES_CACHE_KEY2 = "langie_languages_cache";
   const loadCachedTranslations = () => {
     if (typeof window === "undefined") return;
     const cachedTranslations = getCache(CACHE_KEY);
@@ -1989,7 +2026,7 @@ function createLangieInstance(options = {}) {
   };
   const loadCachedLanguages = () => {
     if (typeof window === "undefined") return;
-    const cachedLanguages = getCache(LANGUAGES_CACHE_KEY);
+    const cachedLanguages = getCache(LANGUAGES_CACHE_KEY2);
     if (cachedLanguages) {
       availableLanguages2.value = cachedLanguages;
     }
@@ -2103,6 +2140,10 @@ function createLangieInstance(options = {}) {
     if (cache[cacheKey]) {
       return cache[cacheKey];
     }
+    const seeded = getSeed(to, text, effectiveCtx);
+    if (seeded) {
+      return seeded;
+    }
     const errorKey = `${text}|${effectiveCtx}|${from}|${to}`;
     if (translationErrors.has(errorKey)) {
       return text;
@@ -2111,6 +2152,7 @@ function createLangieInstance(options = {}) {
     if (recentlyQueued.has(languageCacheKey)) {
       return text;
     }
+    options.onTranslationMiss?.({ text, ctx: effectiveCtx, from, to });
     batching.queueTranslation(text, effectiveCtx, from, to, cacheKey, toLang !== void 0);
     recentlyQueued.add(languageCacheKey);
     const clearDelay = 100;
@@ -2123,6 +2165,42 @@ function createLangieInstance(options = {}) {
   };
   const l = (text, ctx, originalLang, toLang) => translateInternal(text, ctx, originalLang, toLang, false);
   const lr = (text, ctx, originalLang, toLang) => translateInternal(text, ctx, originalLang, toLang, true);
+  const peekTranslation = (text, ctx, toLang) => {
+    const effectiveCtx = ctx !== void 0 ? ctx : ltDefaults.ctx || "ui";
+    const from = ltDefaults.orig || "";
+    const to = toLang || currentLanguage2.value;
+    if (from === to) return text;
+    const baseKey = `${text}|${effectiveCtx}`;
+    const cacheKey = to !== currentLanguage2.value ? `${baseKey}|${from}|${to}` : baseKey;
+    const cache = effectiveCtx === "ui" ? uiTranslations2 : translations2;
+    return cache[cacheKey] || getSeed(to, text, effectiveCtx) || text;
+  };
+  const warmTranslations = async (keys, lang, from = ltDefaults.orig || "") => {
+    const valid = keys.filter((k) => k && k.text);
+    if (valid.length === 0) return {};
+    const items = valid.map((k) => ({
+      [API_FIELD_TEXT]: k.text,
+      [API_FIELD_FROM]: from,
+      [API_FIELD_TO]: lang,
+      [API_FIELD_CTX]: k.ctx ?? ltDefaults.ctx ?? "ui"
+    }));
+    const results = await translateBatch(items, {
+      translatorHost,
+      apiKey: options.apiKey,
+      apiKeyEnv: options.apiKeyEnv
+    });
+    const resolved = {};
+    results.forEach((res, i) => {
+      const src = valid[i];
+      const translated = res?.[API_FIELD_TEXT];
+      if (src && translated && translated !== src.text) {
+        const ctx = src.ctx ?? ltDefaults.ctx ?? "ui";
+        resolved[`${src.text}|${ctx}`] = translated;
+      }
+    });
+    if (Object.keys(resolved).length > 0) seedTranslations({ [lang]: resolved });
+    return resolved;
+  };
   const fetchAndCacheBatch = async (items, from, to = currentLanguage2.value, globalCtx) => {
     if (items.length === 0) return;
     const effectiveFrom = from || ltDefaults.orig || "";
@@ -2252,11 +2330,16 @@ function createLangieInstance(options = {}) {
     isLoading,
     setLanguage,
     fetchLanguages,
+    invalidateLanguages,
     translatorHost,
     // Translation functions
     l,
     lr,
+    peekTranslation,
     fetchAndCacheBatch,
+    // SSR translation seam
+    seedTranslations,
+    warmTranslations,
     // Error handling
     getTranslationError: (text, ctx, from, to) => {
       const effectiveCtx = ctx !== void 0 ? ctx : ltDefaults.ctx || "ui";
@@ -2534,7 +2617,7 @@ var lt_default = /* @__PURE__ */ (0, import_vue9.defineComponent)({
     });
     const props = __props;
     const slots = (0, import_vue11.useSlots)();
-    const { lr, currentLanguage: currentLanguage2, uiTranslations: uiTranslations2, translations: translations2, getLtDefaults } = useLangie();
+    const { lr, peekTranslation, currentLanguage: currentLanguage2, uiTranslations: uiTranslations2, translations: translations2, getLtDefaults } = useLangie();
     const keyStr = (0, import_vue11.computed)(() => {
       if (props.msg) return props.msg;
       const slotContent = slots.default ? slots.default().map((n) => n.children).join("") : "";
@@ -2551,12 +2634,12 @@ var lt_default = /* @__PURE__ */ (0, import_vue9.defineComponent)({
       { deep: true }
     );
     const translated = (0, import_vue11.computed)(() => {
-      if (isNuxt.value && typeof window === "undefined") {
-        return keyStr.value;
-      }
       const globalDefaults = getLtDefaults();
       const effectiveCtx = props.ctx ?? globalDefaults.ctx;
       const effectiveOrig = props.orig ?? globalDefaults.orig;
+      if (isNuxt.value && typeof window === "undefined") {
+        return peekTranslation(keyStr.value, effectiveCtx);
+      }
       void currentLanguage2.value;
       void forceUpdate.value;
       const cacheKey = `${keyStr.value}|${effectiveCtx}`;