translate-kit 0.4.0 → 0.4.1

package/dist/cli.js

@@ -9,6 +9,108 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/scanner/filters.ts
+function isLikelyKebabIdentifier(text2) {
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)+$/.test(text2)) return false;
+  return text2.split("-").length >= 3;
+}
+function isLikelyConstantIdentifier(text2) {
+  return /^(?=.*[_\d])[A-Z0-9_]+$/.test(text2);
+}
+function isContentProperty(propName) {
+  return CONTENT_PROPERTY_NAMES.includes(propName);
+}
+function isTranslatableProp(propName, customProps) {
+  if (NEVER_TRANSLATE_PROPS.includes(propName)) return false;
+  const allowed = customProps ?? DEFAULT_TRANSLATABLE_PROPS;
+  return allowed.includes(propName);
+}
+function isIgnoredTag(tagName) {
+  return IGNORE_TAGS.includes(tagName.toLowerCase());
+}
+function shouldIgnore(text2) {
+  const trimmed = text2.trim();
+  if (trimmed.length === 0) return true;
+  if (isLikelyKebabIdentifier(trimmed)) return true;
+  if (isLikelyConstantIdentifier(trimmed)) return true;
+  return IGNORE_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+var DEFAULT_TRANSLATABLE_PROPS, NEVER_TRANSLATE_PROPS, IGNORE_TAGS, IGNORE_PATTERNS, CONTENT_PROPERTY_NAMES;
+var init_filters = __esm({
+  "src/scanner/filters.ts"() {
+    "use strict";
+    DEFAULT_TRANSLATABLE_PROPS = [
+      "placeholder",
+      "title",
+      "alt",
+      "aria-label",
+      "aria-description",
+      "aria-placeholder",
+      "label"
+    ];
+    NEVER_TRANSLATE_PROPS = [
+      "className",
+      "class",
+      "id",
+      "key",
+      "ref",
+      "href",
+      "src",
+      "type",
+      "name",
+      "value",
+      "htmlFor",
+      "for",
+      "role",
+      "style",
+      "data-testid",
+      "data-cy",
+      "onClick",
+      "onChange",
+      "onSubmit",
+      "onFocus",
+      "onBlur"
+    ];
+    IGNORE_TAGS = [
+      "script",
+      "style",
+      "code",
+      "pre",
+      "svg",
+      "path",
+      "circle",
+      "rect",
+      "line",
+      "polyline",
+      "polygon"
+    ];
+    IGNORE_PATTERNS = [
+      /^\s*$/,
+      // Whitespace only
+      /^https?:\/\//,
+      // URLs
+      /^[\d.,%$€£¥]+$/,
+      // Numbers, currency
+      /^[^\p{L}]*$/u
+      // No letters at all (Unicode-aware)
+    ];
+    CONTENT_PROPERTY_NAMES = [
+      "title",
+      "description",
+      "label",
+      "text",
+      "content",
+      "heading",
+      "subtitle",
+      "caption",
+      "summary",
+      "message",
+      "placeholder",
+      "alt"
+    ];
+  }
+});
+
 // src/config.ts
 import { loadConfig } from "c12";
 import { z } from "zod";
@@ -33,6 +135,7 @@ var configSchema;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
+    init_filters();
     configSchema = z.object({
       model: z.custom(
         (val) => val != null && typeof val === "object",
@@ -56,7 +159,7 @@ var init_config = __esm({
       scan: z.object({
         include: z.array(z.string()),
         exclude: z.array(z.string()).optional(),
-        translatableProps: z.array(z.string()).default(["placeholder", "title", "alt", "aria-label"]),
+        translatableProps: z.array(z.string()).default([...DEFAULT_TRANSLATABLE_PROPS]),
         i18nImport: z.string().default("next-intl")
       }).optional(),
       inline: z.object({
@@ -188,108 +291,6 @@ var init_parser = __esm({
   }
 });
 
-// src/scanner/filters.ts
-function isLikelyKebabIdentifier(text2) {
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)+$/.test(text2)) return false;
-  return text2.split("-").length >= 3;
-}
-function isLikelyConstantIdentifier(text2) {
-  return /^(?=.*[_\d])[A-Z0-9_]+$/.test(text2);
-}
-function isContentProperty(propName) {
-  return CONTENT_PROPERTY_NAMES.includes(propName);
-}
-function isTranslatableProp(propName, customProps) {
-  if (NEVER_TRANSLATE_PROPS.includes(propName)) return false;
-  const allowed = customProps ?? DEFAULT_TRANSLATABLE_PROPS;
-  return allowed.includes(propName);
-}
-function isIgnoredTag(tagName) {
-  return IGNORE_TAGS.includes(tagName.toLowerCase());
-}
-function shouldIgnore(text2) {
-  const trimmed = text2.trim();
-  if (trimmed.length === 0) return true;
-  if (isLikelyKebabIdentifier(trimmed)) return true;
-  if (isLikelyConstantIdentifier(trimmed)) return true;
-  return IGNORE_PATTERNS.some((pattern) => pattern.test(trimmed));
-}
-var DEFAULT_TRANSLATABLE_PROPS, NEVER_TRANSLATE_PROPS, IGNORE_TAGS, IGNORE_PATTERNS, CONTENT_PROPERTY_NAMES;
-var init_filters = __esm({
-  "src/scanner/filters.ts"() {
-    "use strict";
-    DEFAULT_TRANSLATABLE_PROPS = [
-      "placeholder",
-      "title",
-      "alt",
-      "aria-label",
-      "aria-description",
-      "aria-placeholder",
-      "label"
-    ];
-    NEVER_TRANSLATE_PROPS = [
-      "className",
-      "class",
-      "id",
-      "key",
-      "ref",
-      "href",
-      "src",
-      "type",
-      "name",
-      "value",
-      "htmlFor",
-      "for",
-      "role",
-      "style",
-      "data-testid",
-      "data-cy",
-      "onClick",
-      "onChange",
-      "onSubmit",
-      "onFocus",
-      "onBlur"
-    ];
-    IGNORE_TAGS = [
-      "script",
-      "style",
-      "code",
-      "pre",
-      "svg",
-      "path",
-      "circle",
-      "rect",
-      "line",
-      "polyline",
-      "polygon"
-    ];
-    IGNORE_PATTERNS = [
-      /^\s*$/,
-      // Whitespace only
-      /^https?:\/\//,
-      // URLs
-      /^[\d.,%$€£¥]+$/,
-      // Numbers, currency
-      /^[^\p{L}]*$/u
-      // No letters at all (Unicode-aware)
-    ];
-    CONTENT_PROPERTY_NAMES = [
-      "title",
-      "description",
-      "label",
-      "text",
-      "content",
-      "heading",
-      "subtitle",
-      "caption",
-      "summary",
-      "message",
-      "placeholder",
-      "alt"
-    ];
-  }
-});
-
 // src/utils/ast-helpers.ts
 function resolveDefault(mod) {
   if (typeof mod === "function") return mod;
@@ -374,6 +375,31 @@ function getComponentName(path) {
   }
   return void 0;
 }
+function isPascalCase(name) {
+  if (name === "__default__") return true;
+  return /^[A-Z]/.test(name);
+}
+function getTopLevelConstName(path) {
+  let current = path.parentPath;
+  while (current) {
+    if (current.isFunctionDeclaration() || current.isFunctionExpression() || current.isArrowFunctionExpression() || current.isClassDeclaration() || current.isClassExpression() || current.isClassMethod() || current.isClassPrivateMethod()) {
+      return void 0;
+    }
+    if (current.isVariableDeclarator()) {
+      const declParent = current.parentPath;
+      if (declParent?.isVariableDeclaration() && declParent.node.kind === "const") {
+        const grandParent = declParent.parentPath;
+        if (grandParent?.isProgram() || grandParent?.isExportNamedDeclaration()) {
+          const id = current.node.id;
+          if (id.type === "Identifier") return id.name;
+        }
+      }
+      return void 0;
+    }
+    current = current.parentPath;
+  }
+  return void 0;
+}
 function getParentTagName(path) {
   let current = path.parentPath;
   while (current) {
@@ -617,11 +643,59 @@ function extractStrings(ast, filePath, translatableProps) {
       });
     },
     ObjectProperty(path) {
-      if (!isInsideFunction(path)) return;
+      const inFunction = isInsideFunction(path);
+      if (!inFunction) {
+        const constName = getTopLevelConstName(path);
+        if (!constName) return;
+        const keyNode2 = path.node.key;
+        if (keyNode2.type !== "Identifier" && keyNode2.type !== "StringLiteral")
+          return;
+        const propName2 = keyNode2.type === "Identifier" ? keyNode2.name : keyNode2.value;
+        if (!isContentProperty(propName2)) return;
+        const valueNode2 = path.node.value;
+        if (valueNode2.type === "ConditionalExpression") {
+          const texts = collectConditionalTexts(valueNode2);
+          for (const t3 of texts) {
+            results.push({
+              text: t3,
+              type: "module-object-property",
+              file: filePath,
+              line: valueNode2.loc?.start.line ?? 0,
+              column: valueNode2.loc?.start.column ?? 0,
+              propName: propName2,
+              parentConstName: constName
+            });
+          }
+          return;
+        }
+        let text3;
+        if (valueNode2.type === "StringLiteral") {
+          text3 = valueNode2.value.trim();
+        } else if (valueNode2.type === "TemplateLiteral") {
+          const info = buildTemplateLiteralText(
+            valueNode2.quasis,
+            valueNode2.expressions
+          );
+          if (info) text3 = info.text;
+        }
+        if (!text3 || shouldIgnore(text3)) return;
+        results.push({
+          text: text3,
+          type: "module-object-property",
+          file: filePath,
+          line: valueNode2.loc?.start.line ?? 0,
+          column: valueNode2.loc?.start.column ?? 0,
+          propName: propName2,
+          parentConstName: constName
+        });
+        return;
+      }
       const ownerFn = getNearestFunctionPath(path);
       if (!ownerFn) return;
       if (!functionContainsJSX(ownerFn)) return;
-      const componentName = getComponentName(ownerFn);
+      const componentName = getComponentName(
+        ownerFn
+      );
       if (!componentName) return;
       const keyNode = path.node.key;
       if (keyNode.type !== "Identifier" && keyNode.type !== "StringLiteral")
@@ -740,14 +814,14 @@ var init_extractor = __esm({
 
 // src/scanner/context-enricher.ts
 function deriveRoutePath(filePath) {
-  const appMatch = filePath.match(/src\/app\/(.+?)\/page\.[jt]sx?$/);
+  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\/(.+?)\//);
+  const compMatch = filePath.match(/(?:src\/)?components\/(.+?)\//);
   if (compMatch) return compMatch[1];
   return void 0;
 }
@@ -981,6 +1055,7 @@ function buildPrompt(strings, existingMap) {
       if (str.componentName) parts.push(`component: ${str.componentName}`);
       if (str.parentTag) parts.push(`tag: ${str.parentTag}`);
       if (str.propName) parts.push(`prop: ${str.propName}`);
+      if (str.parentConstName) parts.push(`const: ${str.parentConstName}`);
       if (str.sectionHeading) parts.push(`section: "${str.sectionHeading}"`);
       if (str.siblingTexts?.length) {
         parts.push(
@@ -1368,7 +1443,11 @@ function resolveNamedImportLocal(ast, importSource, importedName) {
   return null;
 }
 function ensureNamedImportLocal(ast, importSource, importedName) {
-  const existingLocal = resolveNamedImportLocal(ast, importSource, importedName);
+  const existingLocal = resolveNamedImportLocal(
+    ast,
+    importSource,
+    importedName
+  );
   if (existingLocal) return existingLocal;
   for (const node of ast.program.body) {
     if (node.type !== "ImportDeclaration" || node.source.value !== importSource) {
@@ -1380,12 +1459,7 @@ function ensureNamedImportLocal(ast, importSource, importedName) {
     return importedName;
   }
   const importDecl = t2.importDeclaration(
-    [
-      t2.importSpecifier(
-        t2.identifier(importedName),
-        t2.identifier(importedName)
-      )
-    ],
+    [t2.importSpecifier(t2.identifier(importedName), t2.identifier(importedName))],
     t2.stringLiteral(importSource)
   );
   const lastImportIndex = findLastImportIndex(ast);
@@ -1562,6 +1636,142 @@ function transformConditionalBranchInline(node, textToKey) {
   }
   return { node, count: 0 };
 }
+function preDiscoverFactoryRefComponents(ast, importedNames) {
+  if (importedNames.length === 0) return /* @__PURE__ */ new Set();
+  const nameSet = new Set(importedNames);
+  const comps = /* @__PURE__ */ new Set();
+  traverse2(ast, {
+    Identifier(path) {
+      if (!nameSet.has(path.node.name)) return;
+      const parent = path.parent;
+      if (parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier" || parent.type === "ImportNamespaceSpecifier" || parent.type === "ExportSpecifier") return;
+      if (parent.type === "VariableDeclarator" && parent.id === path.node) return;
+      if (parent.type === "CallExpression" && parent.callee === path.node) return;
+      const binding = path.scope?.getBinding(path.node.name);
+      if (binding) {
+        const bPath = binding.path;
+        const isImportBinding = bPath.isImportSpecifier() || bPath.isImportDefaultSpecifier();
+        const isTopLevelConst = bPath.isVariableDeclarator() && bPath.parentPath?.isVariableDeclaration() && (bPath.parentPath.parentPath?.isProgram() || bPath.parentPath.parentPath?.isExportNamedDeclaration());
+        if (!isImportBinding && !isTopLevelConst) return;
+      }
+      if (!isInsideFunction(path)) return;
+      const comp = getComponentName(path);
+      if (comp && isPascalCase(comp)) comps.add(comp);
+    }
+  });
+  return comps;
+}
+function wrapModuleFactoryDeclarations(ast, constNames) {
+  if (constNames.length === 0) return false;
+  const nameSet = new Set(constNames);
+  let wrapped = false;
+  for (const node of ast.program.body) {
+    let decl;
+    if (node.type === "VariableDeclaration") {
+      decl = node;
+    } else if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration") {
+      decl = node.declaration;
+    }
+    if (!decl || decl.kind !== "const") continue;
+    for (const declarator of decl.declarations) {
+      if (declarator.id.type !== "Identifier") continue;
+      if (!nameSet.has(declarator.id.name)) continue;
+      if (!declarator.init) continue;
+      const typeAnnotation = declarator.id.typeAnnotation;
+      if (typeAnnotation) {
+        declarator.id.typeAnnotation = null;
+      }
+      if (declarator.init.type === "ArrowFunctionExpression" && declarator.init.params.length === 1 && declarator.init.params[0].type === "Identifier" && declarator.init.params[0].name === "t") {
+        continue;
+      }
+      const originalInit = declarator.init;
+      const tParam = t2.identifier("t");
+      tParam.typeAnnotation = t2.tsTypeAnnotation(t2.tsAnyKeyword());
+      const arrowFn = t2.arrowFunctionExpression(
+        [tParam],
+        t2.parenthesizedExpression(originalInit)
+      );
+      if (typeAnnotation) {
+        arrowFn.returnType = typeAnnotation;
+      }
+      declarator.init = arrowFn;
+      wrapped = true;
+    }
+  }
+  return wrapped;
+}
+function isInsideFunctionParam(path) {
+  let current = path;
+  while (current.parentPath) {
+    if (current.parentPath.isFunction()) {
+      const fn = current.parentPath.node;
+      return fn.params.includes(current.node);
+    }
+    current = current.parentPath;
+  }
+  return false;
+}
+function rewriteModuleFactoryReferences(ast, importedNames, componentTranslatorIds) {
+  if (importedNames.length === 0) return { componentsNeedingT: /* @__PURE__ */ new Set(), rewrote: false };
+  const nameSet = new Set(importedNames);
+  const componentsNeedingT = /* @__PURE__ */ new Set();
+  let rewrote = false;
+  const rewrites = [];
+  traverse2(ast, {
+    Identifier(path) {
+      if (!nameSet.has(path.node.name)) return;
+      const parent = path.parent;
+      if (parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier" || parent.type === "ImportNamespaceSpecifier" || parent.type === "ExportSpecifier") {
+        return;
+      }
+      if (parent.type.startsWith("TS") && parent.type !== "TSNonNullExpression" && parent.type !== "TSAsExpression" && parent.type !== "TSSatisfiesExpression") {
+        return;
+      }
+      if (parent.type === "CallExpression" && parent.callee === path.node) {
+        return;
+      }
+      if (parent.type === "ObjectProperty" && parent.key === path.node) {
+        if (parent.shorthand) {
+          if (path.key === "key") return;
+        } else {
+          return;
+        }
+      }
+      const binding = path.scope?.getBinding(path.node.name);
+      if (binding) {
+        const bPath = binding.path;
+        const isImportBinding = bPath.isImportSpecifier() || bPath.isImportDefaultSpecifier();
+        const isTopLevelConst = bPath.isVariableDeclarator() && bPath.parentPath?.isVariableDeclaration() && (bPath.parentPath.parentPath?.isProgram() || bPath.parentPath.parentPath?.isExportNamedDeclaration());
+        if (!isImportBinding && !isTopLevelConst) return;
+      }
+      if (isInsideFunctionParam(path)) return;
+      if (!isInsideFunction(path)) return;
+      const compName = getComponentName(path);
+      if (!compName || !isPascalCase(compName)) return;
+      const translatorId = componentTranslatorIds.get(compName) ?? "t";
+      if (parent.type === "ObjectProperty" && parent.shorthand) {
+        rewrites.push({ path, translatorId, compName, shorthandProp: parent });
+      } else {
+        rewrites.push({ path, translatorId, compName });
+      }
+    }
+  });
+  for (const { path, translatorId, compName, shorthandProp } of rewrites) {
+    const callExpr = t2.callExpression(
+      t2.identifier(path.node.name),
+      [t2.identifier(translatorId)]
+    );
+    if (shorthandProp) {
+      shorthandProp.shorthand = false;
+      shorthandProp.value = callExpr;
+    } else {
+      path.replaceWith(callExpr);
+    }
+    componentsNeedingT.add(compName);
+    rewrote = true;
+  }
+  return { componentsNeedingT, rewrote };
+}
 function transform(ast, textToKey, options = {}) {
   if (options.mode === "inline") {
     return transformInline(ast, textToKey, options);
@@ -1592,6 +1802,8 @@ function transform(ast, textToKey, options = {}) {
       if (isInsideClass(path)) return;
       const text2 = path.node.value.trim();
       if (!text2 || !(text2 in textToKey)) return;
+      const compName = getComponentName(path);
+      if (!compName || !isPascalCase(compName)) return;
       const parent = path.parentPath;
       if (!parent?.isJSXElement()) return;
       const key = textToKey[text2];
@@ -1623,6 +1835,8 @@ function transform(ast, textToKey, options = {}) {
       if (isInsideClass(path)) return;
       const expr = path.node.expression;
       if (path.parent.type === "JSXAttribute") return;
+      const compName = getComponentName(path);
+      if (!compName || !isPascalCase(compName)) return;
       if (expr.type === "ConditionalExpression") {
         const result = transformConditionalBranch(expr, textToKey);
         if (result.count > 0) {
@@ -1654,6 +1868,11 @@ function transform(ast, textToKey, options = {}) {
       if (isInsideClass(path)) return;
       const value = path.node.value;
       if (!value) return;
+      const attrName = path.node.name;
+      const propName = attrName.type === "JSXIdentifier" ? attrName.name : attrName.name.name;
+      if (!isTranslatableProp(propName, options.translatableProps)) return;
+      const compName = getComponentName(path);
+      if (!compName || !isPascalCase(compName)) return;
       if (value.type === "JSXExpressionContainer" && value.expression.type === "ConditionalExpression") {
         const result = transformConditionalBranch(value.expression, textToKey);
         if (result.count > 0) {
@@ -1708,8 +1927,66 @@ function transform(ast, textToKey, options = {}) {
     },
     ObjectProperty(path) {
       if (isInsideClass(path)) return;
-      if (!isInsideFunction(path)) return;
-      const ownerFn = getNearestFunctionPath2(path);
+      const factoryConstNames = options.moduleFactoryConstNames ?? [];
+      const inFunction = isInsideFunction(path);
+      if (!inFunction) {
+        const constName = getTopLevelConstName(path);
+        if (!constName || !factoryConstNames.includes(constName)) return;
+        const keyNode2 = path.node.key;
+        if (keyNode2.type !== "Identifier" && keyNode2.type !== "StringLiteral")
+          return;
+        const propName2 = keyNode2.type === "Identifier" ? keyNode2.name : keyNode2.value;
+        if (!isContentProperty(propName2)) return;
+        const valueNode2 = path.node.value;
+        if (valueNode2.type === "ConditionalExpression") {
+          const result = transformConditionalBranch(valueNode2, textToKey);
+          if (result.count > 0) {
+            path.node.value = result.node;
+            stringsWrapped += result.count;
+            collectConditionalKeys(valueNode2, textToKey).forEach(
+              (k) => allUsedKeys.push(k)
+            );
+          }
+          return;
+        }
+        let text3;
+        let templateInfo2;
+        if (valueNode2.type === "StringLiteral") {
+          text3 = valueNode2.value;
+        } else if (valueNode2.type === "TemplateLiteral") {
+          const info = buildTemplateLiteralText(
+            valueNode2.quasis,
+            valueNode2.expressions
+          );
+          if (info) {
+            text3 = info.text;
+            templateInfo2 = {
+              placeholders: info.placeholders,
+              expressions: valueNode2.expressions
+            };
+          }
+        }
+        if (!text3 || !(text3 in textToKey)) return;
+        const key2 = textToKey[text3];
+        const args2 = [t2.stringLiteral(key2)];
+        if (templateInfo2 && templateInfo2.placeholders.length > 0) {
+          args2.push(
+            buildValuesObject(
+              templateInfo2.expressions,
+              templateInfo2.placeholders
+            )
+          );
+        }
+        path.node.value = markGeneratedCall(
+          t2.callExpression(t2.identifier("t"), args2)
+        );
+        stringsWrapped++;
+        allUsedKeys.push(key2);
+        return;
+      }
+      const ownerFn = getNearestFunctionPath2(
+        path
+      );
       if (!ownerFn) return;
       if (!functionContainsJSX2(ownerFn.node)) return;
       const compName = getComponentName(ownerFn);
@@ -1766,7 +2043,8 @@ function transform(ast, textToKey, options = {}) {
       trackKey(path, key);
     }
   });
-  if (stringsWrapped === 0) {
+  const hasModuleFactoryWork = (options.moduleFactoryConstNames?.length ?? 0) > 0 || (options.moduleFactoryImportedNames?.length ?? 0) > 0;
+  if (stringsWrapped === 0 && !hasModuleFactoryWork) {
     return {
       code: generate(ast).code,
       stringsWrapped: 0,
@@ -1774,18 +2052,28 @@ function transform(ast, textToKey, options = {}) {
       usedKeys: []
     };
   }
+  const moduleFactoryImportedNames = options.moduleFactoryImportedNames ?? [];
+  const factoryRefComponents = preDiscoverFactoryRefComponents(ast, moduleFactoryImportedNames);
+  for (const comp of factoryRefComponents) {
+    componentsNeedingT.add(comp);
+  }
   const componentNamespaces = /* @__PURE__ */ new Map();
   for (const [comp, keys] of componentKeys) {
-    componentNamespaces.set(comp, detectNamespace([...keys]));
+    if (factoryRefComponents.has(comp)) {
+      componentNamespaces.set(comp, null);
+    } else {
+      componentNamespaces.set(comp, detectNamespace([...keys]));
+    }
+  }
+  for (const comp of factoryRefComponents) {
+    if (!componentNamespaces.has(comp)) {
+      componentNamespaces.set(comp, null);
+    }
   }
   const namespacedComponents = /* @__PURE__ */ new Set();
   const componentTranslatorIds = /* @__PURE__ */ new Map();
   if (isClient) {
-    const useTranslationsLocal = ensureNamedImportLocal(
-      ast,
-      importSource,
-      "useTranslations"
-    );
+    const useTranslationsLocal = componentsNeedingT.size > 0 ? ensureNamedImportLocal(ast, importSource, "useTranslations") : "useTranslations";
     traverse2(ast, {
       FunctionDeclaration(path) {
         const name = getComponentName(path);
@@ -1881,11 +2169,7 @@ function transform(ast, textToKey, options = {}) {
     });
   } else {
     const serverSource = `${importSource}/server`;
-    const getTranslationsLocal = ensureNamedImportLocal(
-      ast,
-      serverSource,
-      "getTranslations"
-    );
+    const getTranslationsLocal = componentsNeedingT.size > 0 ? ensureNamedImportLocal(ast, serverSource, "getTranslations") : "getTranslations";
     traverse2(ast, {
       FunctionDeclaration(path) {
         const name = getComponentName(path);
@@ -1991,20 +2275,31 @@ function transform(ast, textToKey, options = {}) {
       noScope: true
     });
   }
+  const moduleFactoryConstNames = options.moduleFactoryConstNames ?? [];
+  const didWrapFactory = wrapModuleFactoryDeclarations(ast, moduleFactoryConstNames);
   const effectiveNamespaces = /* @__PURE__ */ new Map();
   for (const [comp, ns] of componentNamespaces) {
     effectiveNamespaces.set(comp, namespacedComponents.has(comp) ? ns : null);
   }
   rewriteKeysForNamespaces(ast, effectiveNamespaces);
   rewriteGeneratedCallsForTranslator(ast, componentTranslatorIds);
+  const { componentsNeedingT: factoryComponentsNeedingT, rewrote: didRewriteRefs } = rewriteModuleFactoryReferences(
+    ast,
+    moduleFactoryImportedNames,
+    componentTranslatorIds
+  );
+  for (const comp of factoryComponentsNeedingT) {
+    componentsNeedingT.add(comp);
+  }
   if (needsClientDirective && componentsNeedingT.size > 0) {
     addUseClientDirective(ast);
   }
+  const didModify = stringsWrapped > 0 || didWrapFactory || didRewriteRefs;
   const output = generate(ast, { retainLines: false });
   return {
     code: output.code,
     stringsWrapped,
-    modified: true,
+    modified: didModify,
     usedKeys: allUsedKeys
   };
 }
@@ -2044,7 +2339,10 @@ function injectTIntoBlock(block, useTranslationsLocal, namespace, componentName,
       if (d.id.type !== "Identifier") continue;
       if (isTranslationFactoryCall(d.init, useTranslationsLocal)) {
         return {
-          namespaced: updateCallNamespace(d.init, namespace),
+          namespaced: updateCallNamespace(
+            d.init,
+            namespace
+          ),
           translatorId: d.id.name
         };
       }
@@ -2088,7 +2386,10 @@ function injectAsyncTIntoBlock(block, getTranslationsLocal, namespace, component
       }
       if (isGetTranslationsCall(d.init, getTranslationsLocal)) {
         return {
-          namespaced: updateCallNamespace(d.init, namespace),
+          namespaced: updateCallNamespace(
+            d.init,
+            namespace
+          ),
           translatorId: d.id.name
         };
       }
@@ -2291,9 +2592,7 @@ function addUseClientDirective(ast) {
   if (!ast.program.directives) {
     ast.program.directives = [];
   }
-  ast.program.directives.unshift(
-    t2.directive(t2.directiveLiteral("use client"))
-  );
+  ast.program.directives.unshift(t2.directive(t2.directiveLiteral("use client")));
 }
 function transformInline(ast, textToKey, options) {
   const componentPath = options.componentPath ?? "@/components/t";
@@ -2327,6 +2626,8 @@ function transformInline(ast, textToKey, options) {
       if (isInsideClass(path)) return;
       const text2 = path.node.value.trim();
       if (!text2 || !(text2 in textToKey)) return;
+      const compName = getComponentName(path);
+      if (!compName || !isPascalCase(compName)) return;
       const parent = path.parentPath;
       if (!parent?.isJSXElement()) return;
       const parentOpening = parent.node.openingElement;
@@ -2365,13 +2666,14 @@ function transformInline(ast, textToKey, options) {
       if (isInsideClass(path)) return;
       const expr = path.node.expression;
       if (path.parent.type === "JSXAttribute") return;
+      const compName = getComponentName(path);
+      if (!compName || !isPascalCase(compName)) 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);
+          componentsNeedingT.add(compName);
         }
         return;
       }
@@ -2390,13 +2692,17 @@ function transformInline(ast, textToKey, options) {
         t2.callExpression(t2.identifier("t"), args)
       );
       stringsWrapped++;
-      const compName = getComponentName(path);
-      if (compName) componentsNeedingT.add(compName);
+      componentsNeedingT.add(compName);
     },
     JSXAttribute(path) {
       if (isInsideClass(path)) return;
       const value = path.node.value;
       if (!value) return;
+      const attrName = path.node.name;
+      const propName = attrName.type === "JSXIdentifier" ? attrName.name : attrName.name.name;
+      if (!isTranslatableProp(propName, options.translatableProps)) return;
+      const compName = getComponentName(path);
+      if (!compName || !isPascalCase(compName)) return;
       if (value.type === "JSXExpressionContainer" && value.expression.type === "ConditionalExpression") {
         const result = transformConditionalBranchInline(
           value.expression,
@@ -2405,8 +2711,7 @@ function transformInline(ast, textToKey, options) {
         if (result.count > 0) {
           path.node.value = t2.jsxExpressionContainer(result.node);
           stringsWrapped += result.count;
-          const compName2 = getComponentName(path);
-          if (compName2) componentsNeedingT.add(compName2);
+          componentsNeedingT.add(compName);
         }
         return;
       }
@@ -2452,13 +2757,69 @@ function transformInline(ast, textToKey, options) {
         markGeneratedCall(t2.callExpression(t2.identifier("t"), args))
       );
       stringsWrapped++;
-      const compName = getComponentName(path);
-      if (compName) componentsNeedingT.add(compName);
+      componentsNeedingT.add(compName);
     },
     ObjectProperty(path) {
       if (isInsideClass(path)) return;
-      if (!isInsideFunction(path)) return;
-      const ownerFn = getNearestFunctionPath2(path);
+      const factoryConstNames = options.moduleFactoryConstNames ?? [];
+      const inFunction = isInsideFunction(path);
+      if (!inFunction) {
+        const constName = getTopLevelConstName(path);
+        if (!constName || !factoryConstNames.includes(constName)) return;
+        const keyNode2 = path.node.key;
+        if (keyNode2.type !== "Identifier" && keyNode2.type !== "StringLiteral")
+          return;
+        const propName2 = keyNode2.type === "Identifier" ? keyNode2.name : keyNode2.value;
+        if (!isContentProperty(propName2)) return;
+        const valueNode2 = path.node.value;
+        if (valueNode2.type === "ConditionalExpression") {
+          const result = transformConditionalBranchInline(valueNode2, textToKey);
+          if (result.count > 0) {
+            path.node.value = result.node;
+            stringsWrapped += result.count;
+          }
+          return;
+        }
+        let text3;
+        let templateInfo2;
+        if (valueNode2.type === "StringLiteral") {
+          text3 = valueNode2.value;
+        } else if (valueNode2.type === "TemplateLiteral") {
+          const info = buildTemplateLiteralText(
+            valueNode2.quasis,
+            valueNode2.expressions
+          );
+          if (info) {
+            text3 = info.text;
+            templateInfo2 = {
+              placeholders: info.placeholders,
+              expressions: valueNode2.expressions
+            };
+          }
+        }
+        if (!text3 || !(text3 in textToKey)) return;
+        const key2 = textToKey[text3];
+        const args2 = [
+          t2.stringLiteral(text3),
+          t2.stringLiteral(key2)
+        ];
+        if (templateInfo2 && templateInfo2.placeholders.length > 0) {
+          args2.push(
+            buildValuesObject(
+              templateInfo2.expressions,
+              templateInfo2.placeholders
+            )
+          );
+        }
+        path.node.value = markGeneratedCall(
+          t2.callExpression(t2.identifier("t"), args2)
+        );
+        stringsWrapped++;
+        return;
+      }
+      const ownerFn = getNearestFunctionPath2(
+        path
+      );
       if (!ownerFn) return;
       if (!functionContainsJSX2(ownerFn.node)) return;
       const compName = getComponentName(ownerFn);
@@ -2516,7 +2877,8 @@ function transformInline(ast, textToKey, options) {
       componentsNeedingT.add(compName);
     }
   });
-  if (stringsWrapped === 0 && !repaired && !boundaryRepaired) {
+  const hasModuleFactoryWorkInline = (options.moduleFactoryConstNames?.length ?? 0) > 0 || (options.moduleFactoryImportedNames?.length ?? 0) > 0;
+  if (stringsWrapped === 0 && !repaired && !boundaryRepaired && !hasModuleFactoryWorkInline) {
     return {
       code: generate(ast).code,
       stringsWrapped: 0,
@@ -2524,7 +2886,7 @@ function transformInline(ast, textToKey, options) {
       usedKeys: []
     };
   }
-  if (stringsWrapped === 0 && (repaired || boundaryRepaired)) {
+  if (stringsWrapped === 0 && !hasModuleFactoryWorkInline && (repaired || boundaryRepaired)) {
     if (needsClientDirective && boundaryRepaired) {
       addUseClientDirective(ast);
     }
@@ -2536,6 +2898,11 @@ function transformInline(ast, textToKey, options) {
       usedKeys: []
     };
   }
+  const moduleFactoryImportedNamesInline = options.moduleFactoryImportedNames ?? [];
+  const factoryRefComponentsInline = preDiscoverFactoryRefComponents(ast, moduleFactoryImportedNamesInline);
+  for (const comp of factoryRefComponentsInline) {
+    componentsNeedingT.add(comp);
+  }
   const needsHook = componentsNeedingT.size > 0;
   const hookName = isClient ? "useT" : "createT";
   const importPath = isClient ? componentPath : `${componentPath}-server`;
@@ -2585,6 +2952,7 @@ function transformInline(ast, textToKey, options) {
     const importedHookName = isClient ? "useT" : "createT";
     const hookLocalName = resolveImportedLocalName(ast, hookSources, importedHookName) ?? importedHookName;
     const hookCall = isClient ? t2.callExpression(t2.identifier(hookLocalName), []) : t2.callExpression(t2.identifier(hookLocalName), []);
+    const serverAwait = !isClient;
     traverse2(ast, {
       FunctionDeclaration(path) {
         const name = getComponentName(path);
@@ -2595,7 +2963,8 @@ function transformInline(ast, textToKey, options) {
           body,
           hookCall,
           name,
-          path.node
+          path.node,
+          serverAwait
         );
         componentTranslatorIds.set(name, translatorId);
       },
@@ -2611,7 +2980,8 @@ function transformInline(ast, textToKey, options) {
             block,
             hookCall,
             name,
-            init
+            init,
+            serverAwait
           );
           componentTranslatorIds.set(name, translatorId);
           return;
@@ -2624,7 +2994,8 @@ function transformInline(ast, textToKey, options) {
             block,
             hookCall,
             name,
-            wrappedFn
+            wrappedFn,
+            serverAwait
           );
           componentTranslatorIds.set(name, translatorId);
         }
@@ -2638,7 +3009,8 @@ function transformInline(ast, textToKey, options) {
             decl.body,
             hookCall,
             name,
-            decl
+            decl,
+            serverAwait
           );
           componentTranslatorIds.set(name, translatorId);
           return;
@@ -2649,7 +3021,8 @@ function transformInline(ast, textToKey, options) {
             block,
             hookCall,
             name,
-            decl
+            decl,
+            serverAwait
           );
           componentTranslatorIds.set(name, translatorId);
           return;
@@ -2662,7 +3035,8 @@ function transformInline(ast, textToKey, options) {
             block,
             hookCall,
             name,
-            wrappedFn
+            wrappedFn,
+            serverAwait
           );
           componentTranslatorIds.set(name, translatorId);
         }
@@ -2670,24 +3044,44 @@ function transformInline(ast, textToKey, options) {
       noScope: true
     });
   }
+  const moduleFactoryConstNames = options.moduleFactoryConstNames ?? [];
+  const didWrapFactoryInline = wrapModuleFactoryDeclarations(ast, moduleFactoryConstNames);
   rewriteGeneratedCallsForTranslator(ast, componentTranslatorIds);
+  const moduleFactoryImportedNames = options.moduleFactoryImportedNames ?? [];
+  const { componentsNeedingT: factoryComponentsNeedingT, rewrote: didRewriteRefsInline } = rewriteModuleFactoryReferences(
+    ast,
+    moduleFactoryImportedNames,
+    componentTranslatorIds
+  );
+  for (const comp of factoryComponentsNeedingT) {
+    componentsNeedingT.add(comp);
+  }
   if (needsClientDirective && (needsHook || boundaryRepaired)) {
     addUseClientDirective(ast);
   }
+  const didModifyInline = stringsWrapped > 0 || repaired || boundaryRepaired || didWrapFactoryInline || didRewriteRefsInline;
   const output = generate(ast, { retainLines: false });
-  return { code: output.code, stringsWrapped, modified: true, usedKeys: [] };
+  return { code: output.code, stringsWrapped, modified: didModifyInline, usedKeys: [] };
 }
-function injectInlineHookIntoBlock(block, hookCall, componentName, ownerFn) {
+function injectInlineHookIntoBlock(block, hookCall, componentName, ownerFn, useAwait) {
   const targetName = hookCall.callee.type === "Identifier" ? hookCall.callee.name : void 0;
   let sawConflictingT = false;
   for (const stmt of block.body) {
     if (stmt.type !== "VariableDeclaration") continue;
     for (const d of stmt.declarations) {
       if (d.id.type !== "Identifier") continue;
-      if (d.init?.type === "CallExpression" && d.init.callee.type === "Identifier" && (d.init.callee.name === "useT" || d.init.callee.name === "createT" || (targetName ? d.init.callee.name === targetName : false))) {
+      const callExpr = d.init?.type === "AwaitExpression" && d.init.argument.type === "CallExpression" ? d.init.argument : d.init?.type === "CallExpression" ? d.init : null;
+      if (callExpr && callExpr.callee.type === "Identifier" && (callExpr.callee.name === "useT" || callExpr.callee.name === "createT" || (targetName ? callExpr.callee.name === targetName : false))) {
         const translatorId2 = d.id.name;
-        if (targetName && d.init.callee.name !== targetName) {
-          d.init.callee = t2.identifier(targetName);
+        if (targetName && callExpr.callee.name !== targetName) {
+          callExpr.callee = t2.identifier(targetName);
+        }
+        if (useAwait && d.init?.type !== "AwaitExpression") {
+          d.init = t2.awaitExpression(d.init);
+          if (ownerFn && !ownerFn.async) {
+            ownerFn.async = true;
+            ownerFn.returnType = null;
+          }
         }
         return translatorId2;
       }
@@ -2701,13 +3095,15 @@ function injectInlineHookIntoBlock(block, hookCall, componentName, ownerFn) {
   Injected fallback translator "${translatorId}" to avoid conflicts.` : `Detected "const t = ..." conflict. Injected fallback translator "${translatorId}".`
     );
   }
+  const initExpr = useAwait ? t2.awaitExpression(t2.cloneNode(hookCall, true)) : t2.cloneNode(hookCall, true);
   const tDecl = t2.variableDeclaration("const", [
-    t2.variableDeclarator(
-      t2.identifier(translatorId),
-      t2.cloneNode(hookCall, true)
-    )
+    t2.variableDeclarator(t2.identifier(translatorId), initExpr)
   ]);
   block.body.unshift(tDecl);
+  if (useAwait && ownerFn && !ownerFn.async) {
+    ownerFn.async = true;
+    ownerFn.returnType = null;
+  }
   return translatorId;
 }
 var traverse2, generate;
@@ -2724,7 +3120,7 @@ var init_transform = __esm({
 });
 
 // src/codegen/index.ts
-import { dirname, extname, join as join2, resolve } from "path";
+import { basename, dirname, extname, join as join2, resolve } from "path";
 import { readFile as readFile3, writeFile } from "fs/promises";
 import _traverse3 from "@babel/traverse";
 import { glob as glob2 } from "tinyglobby";
@@ -2896,6 +3292,445 @@ function buildClientGraph(entries, cwd, pathAliases) {
   }
   return clientReachable;
 }
+function hasTranslatableValue(node, textToKey) {
+  if (node.type === "StringLiteral") {
+    const text2 = node.value.trim();
+    return !!text2 && text2 in textToKey;
+  }
+  if (node.type === "TemplateLiteral") {
+    const info = buildTemplateLiteralText(node.quasis, node.expressions);
+    return !!info && info.text in textToKey;
+  }
+  if (node.type === "ConditionalExpression") {
+    return hasTranslatableValue(node.consequent, textToKey) || hasTranslatableValue(node.alternate, textToKey);
+  }
+  return false;
+}
+function collectModuleFactoryCandidates(entries, textToKey) {
+  const candidates = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.ast) continue;
+    const topLevelConsts = /* @__PURE__ */ new Map();
+    for (const node of entry.ast.program.body) {
+      let decl;
+      let exported = false;
+      if (node.type === "VariableDeclaration" && node.kind === "const") {
+        decl = node;
+      } else if (node.type === "ExportNamedDeclaration" && node.declaration?.type === "VariableDeclaration" && node.declaration.kind === "const") {
+        decl = node.declaration;
+        exported = true;
+      }
+      if (!decl) continue;
+      for (const declarator of decl.declarations) {
+        if (declarator.id.type !== "Identifier") continue;
+        const typed = !!declarator.id.typeAnnotation;
+        topLevelConsts.set(declarator.id.name, { exported, typed });
+      }
+    }
+    traverse3(entry.ast, {
+      ObjectProperty(path) {
+        let current = path.parentPath;
+        let insideFunction = false;
+        let constName;
+        while (current) {
+          if (current.isFunctionDeclaration?.() || current.isFunctionExpression?.() || current.isArrowFunctionExpression?.()) {
+            insideFunction = true;
+            break;
+          }
+          if (current.isVariableDeclarator?.()) {
+            const id = current.node.id;
+            if (id.type === "Identifier" && topLevelConsts.has(id.name)) {
+              constName = id.name;
+            }
+          }
+          current = current.parentPath;
+        }
+        if (insideFunction || !constName) return;
+        const info = topLevelConsts.get(constName);
+        if (!info) return;
+        if (info.exported && FRAMEWORK_RESERVED_EXPORTS.has(constName)) 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 (!hasTranslatableValue(valueNode, textToKey)) return;
+        if (!candidates.has(entry.filePath)) {
+          candidates.set(entry.filePath, /* @__PURE__ */ new Set());
+        }
+        candidates.get(entry.filePath).add(constName);
+      },
+      noScope: true
+    });
+  }
+  return candidates;
+}
+function collectModuleFactoryImportEdges(entries, candidates, cwd, knownFiles, pathAliases) {
+  const importsByFile = /* @__PURE__ */ new Map();
+  const factoryExports = /* @__PURE__ */ new Map();
+  for (const [file, names] of candidates) {
+    factoryExports.set(file, names);
+  }
+  for (const entry of entries) {
+    if (!entry.ast) continue;
+    for (const node of entry.ast.program.body) {
+      if (node.type !== "ImportDeclaration") continue;
+      if (node.specifiers.some((s) => s.type === "ImportNamespaceSpecifier")) continue;
+      const source = node.source.value;
+      const resolved = resolveLocalImport(
+        entry.filePath,
+        source,
+        cwd,
+        knownFiles,
+        pathAliases
+      );
+      if (!resolved || !factoryExports.has(resolved)) continue;
+      const exportedNames = factoryExports.get(resolved);
+      for (const spec of node.specifiers) {
+        if (spec.type !== "ImportSpecifier") continue;
+        const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+        if (!exportedNames.has(importedName)) continue;
+        const localName = spec.local.name;
+        if (!importsByFile.has(entry.filePath)) {
+          importsByFile.set(entry.filePath, []);
+        }
+        importsByFile.get(entry.filePath).push(localName);
+      }
+    }
+  }
+  return importsByFile;
+}
+function collectLocalFactoryUsages(ast, constNames) {
+  const used = /* @__PURE__ */ new Set();
+  traverse3(ast, {
+    Identifier(path) {
+      if (!constNames.has(path.node.name)) return;
+      const parent = path.parent;
+      if (parent.type === "VariableDeclarator" && parent.id === path.node) return;
+      if (parent.type === "ImportSpecifier" || parent.type === "ExportSpecifier" || parent.type === "ImportDefaultSpecifier") return;
+      const compName = getComponentName(path);
+      if (compName && isPascalCase(compName)) {
+        used.add(path.node.name);
+      }
+    },
+    noScope: true
+  });
+  return [...used];
+}
+function markUnsafeExport(importerAst, localName, importerFile, safeCandidates, entries, cwd, knownFiles, pathAliases, unsafeExportedNames) {
+  for (const node of importerAst.program.body) {
+    if (node.type !== "ImportDeclaration") continue;
+    for (const spec of node.specifiers) {
+      if (spec.type !== "ImportSpecifier") continue;
+      if (spec.local.name !== localName) continue;
+      const exportedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+      const resolved = resolveLocalImport(
+        importerFile,
+        node.source.value,
+        cwd,
+        knownFiles,
+        pathAliases
+      );
+      if (resolved && safeCandidates.has(resolved)) {
+        if (!unsafeExportedNames.has(resolved)) {
+          unsafeExportedNames.set(resolved, /* @__PURE__ */ new Set());
+        }
+        unsafeExportedNames.get(resolved).add(exportedName);
+      }
+    }
+  }
+  if (safeCandidates.has(importerFile) && safeCandidates.get(importerFile).has(localName)) {
+    if (!unsafeExportedNames.has(importerFile)) {
+      unsafeExportedNames.set(importerFile, /* @__PURE__ */ new Set());
+    }
+    unsafeExportedNames.get(importerFile).add(localName);
+  }
+}
+function resolveLocalToExportedName(importerAst, localName, importerFile, sourceFile, cwd, knownFiles, pathAliases) {
+  if (!importerAst) return void 0;
+  for (const node of importerAst.program.body) {
+    if (node.type !== "ImportDeclaration") continue;
+    for (const spec of node.specifiers) {
+      if (spec.type !== "ImportSpecifier") continue;
+      if (spec.local.name !== localName) continue;
+      const resolved = resolveLocalImport(
+        importerFile,
+        node.source.value,
+        cwd,
+        knownFiles,
+        pathAliases
+      );
+      if (resolved !== sourceFile) continue;
+      return spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+    }
+  }
+  if (importerFile === sourceFile) return localName;
+  return void 0;
+}
+function isInsideFunctionParam2(path) {
+  let current = path;
+  while (current.parentPath) {
+    if (current.parentPath.isFunction()) {
+      const fn = current.parentPath.node;
+      return fn.params.includes(current.node);
+    }
+    current = current.parentPath;
+  }
+  return false;
+}
+function getBindingSafety(ast, bindingName) {
+  let unsafe = false;
+  let reason;
+  traverse3(ast, {
+    Identifier(path) {
+      if (unsafe) return;
+      if (path.node.name !== bindingName) return;
+      const binding = path.scope?.getBinding(bindingName);
+      if (!binding) return;
+      const bPath = binding.path;
+      const isTopLevel = bPath.isVariableDeclarator?.() && bPath.parentPath?.isVariableDeclaration?.() && (bPath.parentPath.parentPath?.isProgram?.() || bPath.parentPath.parentPath?.isExportNamedDeclaration?.());
+      const isImportBinding = bPath.isImportSpecifier?.() || bPath.isImportDefaultSpecifier?.();
+      if (!isTopLevel && !isImportBinding) return;
+      const parent = path.parent;
+      if (parent.type === "ImportSpecifier" || parent.type === "ImportDefaultSpecifier" || parent.type === "ExportSpecifier") {
+        return;
+      }
+      if (parent.type === "TSTypeReference" || parent.type === "TSTypeQuery" || parent.type === "TSTypeAnnotation") {
+        return;
+      }
+      if (parent.type === "VariableDeclarator" && parent.id === path.node) {
+        return;
+      }
+      const compName = getComponentName(path);
+      if (!compName || !isPascalCase(compName)) {
+        unsafe = true;
+        reason = `"${bindingName}" is referenced outside a React component`;
+        return;
+      }
+      if (isInsideFunctionParam2(path)) {
+        unsafe = true;
+        reason = `"${bindingName}" is referenced in a function parameter default`;
+        return;
+      }
+      if (parent.type === "AssignmentExpression" && parent.left === path.node) {
+        unsafe = true;
+        reason = `"${bindingName}" is mutated via assignment`;
+        return;
+      }
+      if (parent.type === "MemberExpression" && parent.object === path.node) {
+        const grandParent = path.parentPath?.parent;
+        if (grandParent?.type === "CallExpression" && grandParent.callee === parent && parent.property.type === "Identifier" && ["push", "splice", "pop", "shift", "unshift", "sort", "reverse", "fill"].includes(parent.property.name)) {
+          unsafe = true;
+          reason = `"${bindingName}" is mutated via .${parent.property.name}()`;
+          return;
+        }
+        if (grandParent?.type === "AssignmentExpression" && grandParent.left === parent) {
+          unsafe = true;
+          reason = `"${bindingName}" is mutated via property/indexed assignment`;
+          return;
+        }
+        if (grandParent?.type === "UnaryExpression" && grandParent.operator === "delete") {
+          unsafe = true;
+          reason = `"${bindingName}" is mutated via delete`;
+          return;
+        }
+      }
+      if (parent.type === "UpdateExpression") {
+        unsafe = true;
+        reason = `"${bindingName}" is mutated via ${parent.operator}`;
+        return;
+      }
+    }
+  });
+  return unsafe ? { safe: false, reason } : { safe: true };
+}
+async function findExternalImportersOfCandidates(candidates, entries, cwd, pathAliases) {
+  const blocked = /* @__PURE__ */ new Map();
+  if (candidates.size === 0) return blocked;
+  const allFiles = await glob2(["**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}"], {
+    ignore: ["node_modules/**", "dist/**", "build/**", ".next/**", ".output/**"],
+    cwd,
+    absolute: true
+  });
+  const includedFiles = new Set(entries.map((e) => e.filePath));
+  const externalFiles = allFiles.filter((f) => !includedFiles.has(f));
+  if (externalFiles.length === 0) return blocked;
+  const candidateBasenames = /* @__PURE__ */ new Set();
+  for (const file of candidates.keys()) {
+    candidateBasenames.add(basename(file).replace(/\.[^.]+$/, ""));
+  }
+  const allKnownFiles = new Set(allFiles);
+  const parseLimit = pLimit3(10);
+  await Promise.all(
+    externalFiles.map(
+      (extFile) => parseLimit(async () => {
+        let content;
+        try {
+          content = await readFile3(extFile, "utf-8");
+        } catch {
+          return;
+        }
+        let mightImport = false;
+        for (const base of candidateBasenames) {
+          if (content.includes(base)) {
+            mightImport = true;
+            break;
+          }
+        }
+        if (!mightImport) return;
+        let ast;
+        try {
+          ast = parseFile(content, extFile);
+        } catch {
+          return;
+        }
+        for (const node of ast.program.body) {
+          if (node.type !== "ImportDeclaration") continue;
+          const resolved = resolveLocalImport(
+            extFile,
+            node.source.value,
+            cwd,
+            allKnownFiles,
+            pathAliases
+          );
+          if (!resolved || !candidates.has(resolved)) continue;
+          const exportedNames = candidates.get(resolved);
+          if (node.specifiers.some((s) => s.type === "ImportNamespaceSpecifier")) {
+            if (!blocked.has(resolved)) blocked.set(resolved, /* @__PURE__ */ new Set());
+            for (const name of exportedNames) {
+              blocked.get(resolved).add(name);
+            }
+            continue;
+          }
+          for (const spec of node.specifiers) {
+            if (spec.type !== "ImportSpecifier") continue;
+            const importedName = spec.imported.type === "Identifier" ? spec.imported.name : spec.imported.value;
+            if (exportedNames.has(importedName)) {
+              if (!blocked.has(resolved)) blocked.set(resolved, /* @__PURE__ */ new Set());
+              blocked.get(resolved).add(importedName);
+            }
+          }
+        }
+      })
+    )
+  );
+  return blocked;
+}
+async function buildModuleFactoryPlan(entries, textToKey, cwd, pathAliases) {
+  const candidates = collectModuleFactoryCandidates(entries, textToKey);
+  const knownFiles = new Set(entries.filter((e) => e.ast).map((e) => e.filePath));
+  const externallyBlocked = await findExternalImportersOfCandidates(
+    candidates,
+    entries,
+    cwd,
+    pathAliases
+  );
+  for (const [file, names] of externallyBlocked) {
+    const candidateNames = candidates.get(file);
+    if (!candidateNames) continue;
+    for (const name of names) {
+      if (candidateNames.has(name)) {
+        candidateNames.delete(name);
+        logWarning(
+          `Module factory: blocking "${name}" in ${file} \u2014 imported by a file outside the include scope`
+        );
+      }
+    }
+    if (candidateNames.size === 0) {
+      candidates.delete(file);
+    }
+  }
+  const safeCandidates = /* @__PURE__ */ new Map();
+  for (const [file, names] of candidates) {
+    const entry = entries.find((e) => e.filePath === file);
+    if (!entry?.ast) continue;
+    const safeNames = /* @__PURE__ */ new Set();
+    for (const name of names) {
+      const safety = getBindingSafety(entry.ast, name);
+      if (safety.safe) {
+        safeNames.add(name);
+      } else {
+        logWarning(`Module factory: skipping "${name}" in ${file}: ${safety.reason}`);
+      }
+    }
+    if (safeNames.size > 0) {
+      safeCandidates.set(file, safeNames);
+    }
+  }
+  const importEdges = collectModuleFactoryImportEdges(
+    entries,
+    safeCandidates,
+    cwd,
+    knownFiles,
+    pathAliases
+  );
+  for (const [file, names] of safeCandidates) {
+    const entry = entries.find((e) => e.filePath === file);
+    if (!entry?.ast) continue;
+    const localRefs = collectLocalFactoryUsages(entry.ast, names);
+    if (localRefs.length > 0) {
+      const existing = importEdges.get(file) ?? [];
+      importEdges.set(file, [...existing, ...localRefs]);
+    }
+  }
+  const unsafeExportedNames = /* @__PURE__ */ new Map();
+  const safeImports = /* @__PURE__ */ new Map();
+  for (const [file, localNames] of importEdges) {
+    const entry = entries.find((e) => e.filePath === file);
+    if (!entry?.ast) continue;
+    const safeLocalNames = [];
+    for (const name of localNames) {
+      const safety = getBindingSafety(entry.ast, name);
+      if (safety.safe) {
+        safeLocalNames.push(name);
+      } else {
+        logWarning(`Module factory: skipping import "${name}" in ${file}: ${safety.reason}`);
+        markUnsafeExport(entry.ast, name, file, safeCandidates, entries, cwd, knownFiles, pathAliases, unsafeExportedNames);
+      }
+    }
+    if (safeLocalNames.length > 0) {
+      safeImports.set(file, safeLocalNames);
+    }
+  }
+  for (const [sourceFile, unsafeNames] of unsafeExportedNames) {
+    const safeNames = safeCandidates.get(sourceFile);
+    if (!safeNames) continue;
+    for (const name of unsafeNames) {
+      safeNames.delete(name);
+      logWarning(`Module factory: blocking "${name}" in ${sourceFile} because an importer cannot be safely rewritten`);
+    }
+    if (safeNames.size === 0) {
+      safeCandidates.delete(sourceFile);
+    }
+    for (const [importFile, locals] of safeImports) {
+      const filtered = locals.filter((l) => {
+        const exportedName = resolveLocalToExportedName(
+          entries.find((e) => e.filePath === importFile)?.ast,
+          l,
+          importFile,
+          sourceFile,
+          cwd,
+          knownFiles,
+          pathAliases
+        );
+        return !exportedName || !unsafeNames.has(exportedName);
+      });
+      if (filtered.length > 0) {
+        safeImports.set(importFile, filtered);
+      } else {
+        safeImports.delete(importFile);
+      }
+    }
+  }
+  const factoryConstsByFile = /* @__PURE__ */ new Map();
+  for (const [file, names] of safeCandidates) {
+    factoryConstsByFile.set(file, [...names]);
+  }
+  return {
+    factoryConstsByFile,
+    factoryImportsByFile: safeImports
+  };
+}
 async function codegen(options, cwd = process.cwd()) {
   const files = await glob2(options.include, {
     ignore: options.exclude ?? [],
@@ -2905,7 +3740,8 @@ async function codegen(options, cwd = process.cwd()) {
   const transformOpts = {
     i18nImport: options.i18nImport,
     mode: options.mode,
-    componentPath: options.componentPath
+    componentPath: options.componentPath,
+    translatableProps: options.translatableProps
   };
   const parseLimit = pLimit3(10);
   const parsedEntries = await Promise.all(
@@ -2933,6 +3769,15 @@ async function codegen(options, cwd = process.cwd()) {
   );
   const pathAliases = await loadPathAliasResolvers(cwd);
   const forceClientSet = buildClientGraph(parsedEntries, cwd, pathAliases);
+  let factoryPlan;
+  if (options.moduleFactory) {
+    factoryPlan = await buildModuleFactoryPlan(
+      parsedEntries,
+      options.textToKey,
+      cwd,
+      pathAliases
+    );
+  }
   const limit = pLimit3(10);
   let completed = 0;
   const clientNamespacesSet = /* @__PURE__ */ new Set();
@@ -2950,7 +3795,9 @@ async function codegen(options, cwd = process.cwd()) {
         const isClient = forceClientSet.has(entry.filePath) || entry.isClientRoot;
         const fileTransformOpts = {
           ...transformOpts,
-          forceClient: forceClientSet.has(entry.filePath)
+          forceClient: forceClientSet.has(entry.filePath),
+          moduleFactoryConstNames: factoryPlan?.factoryConstsByFile.get(entry.filePath),
+          moduleFactoryImportedNames: factoryPlan?.factoryImportsByFile.get(entry.filePath)
         };
         const result = transform(
           entry.ast,
@@ -3009,13 +3856,15 @@ async function codegen(options, cwd = process.cwd()) {
     clientNamespaces: [...clientNamespacesSet].sort()
   };
 }
-var traverse3, SOURCE_EXTENSIONS;
+var traverse3, SOURCE_EXTENSIONS, FRAMEWORK_RESERVED_EXPORTS;
 var init_codegen = __esm({
   "src/codegen/index.ts"() {
     "use strict";
     init_parser();
     init_ast_helpers();
     init_transform();
+    init_filters();
+    init_template_literal();
     init_logger();
     traverse3 = resolveDefault(_traverse3);
     SOURCE_EXTENSIONS = [
@@ -3028,6 +3877,20 @@ var init_codegen = __esm({
       ".mjs",
       ".cjs"
     ];
+    FRAMEWORK_RESERVED_EXPORTS = /* @__PURE__ */ new Set([
+      "metadata",
+      "generateMetadata",
+      "viewport",
+      "generateViewport",
+      "revalidate",
+      "dynamic",
+      "dynamicParams",
+      "fetchCache",
+      "runtime",
+      "preferredRegion",
+      "maxDuration",
+      "generateStaticParams"
+    ]);
   }
 });
 
@@ -3224,7 +4087,10 @@ async function translateAll(input) {
     )
   );
   if (totalInputTokens > 0 || totalOutputTokens > 0) {
-    onUsage?.({ inputTokens: totalInputTokens, outputTokens: totalOutputTokens });
+    onUsage?.({
+      inputTokens: totalInputTokens,
+      outputTokens: totalOutputTokens
+    });
   }
   return results;
 }
@@ -3266,7 +4132,9 @@ async function writeTranslationSplit(dir, flatEntries) {
     const content = JSON.stringify(nested, null, 2) + "\n";
     await writeFile2(filePath, content, "utf-8");
   }
-  const currentFiles = new Set([...byNamespace.keys()].map((ns) => `${ns}.json`));
+  const currentFiles = new Set(
+    [...byNamespace.keys()].map((ns) => `${ns}.json`)
+  );
   let existing;
   try {
     existing = await readdir(dir);
@@ -3483,7 +4351,11 @@ async function runScanStep(input) {
       await writeFile4(sourceFile, content, "utf-8");
     }
     if (config.typeSafe) {
-      await generateNextIntlTypes(config.messagesDir, config.sourceLocale, config.splitByNamespace);
+      await generateNextIntlTypes(
+        config.messagesDir,
+        config.sourceLocale,
+        config.splitByNamespace
+      );
     }
   }
   return {
@@ -3513,6 +4385,8 @@ async function runCodegenStep(input) {
       i18nImport: config.scan.i18nImport,
       mode,
       componentPath: config.inline?.componentPath,
+      moduleFactory: input.moduleFactory,
+      translatableProps: config.scan.translatableProps,
       onProgress: callbacks?.onProgress
     },
     cwd
@@ -3659,7 +4533,11 @@ function createUsageTracker() {
       outputTokens += usage.outputTokens ?? 0;
     },
     get() {
-      return { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens };
+      return {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens
+      };
     }
   };
 }
@@ -3679,7 +4557,11 @@ async function estimateCost(model, usage) {
       providers
     });
     if (costs.totalUSD == null) return null;
-    return { totalUSD: costs.totalUSD, inputUSD: costs.inputUSD ?? 0, outputUSD: costs.outputUSD ?? 0 };
+    return {
+      totalUSD: costs.totalUSD,
+      inputUSD: costs.inputUSD ?? 0,
+      outputUSD: costs.outputUSD ?? 0
+    };
   } catch {
     return null;
   }
@@ -3724,6 +4606,19 @@ var init_cli_utils = __esm({
 });
 
 // src/templates/t-component.ts
+function buildSingleFileLoadBody(targetLocales, relativeMessagesDir) {
+  const cases = targetLocales.map(
+    (locale) => `      case "${locale}": return (await import("${relativeMessagesDir}/${locale}.json")).default;`
+  ).join("\n");
+  return `  try {
+    switch (locale) {
+${cases}
+      default: return {};
+    }
+  } catch {
+    return {};
+  }`;
+}
 function serverTemplate(clientBasename, opts) {
   if (!opts) {
     return `import type { ReactNode } from "react";
@@ -3757,6 +4652,15 @@ export function createT(messages?: Messages) {
   }
   const allLocales = [opts.sourceLocale, ...opts.targetLocales];
   const allLocalesStr = allLocales.map((l) => `"${l}"`).join(", ");
+  const isSplit = !!opts.splitByNamespace;
+  let messagesImportPath = opts.relativeMessagesDir ?? opts.messagesDir;
+  if (!messagesImportPath.startsWith(".") && !messagesImportPath.startsWith("/")) {
+    messagesImportPath = `./${messagesImportPath}`;
+  }
+  const loadBody = isSplit ? SPLIT_LOAD_BODY : buildSingleFileLoadBody(opts.targetLocales, messagesImportPath);
+  const messagesDirConst = isSplit ? `
+const messagesDir = "${opts.messagesDir}";
+` : "\n";
   return `import type { ReactNode } from "react";
 import { cache } from "react";
 export { I18nProvider } from "./${clientBasename}";
@@ -3765,9 +4669,7 @@ type Messages = Record<string, string>;
 
 const supported = [${allLocalesStr}] as const;
 type Locale = (typeof supported)[number];
-const defaultLocale: Locale = "${opts.sourceLocale}";
-const messagesDir = "${opts.messagesDir}";
-
+const defaultLocale: Locale = "${opts.sourceLocale}";${messagesDirConst}
 function parseAcceptLanguage(header: string): Locale {
   const langs = header
     .split(",")
@@ -3789,8 +4691,7 @@ export function setLocale(locale: string) {
   getLocaleStore().current = locale;
 }
 
-// Per-request cached message loading \u2014 works even when layout is cached during client-side navigation
-// Uses dynamic imports so this file can be safely imported from client components
+// Per-request cached message loading \u2014 works on all platforms via static imports
 const getCachedMessages = cache(async (): Promise<Messages> => {
   let locale: Locale | null = getLocaleStore().current as Locale | null;
 
@@ -3813,7 +4714,7 @@ const getCachedMessages = cache(async (): Promise<Messages> => {
   }
 
   if (locale === defaultLocale) return {};
-${opts.splitByNamespace ? SPLIT_LOAD_BODY : SINGLE_FILE_LOAD_BODY}
+${loadBody}
 });
 
 // Per-request message store (populated by setServerMessages in layout)
@@ -3942,7 +4843,7 @@ ${getMessagesBody}
 }
 `;
 }
-var CLIENT_TEMPLATE, SINGLE_FILE_LOAD_BODY, SPLIT_LOAD_BODY;
+var CLIENT_TEMPLATE, SPLIT_LOAD_BODY;
 var init_t_component = __esm({
   "src/templates/t-component.ts"() {
     "use strict";
@@ -3976,18 +4877,9 @@ export function useT() {
   };
 }
 `;
-    SINGLE_FILE_LOAD_BODY = `  const { readFile } = await import("node:fs/promises");
-  const { join } = await import("node:path");
-  try {
-    const filePath = join(process.cwd(), messagesDir, \`\${locale}.json\`);
-    const content = await readFile(filePath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }`;
-    SPLIT_LOAD_BODY = `  const { readFile, readdir } = await import("node:fs/promises");
-  const { join } = await import("node:path");
-  try {
+    SPLIT_LOAD_BODY = `  try {
+    const { readFile, readdir } = await import("node:fs/promises");
+    const { join } = await import("node:path");
     const dir = join(process.cwd(), messagesDir, locale);
     let files: string[];
     try { files = (await readdir(dir)).filter(f => f.endsWith(".json")); } catch { return {}; }
@@ -4013,24 +4905,32 @@ export function useT() {
 // src/init.ts
 var init_exports = {};
 __export(init_exports, {
+  detectIncludePatterns: () => detectIncludePatterns,
   generateConfigFile: () => generateConfigFile,
   runInitWizard: () => runInitWizard,
   updateLayoutWithSelectiveMessages: () => updateLayoutWithSelectiveMessages
 });
 import * as p from "@clack/prompts";
 import { existsSync } from "fs";
-import { basename, join as join6, relative } from "path";
+import { basename as basename2, join as join6, relative } from "path";
 import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir4 } from "fs/promises";
 function detectIncludePatterns(cwd) {
   const patterns = [];
-  if (existsSync(join6(cwd, "app")))
+  const hasSrc = existsSync(join6(cwd, "src"));
+  if (hasSrc && existsSync(join6(cwd, "src", "app"))) {
+    patterns.push("src/app/**/*.tsx", "src/app/**/*.jsx");
+  } else if (existsSync(join6(cwd, "app"))) {
     patterns.push("app/**/*.tsx", "app/**/*.jsx");
-  if (existsSync(join6(cwd, "src")))
-    patterns.push("src/**/*.tsx", "src/**/*.jsx");
-  if (existsSync(join6(cwd, "pages")))
+  }
+  if (hasSrc && existsSync(join6(cwd, "src", "pages"))) {
+    patterns.push("src/pages/**/*.tsx", "src/pages/**/*.jsx");
+  } else if (existsSync(join6(cwd, "pages"))) {
     patterns.push("pages/**/*.tsx", "pages/**/*.jsx");
-  if (existsSync(join6(cwd, "src", "app"))) {
-    return patterns.filter((p2) => !p2.startsWith("app/"));
+  }
+  if (hasSrc && existsSync(join6(cwd, "src", "components"))) {
+    patterns.push("src/components/**/*.tsx", "src/components/**/*.jsx");
+  } else if (existsSync(join6(cwd, "components"))) {
+    patterns.push("components/**/*.tsx", "components/**/*.jsx");
   }
   return patterns.length > 0 ? patterns : ["**/*.tsx", "**/*.jsx"];
 }
@@ -4097,6 +4997,13 @@ function generateConfigFile(opts) {
   lines.push(
     `    include: [${opts.includePatterns.map((p2) => `"${p2}"`).join(", ")}],`
   );
+  lines.push(`    // Add more directories as needed. Examples:`);
+  lines.push(`    // "config/**/*.ts"   \u2014 for data/config files (needed with --module-factory)`);
+  lines.push(`    // "lib/**/*.ts"      \u2014 for utility files with translatable strings`);
+  lines.push(`    // "layouts/**/*.tsx"  \u2014 for layout components`);
+  lines.push(`    //`);
+  lines.push(`    // Note: When using codegen --module-factory, include any directories`);
+  lines.push(`    // that contain exported constants with translatable strings (e.g. config/).`);
   lines.push(`    exclude: ["**/*.test.*", "**/*.spec.*"],`);
   if (opts.mode === "keys" && opts.i18nImport) {
     lines.push(`    i18nImport: "${opts.i18nImport}",`);
@@ -4259,11 +5166,7 @@ export default getRequestConfig(async () => {
         "export default withNextIntl($1);"
       );
       const updated = importLine + "\n" + pluginLine + "\n" + wrapped;
-      if (await safeWriteModifiedFile(
-        nextConfigPath,
-        updated,
-        "next.config.ts"
-      )) {
+      if (await safeWriteModifiedFile(nextConfigPath, updated, "next.config.ts")) {
         filesCreated.push("next.config.ts (updated)");
       }
     }
@@ -4287,16 +5190,16 @@ export default getRequestConfig(async () => {
         /<\/body>/,
         "  </NextIntlClientProvider>\n      </body>"
       );
-      if (await safeWriteModifiedFile(
-        layoutPath,
-        layoutContent,
-        "root layout"
-      )) {
+      if (await safeWriteModifiedFile(layoutPath, layoutContent, "root layout")) {
         filesCreated.push(relative(cwd, layoutPath) + " (updated)");
       }
     }
   }
-  await createEmptyMessageFiles(join6(cwd, messagesDir), allLocales, splitByNamespace);
+  await createEmptyMessageFiles(
+    join6(cwd, messagesDir),
+    allLocales,
+    splitByNamespace
+  );
   if (filesCreated.length > 0) {
     p.log.success(`next-intl configured: ${filesCreated.join(", ")}`);
   }
@@ -4307,9 +5210,19 @@ async function dropInlineComponents(cwd, componentPath, localeOpts) {
   await mkdir4(dir, { recursive: true });
   const clientFile = `${fsPath}.tsx`;
   const serverFile = `${fsPath}-server.tsx`;
-  const clientBasename = basename(fsPath);
+  const clientBasename = basename2(fsPath);
+  const serverDir = join6(serverFile, "..");
+  const absoluteMessagesDir = join6(cwd, localeOpts.messagesDir);
+  let relativeMessagesDir = relative(serverDir, absoluteMessagesDir);
+  if (!relativeMessagesDir.startsWith(".")) {
+    relativeMessagesDir = `./${relativeMessagesDir}`;
+  }
   await writeFile5(clientFile, CLIENT_TEMPLATE, "utf-8");
-  await writeFile5(serverFile, serverTemplate(clientBasename, localeOpts), "utf-8");
+  await writeFile5(
+    serverFile,
+    serverTemplate(clientBasename, { ...localeOpts, relativeMessagesDir }),
+    "utf-8"
+  );
   const relClient = relative(cwd, clientFile);
   const relServer = relative(cwd, serverFile);
   p.log.success(`Created inline components: ${relClient}, ${relServer}`);
@@ -4353,19 +5266,16 @@ import { getLocale, getMessages } from "@/i18n";
         /<\/body>/,
         "	</I18nProvider>\n			</body>"
       );
-      if (await safeWriteModifiedFile(
-        layoutPath,
-        layoutContent,
-        "root layout"
-      )) {
+      if (await safeWriteModifiedFile(layoutPath, layoutContent, "root layout")) {
         filesCreated.push(relative(cwd, layoutPath) + " (updated)");
       }
     }
   }
-  await createEmptyMessageFiles(join6(cwd, messagesDir), [
-    sourceLocale,
-    ...targetLocales
-  ], splitByNamespace);
+  await createEmptyMessageFiles(
+    join6(cwd, messagesDir),
+    [sourceLocale, ...targetLocales],
+    splitByNamespace
+  );
   if (filesCreated.length > 0) {
     p.log.success(`Inline i18n configured: ${filesCreated.join(", ")}`);
   }
@@ -4402,7 +5312,11 @@ async function updateLayoutWithSelectiveMessages(cwd, clientNamespaces) {
       "messages={clientMessages}"
     );
   }
-  if (await safeWriteModifiedFile(layoutPath, content, "root layout (selective messages)")) {
+  if (await safeWriteModifiedFile(
+    layoutPath,
+    content,
+    "root layout (selective messages)"
+  )) {
     const rel = relative(cwd, layoutPath);
     p.log.success(
       `Updated ${rel} with selective message passing (${clientNamespaces.length} namespaces)`
@@ -4485,21 +5399,13 @@ async function runInitWizard() {
     splitByNamespace = split;
   }
   const detected = detectIncludePatterns(cwd);
-  let includePatterns;
-  const useDetected = await p.confirm({
-    message: `Detected: ${detected.join(", ")} \u2014 Use these patterns?`
+  const patternsInput = await p.text({
+    message: "Include patterns (comma-separated):",
+    initialValue: detected.join(", "),
+    placeholder: "app/**/*.tsx, components/**/*.tsx"
   });
-  if (p.isCancel(useDetected)) cancel2();
-  if (useDetected) {
-    includePatterns = detected;
-  } else {
-    const customPatterns = await p.text({
-      message: "Include patterns (comma-separated):",
-      initialValue: "src/**/*.tsx, src/**/*.jsx"
-    });
-    if (p.isCancel(customPatterns)) cancel2();
-    includePatterns = customPatterns.split(",").map((s) => s.trim());
-  }
+  if (p.isCancel(patternsInput)) cancel2();
+  const includePatterns = patternsInput.split(",").map((s) => s.trim());
   let i18nImport = "";
   let componentPath;
   let typeSafe = false;
@@ -4570,7 +5476,13 @@ async function runInitWizard() {
       splitByNamespace
     );
   } else {
-    await setupNextIntl(cwd, sourceLocale, targetLocales, messagesDir, splitByNamespace);
+    await setupNextIntl(
+      cwd,
+      sourceLocale,
+      targetLocales,
+      messagesDir,
+      splitByNamespace
+    );
   }
   const runPipeline = await p.confirm({
     message: "Run the full pipeline now?"
@@ -4623,7 +5535,10 @@ async function runInitWizard() {
     `Codegen... ${codegenResult.stringsWrapped} strings wrapped in ${codegenResult.filesModified} files`
   );
   if (codegenResult.clientNamespaces.length > 0) {
-    await updateLayoutWithSelectiveMessages(cwd, codegenResult.clientNamespaces);
+    await updateLayoutWithSelectiveMessages(
+      cwd,
+      codegenResult.clientNamespaces
+    );
   }
   for (const locale of targetLocales) {
     const st = p.spinner();
@@ -4685,6 +5600,7 @@ var init_init = __esm({
       }
     };
     LOCALE_OPTIONS = [
+      { value: "en", label: "English (en)" },
       { value: "es", label: "Spanish (es)" },
       { value: "fr", label: "French (fr)" },
       { value: "de", label: "German (de)" },
@@ -4946,6 +5862,11 @@ var codegenCommand = defineCommand({
       type: "boolean",
       description: "Show what would be changed without modifying files",
       default: false
+    },
+    "module-factory": {
+      type: "boolean",
+      description: "Convert module-level constants with translatable strings into factory functions",
+      default: false
     }
   },
   async run({ args }) {
@@ -4989,6 +5910,7 @@ var codegenCommand = defineCommand({
     const result = await runCodegenStep({
       config,
       cwd: process.cwd(),
+      moduleFactory: args["module-factory"],
       callbacks: {
         onProgress: (c, t3) => logProgress(c, t3, "Processing files...")
       }
@@ -5015,7 +5937,11 @@ var typegenCommand = defineCommand({
       logWarning("Type generation is only available in keys mode.");
       return;
     }
-    await generateNextIntlTypes(config.messagesDir, config.sourceLocale, config.splitByNamespace);
+    await generateNextIntlTypes(
+      config.messagesDir,
+      config.sourceLocale,
+      config.splitByNamespace
+    );
     logSuccess(`Generated ${join7(config.messagesDir, "next-intl.d.ts")}`);
   }
 });
@@ -5035,6 +5961,11 @@ var runCommand = defineCommand({
       default: false,
       description: "Ignore translation cache"
     },
+    "module-factory": {
+      type: "boolean",
+      description: "Convert module-level constants with translatable strings into factory functions",
+      default: false
+    },
     verbose: {
       type: "boolean",
       default: false,
@@ -5044,7 +5975,9 @@ var runCommand = defineCommand({
   async run({ args }) {
     const config = await loadTranslateKitConfig();
     if (!config.scan) {
-      logError("No scan configuration found. Add a 'scan' section to your config.");
+      logError(
+        "No scan configuration found. Add a 'scan' section to your config."
+      );
       process.exit(1);
     }
     const usageTracker = createUsageTracker();
@@ -5059,7 +5992,9 @@ var runCommand = defineCommand({
       }
     });
     logProgressClear();
-    logSuccess(`Scan: ${scanResult.bareStringCount} strings from ${scanResult.fileCount} files`);
+    logSuccess(
+      `Scan: ${scanResult.bareStringCount} strings from ${scanResult.fileCount} files`
+    );
     if (scanResult.bareStringCount === 0 && Object.keys(scanResult.textToKey).length === 0) {
       logWarning("No translatable strings found.");
       return;
@@ -5068,12 +6003,15 @@ var runCommand = defineCommand({
       config,
       cwd: process.cwd(),
       textToKey: scanResult.textToKey,
+      moduleFactory: args["module-factory"],
       callbacks: {
         onProgress: (c, t3) => logProgress(c, t3, "Codegen...")
       }
     });
     logProgressClear();
-    logSuccess(`Codegen: ${codegenResult.stringsWrapped} strings wrapped in ${codegenResult.filesModified} files`);
+    logSuccess(
+      `Codegen: ${codegenResult.stringsWrapped} strings wrapped in ${codegenResult.filesModified} files`
+    );
     const locales = config.targetLocales;
     logStart(config.sourceLocale, locales);
     const translateResult = await runTranslateStep({
@@ -5095,7 +6033,10 @@ var runCommand = defineCommand({
     const usage = usageTracker.get();
     if (usage.totalTokens > 0) {
       const cost = await estimateCost(config.model, usage);
-      logUsage(formatUsage(usage), cost ? formatCost(cost.totalUSD) : void 0);
+      logUsage(
+        formatUsage(usage),
+        cost ? formatCost(cost.totalUSD) : void 0
+      );
     }
   }
 });
@@ -5140,10 +6081,11 @@ var main = defineCommand({
     typegen     Generate TypeScript types for message keys
 
   Flags:
-    --dry-run   Preview without writing files
-    --force     Ignore translation cache
-    --locale    Only translate a specific locale
-    --verbose   Verbose output
+    --dry-run          Preview without writing files
+    --force            Ignore translation cache
+    --locale           Only translate a specific locale
+    --module-factory   Convert module-level constants into factory functions
+    --verbose          Verbose output
 
   Examples:
     translate-kit init              # Set up a new project