translate-kit 0.1.0 → 0.3.0

package/dist/cli.js

@@ -48,12 +48,12 @@ var init_config = __esm({
         glossary: z.record(z.string()).optional(),
         tone: z.string().optional(),
         retries: z.number().int().min(0).default(2),
-        concurrency: z.number().int().positive().default(3)
+        concurrency: z.number().int().positive().default(3),
+        validatePlaceholders: z.boolean().default(true).optional()
       }).optional(),
       scan: z.object({
         include: z.array(z.string()),
         exclude: z.array(z.string()).optional(),
-        keyStrategy: z.enum(["hash", "path"]).default("hash"),
         translatableProps: z.array(z.string()).default(["placeholder", "title", "alt", "aria-label"]),
         i18nImport: z.string().default("next-intl")
       }).optional(),
@@ -166,151 +166,6 @@ function computeDiff(sourceFlat, targetFlat, lockData) {
 var init_diff = __esm({
   "src/diff.ts"() {
     "use strict";
-    init_flatten();
-  }
-});
-
-// src/translate.ts
-import { generateObject } from "ai";
-import { z as z2 } from "zod";
-import pLimit from "p-limit";
-function buildPrompt(entries, sourceLocale, targetLocale, options) {
-  const lines = [
-    `Translate the following strings from "${sourceLocale}" to "${targetLocale}".`,
-    "",
-    "Rules:",
-    "- Preserve all placeholders like {name}, {{count}}, %s, %d exactly as-is",
-    "- Preserve HTML tags and markdown formatting",
-    "- Do NOT translate proper nouns, brand names, or technical identifiers",
-    "- Maintain the same level of formality and register",
-    "- Return natural, fluent translations (not word-for-word)"
-  ];
-  if (options?.tone) {
-    lines.push(`- Use a ${options.tone} tone`);
-  }
-  if (options?.context) {
-    lines.push(`
-Context: ${options.context}`);
-  }
-  if (options?.glossary && Object.keys(options.glossary).length > 0) {
-    lines.push("\nGlossary (use these exact translations):");
-    for (const [term, translation] of Object.entries(options.glossary)) {
-      lines.push(`  "${term}" \u2192 "${translation}"`);
-    }
-  }
-  lines.push("\nStrings to translate:");
-  for (const [key, value] of Object.entries(entries)) {
-    lines.push(`  "${key}": "${value}"`);
-  }
-  return lines.join("\n");
-}
-function buildSchema(keys) {
-  const shape = {};
-  for (const key of keys) {
-    shape[key] = z2.string();
-  }
-  return z2.object(shape);
-}
-async function translateBatchWithRetry(input, retries) {
-  const { model, entries, sourceLocale, targetLocale, options } = input;
-  const keys = Object.keys(entries);
-  const prompt = buildPrompt(entries, sourceLocale, targetLocale, options);
-  const schema = buildSchema(keys);
-  let lastError;
-  for (let attempt = 0; attempt <= retries; attempt++) {
-    try {
-      const { object } = await generateObject({
-        model,
-        prompt,
-        schema
-      });
-      return object;
-    } catch (error) {
-      lastError = error;
-      if (attempt < retries) {
-        const delay = Math.min(Math.pow(2, attempt) * 1e3, 3e4);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-  }
-  throw lastError;
-}
-async function translateAll(input) {
-  const {
-    model,
-    entries,
-    sourceLocale,
-    targetLocale,
-    options,
-    onBatchComplete
-  } = input;
-  const keys = Object.keys(entries);
-  if (keys.length === 0) return {};
-  const batchSize = options?.batchSize ?? 50;
-  const concurrency = options?.concurrency ?? 3;
-  const retries = options?.retries ?? 2;
-  const limit = pLimit(concurrency);
-  const batches = [];
-  for (let i = 0; i < keys.length; i += batchSize) {
-    const batchKeys = keys.slice(i, i + batchSize);
-    const batch = {};
-    for (const key of batchKeys) {
-      batch[key] = entries[key];
-    }
-    batches.push(batch);
-  }
-  const results = {};
-  await Promise.all(
-    batches.map(
-      (batch) => limit(async () => {
-        const translated = await translateBatchWithRetry(
-          { model, entries: batch, sourceLocale, targetLocale, options },
-          retries
-        );
-        Object.assign(results, translated);
-        onBatchComplete?.(translated);
-      })
-    )
-  );
-  return results;
-}
-var init_translate = __esm({
-  "src/translate.ts"() {
-    "use strict";
-  }
-});
-
-// src/writer.ts
-import { writeFile, mkdir } from "fs/promises";
-import { join as join2, dirname } from "path";
-async function writeTranslation(filePath, flatEntries, options) {
-  await mkdir(dirname(filePath), { recursive: true });
-  const data = options?.flat ? flatEntries : unflatten(flatEntries);
-  const content = JSON.stringify(data, null, 2) + "\n";
-  await writeFile(filePath, content, "utf-8");
-}
-async function writeLockFile(messagesDir, sourceFlat, existingLock, translatedKeys) {
-  const lock = { ...existingLock };
-  for (const key of translatedKeys) {
-    if (key in sourceFlat) {
-      lock[key] = hashValue(sourceFlat[key]);
-    }
-  }
-  for (const key of Object.keys(lock)) {
-    if (!(key in sourceFlat)) {
-      delete lock[key];
-    }
-  }
-  const lockPath = join2(messagesDir, ".translate-lock.json");
-  await mkdir(dirname(lockPath), { recursive: true });
-  const content = JSON.stringify(lock, null, 2) + "\n";
-  await writeFile(lockPath, content, "utf-8");
-}
-var init_writer = __esm({
-  "src/writer.ts"() {
-    "use strict";
-    init_flatten();
-    init_diff();
   }
 });
 
@@ -408,8 +263,8 @@ var init_filters = __esm({
       // CONSTANT_CASE
       /^[\d.,%$€£¥]+$/,
       // Numbers, currency
-      /^[^a-zA-Z]*$/
-      // No letters at all
+      /^[^\p{L}]*$/u
+      // No letters at all (Unicode-aware)
     ];
     CONTENT_PROPERTY_NAMES = [
       "title",
@@ -487,8 +342,92 @@ var init_ast_helpers = __esm({
   }
 });
 
+// src/utils/template-literal.ts
+import * as t from "@babel/types";
+function memberExpressionToName(node) {
+  if (node.type === "Identifier") return node.name;
+  if (node.type === "MemberExpression" && !node.computed && node.property.type === "Identifier") {
+    const objectName = memberExpressionToName(node.object);
+    if (!objectName) return null;
+    const prop = node.property.name;
+    return objectName + prop.charAt(0).toUpperCase() + prop.slice(1);
+  }
+  return null;
+}
+function buildTemplateLiteralText(quasis, expressions) {
+  const placeholders = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  let text2 = "";
+  for (let i = 0; i < quasis.length; i++) {
+    text2 += quasis[i].value.cooked ?? quasis[i].value.raw;
+    if (i < expressions.length) {
+      const expr = expressions[i];
+      let name = null;
+      if (expr.type === "Identifier") {
+        name = expr.name;
+      } else if (expr.type === "MemberExpression") {
+        name = memberExpressionToName(expr);
+      }
+      if (name === null) return null;
+      let finalName = name;
+      if (usedNames.has(finalName)) {
+        let suffix = 2;
+        while (usedNames.has(`${name}${suffix}`)) suffix++;
+        finalName = `${name}${suffix}`;
+      }
+      usedNames.add(finalName);
+      placeholders.push(finalName);
+      text2 += `{${finalName}}`;
+    }
+  }
+  return { text: text2, placeholders };
+}
+function buildValuesObject(expressions, placeholders) {
+  const properties = placeholders.map((name, i) => {
+    const expr = expressions[i];
+    const isShorthand = expr.type === "Identifier" && expr.name === name;
+    return t.objectProperty(
+      t.identifier(name),
+      t.cloneNode(expr),
+      false,
+      isShorthand
+    );
+  });
+  return t.objectExpression(properties);
+}
+var init_template_literal = __esm({
+  "src/utils/template-literal.ts"() {
+    "use strict";
+  }
+});
+
 // src/scanner/extractor.ts
 import _traverse from "@babel/traverse";
+function extractTextFromNode(node) {
+  if (node.type === "StringLiteral") {
+    const trimmed = node.value.trim();
+    return trimmed || null;
+  }
+  if (node.type === "TemplateLiteral") {
+    const info = buildTemplateLiteralText(node.quasis, node.expressions);
+    return info ? info.text : null;
+  }
+  return null;
+}
+function collectConditionalTexts(node) {
+  const texts = [];
+  for (const branch of [node.consequent, node.alternate]) {
+    if (branch.type === "ConditionalExpression") {
+      texts.push(...collectConditionalTexts(branch));
+    } else {
+      const text2 = extractTextFromNode(branch);
+      if (text2 && !shouldIgnore(text2)) {
+        texts.push(text2);
+      }
+    }
+  }
+  return texts;
+}
 function extractStrings(ast, filePath, translatableProps) {
   const results = [];
   traverse(ast, {
@@ -517,8 +456,33 @@ function extractStrings(ast, filePath, translatableProps) {
       let text2;
       if (value.type === "StringLiteral") {
         text2 = value.value;
-      } else if (value.type === "JSXExpressionContainer" && value.expression.type === "StringLiteral") {
-        text2 = value.expression.value;
+      } else if (value.type === "JSXExpressionContainer") {
+        if (value.expression.type === "StringLiteral") {
+          text2 = value.expression.value;
+        } else if (value.expression.type === "TemplateLiteral") {
+          const info = buildTemplateLiteralText(
+            value.expression.quasis,
+            value.expression.expressions
+          );
+          if (info) text2 = info.text;
+        } else if (value.expression.type === "ConditionalExpression") {
+          const parentTag2 = getParentTagName(path);
+          if (parentTag2 && isIgnoredTag(parentTag2)) return;
+          const texts = collectConditionalTexts(value.expression);
+          for (const t3 of texts) {
+            results.push({
+              text: t3,
+              type: "jsx-attribute",
+              file: filePath,
+              line: path.node.loc?.start.line ?? 0,
+              column: path.node.loc?.start.column ?? 0,
+              componentName: getComponentName(path),
+              propName,
+              parentTag: parentTag2
+            });
+          }
+          return;
+        }
       }
       if (!text2 || shouldIgnore(text2)) return;
       const parentTag = getParentTagName(path);
@@ -535,11 +499,33 @@ function extractStrings(ast, filePath, translatableProps) {
       });
     },
     JSXExpressionContainer(path) {
-      const expr = path.node.expression;
-      if (expr.type !== "StringLiteral") return;
-      const text2 = expr.value.trim();
-      if (shouldIgnore(text2)) return;
       if (path.parent.type === "JSXAttribute") return;
+      const expr = path.node.expression;
+      if (expr.type === "ConditionalExpression") {
+        const parentTag2 = getParentTagName(path);
+        if (parentTag2 && isIgnoredTag(parentTag2)) return;
+        const texts = collectConditionalTexts(expr);
+        for (const t3 of texts) {
+          results.push({
+            text: t3,
+            type: "jsx-expression",
+            file: filePath,
+            line: path.node.loc?.start.line ?? 0,
+            column: path.node.loc?.start.column ?? 0,
+            componentName: getComponentName(path),
+            parentTag: parentTag2
+          });
+        }
+        return;
+      }
+      let text2;
+      if (expr.type === "StringLiteral") {
+        text2 = expr.value.trim();
+      } else if (expr.type === "TemplateLiteral") {
+        const info = buildTemplateLiteralText(expr.quasis, expr.expressions);
+        if (info) text2 = info.text;
+      }
+      if (!text2 || shouldIgnore(text2)) return;
       const parentTag = getParentTagName(path);
       if (parentTag && isIgnoredTag(parentTag)) return;
       results.push({
@@ -560,9 +546,32 @@ function extractStrings(ast, filePath, translatableProps) {
       const propName = keyNode.type === "Identifier" ? keyNode.name : keyNode.value;
       if (!isContentProperty(propName)) return;
       const valueNode = path.node.value;
-      if (valueNode.type !== "StringLiteral") return;
-      const text2 = valueNode.value.trim();
-      if (shouldIgnore(text2)) return;
+      if (valueNode.type === "ConditionalExpression") {
+        const texts = collectConditionalTexts(valueNode);
+        for (const t3 of texts) {
+          results.push({
+            text: t3,
+            type: "object-property",
+            file: filePath,
+            line: valueNode.loc?.start.line ?? 0,
+            column: valueNode.loc?.start.column ?? 0,
+            componentName: getComponentName(path),
+            propName
+          });
+        }
+        return;
+      }
+      let text2;
+      if (valueNode.type === "StringLiteral") {
+        text2 = valueNode.value.trim();
+      } else if (valueNode.type === "TemplateLiteral") {
+        const info = buildTemplateLiteralText(
+          valueNode.quasis,
+          valueNode.expressions
+        );
+        if (info) text2 = info.text;
+      }
+      if (!text2 || shouldIgnore(text2)) return;
       results.push({
         text: text2,
         type: "object-property",
@@ -641,33 +650,48 @@ var init_extractor = __esm({
     "use strict";
     init_filters();
     init_ast_helpers();
+    init_template_literal();
     traverse = resolveDefault(_traverse);
   }
 });
 
-// src/scanner/key-generator.ts
-import { createHash as createHash2 } from "crypto";
-function slugify(text2) {
-  return text2.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "").slice(0, 32);
+// src/scanner/context-enricher.ts
+function deriveRoutePath(filePath) {
+  const appMatch = filePath.match(/src\/app\/(.+?)\/page\.[jt]sx?$/);
+  if (appMatch) return appMatch[1].replace(/\//g, ".");
+  const pagesMatch = filePath.match(/(?:src\/)?pages\/(.+?)\.[jt]sx?$/);
+  if (pagesMatch) {
+    const route = pagesMatch[1].replace(/\/index$/, "").replace(/\//g, ".");
+    return route || void 0;
+  }
+  const compMatch = filePath.match(/src\/components\/(.+?)\//);
+  if (compMatch) return compMatch[1];
+  return void 0;
 }
-function generateKey(extracted, strategy) {
-  if (strategy === "hash") {
-    const hash = createHash2("sha256").update(extracted.text).digest("hex").slice(0, 12);
-    return hash;
-  }
-  const parts = [];
-  if (extracted.componentName) {
-    parts.push(extracted.componentName);
-  }
-  if (extracted.parentTag) {
-    parts.push(extracted.parentTag);
-  }
-  const slug = slugify(extracted.text);
-  parts.push(slug);
-  return parts.join(".");
+function enrichStrings(strings, filePath) {
+  const routePath = deriveRoutePath(filePath);
+  const byComponent = /* @__PURE__ */ new Map();
+  for (const str of strings) {
+    const key = str.componentName ?? "__root__";
+    if (!byComponent.has(key)) byComponent.set(key, []);
+    byComponent.get(key).push(str);
+  }
+  const headings = strings.filter((s) => s.parentTag && /^h[1-3]$/.test(s.parentTag));
+  const defaultHeading = headings.length > 0 ? headings[0].text : void 0;
+  return strings.map((str) => {
+    const enriched = { ...str };
+    if (routePath) enriched.routePath = routePath;
+    const siblings = byComponent.get(str.componentName ?? "__root__") ?? [];
+    const siblingTexts = siblings.filter((s) => s !== str).slice(0, 5).map((s) => s.text);
+    if (siblingTexts.length > 0) enriched.siblingTexts = siblingTexts;
+    if (defaultHeading && str.text !== defaultHeading) {
+      enriched.sectionHeading = defaultHeading;
+    }
+    return enriched;
+  });
 }
-var init_key_generator = __esm({
-  "src/scanner/key-generator.ts"() {
+var init_context_enricher = __esm({
+  "src/scanner/context-enricher.ts"() {
     "use strict";
   }
 });
@@ -741,6 +765,22 @@ function logVerbose(message, verbose) {
     console.log(pc.dim(`  ${message}`));
   }
 }
+function logUsage(tokens, cost) {
+  console.log(`
+  ${pc.dim("Tokens:")} ${tokens}`);
+  if (cost) console.log(`  ${pc.dim("Est. cost:")} ${cost}`);
+}
+function logProgress(current, total, label) {
+  if (!process.stdout.isTTY) return;
+  const pct = total > 0 ? Math.round(current / total * 100) : 0;
+  process.stdout.write(
+    `\r  ${pc.dim(label)} ${pc.bold(`${current}`)}${pc.dim(`/${total}`)} ${pc.dim(`(${pct}%)`)}`
+  );
+}
+function logProgressClear() {
+  if (!process.stdout.isTTY) return;
+  process.stdout.write("\r" + " ".repeat(60) + "\r");
+}
 var init_logger = __esm({
   "src/logger.ts"() {
     "use strict";
@@ -750,39 +790,46 @@ var init_logger = __esm({
 // src/scanner/index.ts
 import { readFile as readFile2 } from "fs/promises";
 import { glob } from "tinyglobby";
-async function scan(options, cwd = process.cwd()) {
+import pLimit from "p-limit";
+async function scan(options, cwd = process.cwd(), callbacks) {
   const files = await glob(options.include, {
     ignore: options.exclude ?? [],
     cwd,
     absolute: true
   });
   const allStrings = [];
-  const messages = {};
-  const keyStrategy = options.keyStrategy ?? "hash";
-  for (const filePath of files) {
-    const code = await readFile2(filePath, "utf-8");
-    let ast;
-    try {
-      ast = parseFile(code, filePath);
-    } catch (err) {
-      logVerbose(
-        `Skipping unparseable file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
-        true
-      );
-      continue;
-    }
-    const strings = extractStrings(ast, filePath, options.translatableProps);
-    for (const str of strings) {
-      const key = generateKey(str, keyStrategy);
-      if (!(key in messages)) {
-        messages[key] = str.text;
-      }
-      allStrings.push(str);
-    }
+  const limit = pLimit(10);
+  let completed = 0;
+  const fileResults = await Promise.all(
+    files.map(
+      (filePath) => limit(async () => {
+        const code = await readFile2(filePath, "utf-8");
+        let ast;
+        try {
+          ast = parseFile(code, filePath);
+        } catch (err) {
+          logVerbose(
+            `Skipping unparseable file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
+            false
+          );
+          completed++;
+          callbacks?.onProgress?.(completed, files.length);
+          return null;
+        }
+        const raw = extractStrings(ast, filePath, options.translatableProps);
+        const strings = enrichStrings(raw, filePath);
+        completed++;
+        callbacks?.onProgress?.(completed, files.length);
+        return { strings, filePath };
+      })
+    )
+  );
+  for (const result of fileResults) {
+    if (!result) continue;
+    allStrings.push(...result.strings);
   }
   return {
     strings: allStrings,
-    messages,
     fileCount: files.length
   };
 }
@@ -791,16 +838,16 @@ var init_scanner = __esm({
     "use strict";
     init_parser();
     init_extractor();
-    init_key_generator();
+    init_context_enricher();
     init_logger();
   }
 });
 
 // src/scanner/key-ai.ts
-import { generateObject as generateObject2 } from "ai";
-import { z as z3 } from "zod";
+import { generateObject } from "ai";
+import { z as z2 } from "zod";
 import pLimit2 from "p-limit";
-function buildPrompt2(strings) {
+function buildPrompt(strings) {
   const lines = [
     "Generate semantic i18n keys for these UI strings.",
     "",
@@ -825,41 +872,49 @@ function buildPrompt2(strings) {
     if (str.parentTag) parts.push(`tag: ${str.parentTag}`);
     if (str.propName) parts.push(`prop: ${str.propName}`);
     if (str.file) parts.push(`file: ${str.file}`);
+    if (str.routePath) parts.push(`route: ${str.routePath}`);
+    if (str.sectionHeading) parts.push(`section: "${str.sectionHeading}"`);
+    if (str.siblingTexts?.length) {
+      parts.push(`siblings: [${str.siblingTexts.slice(0, 3).map((t3) => `"${t3}"`).join(", ")}]`);
+    }
     lines.push(`  ${parts.join(", ")}`);
   }
   return lines.join("\n");
 }
 async function generateKeysBatchWithRetry(model, strings, retries) {
-  const prompt = buildPrompt2(strings);
+  const prompt = buildPrompt(strings);
   const texts = strings.map((s) => s.text);
-  const schema = z3.object({
-    mappings: z3.array(
-      z3.object({
-        index: z3.number().describe("Zero-based index of the string"),
-        key: z3.string().describe("Semantic i18n key")
+  const schema = z2.object({
+    mappings: z2.array(
+      z2.object({
+        index: z2.number().describe("Zero-based index of the string"),
+        key: z2.string().describe("Semantic i18n key")
       })
     )
   });
   let lastError;
+  let totalUsage = { inputTokens: 0, outputTokens: 0 };
   for (let attempt = 0; attempt <= retries; attempt++) {
     try {
-      const { object } = await generateObject2({
+      const { object, usage } = await generateObject({
         model,
         prompt,
         schema
       });
+      totalUsage.inputTokens += usage.inputTokens ?? 0;
+      totalUsage.outputTokens += usage.outputTokens ?? 0;
       const result = {};
       for (const mapping of object.mappings) {
         if (mapping.index >= 0 && mapping.index < texts.length) {
           result[texts[mapping.index]] = mapping.key;
         }
       }
-      return result;
+      return { keys: result, usage: totalUsage };
     } catch (error) {
       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));
       }
     }
   }
@@ -885,12 +940,22 @@ async function generateSemanticKeys(input) {
     model,
     strings,
     existingMap = {},
+    allTexts,
     batchSize = 50,
     concurrency = 3,
-    retries = 2
+    retries = 2,
+    onProgress,
+    onUsage
   } = input;
-  const newStrings = strings.filter((s) => !(s.text in existingMap));
-  if (newStrings.length === 0) return { ...existingMap };
+  const activeTexts = allTexts ?? new Set(strings.map((s) => s.text));
+  const activeExisting = {};
+  for (const [text2, key] of Object.entries(existingMap)) {
+    if (activeTexts.has(text2)) {
+      activeExisting[text2] = key;
+    }
+  }
+  const newStrings = strings.filter((s) => !(s.text in activeExisting));
+  if (newStrings.length === 0) return activeExisting;
   const uniqueMap = /* @__PURE__ */ new Map();
   for (const str of newStrings) {
     if (!uniqueMap.has(str.text)) {
@@ -904,16 +969,26 @@ async function generateSemanticKeys(input) {
     batches.push(uniqueStrings.slice(i, i + batchSize));
   }
   const allNewKeys = {};
+  let completedStrings = 0;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
   await Promise.all(
     batches.map(
       (batch) => limit(async () => {
-        const keys = await generateKeysBatchWithRetry(model, batch, retries);
+        const { keys, usage } = await generateKeysBatchWithRetry(model, batch, retries);
         Object.assign(allNewKeys, keys);
+        totalInputTokens += usage.inputTokens;
+        totalOutputTokens += usage.outputTokens;
+        completedStrings += batch.length;
+        onProgress?.(completedStrings, uniqueStrings.length);
       })
     )
   );
-  const resolved = resolveCollisions(allNewKeys, existingMap);
-  return { ...existingMap, ...resolved };
+  if (totalInputTokens > 0 || totalOutputTokens > 0) {
+    onUsage?.({ inputTokens: totalInputTokens, outputTokens: totalOutputTokens });
+  }
+  const resolved = resolveCollisions(allNewKeys, activeExisting);
+  return { ...activeExisting, ...resolved };
 }
 var init_key_ai = __esm({
   "src/scanner/key-ai.ts"() {
@@ -924,7 +999,14 @@ var init_key_ai = __esm({
 // src/codegen/transform.ts
 import _traverse2 from "@babel/traverse";
 import _generate from "@babel/generator";
-import * as t from "@babel/types";
+import * as t2 from "@babel/types";
+function hasSubstantialSiblings(parent) {
+  const count = parent.node.children.filter((child) => {
+    if (child.type === "JSXText") return child.value.trim().length > 0;
+    return true;
+  }).length;
+  return count > 1;
+}
 function findLastImportIndex(ast) {
   let idx = -1;
   for (let i = 0; i < ast.program.body.length; i++) {
@@ -946,25 +1028,123 @@ function hasUseTranslationsImport(ast, importSource) {
   }
   return false;
 }
-function hasUseTranslationsCall(ast) {
-  let found = false;
-  traverse2(ast, {
-    VariableDeclarator(path) {
-      const init = path.node.init;
-      if (init?.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === "useTranslations") {
-        found = true;
-        path.stop();
+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;
+        }
       }
-    },
-    noScope: true
-  });
-  return found;
+    }
+  }
+  return false;
+}
+function transformConditionalBranch(node, textToKey) {
+  if (node.type === "ConditionalExpression") {
+    const cons = transformConditionalBranch(
+      node.consequent,
+      textToKey
+    );
+    const alt = transformConditionalBranch(
+      node.alternate,
+      textToKey
+    );
+    if (cons.count > 0 || alt.count > 0) {
+      return {
+        node: t2.conditionalExpression(node.test, cons.node, alt.node),
+        count: cons.count + alt.count
+      };
+    }
+    return { node, count: 0 };
+  }
+  if (node.type === "StringLiteral") {
+    const text2 = node.value.trim();
+    if (text2 && text2 in textToKey) {
+      const key = textToKey[text2];
+      return {
+        node: t2.callExpression(t2.identifier("t"), [t2.stringLiteral(key)]),
+        count: 1
+      };
+    }
+    return { node, count: 0 };
+  }
+  if (node.type === "TemplateLiteral") {
+    const info = buildTemplateLiteralText(node.quasis, node.expressions);
+    if (info && info.text in textToKey) {
+      const key = textToKey[info.text];
+      const args = [t2.stringLiteral(key)];
+      if (info.placeholders.length > 0) {
+        args.push(buildValuesObject(node.expressions, info.placeholders));
+      }
+      return {
+        node: t2.callExpression(t2.identifier("t"), args),
+        count: 1
+      };
+    }
+    return { node, count: 0 };
+  }
+  return { node, count: 0 };
+}
+function transformConditionalBranchInline(node, textToKey) {
+  if (node.type === "ConditionalExpression") {
+    const cons = transformConditionalBranchInline(
+      node.consequent,
+      textToKey
+    );
+    const alt = transformConditionalBranchInline(
+      node.alternate,
+      textToKey
+    );
+    if (cons.count > 0 || alt.count > 0) {
+      return {
+        node: t2.conditionalExpression(node.test, cons.node, alt.node),
+        count: cons.count + alt.count
+      };
+    }
+    return { node, count: 0 };
+  }
+  if (node.type === "StringLiteral") {
+    const text2 = node.value.trim();
+    if (text2 && text2 in textToKey) {
+      const key = textToKey[text2];
+      return {
+        node: t2.callExpression(t2.identifier("t"), [
+          t2.stringLiteral(text2),
+          t2.stringLiteral(key)
+        ]),
+        count: 1
+      };
+    }
+    return { node, count: 0 };
+  }
+  if (node.type === "TemplateLiteral") {
+    const info = buildTemplateLiteralText(node.quasis, node.expressions);
+    if (info && info.text in textToKey) {
+      const key = textToKey[info.text];
+      const args = [
+        t2.stringLiteral(info.text),
+        t2.stringLiteral(key)
+      ];
+      if (info.placeholders.length > 0) {
+        args.push(buildValuesObject(node.expressions, info.placeholders));
+      }
+      return {
+        node: t2.callExpression(t2.identifier("t"), args),
+        count: 1
+      };
+    }
+    return { node, count: 0 };
+  }
+  return { node, count: 0 };
 }
 function transform(ast, textToKey, options = {}) {
   if (options.mode === "inline") {
     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, {
@@ -974,14 +1154,10 @@ function transform(ast, textToKey, options = {}) {
       const parent = path.parentPath;
       if (!parent?.isJSXElement()) return;
       const key = textToKey[text2];
-      const tCall = t.jsxExpressionContainer(
-        t.callExpression(t.identifier("t"), [t.stringLiteral(key)])
+      const tCall = t2.jsxExpressionContainer(
+        t2.callExpression(t2.identifier("t"), [t2.stringLiteral(key)])
       );
-      const siblings = parent.node.children.filter((child) => {
-        if (child.type === "JSXText") return child.value.trim().length > 0;
-        return true;
-      });
-      if (siblings.length === 1) {
+      if (!hasSubstantialSiblings(parent)) {
         path.replaceWith(tCall);
       } else {
         const raw = path.node.value;
@@ -989,11 +1165,11 @@ function transform(ast, textToKey, options = {}) {
         const hasTrailing = raw !== raw.trimEnd();
         const nodes = [];
         if (hasLeading) {
-          nodes.push(t.jsxExpressionContainer(t.stringLiteral(" ")));
+          nodes.push(t2.jsxExpressionContainer(t2.stringLiteral(" ")));
         }
         nodes.push(tCall);
         if (hasTrailing) {
-          nodes.push(t.jsxExpressionContainer(t.stringLiteral(" ")));
+          nodes.push(t2.jsxExpressionContainer(t2.stringLiteral(" ")));
         }
         path.replaceWithMultiple(nodes);
       }
@@ -1001,68 +1177,162 @@ function transform(ast, textToKey, options = {}) {
       const compName = getComponentName(path);
       if (compName) componentsNeedingT.add(compName);
     },
-    JSXAttribute(path) {
-      const value = path.node.value;
-      if (!value) return;
-      let text2;
-      if (value.type === "StringLiteral") {
-        text2 = value.value;
-      } else if (value.type === "JSXExpressionContainer" && value.expression.type === "StringLiteral") {
-        text2 = value.expression.value;
-      }
-      if (!text2 || !(text2 in textToKey)) return;
-      if (value.type === "JSXExpressionContainer" && value.expression.type === "CallExpression" && value.expression.callee.type === "Identifier" && value.expression.callee.name === "t") {
+    JSXExpressionContainer(path) {
+      const expr = path.node.expression;
+      if (path.parent.type === "JSXAttribute") return;
+      if (expr.type === "ConditionalExpression") {
+        const result = transformConditionalBranch(expr, textToKey);
+        if (result.count > 0) {
+          path.node.expression = result.node;
+          stringsWrapped += result.count;
+          const compName2 = getComponentName(path);
+          if (compName2) componentsNeedingT.add(compName2);
+        }
         return;
       }
+      if (expr.type !== "TemplateLiteral") return;
+      const info = buildTemplateLiteralText(expr.quasis, expr.expressions);
+      if (!info) return;
+      const { text: text2, placeholders } = info;
+      if (!(text2 in textToKey)) return;
       const key = textToKey[text2];
-      path.node.value = t.jsxExpressionContainer(
-        t.callExpression(t.identifier("t"), [t.stringLiteral(key)])
-      );
+      const args = [t2.stringLiteral(key)];
+      if (placeholders.length > 0) {
+        args.push(buildValuesObject(expr.expressions, placeholders));
+      }
+      path.node.expression = t2.callExpression(t2.identifier("t"), args);
+      stringsWrapped++;
+      const compName = getComponentName(path);
+      if (compName) componentsNeedingT.add(compName);
+    },
+    JSXAttribute(path) {
+      const value = path.node.value;
+      if (!value) return;
+      if (value.type === "JSXExpressionContainer" && value.expression.type === "ConditionalExpression") {
+        const result = transformConditionalBranch(value.expression, textToKey);
+        if (result.count > 0) {
+          path.node.value = t2.jsxExpressionContainer(result.node);
+          stringsWrapped += result.count;
+          const compName2 = getComponentName(path);
+          if (compName2) componentsNeedingT.add(compName2);
+        }
+        return;
+      }
+      let text2;
+      let templateInfo;
+      if (value.type === "StringLiteral") {
+        text2 = value.value;
+      } else if (value.type === "JSXExpressionContainer") {
+        if (value.expression.type === "StringLiteral") {
+          text2 = value.expression.value;
+        } else if (value.expression.type === "TemplateLiteral") {
+          const info = buildTemplateLiteralText(
+            value.expression.quasis,
+            value.expression.expressions
+          );
+          if (info) {
+            text2 = info.text;
+            templateInfo = {
+              placeholders: info.placeholders,
+              expressions: value.expression.expressions
+            };
+          }
+        }
+      }
+      if (!text2 || !(text2 in textToKey)) return;
+      if (value.type === "JSXExpressionContainer" && value.expression.type === "CallExpression" && value.expression.callee.type === "Identifier" && value.expression.callee.name === "t") {
+        return;
+      }
+      const key = textToKey[text2];
+      const args = [t2.stringLiteral(key)];
+      if (templateInfo && templateInfo.placeholders.length > 0) {
+        args.push(
+          buildValuesObject(
+            templateInfo.expressions,
+            templateInfo.placeholders
+          )
+        );
+      }
+      path.node.value = t2.jsxExpressionContainer(
+        t2.callExpression(t2.identifier("t"), args)
+      );
       stringsWrapped++;
       const compName = getComponentName(path);
       if (compName) componentsNeedingT.add(compName);
     },
     ObjectProperty(path) {
       if (!isInsideFunction(path)) return;
+      const compName = getComponentName(path);
+      if (!compName) return;
       const keyNode = path.node.key;
       if (keyNode.type !== "Identifier" && keyNode.type !== "StringLiteral")
         return;
       const propName = keyNode.type === "Identifier" ? keyNode.name : keyNode.value;
       if (!isContentProperty(propName)) return;
       const valueNode = path.node.value;
-      if (valueNode.type !== "StringLiteral") return;
-      const text2 = valueNode.value;
+      if (valueNode.type === "ConditionalExpression") {
+        const result = transformConditionalBranch(valueNode, textToKey);
+        if (result.count > 0) {
+          path.node.value = result.node;
+          stringsWrapped += result.count;
+          componentsNeedingT.add(compName);
+        }
+        return;
+      }
+      let text2;
+      let templateInfo;
+      if (valueNode.type === "StringLiteral") {
+        text2 = valueNode.value;
+      } else if (valueNode.type === "TemplateLiteral") {
+        const info = buildTemplateLiteralText(
+          valueNode.quasis,
+          valueNode.expressions
+        );
+        if (info) {
+          text2 = info.text;
+          templateInfo = {
+            placeholders: info.placeholders,
+            expressions: valueNode.expressions
+          };
+        }
+      }
       if (!text2 || !(text2 in textToKey)) return;
       const key = textToKey[text2];
-      path.node.value = t.callExpression(t.identifier("t"), [
-        t.stringLiteral(key)
-      ]);
+      const args = [t2.stringLiteral(key)];
+      if (templateInfo && templateInfo.placeholders.length > 0) {
+        args.push(
+          buildValuesObject(
+            templateInfo.expressions,
+            templateInfo.placeholders
+          )
+        );
+      }
+      path.node.value = t2.callExpression(t2.identifier("t"), args);
       stringsWrapped++;
-      const compName = getComponentName(path);
-      if (compName) componentsNeedingT.add(compName);
+      componentsNeedingT.add(compName);
     }
   });
   if (stringsWrapped === 0) {
     return { code: generate(ast).code, stringsWrapped: 0, modified: false };
   }
-  if (!hasUseTranslationsImport(ast, importSource)) {
-    const importDecl = t.importDeclaration(
-      [
-        t.importSpecifier(
-          t.identifier("useTranslations"),
-          t.identifier("useTranslations")
-        )
-      ],
-      t.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);
+      }
     }
-  }
-  if (!hasUseTranslationsCall(ast)) {
     traverse2(ast, {
       FunctionDeclaration(path) {
         const name = path.node.id?.name;
@@ -1083,6 +1353,47 @@ function transform(ast, textToKey, options = {}) {
       },
       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);
+      }
+    }
+    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 };
@@ -1095,20 +1406,38 @@ 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;
+    }
+  }
+  const tDecl = t2.variableDeclaration("const", [
+    t2.variableDeclarator(
+      t2.identifier("t"),
+      t2.callExpression(t2.identifier("useTranslations"), [])
+    )
+  ]);
+  block.body.unshift(tDecl);
+}
+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 = t.variableDeclaration("const", [
-    t.variableDeclarator(
-      t.identifier("t"),
-      t.callExpression(t.identifier("useTranslations"), [])
+  const tDecl = t2.variableDeclaration("const", [
+    t2.variableDeclarator(
+      t2.identifier("t"),
+      t2.awaitExpression(
+        t2.callExpression(t2.identifier("getTranslations"), [])
+      )
     )
   ]);
   block.body.unshift(tDecl);
 }
-function isClientFile(ast) {
+function detectClientFile(ast) {
   if (ast.program.directives) {
     for (const directive of ast.program.directives) {
       if (directive.value?.value === "use client") {
@@ -1121,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;
@@ -1141,27 +1481,46 @@ function hasInlineImport(ast, componentPath) {
   }
   return { hasT, hasHook };
 }
-function hasInlineHookCall(ast, hookName) {
-  let found = false;
-  traverse2(ast, {
-    VariableDeclarator(path) {
-      const init = path.node.init;
-      if (init?.type === "CallExpression" && init.callee.type === "Identifier" && init.callee.name === hookName) {
-        found = true;
-        path.stop();
+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;
       }
-    },
-    noScope: true
-  });
-  return found;
+      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) {
@@ -1190,19 +1549,15 @@ function transformInline(ast, textToKey, options) {
       }
       const key = textToKey[text2];
       needsTComponent = true;
-      const tElement = t.jsxElement(
-        t.jsxOpeningElement(t.jsxIdentifier("T"), [
-          t.jsxAttribute(t.jsxIdentifier("id"), t.stringLiteral(key))
+      const tElement = t2.jsxElement(
+        t2.jsxOpeningElement(t2.jsxIdentifier("T"), [
+          t2.jsxAttribute(t2.jsxIdentifier("id"), t2.stringLiteral(key))
         ]),
-        t.jsxClosingElement(t.jsxIdentifier("T")),
-        [t.jsxText(text2)],
+        t2.jsxClosingElement(t2.jsxIdentifier("T")),
+        [t2.jsxText(text2)],
         false
       );
-      const siblings = parent.node.children.filter((child) => {
-        if (child.type === "JSXText") return child.value.trim().length > 0;
-        return true;
-      });
-      if (siblings.length === 1) {
+      if (!hasSubstantialSiblings(parent)) {
         path.replaceWith(tElement);
       } else {
         const raw = path.node.value;
@@ -1210,35 +1565,101 @@ function transformInline(ast, textToKey, options) {
         const hasTrailing = raw !== raw.trimEnd();
         const nodes = [];
         if (hasLeading) {
-          nodes.push(t.jsxExpressionContainer(t.stringLiteral(" ")));
+          nodes.push(t2.jsxExpressionContainer(t2.stringLiteral(" ")));
         }
         nodes.push(tElement);
         if (hasTrailing) {
-          nodes.push(t.jsxExpressionContainer(t.stringLiteral(" ")));
+          nodes.push(t2.jsxExpressionContainer(t2.stringLiteral(" ")));
         }
         path.replaceWithMultiple(nodes);
       }
       stringsWrapped++;
     },
+    JSXExpressionContainer(path) {
+      const expr = path.node.expression;
+      if (path.parent.type === "JSXAttribute") return;
+      if (expr.type === "ConditionalExpression") {
+        const result = transformConditionalBranchInline(expr, textToKey);
+        if (result.count > 0) {
+          path.node.expression = result.node;
+          stringsWrapped += result.count;
+          const compName2 = getComponentName(path);
+          if (compName2) componentsNeedingT.add(compName2);
+        }
+        return;
+      }
+      if (expr.type !== "TemplateLiteral") return;
+      const info = buildTemplateLiteralText(expr.quasis, expr.expressions);
+      if (!info || !(info.text in textToKey)) return;
+      const key = textToKey[info.text];
+      const args = [
+        t2.stringLiteral(info.text),
+        t2.stringLiteral(key)
+      ];
+      if (info.placeholders.length > 0) {
+        args.push(buildValuesObject(expr.expressions, info.placeholders));
+      }
+      path.node.expression = t2.callExpression(t2.identifier("t"), args);
+      stringsWrapped++;
+      const compName = getComponentName(path);
+      if (compName) componentsNeedingT.add(compName);
+    },
     JSXAttribute(path) {
       const value = path.node.value;
       if (!value) return;
+      if (value.type === "JSXExpressionContainer" && value.expression.type === "ConditionalExpression") {
+        const result = transformConditionalBranchInline(
+          value.expression,
+          textToKey
+        );
+        if (result.count > 0) {
+          path.node.value = t2.jsxExpressionContainer(result.node);
+          stringsWrapped += result.count;
+          const compName2 = getComponentName(path);
+          if (compName2) componentsNeedingT.add(compName2);
+        }
+        return;
+      }
       let text2;
+      let templateInfo;
       if (value.type === "StringLiteral") {
         text2 = value.value;
-      } else if (value.type === "JSXExpressionContainer" && value.expression.type === "StringLiteral") {
-        text2 = value.expression.value;
+      } else if (value.type === "JSXExpressionContainer") {
+        if (value.expression.type === "StringLiteral") {
+          text2 = value.expression.value;
+        } else if (value.expression.type === "TemplateLiteral") {
+          const info = buildTemplateLiteralText(
+            value.expression.quasis,
+            value.expression.expressions
+          );
+          if (info) {
+            text2 = info.text;
+            templateInfo = {
+              placeholders: info.placeholders,
+              expressions: value.expression.expressions
+            };
+          }
+        }
       }
       if (!text2 || !(text2 in textToKey)) return;
       if (value.type === "JSXExpressionContainer" && value.expression.type === "CallExpression" && value.expression.callee.type === "Identifier" && value.expression.callee.name === "t") {
         return;
       }
       const key = textToKey[text2];
-      path.node.value = t.jsxExpressionContainer(
-        t.callExpression(t.identifier("t"), [
-          t.stringLiteral(text2),
-          t.stringLiteral(key)
-        ])
+      const args = [
+        t2.stringLiteral(text2),
+        t2.stringLiteral(key)
+      ];
+      if (templateInfo && templateInfo.placeholders.length > 0) {
+        args.push(
+          buildValuesObject(
+            templateInfo.expressions,
+            templateInfo.placeholders
+          )
+        );
+      }
+      path.node.value = t2.jsxExpressionContainer(
+        t2.callExpression(t2.identifier("t"), args)
       );
       stringsWrapped++;
       const compName = getComponentName(path);
@@ -1246,29 +1667,63 @@ function transformInline(ast, textToKey, options) {
     },
     ObjectProperty(path) {
       if (!isInsideFunction(path)) return;
+      const compName = getComponentName(path);
+      if (!compName) return;
       const keyNode = path.node.key;
       if (keyNode.type !== "Identifier" && keyNode.type !== "StringLiteral")
         return;
       const propName = keyNode.type === "Identifier" ? keyNode.name : keyNode.value;
       if (!isContentProperty(propName)) return;
       const valueNode = path.node.value;
-      if (valueNode.type !== "StringLiteral") return;
-      const text2 = valueNode.value;
+      if (valueNode.type === "ConditionalExpression") {
+        const result = transformConditionalBranchInline(valueNode, textToKey);
+        if (result.count > 0) {
+          path.node.value = result.node;
+          stringsWrapped += result.count;
+          componentsNeedingT.add(compName);
+        }
+        return;
+      }
+      let text2;
+      let templateInfo;
+      if (valueNode.type === "StringLiteral") {
+        text2 = valueNode.value;
+      } else if (valueNode.type === "TemplateLiteral") {
+        const info = buildTemplateLiteralText(
+          valueNode.quasis,
+          valueNode.expressions
+        );
+        if (info) {
+          text2 = info.text;
+          templateInfo = {
+            placeholders: info.placeholders,
+            expressions: valueNode.expressions
+          };
+        }
+      }
       if (!text2 || !(text2 in textToKey)) return;
       const key = textToKey[text2];
-      path.node.value = t.callExpression(t.identifier("t"), [
-        t.stringLiteral(text2),
-        t.stringLiteral(key)
-      ]);
+      const args = [
+        t2.stringLiteral(text2),
+        t2.stringLiteral(key)
+      ];
+      if (templateInfo && templateInfo.placeholders.length > 0) {
+        args.push(
+          buildValuesObject(
+            templateInfo.expressions,
+            templateInfo.placeholders
+          )
+        );
+      }
+      path.node.value = t2.callExpression(t2.identifier("t"), args);
       stringsWrapped++;
-      const compName = getComponentName(path);
-      if (compName) componentsNeedingT.add(compName);
+      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 };
   }
@@ -1278,11 +1733,11 @@ function transformInline(ast, textToKey, options) {
   const existing = hasInlineImport(ast, componentPath);
   const specifiers = [];
   if (needsTComponent && !existing.hasT) {
-    specifiers.push(t.importSpecifier(t.identifier("T"), t.identifier("T")));
+    specifiers.push(t2.importSpecifier(t2.identifier("T"), t2.identifier("T")));
   }
   if (needsHook && !existing.hasHook) {
     specifiers.push(
-      t.importSpecifier(t.identifier(hookName), t.identifier(hookName))
+      t2.importSpecifier(t2.identifier(hookName), t2.identifier(hookName))
     );
   }
   if (specifiers.length > 0) {
@@ -1296,9 +1751,9 @@ function transformInline(ast, textToKey, options) {
       }
     }
     if (!appended) {
-      const importDecl = t.importDeclaration(
+      const importDecl = t2.importDeclaration(
         specifiers,
-        t.stringLiteral(importPath)
+        t2.stringLiteral(importPath)
       );
       const lastImportIndex = findLastImportIndex(ast);
       if (lastImportIndex >= 0) {
@@ -1312,8 +1767,8 @@ function transformInline(ast, textToKey, options) {
       }
     }
   }
-  if (needsHook && !hasInlineHookCall(ast, hookName)) {
-    const hookCall = isClient ? t.callExpression(t.identifier("useT"), []) : t.callExpression(t.identifier("createT"), []);
+  if (needsHook) {
+    const hookCall = isClient ? t2.callExpression(t2.identifier("useT"), []) : t2.callExpression(t2.identifier("createT"), []);
     traverse2(ast, {
       FunctionDeclaration(path) {
         const name = path.node.id?.name;
@@ -1348,8 +1803,8 @@ function injectInlineHookIntoBlock(block, hookCall) {
       return;
     }
   }
-  const tDecl = t.variableDeclaration("const", [
-    t.variableDeclarator(t.identifier("t"), hookCall)
+  const tDecl = t2.variableDeclaration("const", [
+    t2.variableDeclarator(t2.identifier("t"), hookCall)
   ]);
   block.body.unshift(tDecl);
 }
@@ -1359,63 +1814,914 @@ var init_transform = __esm({
     "use strict";
     init_filters();
     init_ast_helpers();
+    init_template_literal();
     init_logger();
     traverse2 = resolveDefault(_traverse2);
     generate = resolveDefault(_generate);
   }
 });
 
-// src/codegen/index.ts
-import { readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
-import { glob as glob2 } from "tinyglobby";
-async function codegen(options, cwd = process.cwd()) {
-  const files = await glob2(options.include, {
-    ignore: options.exclude ?? [],
-    cwd,
-    absolute: true
-  });
-  let filesModified = 0;
-  let stringsWrapped = 0;
-  const transformOpts = {
-    i18nImport: options.i18nImport,
-    mode: options.mode,
-    componentPath: options.componentPath
-  };
-  for (const filePath of files) {
-    const code = await readFile3(filePath, "utf-8");
-    let ast;
-    try {
-      ast = parseFile(code, filePath);
-    } catch (err) {
-      logVerbose(
-        `Skipping unparseable file ${filePath}: ${err instanceof Error ? err.message : String(err)}`,
-        true
-      );
-      continue;
-    }
-    const result = transform(ast, options.textToKey, transformOpts);
-    if (result.modified) {
-      await writeFile2(filePath, result.code, "utf-8");
-      filesModified++;
-      stringsWrapped += result.stringsWrapped;
+// 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 ?? [],
+    cwd,
+    absolute: true
+  });
+  const transformOpts = {
+    i18nImport: options.i18nImport,
+    mode: options.mode,
+    componentPath: options.componentPath
+  };
+  const parseLimit = pLimit3(10);
+  const parsedEntries = await Promise.all(
+    files.map(
+      (filePath) => parseLimit(async () => {
+        const code = await readFile3(filePath, "utf-8");
+        try {
+          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 ${entry.filePath}: ${entry.parseError ?? "unknown parse error"}`
+          );
+          completed++;
+          options.onProgress?.(completed, files.length);
+          return { modified: false, wrapped: 0, skipped: false };
+        }
+        const fileTransformOpts = {
+          ...transformOpts,
+          forceClient: forceClientSet.has(entry.filePath)
+        };
+        const result = transform(
+          entry.ast,
+          options.textToKey,
+          fileTransformOpts
+        );
+        if (result.modified) {
+          try {
+            parseFile(result.code, entry.filePath);
+          } catch {
+            logWarning(
+              `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(entry.filePath, result.code, "utf-8");
+          completed++;
+          options.onProgress?.(completed, files.length);
+          return {
+            modified: true,
+            wrapped: result.stringsWrapped,
+            skipped: false
+          };
+        }
+        completed++;
+        options.onProgress?.(completed, files.length);
+        return { modified: false, wrapped: 0, skipped: false };
+      })
+    )
+  );
+  let filesModified = 0;
+  let stringsWrapped = 0;
+  let filesSkipped = 0;
+  for (const r of fileResults) {
+    if (r.modified) {
+      filesModified++;
+      stringsWrapped += r.wrapped;
+    }
+    if (r.skipped) filesSkipped++;
+  }
+  return {
+    filesModified,
+    stringsWrapped,
+    filesProcessed: files.length,
+    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"
+    ];
+  }
+});
+
+// src/validate.ts
+function extractPlaceholders(text2) {
+  const matches = text2.match(PLACEHOLDER_REGEX);
+  if (!matches) return [];
+  return matches.slice().sort();
+}
+function validatePlaceholders(source, translated) {
+  const sourcePlaceholders = extractPlaceholders(source);
+  const translatedPlaceholders = extractPlaceholders(translated);
+  const sourceCount = /* @__PURE__ */ new Map();
+  for (const p2 of sourcePlaceholders) {
+    sourceCount.set(p2, (sourceCount.get(p2) ?? 0) + 1);
+  }
+  const translatedCount = /* @__PURE__ */ new Map();
+  for (const p2 of translatedPlaceholders) {
+    translatedCount.set(p2, (translatedCount.get(p2) ?? 0) + 1);
+  }
+  const missing = [];
+  const extra = [];
+  for (const [placeholder, count] of sourceCount) {
+    const tCount = translatedCount.get(placeholder) ?? 0;
+    for (let i = 0; i < count - tCount; i++) {
+      missing.push(placeholder);
+    }
+  }
+  for (const [placeholder, count] of translatedCount) {
+    const sCount = sourceCount.get(placeholder) ?? 0;
+    for (let i = 0; i < count - sCount; i++) {
+      extra.push(placeholder);
+    }
+  }
+  return {
+    valid: missing.length === 0 && extra.length === 0,
+    missing,
+    extra
+  };
+}
+function validateBatch(sourceEntries, translatedEntries) {
+  const failures = [];
+  for (const key of Object.keys(sourceEntries)) {
+    const source = sourceEntries[key];
+    const translated = translatedEntries[key];
+    if (translated == null) continue;
+    const result = validatePlaceholders(source, translated);
+    if (!result.valid) {
+      failures.push({ key, missing: result.missing, extra: result.extra });
+    }
+  }
+  return {
+    valid: failures.length === 0,
+    failures
+  };
+}
+var PLACEHOLDER_REGEX;
+var init_validate = __esm({
+  "src/validate.ts"() {
+    "use strict";
+    PLACEHOLDER_REGEX = /\{\{[\w.]+\}\}|\{[\w.]+\}|\{\d+\}|%[sd@]|%\.\d+f|<\/?[\w-]+(?:\s[^>]*)?\s*\/?>|<\/[\w-]+>/g;
+  }
+});
+
+// src/translate.ts
+import { generateObject as generateObject2 } from "ai";
+import { z as z3 } from "zod";
+import pLimit4 from "p-limit";
+function buildPrompt2(entries, sourceLocale, targetLocale, options) {
+  const lines = [
+    `Translate the following strings from "${sourceLocale}" to "${targetLocale}".`,
+    "",
+    "Rules:",
+    "- Preserve all placeholders like {name}, {{count}}, %s, %d exactly as-is",
+    "- Preserve HTML tags and markdown formatting",
+    "- Do NOT translate proper nouns, brand names, or technical identifiers",
+    "- Maintain the same level of formality and register",
+    "- Return natural, fluent translations (not word-for-word)"
+  ];
+  if (options?.tone) {
+    lines.push(`- Use a ${options.tone} tone`);
+  }
+  if (options?.context) {
+    lines.push(`
+Context: ${options.context}`);
+  }
+  if (options?.glossary && Object.keys(options.glossary).length > 0) {
+    lines.push("\nGlossary (use these exact translations):");
+    for (const [term, translation] of Object.entries(options.glossary)) {
+      lines.push(`  "${term}" \u2192 "${translation}"`);
+    }
+  }
+  lines.push("\nStrings to translate:");
+  for (const [key, value] of Object.entries(entries)) {
+    lines.push(`  "${key}": "${value}"`);
+  }
+  return lines.join("\n");
+}
+function buildSchema(keys) {
+  const shape = {};
+  for (const key of keys) {
+    shape[key] = z3.string();
+  }
+  return z3.object(shape);
+}
+async function translateBatchWithRetry(input, retries) {
+  const { model, entries, sourceLocale, targetLocale, options } = input;
+  const keys = Object.keys(entries);
+  const prompt = buildPrompt2(entries, sourceLocale, targetLocale, options);
+  const schema = buildSchema(keys);
+  const shouldValidate = options?.validatePlaceholders !== false;
+  let lastError;
+  let totalUsage = { inputTokens: 0, outputTokens: 0 };
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      const { object, usage } = await generateObject2({
+        model,
+        prompt,
+        schema
+      });
+      totalUsage.inputTokens += usage.inputTokens ?? 0;
+      totalUsage.outputTokens += usage.outputTokens ?? 0;
+      if (shouldValidate) {
+        const validation = validateBatch(entries, object);
+        if (!validation.valid) {
+          if (attempt < retries) {
+            logWarning(
+              `Placeholder mismatch in batch (attempt ${attempt + 1}/${retries + 1}), retrying...`
+            );
+            continue;
+          }
+          for (const failure of validation.failures) {
+            logWarning(
+              `Placeholder mismatch for key "${failure.key}": missing=[${failure.missing.join(", ")}] extra=[${failure.extra.join(", ")}]`
+            );
+          }
+        }
+      }
+      return { translations: object, usage: totalUsage };
+    } catch (error) {
+      lastError = error;
+      if (attempt < retries) {
+        const delay = Math.min(Math.pow(2, attempt) * 1e3, 3e4);
+        await new Promise((resolve2) => setTimeout(resolve2, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+async function translateAll(input) {
+  const {
+    model,
+    entries,
+    sourceLocale,
+    targetLocale,
+    options,
+    onBatchComplete,
+    onProgress,
+    onUsage
+  } = input;
+  const keys = Object.keys(entries);
+  if (keys.length === 0) return {};
+  const batchSize = options?.batchSize ?? 50;
+  const concurrency = options?.concurrency ?? 3;
+  const retries = options?.retries ?? 2;
+  const limit = pLimit4(concurrency);
+  const batches = [];
+  for (let i = 0; i < keys.length; i += batchSize) {
+    const batchKeys = keys.slice(i, i + batchSize);
+    const batch = {};
+    for (const key of batchKeys) {
+      batch[key] = entries[key];
+    }
+    batches.push(batch);
+  }
+  const results = {};
+  let completedKeys = 0;
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  await Promise.all(
+    batches.map(
+      (batch) => limit(async () => {
+        const { translations, usage } = await translateBatchWithRetry(
+          { model, entries: batch, sourceLocale, targetLocale, options },
+          retries
+        );
+        Object.assign(results, translations);
+        totalInputTokens += usage.inputTokens;
+        totalOutputTokens += usage.outputTokens;
+        completedKeys += Object.keys(batch).length;
+        onProgress?.(completedKeys, keys.length);
+        onBatchComplete?.(translations);
+      })
+    )
+  );
+  if (totalInputTokens > 0 || totalOutputTokens > 0) {
+    onUsage?.({ inputTokens: totalInputTokens, outputTokens: totalOutputTokens });
+  }
+  return results;
+}
+var init_translate = __esm({
+  "src/translate.ts"() {
+    "use strict";
+    init_validate();
+    init_logger();
+  }
+});
+
+// src/writer.ts
+import { writeFile as writeFile2, mkdir } from "fs/promises";
+import { join as join3, dirname as dirname2 } from "path";
+async function writeTranslation(filePath, flatEntries, options) {
+  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");
+}
+async function writeLockFile(messagesDir, sourceFlat, existingLock, translatedKeys) {
+  const lock = { ...existingLock };
+  for (const key of translatedKeys) {
+    if (key in sourceFlat) {
+      lock[key] = hashValue(sourceFlat[key]);
+    }
+  }
+  for (const key of Object.keys(lock)) {
+    if (!(key in sourceFlat)) {
+      delete lock[key];
+    }
+  }
+  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");
+}
+var init_writer = __esm({
+  "src/writer.ts"() {
+    "use strict";
+    init_flatten();
+    init_diff();
+  }
+});
+
+// src/pipeline.ts
+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 = join4(messagesDir, ".translate-map.json");
+  let content;
+  try {
+    content = await readFile4(mapPath, "utf-8");
+  } catch {
+    return {};
+  }
+  try {
+    return JSON.parse(content);
+  } catch {
+    logWarning(
+      `.translate-map.json is corrupted (invalid JSON). Starting fresh.`
+    );
+    return {};
+  }
+}
+async function writeMapFile(messagesDir, map) {
+  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");
+}
+async function runScanStep(input) {
+  const { config, cwd, callbacks } = input;
+  const mode = config.mode ?? "keys";
+  const result = await scan(config.scan, cwd, {
+    onProgress: callbacks?.onScanProgress
+  });
+  const bareStrings = result.strings.filter((s) => {
+    if (s.type === "t-call") return false;
+    if (s.type === "T-component" && s.id) return false;
+    return true;
+  });
+  const existingMap = await loadMapFile(config.messagesDir);
+  if (mode === "inline") {
+    const existingTComponents = result.strings.filter(
+      (s) => s.type === "T-component" && s.id
+    );
+    for (const tc of existingTComponents) {
+      if (tc.id && !(tc.text in existingMap)) {
+        existingMap[tc.text] = tc.id;
+      }
+    }
+    const existingInlineTCalls = result.strings.filter(
+      (s) => s.type === "t-call" && s.id
+    );
+    for (const tc of existingInlineTCalls) {
+      if (tc.id && !(tc.text in existingMap)) {
+        existingMap[tc.text] = tc.id;
+      }
+    }
+  }
+  const allTexts = new Set(result.strings.map((s) => s.text));
+  const textToKey = await generateSemanticKeys({
+    model: config.model,
+    strings: bareStrings,
+    existingMap,
+    allTexts,
+    batchSize: config.translation?.batchSize ?? 50,
+    concurrency: config.translation?.concurrency ?? 3,
+    retries: config.translation?.retries ?? 2,
+    onProgress: callbacks?.onKeygenProgress,
+    onUsage: callbacks?.onUsage
+  });
+  await writeMapFile(config.messagesDir, textToKey);
+  const sourceFlat = {};
+  for (const [text2, key] of Object.entries(textToKey)) {
+    sourceFlat[key] = text2;
+  }
+  if (mode !== "inline") {
+    const sourceFile = join4(
+      config.messagesDir,
+      `${config.sourceLocale}.json`
+    );
+    await mkdir2(config.messagesDir, { recursive: true });
+    const nested = unflatten(sourceFlat);
+    const content = JSON.stringify(nested, null, 2) + "\n";
+    await writeFile3(sourceFile, content, "utf-8");
+  }
+  return {
+    textToKey,
+    sourceFlat,
+    bareStringCount: bareStrings.length,
+    fileCount: result.fileCount
+  };
+}
+async function runCodegenStep(input) {
+  const { config, cwd, callbacks } = input;
+  const mode = config.mode ?? "keys";
+  let textToKey = input.textToKey;
+  if (!textToKey) {
+    textToKey = await loadMapFile(config.messagesDir);
+    if (Object.keys(textToKey).length === 0) {
+      throw new Error(
+        "No .translate-map.json found. Run 'translate-kit scan' first."
+      );
+    }
+  }
+  return codegen(
+    {
+      include: config.scan.include,
+      exclude: config.scan.exclude,
+      textToKey,
+      i18nImport: config.scan.i18nImport,
+      mode,
+      componentPath: config.inline?.componentPath,
+      onProgress: callbacks?.onProgress
+    },
+    cwd
+  );
+}
+async function runTranslateStep(input) {
+  const { config, callbacks } = input;
+  const mode = config.mode ?? "keys";
+  const locales = input.locales ?? config.targetLocales;
+  let sourceFlat = input.sourceFlat;
+  if (!sourceFlat) {
+    if (mode === "inline") {
+      const mapData = await loadMapFile(config.messagesDir);
+      sourceFlat = {};
+      for (const [text2, key] of Object.entries(mapData)) {
+        sourceFlat[key] = text2;
+      }
+    } else {
+      const sourceFile = join4(
+        config.messagesDir,
+        `${config.sourceLocale}.json`
+      );
+      const sourceRaw = await loadJsonFile(sourceFile);
+      sourceFlat = flatten(sourceRaw);
+    }
+  }
+  const localeResults = [];
+  for (const locale of locales) {
+    const start = Date.now();
+    const targetFile = join4(config.messagesDir, `${locale}.json`);
+    const targetRaw = await loadJsonFile(targetFile);
+    const targetFlat = flatten(targetRaw);
+    let lockData = await loadLockFile(config.messagesDir);
+    if (input.force) {
+      lockData = {};
+    }
+    const diffResult = computeDiff(sourceFlat, targetFlat, lockData);
+    if (input.dryRun) {
+      localeResults.push({
+        locale,
+        translated: 0,
+        cached: Object.keys(diffResult.unchanged).length,
+        removed: diffResult.removed.length,
+        errors: 0,
+        duration: Date.now() - start
+      });
+      continue;
+    }
+    const toTranslate = { ...diffResult.added, ...diffResult.modified };
+    let translated = {};
+    let errors = 0;
+    let translationFailed = false;
+    if (Object.keys(toTranslate).length > 0) {
+      try {
+        translated = await translateAll({
+          model: config.model,
+          entries: toTranslate,
+          sourceLocale: config.sourceLocale,
+          targetLocale: locale,
+          options: config.translation,
+          onProgress: callbacks?.onLocaleProgress ? (c, t3) => callbacks.onLocaleProgress(locale, c, t3) : void 0,
+          onUsage: callbacks?.onUsage
+        });
+      } catch (err) {
+        errors = Object.keys(toTranslate).length;
+        translationFailed = true;
+      }
+    }
+    if (translationFailed) {
+      localeResults.push({
+        locale,
+        translated: 0,
+        cached: Object.keys(diffResult.unchanged).length,
+        removed: 0,
+        errors,
+        duration: Date.now() - start
+      });
+      continue;
+    }
+    const finalFlat = {
+      ...diffResult.unchanged,
+      ...translated
+    };
+    await writeTranslation(targetFile, finalFlat, {
+      flat: mode === "inline"
+    });
+    const allTranslatedKeys = Object.keys(finalFlat);
+    const currentLock = await loadLockFile(config.messagesDir);
+    await writeLockFile(
+      config.messagesDir,
+      sourceFlat,
+      currentLock,
+      allTranslatedKeys
+    );
+    localeResults.push({
+      locale,
+      translated: Object.keys(translated).length,
+      cached: Object.keys(diffResult.unchanged).length,
+      removed: diffResult.removed.length,
+      errors,
+      duration: Date.now() - start
+    });
+  }
+  return { localeResults };
+}
+var init_pipeline = __esm({
+  "src/pipeline.ts"() {
+    "use strict";
+    init_scanner();
+    init_key_ai();
+    init_codegen();
+    init_translate();
+    init_writer();
+    init_diff();
+    init_flatten();
+    init_logger();
+  }
+});
+
+// src/usage.ts
+import { fetchModels, getTokenCosts } from "tokenlens";
+function createUsageTracker() {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  return {
+    add(usage) {
+      inputTokens += usage.inputTokens ?? 0;
+      outputTokens += usage.outputTokens ?? 0;
+    },
+    get() {
+      return { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens };
+    }
+  };
+}
+async function estimateCost(model, usage) {
+  try {
+    const m = model;
+    const provider = typeof m.provider === "string" ? m.provider : "unknown";
+    const modelId = typeof m.modelId === "string" ? m.modelId : "unknown";
+    const fullId = `${provider}/${modelId}`;
+    const providers = await fetchModels(provider);
+    const costs = getTokenCosts({
+      modelId: fullId,
+      usage: {
+        prompt_tokens: usage.inputTokens,
+        completion_tokens: usage.outputTokens
+      },
+      providers
+    });
+    if (costs.totalUSD == null) return null;
+    return { totalUSD: costs.totalUSD, inputUSD: costs.inputUSD ?? 0, outputUSD: costs.outputUSD ?? 0 };
+  } catch {
+    return null;
+  }
+}
+function formatUsage(usage) {
+  return `${usage.inputTokens.toLocaleString()} in + ${usage.outputTokens.toLocaleString()} out = ${usage.totalTokens.toLocaleString()} tokens`;
+}
+function formatCost(usd) {
+  return usd < 0.01 ? `~$${usd.toFixed(4)}` : `~$${usd.toFixed(2)}`;
+}
+var init_usage = __esm({
+  "src/usage.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli-utils.ts
+function parseTranslateFlags(rawArgs) {
+  const dryRun = rawArgs.includes("--dry-run");
+  const force = rawArgs.includes("--force");
+  const verbose = rawArgs.includes("--verbose");
+  let locale;
+  const equalsArg = rawArgs.find((a) => a.startsWith("--locale="));
+  if (equalsArg) {
+    locale = equalsArg.split("=")[1] || void 0;
+  } else {
+    const idx = rawArgs.indexOf("--locale");
+    if (idx !== -1) {
+      const next = rawArgs[idx + 1];
+      locale = next && !next.startsWith("--") ? next : void 0;
     }
   }
-  return {
-    filesModified,
-    stringsWrapped,
-    filesProcessed: files.length
-  };
+  return { dryRun, force, verbose, locale };
 }
-var init_codegen = __esm({
-  "src/codegen/index.ts"() {
+function validateLocale(locale) {
+  return /^[a-zA-Z0-9_-]+$/.test(locale);
+}
+var init_cli_utils = __esm({
+  "src/cli-utils.ts"() {
     "use strict";
-    init_parser();
-    init_transform();
-    init_logger();
   }
 });
 
 // src/templates/t-component.ts
+function serverTemplate(clientBasename, opts) {
+  if (!opts) {
+    return `import type { ReactNode } from "react";
+import { cache } from "react";
+export { I18nProvider } from "./${clientBasename}";
+
+type Messages = Record<string, string>;
+
+// Per-request message store using React cache
+const getMessageStore = cache(() => ({ current: {} as Messages }));
+
+export function setServerMessages(messages: Messages) {
+  getMessageStore().current = messages;
+}
+
+export function T({ id, children, messages }: { id?: string; children: ReactNode; messages?: Messages }) {
+  if (!id) return <>{children}</>;
+  const msgs = messages ?? getMessageStore().current;
+  return <>{msgs[id] ?? children}</>;
+}
+
+export function createT(messages?: Messages) {
+  return (text: string, id?: string, values?: Record<string, string | number>): string => {
+    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 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;
+}
+
+// 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> => {
+  const { headers } = await import("next/headers");
+  const { readFile } = await import("node:fs/promises");
+  const { join } = await import("node:path");
+
+  const h = await headers();
+  const acceptLang = h.get("accept-language") ?? "";
+  const locale = parseAcceptLanguage(acceptLang);
+  if (locale === defaultLocale) return {};
+  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(", ");
@@ -1460,7 +2766,7 @@ export async function getMessages(locale: string): Promise<Record<string, string
 }
 `;
 }
-var CLIENT_TEMPLATE, SERVER_TEMPLATE;
+var CLIENT_TEMPLATE;
 var init_t_component = __esm({
   "src/templates/t-component.ts"() {
     "use strict";
@@ -1482,25 +2788,10 @@ export function T({ id, children }: { id?: string; children: ReactNode }) {
 
 export function useT() {
   const msgs = useContext(I18nCtx);
-  return (text: string, id?: string): string => {
-    if (!id) return text;
-    return msgs[id] ?? text;
-  };
-}
-`;
-    SERVER_TEMPLATE = `import type { ReactNode } from "react";
-
-type Messages = Record<string, string>;
-
-export function T({ id, children, messages = {} }: { id?: string; children: ReactNode; messages?: Messages }) {
-  if (!id) return <>{children}</>;
-  return <>{messages[id] ?? children}</>;
-}
-
-export function createT(messages: Messages = {}) {
-  return (text: string, id?: string): string => {
-    if (!id) return text;
-    return messages[id] ?? text;
+  return (text: string, id?: string, values?: Record<string, string | number>): string => {
+    const raw = id ? (msgs[id] ?? text) : text;
+    if (!values) return raw;
+    return raw.replace(/\\{(\\w+)\\}/g, (_, k) => String(values[k] ?? \`{\${k}}\`));
   };
 }
 `;
@@ -1514,17 +2805,17 @@ __export(init_exports, {
 });
 import * as p from "@clack/prompts";
 import { existsSync } from "fs";
-import { join as join3, relative } from "path";
-import { readFile as readFile4, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+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(join3(cwd, "app")))
+  if (existsSync(join5(cwd, "app")))
     patterns.push("app/**/*.tsx", "app/**/*.jsx");
-  if (existsSync(join3(cwd, "src")))
+  if (existsSync(join5(cwd, "src")))
     patterns.push("src/**/*.tsx", "src/**/*.jsx");
-  if (existsSync(join3(cwd, "pages")))
+  if (existsSync(join5(cwd, "pages")))
     patterns.push("pages/**/*.tsx", "pages/**/*.jsx");
-  if (existsSync(join3(cwd, "src", "app"))) {
+  if (existsSync(join5(cwd, "src", "app"))) {
     return patterns.filter((p2) => !p2.startsWith("app/"));
   }
   return patterns.length > 0 ? patterns : ["**/*.tsx", "**/*.jsx"];
@@ -1537,10 +2828,10 @@ function findPackageInNodeModules(cwd, pkg) {
   let dir = cwd;
   const parts = pkg.split("/");
   while (true) {
-    if (existsSync(join3(dir, "node_modules", ...parts, "package.json"))) {
+    if (existsSync(join5(dir, "node_modules", ...parts, "package.json"))) {
       return true;
     }
-    const parent = join3(dir, "..");
+    const parent = join5(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -1608,7 +2899,7 @@ function canParse(content, filePath) {
     return false;
   }
 }
-async function safeWriteModifiedFile(filePath, original, modified, label) {
+async function safeWriteModifiedFile(filePath, modified, label) {
   if (!canParse(modified, filePath)) {
     p.log.warn(
       `Could not safely modify ${label}. Please apply changes manually:
@@ -1616,36 +2907,36 @@ async function safeWriteModifiedFile(filePath, original, modified, label) {
     );
     return false;
   }
-  await writeFile3(filePath, modified, "utf-8");
+  await writeFile4(filePath, modified, "utf-8");
   return true;
 }
 function detectSrcDir(cwd) {
-  return existsSync(join3(cwd, "src", "app"));
+  return existsSync(join5(cwd, "src", "app"));
 }
 function resolveComponentPath(cwd, componentPath) {
   if (componentPath.startsWith("@/")) {
     const rel = componentPath.slice(2);
-    const useSrc = existsSync(join3(cwd, "src"));
-    return join3(cwd, useSrc ? "src" : "", rel);
+    const useSrc = existsSync(join5(cwd, "src"));
+    return join5(cwd, useSrc ? "src" : "", rel);
   }
   if (componentPath.startsWith("~/")) {
-    return join3(cwd, componentPath.slice(2));
+    return join5(cwd, componentPath.slice(2));
   }
-  return join3(cwd, componentPath);
+  return join5(cwd, componentPath);
 }
 function findLayoutFile(base) {
   for (const ext of ["tsx", "jsx", "ts", "js"]) {
-    const candidate = join3(base, "app", `layout.${ext}`);
+    const candidate = join5(base, "app", `layout.${ext}`);
     if (existsSync(candidate)) return candidate;
   }
   return void 0;
 }
 async function createEmptyMessageFiles(msgDir, locales) {
-  await mkdir2(msgDir, { recursive: true });
+  await mkdir3(msgDir, { recursive: true });
   for (const locale of locales) {
-    const msgFile = join3(msgDir, `${locale}.json`);
+    const msgFile = join5(msgDir, `${locale}.json`);
     if (!existsSync(msgFile)) {
-      await writeFile3(msgFile, "{}\n", "utf-8");
+      await writeFile4(msgFile, "{}\n", "utf-8");
     }
   }
 }
@@ -1663,16 +2954,16 @@ function ensureAsyncLayout(content) {
 }
 async function setupNextIntl(cwd, sourceLocale, targetLocales, messagesDir) {
   const useSrc = detectSrcDir(cwd);
-  const base = useSrc ? join3(cwd, "src") : cwd;
+  const base = useSrc ? join5(cwd, "src") : cwd;
   const allLocales = [sourceLocale, ...targetLocales];
   const filesCreated = [];
-  const i18nDir = join3(base, "i18n");
-  await mkdir2(i18nDir, { recursive: true });
-  const requestFile = join3(i18nDir, "request.ts");
+  const i18nDir = join5(base, "i18n");
+  await mkdir3(i18nDir, { recursive: true });
+  const requestFile = join5(i18nDir, "request.ts");
   if (!existsSync(requestFile)) {
-    const relMessages = relative(i18nDir, join3(cwd, messagesDir));
+    const relMessages = relative(i18nDir, join5(cwd, messagesDir));
     const allLocalesStr = allLocales.map((l) => `"${l}"`).join(", ");
-    await writeFile3(
+    await writeFile4(
       requestFile,
       `import { getRequestConfig } from "next-intl/server";
 import { headers } from "next/headers";
@@ -1711,9 +3002,9 @@ export default getRequestConfig(async () => {
     );
     filesCreated.push(relative(cwd, requestFile));
   }
-  const nextConfigPath = join3(cwd, "next.config.ts");
+  const nextConfigPath = join5(cwd, "next.config.ts");
   if (existsSync(nextConfigPath)) {
-    const content = await readFile4(nextConfigPath, "utf-8");
+    const content = await readFile5(nextConfigPath, "utf-8");
     if (!content.includes("next-intl")) {
       const importLine = `import createNextIntlPlugin from "next-intl/plugin";
 `;
@@ -1726,7 +3017,6 @@ export default getRequestConfig(async () => {
       const updated = importLine + "\n" + pluginLine + "\n" + wrapped;
       if (await safeWriteModifiedFile(
         nextConfigPath,
-        content,
         updated,
         "next.config.ts"
       )) {
@@ -1736,9 +3026,8 @@ export default getRequestConfig(async () => {
   }
   const layoutPath = findLayoutFile(base);
   if (layoutPath) {
-    let layoutContent = await readFile4(layoutPath, "utf-8");
+    let layoutContent = await readFile5(layoutPath, "utf-8");
     if (!layoutContent.includes("NextIntlClientProvider")) {
-      const original = layoutContent;
       const importLines = 'import { NextIntlClientProvider } from "next-intl";\nimport { getMessages } from "next-intl/server";\n';
       layoutContent = insertImportsAfterLast(layoutContent, importLines);
       layoutContent = ensureAsyncLayout(layoutContent);
@@ -1756,7 +3045,6 @@ export default getRequestConfig(async () => {
       );
       if (await safeWriteModifiedFile(
         layoutPath,
-        original,
         layoutContent,
         "root layout"
       )) {
@@ -1764,52 +3052,53 @@ export default getRequestConfig(async () => {
       }
     }
   }
-  await createEmptyMessageFiles(join3(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 = join3(fsPath, "..");
-  await mkdir2(dir, { recursive: true });
+  const dir = join5(fsPath, "..");
+  await mkdir3(dir, { recursive: true });
   const clientFile = `${fsPath}.tsx`;
   const serverFile = `${fsPath}-server.tsx`;
-  await writeFile3(clientFile, CLIENT_TEMPLATE, "utf-8");
-  await writeFile3(serverFile, SERVER_TEMPLATE, "utf-8");
+  const clientBasename = basename(fsPath);
+  await writeFile4(clientFile, CLIENT_TEMPLATE, "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(join3(cwd, "src"));
-  const base = useSrc ? join3(cwd, "src") : cwd;
+  const useSrc = existsSync(join5(cwd, "src"));
+  const base = useSrc ? join5(cwd, "src") : cwd;
   const filesCreated = [];
-  const i18nDir = join3(base, "i18n");
-  await mkdir2(i18nDir, { recursive: true });
-  const helperFile = join3(i18nDir, "index.ts");
+  const i18nDir = join5(base, "i18n");
+  await mkdir3(i18nDir, { recursive: true });
+  const helperFile = join5(i18nDir, "index.ts");
   if (!existsSync(helperFile)) {
     const helperContent = generateI18nHelper({
       sourceLocale,
       targetLocales,
       messagesDir
     });
-    await writeFile3(helperFile, helperContent, "utf-8");
+    await writeFile4(helperFile, helperContent, "utf-8");
     filesCreated.push(relative(cwd, helperFile));
   }
   const layoutPath = findLayoutFile(base);
   if (layoutPath) {
-    let layoutContent = await readFile4(layoutPath, "utf-8");
+    let layoutContent = await readFile5(layoutPath, "utf-8");
     if (!layoutContent.includes("I18nProvider")) {
-      const original = layoutContent;
       const importLines = `import { I18nProvider } from "${componentPath}";
+import { setServerMessages } 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\n	return ("
+        "const locale = await getLocale();\n	const messages = await getMessages(locale);\n	setServerMessages(messages);\n\n	return ("
       );
       layoutContent = layoutContent.replace(
         /(<body[^>]*>)/,
@@ -1821,7 +3110,6 @@ import { getLocale, getMessages } from "@/i18n";
       );
       if (await safeWriteModifiedFile(
         layoutPath,
-        original,
         layoutContent,
         "root layout"
       )) {
@@ -1829,7 +3117,7 @@ import { getLocale, getMessages } from "@/i18n";
       }
     }
   }
-  await createEmptyMessageFiles(join3(cwd, messagesDir), [
+  await createEmptyMessageFiles(join5(cwd, messagesDir), [
     sourceLocale,
     ...targetLocales
   ]);
@@ -1839,7 +3127,7 @@ import { getLocale, getMessages } from "@/i18n";
 }
 async function runInitWizard() {
   const cwd = process.cwd();
-  const configPath = join3(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({
@@ -1884,7 +3172,12 @@ async function runInitWizard() {
   if (p.isCancel(modelName)) cancel2();
   const sourceLocale = await p.text({
     message: "Source locale:",
-    initialValue: "en"
+    initialValue: "en",
+    validate(value) {
+      if (!validateLocale(value)) {
+        return "Invalid locale. Use only letters, numbers, hyphens, and underscores.";
+      }
+    }
   });
   if (p.isCancel(sourceLocale)) cancel2();
   const targetLocales = await p.multiselect({
@@ -1962,10 +3255,14 @@ async function runInitWizard() {
     mode,
     componentPath
   });
-  await writeFile3(configPath, configContent, "utf-8");
+  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,
@@ -1993,141 +3290,59 @@ async function runInitWizard() {
     p.outro("Config created but pipeline skipped.");
     return;
   }
-  const { model } = config;
-  const scanOptions = {
-    include: includePatterns,
-    exclude: ["**/*.test.*", "**/*.spec.*"],
-    i18nImport
-  };
+  const usageTracker = createUsageTracker();
   const s1 = p.spinner();
   s1.start("Scanning...");
-  const scanResult = await scan(scanOptions, cwd);
-  const transformableStrings = scanResult.strings.filter(
-    (s) => s.type === "jsx-text" || s.type === "jsx-attribute" || s.type === "object-property"
-  );
+  const scanResult = await runScanStep({
+    config,
+    cwd,
+    callbacks: {
+      onScanProgress: (c, t3) => s1.message(`Scanning... ${c}/${t3} files`),
+      onKeygenProgress: (c, t3) => s1.message(`Generating keys... ${c}/${t3}`),
+      onUsage: (usage2) => usageTracker.add(usage2)
+    }
+  });
   s1.stop(
-    `Scanning... ${transformableStrings.length} strings from ${scanResult.fileCount} files`
+    `Found ${scanResult.bareStringCount} strings from ${scanResult.fileCount} files`
   );
-  if (transformableStrings.length === 0) {
+  if (scanResult.bareStringCount === 0) {
     p.log.warn("No translatable strings found. Check your include patterns.");
     p.outro("Config created, but no strings to process.");
     return;
   }
-  const resolvedMessagesDir = join3(cwd, messagesDir);
-  await mkdir2(resolvedMessagesDir, { recursive: true });
-  let existingMap = {};
-  const mapPath = join3(resolvedMessagesDir, ".translate-map.json");
-  try {
-    existingMap = JSON.parse(await readFile4(mapPath, "utf-8"));
-  } catch {
-  }
-  const s2 = p.spinner();
-  s2.start("Generating keys...");
-  const textToKey = await generateSemanticKeys({
-    model,
-    strings: transformableStrings,
-    existingMap,
-    batchSize: config.translation?.batchSize ?? 50,
-    concurrency: config.translation?.concurrency ?? 3,
-    retries: config.translation?.retries ?? 2
-  });
-  s2.stop("Generating keys... done");
-  await writeFile3(mapPath, JSON.stringify(textToKey, null, 2) + "\n", "utf-8");
-  const messages = {};
-  for (const [text2, key] of Object.entries(textToKey)) {
-    messages[key] = text2;
-  }
-  let sourceFlat;
-  if (mode === "inline") {
-    sourceFlat = messages;
-  } else {
-    const sourceFile = join3(resolvedMessagesDir, `${sourceLocale}.json`);
-    const nested = unflatten(messages);
-    await writeFile3(
-      sourceFile,
-      JSON.stringify(nested, null, 2) + "\n",
-      "utf-8"
-    );
-    sourceFlat = messages;
-  }
   const s3 = p.spinner();
   s3.start("Codegen...");
-  const codegenResult = await codegen(
-    {
-      include: includePatterns,
-      exclude: ["**/*.test.*", "**/*.spec.*"],
-      textToKey,
-      i18nImport,
-      mode,
-      componentPath
-    },
-    cwd
-  );
+  const codegenResult = await runCodegenStep({
+    config,
+    cwd,
+    textToKey: scanResult.textToKey,
+    callbacks: {
+      onProgress: (c, t3) => s3.message(`Codegen... ${c}/${t3} files`)
+    }
+  });
   s3.stop(
     `Codegen... ${codegenResult.stringsWrapped} strings wrapped in ${codegenResult.filesModified} files`
   );
-  const postScan = await scan(scanOptions, cwd);
-  const keyToText = {};
-  for (const [text2, key] of Object.entries(textToKey)) {
-    keyToText[key] = text2;
-  }
-  const reconciledMessages = {};
-  if (mode === "inline") {
-    const tComponents = postScan.strings.filter(
-      (s) => s.type === "T-component" && s.id
-    );
-    const inlineTCalls = postScan.strings.filter(
-      (s) => s.type === "t-call" && s.id
-    );
-    for (const tc of tComponents) {
-      if (tc.id && tc.id in keyToText) {
-        reconciledMessages[tc.id] = keyToText[tc.id];
-      }
-    }
-    for (const tc of inlineTCalls) {
-      if (tc.id && tc.id in keyToText) {
-        reconciledMessages[tc.id] = keyToText[tc.id];
-      }
-    }
-  } else {
-    const tCalls = postScan.strings.filter((s) => s.type === "t-call");
-    for (const tCall of tCalls) {
-      const key = tCall.text;
-      if (key in keyToText) {
-        reconciledMessages[key] = keyToText[key];
-      }
-    }
-    const sourceFile = join3(resolvedMessagesDir, `${sourceLocale}.json`);
-    const reconciledNested = unflatten(reconciledMessages);
-    await writeFile3(
-      sourceFile,
-      JSON.stringify(reconciledNested, null, 2) + "\n",
-      "utf-8"
-    );
-  }
-  sourceFlat = reconciledMessages;
-  const translationOpts = config.translation ?? {};
   for (const locale of targetLocales) {
     const st = p.spinner();
     st.start(`Translating ${locale}...`);
-    const translated = await translateAll({
-      model,
-      entries: sourceFlat,
-      sourceLocale,
-      targetLocale: locale,
-      options: translationOpts
+    await runTranslateStep({
+      config,
+      sourceFlat: scanResult.sourceFlat,
+      locales: [locale],
+      callbacks: {
+        onLocaleProgress: (_locale, c, t3) => st.message(`Translating ${locale}... ${c}/${t3} keys`),
+        onUsage: (usage2) => usageTracker.add(usage2)
+      }
     });
-    const targetFile = join3(resolvedMessagesDir, `${locale}.json`);
-    await writeTranslation(targetFile, translated, { flat: mode === "inline" });
-    const lockData = await loadLockFile(resolvedMessagesDir);
-    await writeLockFile(
-      resolvedMessagesDir,
-      sourceFlat,
-      lockData,
-      Object.keys(translated)
-    );
     st.stop(`Translating ${locale}... done`);
   }
+  const usage = usageTracker.get();
+  if (usage.totalTokens > 0) {
+    const cost = await estimateCost(config.model, usage);
+    const costStr = cost ? ` \xB7 ${formatCost(cost.totalUSD)}` : "";
+    p.log.info(`${formatUsage(usage)}${costStr}`);
+  }
   p.outro("You're all set!");
 }
 var AI_PROVIDERS, LOCALE_OPTIONS;
@@ -2135,15 +3350,11 @@ var init_init = __esm({
   "src/init.ts"() {
     "use strict";
     init_config();
-    init_scanner();
-    init_key_ai();
-    init_codegen();
-    init_translate();
-    init_writer();
-    init_diff();
-    init_flatten();
+    init_pipeline();
     init_t_component();
     init_parser();
+    init_usage();
+    init_cli_utils();
     AI_PROVIDERS = {
       openai: {
         pkg: "@ai-sdk/openai",
@@ -2190,31 +3401,14 @@ var init_init = __esm({
 init_config();
 init_flatten();
 init_diff();
-init_translate();
-init_writer();
 init_scanner();
-init_key_ai();
-init_codegen();
+init_pipeline();
 init_logger();
+init_usage();
+init_cli_utils();
 import "dotenv/config";
 import { defineCommand, runMain } from "citty";
-import { join as join4 } from "path";
-import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3 } from "fs/promises";
-async function loadMapFile(messagesDir) {
-  const mapPath = join4(messagesDir, ".translate-map.json");
-  try {
-    const content = await readFile5(mapPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
-}
-async function writeMapFile(messagesDir, map) {
-  const mapPath = join4(messagesDir, ".translate-map.json");
-  await mkdir3(messagesDir, { recursive: true });
-  const content = JSON.stringify(map, null, 2) + "\n";
-  await writeFile4(mapPath, content, "utf-8");
-}
+import { join as join6 } from "path";
 var translateCommand = defineCommand({
   meta: {
     name: "translate",
@@ -2244,15 +3438,51 @@ var translateCommand = defineCommand({
   async run({ args }) {
     const config = await loadTranslateKitConfig();
     const { sourceLocale, targetLocales, messagesDir, model } = config;
-    const opts = config.translation ?? {};
-    const verbose = args.verbose;
     const mode = config.mode ?? "keys";
+    if (args.locale && !validateLocale(args.locale)) {
+      logError(
+        `Invalid locale "${args.locale}". Locale must only contain letters, numbers, hyphens, and underscores.`
+      );
+      process.exit(1);
+    }
     const locales = args.locale ? [args.locale] : targetLocales;
     if (args.locale && !targetLocales.includes(args.locale)) {
       logWarning(
         `Locale "${args.locale}" is not in targetLocales [${targetLocales.join(", ")}]`
       );
     }
+    if (args["dry-run"]) {
+      let sourceFlat2;
+      if (mode === "inline") {
+        const mapData = await loadMapFile(messagesDir);
+        sourceFlat2 = {};
+        for (const [text2, key] of Object.entries(mapData)) {
+          sourceFlat2[key] = text2;
+        }
+      } else {
+        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 ${join6(messagesDir, `${sourceLocale}.json`)}`
+        );
+        process.exit(1);
+      }
+      const dryResult = await runTranslateStep({
+        config,
+        sourceFlat: sourceFlat2,
+        locales,
+        force: args.force,
+        dryRun: true
+      });
+      logStart(sourceLocale, locales);
+      for (const r of dryResult.localeResults) {
+        logDryRun(r.locale, 0, 0, r.removed, r.cached);
+      }
+      return;
+    }
     let sourceFlat;
     if (mode === "inline") {
       const mapData = await loadMapFile(messagesDir);
@@ -2261,92 +3491,48 @@ var translateCommand = defineCommand({
         sourceFlat[key] = text2;
       }
     } else {
-      const sourceFile = join4(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 ${join4(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);
     }
     logStart(sourceLocale, locales);
+    const usageTracker = createUsageTracker();
     const results = [];
-    for (const locale of locales) {
-      const start = Date.now();
-      const targetFile = join4(messagesDir, `${locale}.json`);
-      logLocaleStart(locale);
-      const targetRaw = await loadJsonFile(targetFile);
-      const targetFlat = flatten(targetRaw);
-      let lockData = await loadLockFile(messagesDir);
-      if (args.force) {
-        lockData = {};
-      }
-      const diffResult = computeDiff(sourceFlat, targetFlat, lockData);
-      const toTranslate = { ...diffResult.added, ...diffResult.modified };
-      if (args["dry-run"]) {
-        logDryRun(
-          locale,
-          Object.keys(diffResult.added).length,
-          Object.keys(diffResult.modified).length,
-          diffResult.removed.length,
-          Object.keys(diffResult.unchanged).length
-        );
-        continue;
-      }
-      let translated = {};
-      let errors = 0;
-      if (Object.keys(toTranslate).length > 0) {
-        try {
-          translated = await translateAll({
-            model,
-            entries: toTranslate,
-            sourceLocale,
-            targetLocale: locale,
-            options: opts,
-            onBatchComplete: (batch) => {
-              logVerbose(
-                `Batch complete: ${Object.keys(batch).length} keys`,
-                verbose
-              );
-            }
-          });
-        } catch (err) {
-          errors = Object.keys(toTranslate).length;
-          logError(
-            `Translation failed for ${locale}: ${err instanceof Error ? err.message : String(err)}`
-          );
-        }
+    const translateResult = await runTranslateStep({
+      config,
+      sourceFlat,
+      locales,
+      force: args.force,
+      callbacks: {
+        onLocaleProgress: (locale, c, t3) => logProgress(c, t3, `Translating ${locale}...`),
+        onUsage: (usage2) => usageTracker.add(usage2)
       }
-      const finalFlat = {
-        ...diffResult.unchanged,
-        ...translated
-      };
-      await writeTranslation(targetFile, finalFlat, {
-        flat: mode === "inline"
-      });
-      const allTranslatedKeys = Object.keys(finalFlat);
-      const currentLock = await loadLockFile(messagesDir);
-      await writeLockFile(
-        messagesDir,
-        sourceFlat,
-        currentLock,
-        allTranslatedKeys
-      );
+    });
+    for (const r of translateResult.localeResults) {
+      logLocaleStart(r.locale);
+      logProgressClear();
       const result = {
-        locale,
-        translated: Object.keys(translated).length,
-        cached: Object.keys(diffResult.unchanged).length,
-        removed: diffResult.removed.length,
-        errors,
-        duration: Date.now() - start
+        locale: r.locale,
+        translated: r.translated,
+        cached: r.cached,
+        removed: r.removed,
+        errors: r.errors,
+        duration: r.duration
       };
       logLocaleResult(result);
       results.push(result);
     }
-    if (!args["dry-run"]) {
-      logSummary(results);
+    logSummary(results);
+    const usage = usageTracker.get();
+    if (usage.totalTokens > 0) {
+      const cost = await estimateCost(model, usage);
+      logUsage(formatUsage(usage), cost ? formatCost(cost.totalUSD) : void 0);
     }
   }
 });
@@ -2371,14 +3557,17 @@ var scanCommand = defineCommand({
       );
       process.exit(1);
     }
-    const result = await scan(config.scan);
-    const bareStrings = result.strings.filter((s) => {
-      if (s.type === "t-call") return false;
-      if (s.type === "T-component" && s.id) return false;
-      return true;
-    });
-    logScanResult(bareStrings.length, result.fileCount);
     if (args["dry-run"]) {
+      const result = await scan(config.scan, process.cwd(), {
+        onProgress: (c, t3) => logProgress(c, t3, "Scanning...")
+      });
+      logProgressClear();
+      const bareStrings = result.strings.filter((s) => {
+        if (s.type === "t-call") return false;
+        if (s.type === "T-component" && s.id) return false;
+        return true;
+      });
+      logScanResult(bareStrings.length, result.fileCount);
       for (const str of bareStrings) {
         logInfo(
           `"${str.text}" (${str.componentName ?? "unknown"}, ${str.file})`
@@ -2391,57 +3580,37 @@ var scanCommand = defineCommand({
       }
       return;
     }
-    const existingMap = await loadMapFile(config.messagesDir);
-    if (mode === "inline") {
-      const existingTComponents = result.strings.filter(
-        (s) => s.type === "T-component" && s.id
-      );
-      for (const tc of existingTComponents) {
-        if (tc.id && !(tc.text in existingMap)) {
-          existingMap[tc.text] = tc.id;
-        }
+    const scanUsageTracker = createUsageTracker();
+    const scanResult = await runScanStep({
+      config,
+      cwd: process.cwd(),
+      callbacks: {
+        onScanProgress: (c, t3) => logProgress(c, t3, "Scanning..."),
+        onKeygenProgress: (c, t3) => logProgress(c, t3, "Generating keys..."),
+        onUsage: (usage) => scanUsageTracker.add(usage)
       }
-      const existingInlineTCalls = result.strings.filter(
-        (s) => s.type === "t-call" && s.id
-      );
-      for (const tc of existingInlineTCalls) {
-        if (tc.id && !(tc.text in existingMap)) {
-          existingMap[tc.text] = tc.id;
-        }
-      }
-    }
-    logInfo("Generating semantic keys...");
-    const textToKey = await generateSemanticKeys({
-      model: config.model,
-      strings: bareStrings,
-      existingMap,
-      batchSize: config.translation?.batchSize ?? 50,
-      concurrency: config.translation?.concurrency ?? 3,
-      retries: config.translation?.retries ?? 2
     });
-    await writeMapFile(config.messagesDir, textToKey);
+    logProgressClear();
+    logScanResult(scanResult.bareStringCount, scanResult.fileCount);
     logSuccess(
-      `Written .translate-map.json (${Object.keys(textToKey).length} keys)`
+      `Written .translate-map.json (${Object.keys(scanResult.textToKey).length} keys)`
     );
     if (mode === "inline") {
       logInfo(
         "Inline mode: source text stays in code, no source locale JSON created."
       );
     } else {
-      const messages = {};
-      for (const [text2, key] of Object.entries(textToKey)) {
-        messages[key] = text2;
-      }
-      const sourceFile = join4(
+      const sourceFile = join6(
         config.messagesDir,
         `${config.sourceLocale}.json`
       );
-      await mkdir3(config.messagesDir, { recursive: true });
-      const nested = unflatten(messages);
-      const content = JSON.stringify(nested, null, 2) + "\n";
-      await writeFile4(sourceFile, content, "utf-8");
       logSuccess(`Written to ${sourceFile}`);
     }
+    const scanUsage = scanUsageTracker.get();
+    if (scanUsage.totalTokens > 0) {
+      const cost = await estimateCost(config.model, scanUsage);
+      logUsage(formatUsage(scanUsage), cost ? formatCost(cost.totalUSD) : void 0);
+    }
   }
 });
 var codegenCommand = defineCommand({
@@ -2465,12 +3634,12 @@ var codegenCommand = defineCommand({
       );
       process.exit(1);
     }
-    const textToKey = await loadMapFile(config.messagesDir);
-    if (Object.keys(textToKey).length === 0) {
-      logError("No .translate-map.json found. Run 'translate-kit scan' first.");
-      process.exit(1);
-    }
     if (args["dry-run"]) {
+      const textToKey = await loadMapFile(config.messagesDir);
+      if (Object.keys(textToKey).length === 0) {
+        logError("No .translate-map.json found. Run 'translate-kit scan' first.");
+        process.exit(1);
+      }
       if (mode === "inline") {
         logInfo(
           `
@@ -2492,17 +3661,22 @@ var codegenCommand = defineCommand({
       }
       return;
     }
-    const result = await codegen({
-      include: config.scan.include,
-      exclude: config.scan.exclude,
-      textToKey,
-      i18nImport: config.scan.i18nImport,
-      mode,
-      componentPath: config.inline?.componentPath
+    const result = await runCodegenStep({
+      config,
+      cwd: process.cwd(),
+      callbacks: {
+        onProgress: (c, t3) => logProgress(c, t3, "Processing files...")
+      }
     });
+    logProgressClear();
     logSuccess(
       `Codegen complete: ${result.stringsWrapped} strings wrapped in ${result.filesModified} files (${result.filesProcessed} files processed)`
     );
+    if (result.filesSkipped > 0) {
+      logWarning(
+        `${result.filesSkipped} file(s) skipped due to invalid generated syntax`
+      );
+    }
   }
 });
 var initCommand = defineCommand({
@@ -2530,13 +3704,14 @@ var main = defineCommand({
   // Default to translate command
   async run({ rawArgs }) {
     if (rawArgs.length === 0 || rawArgs[0]?.startsWith("-")) {
+      const { dryRun, force, verbose, locale } = parseTranslateFlags(rawArgs);
       await translateCommand.run({
         args: {
           _: rawArgs,
-          "dry-run": false,
-          force: false,
-          verbose: false,
-          locale: ""
+          "dry-run": dryRun,
+          force,
+          verbose,
+          locale: locale ?? ""
         },
         rawArgs,
         cmd: translateCommand