translate-kit 0.2.0 → 0.3.1

package/dist/cli.js

@@ -45,7 +45,7 @@ var init_config = __esm({
       translation: z.object({
         batchSize: z.number().int().positive().default(50),
         context: z.string().optional(),
-        glossary: z.record(z.string()).optional(),
+        glossary: z.record(z.string(), z.string()).optional(),
         tone: z.string().optional(),
         retries: z.number().int().min(0).default(2),
         concurrency: z.number().int().positive().default(3),
@@ -914,7 +914,7 @@ async function generateKeysBatchWithRetry(model, strings, retries) {
       lastError = error;
       if (attempt < retries) {
         const delay = Math.min(Math.pow(2, attempt) * 1e3, 3e4);
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        await new Promise((resolve2) => setTimeout(resolve2, delay));
       }
     }
   }
@@ -1028,6 +1028,18 @@ function hasUseTranslationsImport(ast, importSource) {
   }
   return false;
 }
+function hasGetTranslationsImport(ast, importSource) {
+  for (const node of ast.program.body) {
+    if (node.type === "ImportDeclaration" && node.source.value === importSource) {
+      for (const spec of node.specifiers) {
+        if (spec.type === "ImportSpecifier" && spec.imported.type === "Identifier" && spec.imported.name === "getTranslations") {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
 function transformConditionalBranch(node, textToKey) {
   if (node.type === "ConditionalExpression") {
     const cons = transformConditionalBranch(
@@ -1131,6 +1143,8 @@ function transform(ast, textToKey, options = {}) {
     return transformInline(ast, textToKey, options);
   }
   const importSource = options.i18nImport ?? "next-intl";
+  const supportsServerSplit = importSource === "next-intl";
+  const isClient = !supportsServerSplit || options.forceClient || detectClientFile(ast);
   let stringsWrapped = 0;
   const componentsNeedingT = /* @__PURE__ */ new Set();
   traverse2(ast, {
@@ -1232,7 +1246,12 @@ function transform(ast, textToKey, options = {}) {
       const key = textToKey[text2];
       const args = [t2.stringLiteral(key)];
       if (templateInfo && templateInfo.placeholders.length > 0) {
-        args.push(buildValuesObject(templateInfo.expressions, templateInfo.placeholders));
+        args.push(
+          buildValuesObject(
+            templateInfo.expressions,
+            templateInfo.placeholders
+          )
+        );
       }
       path.node.value = t2.jsxExpressionContainer(
         t2.callExpression(t2.identifier("t"), args)
@@ -1281,7 +1300,12 @@ function transform(ast, textToKey, options = {}) {
       const key = textToKey[text2];
       const args = [t2.stringLiteral(key)];
       if (templateInfo && templateInfo.placeholders.length > 0) {
-        args.push(buildValuesObject(templateInfo.expressions, templateInfo.placeholders));
+        args.push(
+          buildValuesObject(
+            templateInfo.expressions,
+            templateInfo.placeholders
+          )
+        );
       }
       path.node.value = t2.callExpression(t2.identifier("t"), args);
       stringsWrapped++;
@@ -1291,43 +1315,86 @@ function transform(ast, textToKey, options = {}) {
   if (stringsWrapped === 0) {
     return { code: generate(ast).code, stringsWrapped: 0, modified: false };
   }
-  if (!hasUseTranslationsImport(ast, importSource)) {
-    const importDecl = t2.importDeclaration(
-      [
-        t2.importSpecifier(
-          t2.identifier("useTranslations"),
-          t2.identifier("useTranslations")
-        )
-      ],
-      t2.stringLiteral(importSource)
-    );
-    const lastImportIndex = findLastImportIndex(ast);
-    if (lastImportIndex >= 0) {
-      ast.program.body.splice(lastImportIndex + 1, 0, importDecl);
-    } else {
-      ast.program.body.unshift(importDecl);
+  if (isClient) {
+    if (!hasUseTranslationsImport(ast, importSource)) {
+      const importDecl = t2.importDeclaration(
+        [
+          t2.importSpecifier(
+            t2.identifier("useTranslations"),
+            t2.identifier("useTranslations")
+          )
+        ],
+        t2.stringLiteral(importSource)
+      );
+      const lastImportIndex = findLastImportIndex(ast);
+      if (lastImportIndex >= 0) {
+        ast.program.body.splice(lastImportIndex + 1, 0, importDecl);
+      } else {
+        ast.program.body.unshift(importDecl);
+      }
     }
-  }
-  traverse2(ast, {
-    FunctionDeclaration(path) {
-      const name = path.node.id?.name;
-      if (!name || !componentsNeedingT.has(name)) return;
-      injectTDeclaration(path);
-    },
-    VariableDeclarator(path) {
-      if (path.node.id.type !== "Identifier") return;
-      const name = path.node.id.name;
-      if (!componentsNeedingT.has(name)) return;
-      const init = path.node.init;
-      if (!init) return;
-      if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
-        if (init.body.type === "BlockStatement") {
-          injectTIntoBlock(init.body);
+    traverse2(ast, {
+      FunctionDeclaration(path) {
+        const name = path.node.id?.name;
+        if (!name || !componentsNeedingT.has(name)) return;
+        injectTDeclaration(path);
+      },
+      VariableDeclarator(path) {
+        if (path.node.id.type !== "Identifier") return;
+        const name = path.node.id.name;
+        if (!componentsNeedingT.has(name)) return;
+        const init = path.node.init;
+        if (!init) return;
+        if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+          if (init.body.type === "BlockStatement") {
+            injectTIntoBlock(init.body);
+          }
         }
+      },
+      noScope: true
+    });
+  } else {
+    const serverSource = `${importSource}/server`;
+    if (!hasGetTranslationsImport(ast, serverSource)) {
+      const importDecl = t2.importDeclaration(
+        [
+          t2.importSpecifier(
+            t2.identifier("getTranslations"),
+            t2.identifier("getTranslations")
+          )
+        ],
+        t2.stringLiteral(serverSource)
+      );
+      const lastImportIndex = findLastImportIndex(ast);
+      if (lastImportIndex >= 0) {
+        ast.program.body.splice(lastImportIndex + 1, 0, importDecl);
+      } else {
+        ast.program.body.unshift(importDecl);
       }
-    },
-    noScope: true
-  });
+    }
+    traverse2(ast, {
+      FunctionDeclaration(path) {
+        const name = path.node.id?.name;
+        if (!name || !componentsNeedingT.has(name)) return;
+        path.node.async = true;
+        injectAsyncTIntoBlock(path.node.body);
+      },
+      VariableDeclarator(path) {
+        if (path.node.id.type !== "Identifier") return;
+        const name = path.node.id.name;
+        if (!componentsNeedingT.has(name)) return;
+        const init = path.node.init;
+        if (!init) return;
+        if (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression") {
+          init.async = true;
+          if (init.body.type === "BlockStatement") {
+            injectAsyncTIntoBlock(init.body);
+          }
+        }
+      },
+      noScope: true
+    });
+  }
   const output = generate(ast, { retainLines: false });
   return { code: output.code, stringsWrapped, modified: true };
 }
@@ -1339,7 +1406,7 @@ function injectTDeclaration(path) {
 function injectTIntoBlock(block) {
   for (const stmt of block.body) {
     if (stmt.type === "VariableDeclaration" && stmt.declarations.some(
-      (d) => d.id.type === "Identifier" && d.id.name === "t" && d.init?.type === "CallExpression" && d.init.callee.type === "Identifier" && d.init.callee.name === "useTranslations"
+      (d) => d.id.type === "Identifier" && d.id.name === "t" && (d.init?.type === "CallExpression" && d.init.callee.type === "Identifier" && (d.init.callee.name === "useTranslations" || d.init.callee.name === "getTranslations") || d.init?.type === "AwaitExpression" && d.init.argument.type === "CallExpression" && d.init.argument.callee.type === "Identifier" && d.init.argument.callee.name === "getTranslations")
     )) {
       return;
     }
@@ -1352,7 +1419,25 @@ function injectTIntoBlock(block) {
   ]);
   block.body.unshift(tDecl);
 }
-function isClientFile(ast) {
+function injectAsyncTIntoBlock(block) {
+  for (const stmt of block.body) {
+    if (stmt.type === "VariableDeclaration" && stmt.declarations.some(
+      (d) => d.id.type === "Identifier" && d.id.name === "t" && (d.init?.type === "AwaitExpression" && d.init.argument.type === "CallExpression" && d.init.argument.callee.type === "Identifier" && d.init.argument.callee.name === "getTranslations" || d.init?.type === "CallExpression" && d.init.callee.type === "Identifier" && d.init.callee.name === "getTranslations")
+    )) {
+      return;
+    }
+  }
+  const tDecl = t2.variableDeclaration("const", [
+    t2.variableDeclarator(
+      t2.identifier("t"),
+      t2.awaitExpression(
+        t2.callExpression(t2.identifier("getTranslations"), [])
+      )
+    )
+  ]);
+  block.body.unshift(tDecl);
+}
+function detectClientFile(ast) {
   if (ast.program.directives) {
     for (const directive of ast.program.directives) {
       if (directive.value?.value === "use client") {
@@ -1365,7 +1450,18 @@ function isClientFile(ast) {
       return true;
     }
   }
-  return false;
+  let usesHooks = false;
+  traverse2(ast, {
+    CallExpression(path) {
+      if (usesHooks) return;
+      const callee = path.node.callee;
+      if (callee.type === "Identifier" && /^use[A-Z]/.test(callee.name)) {
+        usesHooks = true;
+      }
+    },
+    noScope: true
+  });
+  return usesHooks;
 }
 function hasInlineImport(ast, componentPath) {
   let hasT = false;
@@ -1385,13 +1481,46 @@ function hasInlineImport(ast, componentPath) {
   }
   return { hasT, hasHook };
 }
+function normalizeInlineImports(ast, componentPath, isClient) {
+  const validSources = /* @__PURE__ */ new Set([
+    componentPath,
+    `${componentPath}-server`,
+    `${componentPath}/t-server`
+  ]);
+  const desiredSource = isClient ? componentPath : `${componentPath}-server`;
+  let changed = false;
+  for (const node of ast.program.body) {
+    if (node.type !== "ImportDeclaration") continue;
+    if (!validSources.has(node.source.value)) continue;
+    if (node.source.value !== desiredSource) {
+      node.source.value = desiredSource;
+      changed = true;
+    }
+    for (const spec of node.specifiers) {
+      if (spec.type !== "ImportSpecifier" || spec.imported.type !== "Identifier") {
+        continue;
+      }
+      if (isClient && spec.imported.name === "createT") {
+        spec.imported = t2.identifier("useT");
+        changed = true;
+      }
+      if (!isClient && spec.imported.name === "useT") {
+        spec.imported = t2.identifier("createT");
+        changed = true;
+      }
+    }
+  }
+  return changed;
+}
 function transformInline(ast, textToKey, options) {
   const componentPath = options.componentPath ?? "@/components/t";
-  const isClient = isClientFile(ast);
+  const isClient = options.forceClient || detectClientFile(ast);
   let stringsWrapped = 0;
   const componentsNeedingT = /* @__PURE__ */ new Set();
   let needsTComponent = false;
   let repaired = false;
+  let boundaryRepaired = false;
+  boundaryRepaired = normalizeInlineImports(ast, componentPath, isClient);
   if (!isClient) {
     traverse2(ast, {
       CallExpression(path) {
@@ -1523,7 +1652,10 @@ function transformInline(ast, textToKey, options) {
       ];
       if (templateInfo && templateInfo.placeholders.length > 0) {
         args.push(
-          buildValuesObject(templateInfo.expressions, templateInfo.placeholders)
+          buildValuesObject(
+            templateInfo.expressions,
+            templateInfo.placeholders
+          )
         );
       }
       path.node.value = t2.jsxExpressionContainer(
@@ -1577,7 +1709,10 @@ function transformInline(ast, textToKey, options) {
       ];
       if (templateInfo && templateInfo.placeholders.length > 0) {
         args.push(
-          buildValuesObject(templateInfo.expressions, templateInfo.placeholders)
+          buildValuesObject(
+            templateInfo.expressions,
+            templateInfo.placeholders
+          )
         );
       }
       path.node.value = t2.callExpression(t2.identifier("t"), args);
@@ -1585,10 +1720,10 @@ function transformInline(ast, textToKey, options) {
       componentsNeedingT.add(compName);
     }
   });
-  if (stringsWrapped === 0 && !repaired) {
+  if (stringsWrapped === 0 && !repaired && !boundaryRepaired) {
     return { code: generate(ast).code, stringsWrapped: 0, modified: false };
   }
-  if (stringsWrapped === 0 && repaired) {
+  if (stringsWrapped === 0 && (repaired || boundaryRepaired)) {
     const output2 = generate(ast, { retainLines: false });
     return { code: output2.code, stringsWrapped: 0, modified: true };
   }
@@ -1687,9 +1822,109 @@ var init_transform = __esm({
 });
 
 // src/codegen/index.ts
+import { dirname, extname, join as join2, resolve } from "path";
 import { readFile as readFile3, writeFile } from "fs/promises";
 import { glob as glob2 } from "tinyglobby";
 import pLimit3 from "p-limit";
+function collectRuntimeImportSources(ast) {
+  const sources = [];
+  for (const node of ast.program.body) {
+    if (node.type === "ImportDeclaration") {
+      if (node.importKind === "type") continue;
+      const allTypeSpecifiers = node.specifiers.length > 0 && node.specifiers.every(
+        (spec) => spec.type === "ImportSpecifier" && spec.importKind === "type"
+      );
+      if (allTypeSpecifiers) continue;
+      sources.push(node.source.value);
+      continue;
+    }
+    if (node.type === "ExportNamedDeclaration" && node.source) {
+      if (node.exportKind !== "type") {
+        sources.push(node.source.value);
+      }
+      continue;
+    }
+    if (node.type === "ExportAllDeclaration") {
+      if (node.exportKind !== "type") {
+        sources.push(node.source.value);
+      }
+    }
+  }
+  return sources;
+}
+function resolveFileCandidate(basePath, knownFiles) {
+  const candidates = /* @__PURE__ */ new Set();
+  const resolvedBase = resolve(basePath);
+  const baseExt = extname(resolvedBase);
+  candidates.add(resolvedBase);
+  if (!baseExt) {
+    for (const ext of SOURCE_EXTENSIONS) {
+      candidates.add(resolve(`${resolvedBase}${ext}`));
+      candidates.add(resolve(join2(resolvedBase, `index${ext}`)));
+    }
+  }
+  if ([".js", ".jsx", ".mjs", ".cjs"].includes(baseExt)) {
+    const noExt = resolvedBase.slice(0, -baseExt.length);
+    for (const ext of SOURCE_EXTENSIONS) {
+      candidates.add(resolve(`${noExt}${ext}`));
+    }
+  }
+  for (const candidate of candidates) {
+    if (knownFiles.has(candidate)) return candidate;
+  }
+  return null;
+}
+function resolveLocalImport(importerPath, source, cwd, knownFiles) {
+  const baseCandidates = [];
+  if (source.startsWith(".")) {
+    baseCandidates.push(resolve(dirname(importerPath), source));
+  } else if (source.startsWith("@/")) {
+    baseCandidates.push(resolve(join2(cwd, "src", source.slice(2))));
+    baseCandidates.push(resolve(join2(cwd, source.slice(2))));
+  } else if (source.startsWith("~/")) {
+    baseCandidates.push(resolve(join2(cwd, source.slice(2))));
+  } else if (source.startsWith("/")) {
+    baseCandidates.push(resolve(join2(cwd, source.slice(1))));
+  } else {
+    return null;
+  }
+  for (const base of baseCandidates) {
+    const resolved = resolveFileCandidate(base, knownFiles);
+    if (resolved) return resolved;
+  }
+  return null;
+}
+function buildClientGraph(entries, cwd) {
+  const parsedEntries = entries.filter((e) => e.ast != null);
+  const knownFiles = new Set(parsedEntries.map((e) => e.filePath));
+  const depsByImporter = /* @__PURE__ */ new Map();
+  for (const entry of parsedEntries) {
+    const deps = [];
+    const imports = collectRuntimeImportSources(entry.ast);
+    for (const source of imports) {
+      const dep = resolveLocalImport(entry.filePath, source, cwd, knownFiles);
+      if (dep) deps.push(dep);
+    }
+    depsByImporter.set(entry.filePath, deps);
+  }
+  const clientReachable = /* @__PURE__ */ new Set();
+  const queue = [];
+  for (const entry of parsedEntries) {
+    if (!entry.isClientRoot) continue;
+    clientReachable.add(entry.filePath);
+    queue.push(entry.filePath);
+  }
+  while (queue.length > 0) {
+    const filePath = queue.shift();
+    const deps = depsByImporter.get(filePath) ?? [];
+    for (const dep of deps) {
+      if (clientReachable.has(dep)) continue;
+      clientReachable.add(dep);
+      queue.push(dep);
+    }
+  }
+  return clientReachable;
+}
 async function codegen(options, cwd = process.cwd()) {
   const files = await glob2(options.include, {
     ignore: options.exclude ?? [],
@@ -1701,39 +1936,72 @@ async function codegen(options, cwd = process.cwd()) {
     mode: options.mode,
     componentPath: options.componentPath
   };
-  const limit = pLimit3(10);
-  let completed = 0;
-  const fileResults = await Promise.all(
+  const parseLimit = pLimit3(10);
+  const parsedEntries = await Promise.all(
     files.map(
-      (filePath) => limit(async () => {
+      (filePath) => parseLimit(async () => {
         const code = await readFile3(filePath, "utf-8");
-        let ast;
         try {
-          ast = parseFile(code, filePath);
+          const ast = parseFile(code, filePath);
+          return {
+            filePath,
+            code,
+            ast,
+            isClientRoot: detectClientFile(ast)
+          };
         } catch (err) {
+          return {
+            filePath,
+            code,
+            parseError: err instanceof Error ? err.message : String(err),
+            isClientRoot: false
+          };
+        }
+      })
+    )
+  );
+  const forceClientSet = buildClientGraph(parsedEntries, cwd);
+  const limit = pLimit3(10);
+  let completed = 0;
+  const fileResults = await Promise.all(
+    parsedEntries.map(
+      (entry) => limit(async () => {
+        if (!entry.ast) {
           logWarning(
-            `Skipping unparseable file ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+            `Skipping unparseable file ${entry.filePath}: ${entry.parseError ?? "unknown parse error"}`
           );
           completed++;
           options.onProgress?.(completed, files.length);
           return { modified: false, wrapped: 0, skipped: false };
         }
-        const result = transform(ast, options.textToKey, transformOpts);
+        const fileTransformOpts = {
+          ...transformOpts,
+          forceClient: forceClientSet.has(entry.filePath)
+        };
+        const result = transform(
+          entry.ast,
+          options.textToKey,
+          fileTransformOpts
+        );
         if (result.modified) {
           try {
-            parseFile(result.code, filePath);
+            parseFile(result.code, entry.filePath);
           } catch {
             logWarning(
-              `Codegen produced invalid syntax for ${filePath}, file was NOT modified.`
+              `Codegen produced invalid syntax for ${entry.filePath}, file was NOT modified.`
             );
             completed++;
             options.onProgress?.(completed, files.length);
             return { modified: false, wrapped: 0, skipped: true };
           }
-          await writeFile(filePath, result.code, "utf-8");
+          await writeFile(entry.filePath, result.code, "utf-8");
           completed++;
           options.onProgress?.(completed, files.length);
-          return { modified: true, wrapped: result.stringsWrapped, skipped: false };
+          return {
+            modified: true,
+            wrapped: result.stringsWrapped,
+            skipped: false
+          };
         }
         completed++;
         options.onProgress?.(completed, files.length);
@@ -1758,12 +2026,23 @@ async function codegen(options, cwd = process.cwd()) {
     filesSkipped
   };
 }
+var SOURCE_EXTENSIONS;
 var init_codegen = __esm({
   "src/codegen/index.ts"() {
     "use strict";
     init_parser();
     init_transform();
     init_logger();
+    SOURCE_EXTENSIONS = [
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mts",
+      ".cts",
+      ".mjs",
+      ".cjs"
+    ];
   }
 });
 
@@ -1907,7 +2186,7 @@ async function translateBatchWithRetry(input, retries) {
       lastError = error;
       if (attempt < retries) {
         const delay = Math.min(Math.pow(2, attempt) * 1e3, 3e4);
-        await new Promise((resolve) => setTimeout(resolve, delay));
+        await new Promise((resolve2) => setTimeout(resolve2, delay));
       }
     }
   }
@@ -1974,9 +2253,9 @@ var init_translate = __esm({
 
 // src/writer.ts
 import { writeFile as writeFile2, mkdir } from "fs/promises";
-import { join as join2, dirname } from "path";
+import { join as join3, dirname as dirname2 } from "path";
 async function writeTranslation(filePath, flatEntries, options) {
-  await mkdir(dirname(filePath), { recursive: true });
+  await mkdir(dirname2(filePath), { recursive: true });
   const data = options?.flat ? flatEntries : unflatten(flatEntries);
   const content = JSON.stringify(data, null, 2) + "\n";
   await writeFile2(filePath, content, "utf-8");
@@ -1993,8 +2272,8 @@ async function writeLockFile(messagesDir, sourceFlat, existingLock, translatedKe
       delete lock[key];
     }
   }
-  const lockPath = join2(messagesDir, ".translate-lock.json");
-  await mkdir(dirname(lockPath), { recursive: true });
+  const lockPath = join3(messagesDir, ".translate-lock.json");
+  await mkdir(dirname2(lockPath), { recursive: true });
   const content = JSON.stringify(lock, null, 2) + "\n";
   await writeFile2(lockPath, content, "utf-8");
 }
@@ -2007,10 +2286,10 @@ var init_writer = __esm({
 });
 
 // src/pipeline.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
 async function loadMapFile(messagesDir) {
-  const mapPath = join3(messagesDir, ".translate-map.json");
+  const mapPath = join4(messagesDir, ".translate-map.json");
   let content;
   try {
     content = await readFile4(mapPath, "utf-8");
@@ -2027,7 +2306,7 @@ async function loadMapFile(messagesDir) {
   }
 }
 async function writeMapFile(messagesDir, map) {
-  const mapPath = join3(messagesDir, ".translate-map.json");
+  const mapPath = join4(messagesDir, ".translate-map.json");
   await mkdir2(messagesDir, { recursive: true });
   const content = JSON.stringify(map, null, 2) + "\n";
   await writeFile3(mapPath, content, "utf-8");
@@ -2080,7 +2359,7 @@ async function runScanStep(input) {
     sourceFlat[key] = text2;
   }
   if (mode !== "inline") {
-    const sourceFile = join3(
+    const sourceFile = join4(
       config.messagesDir,
       `${config.sourceLocale}.json`
     );
@@ -2134,7 +2413,7 @@ async function runTranslateStep(input) {
         sourceFlat[key] = text2;
       }
     } else {
-      const sourceFile = join3(
+      const sourceFile = join4(
         config.messagesDir,
         `${config.sourceLocale}.json`
       );
@@ -2145,7 +2424,7 @@ async function runTranslateStep(input) {
   const localeResults = [];
   for (const locale of locales) {
     const start = Date.now();
-    const targetFile = join3(config.messagesDir, `${locale}.json`);
+    const targetFile = join4(config.messagesDir, `${locale}.json`);
     const targetRaw = await loadJsonFile(targetFile);
     const targetFlat = flatten(targetRaw);
     let lockData = await loadLockFile(config.messagesDir);
@@ -2311,8 +2590,9 @@ var init_cli_utils = __esm({
 });
 
 // src/templates/t-component.ts
-function serverTemplate(clientBasename) {
-  return `import type { ReactNode } from "react";
+function serverTemplate(clientBasename, opts) {
+  if (!opts) {
+    return `import type { ReactNode } from "react";
 import { cache } from "react";
 export { I18nProvider } from "./${clientBasename}";
 
@@ -2339,12 +2619,134 @@ export function createT(messages?: Messages) {
     return raw.replace(/\\{(\\w+)\\}/g, (_, k) => String(values[k] ?? \`{\${k}}\`));
   };
 }
+`;
+  }
+  const allLocales = [opts.sourceLocale, ...opts.targetLocales];
+  const allLocalesStr = allLocales.map((l) => `"${l}"`).join(", ");
+  return `import type { ReactNode } from "react";
+import { cache } from "react";
+export { I18nProvider } from "./${clientBasename}";
+
+type Messages = Record<string, string>;
+
+const supported = [${allLocalesStr}] as const;
+type Locale = (typeof supported)[number];
+const defaultLocale: Locale = "${opts.sourceLocale}";
+const messagesDir = "${opts.messagesDir}";
+
+function parseAcceptLanguage(header: string): Locale {
+  const langs = header
+    .split(",")
+    .map((part) => {
+      const [lang, q] = part.trim().split(";q=");
+      return { lang: lang.split("-")[0].toLowerCase(), q: q ? parseFloat(q) : 1 };
+    })
+    .sort((a, b) => b.q - a.q);
+
+  for (const { lang } of langs) {
+    if (supported.includes(lang as Locale)) return lang as Locale;
+  }
+  return defaultLocale;
+}
+
+const getLocaleStore = cache(() => ({ current: null as string | null }));
+
+export function setLocale(locale: string) {
+  getLocaleStore().current = locale;
+}
+
+// Per-request cached message loading \u2014 works even when layout is cached during client-side navigation
+// Uses dynamic imports so this file can be safely imported from client components
+const getCachedMessages = cache(async (): Promise<Messages> => {
+  let locale: Locale | null = getLocaleStore().current as Locale | null;
+
+  if (!locale) {
+    try {
+      const { cookies } = await import("next/headers");
+      const c = await cookies();
+      const cookieLocale = c.get("NEXT_LOCALE")?.value;
+      if (cookieLocale && supported.includes(cookieLocale as Locale)) {
+        locale = cookieLocale as Locale;
+      }
+    } catch {}
+  }
+
+  if (!locale) {
+    const { headers } = await import("next/headers");
+    const h = await headers();
+    const acceptLang = h.get("accept-language") ?? "";
+    locale = parseAcceptLanguage(acceptLang);
+  }
+
+  if (locale === defaultLocale) return {};
+  const { readFile } = await import("node:fs/promises");
+  const { join } = await import("node:path");
+  try {
+    const filePath = join(process.cwd(), messagesDir, \`\${locale}.json\`);
+    const content = await readFile(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+});
+
+// Per-request message store (populated by setServerMessages in layout)
+const getMessageStore = cache(() => ({ current: null as Messages | null }));
+
+export function setServerMessages(messages: Messages) {
+  getMessageStore().current = messages;
+}
+
+async function resolveMessages(explicit?: Messages): Promise<Messages> {
+  if (explicit) return explicit;
+  const store = getMessageStore().current;
+  if (store) return store;
+  return getCachedMessages();
+}
+
+export async function T({ id, children, messages }: { id?: string; children: ReactNode; messages?: Messages }) {
+  if (!id) return <>{children}</>;
+  const msgs = await resolveMessages(messages);
+  // Populate store so sync createT() calls in the same request benefit
+  if (!messages && !getMessageStore().current) {
+    getMessageStore().current = msgs;
+  }
+  return <>{msgs[id] ?? children}</>;
+}
+
+type TFn = (text: string, id?: string, values?: Record<string, string | number>) => string;
+
+// Backward-compatible: works both as sync createT() and async await createT()
+// - Sync: reads from store (works when layout called setServerMessages)
+// - Async: lazily loads messages from filesystem (works during client-side navigation)
+export function createT(messages?: Messages): TFn & PromiseLike<TFn> {
+  const t: TFn = (text, id, values) => {
+    const msgs = messages ?? getMessageStore().current ?? {};
+    const raw = id ? (msgs[id] ?? text) : text;
+    if (!values) return raw;
+    return raw.replace(/\\{(\\w+)\\}/g, (_, k) => String(values[k] ?? \`{\${k}}\`));
+  };
+
+  const asyncResult = resolveMessages(messages).then(msgs => {
+    if (!messages && !getMessageStore().current) {
+      getMessageStore().current = msgs;
+    }
+    const bound: TFn = (text, id, values) => {
+      const raw = id ? (msgs[id] ?? text) : text;
+      if (!values) return raw;
+      return raw.replace(/\\{(\\w+)\\}/g, (_, k) => String(values[k] ?? \`{\${k}}\`));
+    };
+    return bound;
+  });
+
+  return Object.assign(t, { then: asyncResult.then.bind(asyncResult) });
+}
 `;
 }
 function generateI18nHelper(opts) {
   const allLocales = [opts.sourceLocale, ...opts.targetLocales];
   const allLocalesStr = allLocales.map((l) => `"${l}"`).join(", ");
-  return `import { headers } from "next/headers";
+  return `import { headers, cookies } from "next/headers";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 
@@ -2368,6 +2770,13 @@ function parseAcceptLanguage(header: string): Locale {
 }
 
 export async function getLocale(): Promise<Locale> {
+  try {
+    const c = await cookies();
+    const cookieLocale = c.get("NEXT_LOCALE")?.value;
+    if (cookieLocale && supported.includes(cookieLocale as Locale)) {
+      return cookieLocale as Locale;
+    }
+  } catch {}
   const h = await headers();
   const acceptLang = h.get("accept-language") ?? "";
   return parseAcceptLanguage(acceptLang);
@@ -2390,12 +2799,17 @@ var init_t_component = __esm({
   "src/templates/t-component.ts"() {
     "use strict";
     CLIENT_TEMPLATE = `"use client";
-import { createContext, useContext, type ReactNode } from "react";
+import { createContext, useContext, useEffect, type ReactNode } from "react";
 
 type Messages = Record<string, string>;
 const I18nCtx = createContext<Messages>({});
 
-export function I18nProvider({ messages = {}, children }: { messages?: Messages; children: ReactNode }) {
+export function I18nProvider({ messages = {}, locale, children }: { messages?: Messages; locale?: string; children: ReactNode }) {
+  useEffect(() => {
+    if (locale) {
+      document.cookie = \`NEXT_LOCALE=\${locale}; path=/; max-age=31536000; SameSite=Lax\`;
+    }
+  }, [locale]);
   return <I18nCtx.Provider value={messages}>{children}</I18nCtx.Provider>;
 }
 
@@ -2424,17 +2838,17 @@ __export(init_exports, {
 });
 import * as p from "@clack/prompts";
 import { existsSync } from "fs";
-import { basename, join as join4, relative } from "path";
+import { basename, join as join5, relative } from "path";
 import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
 function detectIncludePatterns(cwd) {
   const patterns = [];
-  if (existsSync(join4(cwd, "app")))
+  if (existsSync(join5(cwd, "app")))
     patterns.push("app/**/*.tsx", "app/**/*.jsx");
-  if (existsSync(join4(cwd, "src")))
+  if (existsSync(join5(cwd, "src")))
     patterns.push("src/**/*.tsx", "src/**/*.jsx");
-  if (existsSync(join4(cwd, "pages")))
+  if (existsSync(join5(cwd, "pages")))
     patterns.push("pages/**/*.tsx", "pages/**/*.jsx");
-  if (existsSync(join4(cwd, "src", "app"))) {
+  if (existsSync(join5(cwd, "src", "app"))) {
     return patterns.filter((p2) => !p2.startsWith("app/"));
   }
   return patterns.length > 0 ? patterns : ["**/*.tsx", "**/*.jsx"];
@@ -2447,10 +2861,10 @@ function findPackageInNodeModules(cwd, pkg) {
   let dir = cwd;
   const parts = pkg.split("/");
   while (true) {
-    if (existsSync(join4(dir, "node_modules", ...parts, "package.json"))) {
+    if (existsSync(join5(dir, "node_modules", ...parts, "package.json"))) {
       return true;
     }
-    const parent = join4(dir, "..");
+    const parent = join5(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -2530,22 +2944,22 @@ async function safeWriteModifiedFile(filePath, modified, label) {
   return true;
 }
 function detectSrcDir(cwd) {
-  return existsSync(join4(cwd, "src", "app"));
+  return existsSync(join5(cwd, "src", "app"));
 }
 function resolveComponentPath(cwd, componentPath) {
   if (componentPath.startsWith("@/")) {
     const rel = componentPath.slice(2);
-    const useSrc = existsSync(join4(cwd, "src"));
-    return join4(cwd, useSrc ? "src" : "", rel);
+    const useSrc = existsSync(join5(cwd, "src"));
+    return join5(cwd, useSrc ? "src" : "", rel);
   }
   if (componentPath.startsWith("~/")) {
-    return join4(cwd, componentPath.slice(2));
+    return join5(cwd, componentPath.slice(2));
   }
-  return join4(cwd, componentPath);
+  return join5(cwd, componentPath);
 }
 function findLayoutFile(base) {
   for (const ext of ["tsx", "jsx", "ts", "js"]) {
-    const candidate = join4(base, "app", `layout.${ext}`);
+    const candidate = join5(base, "app", `layout.${ext}`);
     if (existsSync(candidate)) return candidate;
   }
   return void 0;
@@ -2553,7 +2967,7 @@ function findLayoutFile(base) {
 async function createEmptyMessageFiles(msgDir, locales) {
   await mkdir3(msgDir, { recursive: true });
   for (const locale of locales) {
-    const msgFile = join4(msgDir, `${locale}.json`);
+    const msgFile = join5(msgDir, `${locale}.json`);
     if (!existsSync(msgFile)) {
       await writeFile4(msgFile, "{}\n", "utf-8");
     }
@@ -2573,14 +2987,14 @@ function ensureAsyncLayout(content) {
 }
 async function setupNextIntl(cwd, sourceLocale, targetLocales, messagesDir) {
   const useSrc = detectSrcDir(cwd);
-  const base = useSrc ? join4(cwd, "src") : cwd;
+  const base = useSrc ? join5(cwd, "src") : cwd;
   const allLocales = [sourceLocale, ...targetLocales];
   const filesCreated = [];
-  const i18nDir = join4(base, "i18n");
+  const i18nDir = join5(base, "i18n");
   await mkdir3(i18nDir, { recursive: true });
-  const requestFile = join4(i18nDir, "request.ts");
+  const requestFile = join5(i18nDir, "request.ts");
   if (!existsSync(requestFile)) {
-    const relMessages = relative(i18nDir, join4(cwd, messagesDir));
+    const relMessages = relative(i18nDir, join5(cwd, messagesDir));
     const allLocalesStr = allLocales.map((l) => `"${l}"`).join(", ");
     await writeFile4(
       requestFile,
@@ -2621,7 +3035,7 @@ export default getRequestConfig(async () => {
     );
     filesCreated.push(relative(cwd, requestFile));
   }
-  const nextConfigPath = join4(cwd, "next.config.ts");
+  const nextConfigPath = join5(cwd, "next.config.ts");
   if (existsSync(nextConfigPath)) {
     const content = await readFile5(nextConfigPath, "utf-8");
     if (!content.includes("next-intl")) {
@@ -2671,31 +3085,31 @@ export default getRequestConfig(async () => {
       }
     }
   }
-  await createEmptyMessageFiles(join4(cwd, messagesDir), allLocales);
+  await createEmptyMessageFiles(join5(cwd, messagesDir), allLocales);
   if (filesCreated.length > 0) {
     p.log.success(`next-intl configured: ${filesCreated.join(", ")}`);
   }
 }
-async function dropInlineComponents(cwd, componentPath) {
+async function dropInlineComponents(cwd, componentPath, localeOpts) {
   const fsPath = resolveComponentPath(cwd, componentPath);
-  const dir = join4(fsPath, "..");
+  const dir = join5(fsPath, "..");
   await mkdir3(dir, { recursive: true });
   const clientFile = `${fsPath}.tsx`;
   const serverFile = `${fsPath}-server.tsx`;
   const clientBasename = basename(fsPath);
   await writeFile4(clientFile, CLIENT_TEMPLATE, "utf-8");
-  await writeFile4(serverFile, serverTemplate(clientBasename), "utf-8");
+  await writeFile4(serverFile, serverTemplate(clientBasename, localeOpts), "utf-8");
   const relClient = relative(cwd, clientFile);
   const relServer = relative(cwd, serverFile);
   p.log.success(`Created inline components: ${relClient}, ${relServer}`);
 }
 async function setupInlineI18n(cwd, componentPath, sourceLocale, targetLocales, messagesDir) {
-  const useSrc = existsSync(join4(cwd, "src"));
-  const base = useSrc ? join4(cwd, "src") : cwd;
+  const useSrc = existsSync(join5(cwd, "src"));
+  const base = useSrc ? join5(cwd, "src") : cwd;
   const filesCreated = [];
-  const i18nDir = join4(base, "i18n");
+  const i18nDir = join5(base, "i18n");
   await mkdir3(i18nDir, { recursive: true });
-  const helperFile = join4(i18nDir, "index.ts");
+  const helperFile = join5(i18nDir, "index.ts");
   if (!existsSync(helperFile)) {
     const helperContent = generateI18nHelper({
       sourceLocale,
@@ -2710,18 +3124,18 @@ async function setupInlineI18n(cwd, componentPath, sourceLocale, targetLocales,
     let layoutContent = await readFile5(layoutPath, "utf-8");
     if (!layoutContent.includes("I18nProvider")) {
       const importLines = `import { I18nProvider } from "${componentPath}";
-import { setServerMessages } from "${componentPath}-server";
+import { setServerMessages, setLocale } from "${componentPath}-server";
 import { getLocale, getMessages } from "@/i18n";
 `;
       layoutContent = insertImportsAfterLast(layoutContent, importLines);
       layoutContent = ensureAsyncLayout(layoutContent);
       layoutContent = layoutContent.replace(
         /return\s*\(/,
-        "const locale = await getLocale();\n	const messages = await getMessages(locale);\n	setServerMessages(messages);\n\n	return ("
+        "const locale = await getLocale();\n	setLocale(locale);\n	const messages = await getMessages(locale);\n	setServerMessages(messages);\n\n	return ("
       );
       layoutContent = layoutContent.replace(
         /(<body[^>]*>)/,
-        "$1\n				<I18nProvider messages={messages}>"
+        "$1\n				<I18nProvider messages={messages} locale={locale}>"
       );
       layoutContent = layoutContent.replace(
         /<\/body>/,
@@ -2736,7 +3150,7 @@ import { getLocale, getMessages } from "@/i18n";
       }
     }
   }
-  await createEmptyMessageFiles(join4(cwd, messagesDir), [
+  await createEmptyMessageFiles(join5(cwd, messagesDir), [
     sourceLocale,
     ...targetLocales
   ]);
@@ -2746,7 +3160,7 @@ import { getLocale, getMessages } from "@/i18n";
 }
 async function runInitWizard() {
   const cwd = process.cwd();
-  const configPath = join4(cwd, "translate-kit.config.ts");
+  const configPath = join5(cwd, "translate-kit.config.ts");
   p.intro("translate-kit setup");
   if (existsSync(configPath)) {
     const overwrite = await p.confirm({
@@ -2792,7 +3206,7 @@ async function runInitWizard() {
   const sourceLocale = await p.text({
     message: "Source locale:",
     initialValue: "en",
-    validate(value) {
+    validate(value = "") {
       if (!validateLocale(value)) {
         return "Invalid locale. Use only letters, numbers, hyphens, and underscores.";
       }
@@ -2877,7 +3291,11 @@ async function runInitWizard() {
   await writeFile4(configPath, configContent, "utf-8");
   p.log.success("Created translate-kit.config.ts");
   if (mode === "inline" && componentPath) {
-    await dropInlineComponents(cwd, componentPath);
+    await dropInlineComponents(cwd, componentPath, {
+      sourceLocale,
+      targetLocales,
+      messagesDir
+    });
     await setupInlineI18n(
       cwd,
       componentPath,
@@ -3023,7 +3441,7 @@ init_usage();
 init_cli_utils();
 import "dotenv/config";
 import { defineCommand, runMain } from "citty";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var translateCommand = defineCommand({
   meta: {
     name: "translate",
@@ -3075,13 +3493,13 @@ var translateCommand = defineCommand({
           sourceFlat2[key] = text2;
         }
       } else {
-        const sourceFile = join5(messagesDir, `${sourceLocale}.json`);
+        const sourceFile = join6(messagesDir, `${sourceLocale}.json`);
         const sourceRaw = await loadJsonFile(sourceFile);
         sourceFlat2 = flatten(sourceRaw);
       }
       if (Object.keys(sourceFlat2).length === 0) {
         logError(
-          mode === "inline" ? `No keys found in .translate-map.json. Run 'translate-kit scan' first.` : `No keys found in ${join5(messagesDir, `${sourceLocale}.json`)}`
+          mode === "inline" ? `No keys found in .translate-map.json. Run 'translate-kit scan' first.` : `No keys found in ${join6(messagesDir, `${sourceLocale}.json`)}`
         );
         process.exit(1);
       }
@@ -3106,13 +3524,13 @@ var translateCommand = defineCommand({
         sourceFlat[key] = text2;
       }
     } else {
-      const sourceFile = join5(messagesDir, `${sourceLocale}.json`);
+      const sourceFile = join6(messagesDir, `${sourceLocale}.json`);
       const sourceRaw = await loadJsonFile(sourceFile);
       sourceFlat = flatten(sourceRaw);
     }
     if (Object.keys(sourceFlat).length === 0) {
       logError(
-        mode === "inline" ? `No keys found in .translate-map.json. Run 'translate-kit scan' first.` : `No keys found in ${join5(messagesDir, `${sourceLocale}.json`)}`
+        mode === "inline" ? `No keys found in .translate-map.json. Run 'translate-kit scan' first.` : `No keys found in ${join6(messagesDir, `${sourceLocale}.json`)}`
       );
       process.exit(1);
     }
@@ -3215,7 +3633,7 @@ var scanCommand = defineCommand({
         "Inline mode: source text stays in code, no source locale JSON created."
       );
     } else {
-      const sourceFile = join5(
+      const sourceFile = join6(
         config.messagesDir,
         `${config.sourceLocale}.json`
       );