@xndrjs/i18n 0.7.0 → 0.8.0

package/dist/codegen/index.js

@@ -1,6 +1,8 @@
 import { z } from 'zod';
-import path from 'path';
-import fs from 'fs';
+import path8 from 'path';
+import fs3 from 'fs';
+import { parse } from '@formatjs/icu-messageformat-parser';
+import { parse as parse$1 } from 'yaml';
 
 // src/codegen/codegen-config-schema.ts
 
@@ -43,64 +45,135 @@ function getDeliveryArtifactsStructureIssues(deliveryArtifacts) {
   }
   return issues;
 }
+function getDeliveryArtifactsPartitionIssues(deliveryArtifacts, requestLocales) {
+  const issues = [];
+  const artifactLocales = /* @__PURE__ */ new Set();
+  for (const locales of Object.values(deliveryArtifacts)) {
+    for (const locale of locales) {
+      artifactLocales.add(locale);
+    }
+  }
+  const missing = [...requestLocales].filter((locale) => !artifactLocales.has(locale)).sort();
+  if (missing.length > 0) {
+    issues.push({
+      path: ["deliveryArtifacts"],
+      message: `deliveryArtifacts is missing locales required by dictionaries and localeFallback: ${missing.join(", ")}`
+    });
+  }
+  const excess = [...artifactLocales].filter((locale) => !requestLocales.has(locale)).sort();
+  if (excess.length > 0) {
+    issues.push({
+      path: ["deliveryArtifacts"],
+      message: `deliveryArtifacts includes locales not required by dictionaries and localeFallback: ${excess.join(", ")}`
+    });
+  }
+  return issues;
+}
+function getDeliveryArtifactsIssues(deliveryArtifacts, requestLocales) {
+  return [
+    ...getDeliveryArtifactsStructureIssues(deliveryArtifacts),
+    ...getDeliveryArtifactsPartitionIssues(deliveryArtifacts, requestLocales)
+  ];
+}
+function getDeliveryAreaNames(deliveryArtifacts) {
+  return Object.keys(deliveryArtifacts).sort();
+}
+function getLocaleDeliveryAreaMap(deliveryArtifacts) {
+  const localeToArea = {};
+  for (const [area, locales] of Object.entries(deliveryArtifacts)) {
+    for (const locale of locales) {
+      localeToArea[locale] = area;
+    }
+  }
+  return localeToArea;
+}
+function formatLocaleDeliveryAreaBlock(deliveryArtifacts, constName, localeTypeName, deliveryAreaTypeName) {
+  const localeToArea = getLocaleDeliveryAreaMap(deliveryArtifacts);
+  const lines = Object.keys(localeToArea).sort().map((locale) => `  ${JSON.stringify(locale)}: ${JSON.stringify(localeToArea[locale])},`).join("\n");
+  return `export const ${constName} = {
+${lines}
+} as const satisfies Record<${localeTypeName}, ${deliveryAreaTypeName}>;
+
+`;
+}
+function getDeliveryArtifactsTypeName(deliveryAreaTypeName) {
+  return deliveryAreaTypeName.endsWith("DeliveryArea") ? deliveryAreaTypeName.replace(/DeliveryArea$/, "DeliveryArtifacts") : `${deliveryAreaTypeName}Artifacts`;
+}
+function formatDeliveryArtifactsBlock(deliveryArtifacts, constName, localeTypeName, deliveryAreaTypeName) {
+  const deliveryArtifactsTypeName = getDeliveryArtifactsTypeName(deliveryAreaTypeName);
+  const areaEntries = getDeliveryAreaNames(deliveryArtifacts).map((area) => {
+    const locales = [...deliveryArtifacts[area]].sort().map((locale) => JSON.stringify(locale)).join(", ");
+    return `  ${JSON.stringify(area)}: [${locales}] as const,`;
+  }).join("\n");
+  return `export const ${constName} = {
+${areaEntries}
+} as const satisfies Record<${deliveryAreaTypeName}, readonly ${localeTypeName}[]>;
+
+export type ${deliveryArtifactsTypeName} = typeof ${constName};
+
+export type LocalesForDeliveryArea<A extends ${deliveryAreaTypeName}> = ${deliveryArtifactsTypeName}[A][number];
+
+`;
+}
+
+// src/codegen-config/type-names.ts
+function inferProjectName(dirName) {
+  const parts = dirName.split(/[-_]+/).filter(Boolean);
+  if (parts.length === 0) {
+    return "App";
+  }
+  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function typeNamesForProject(project) {
+  return {
+    paramsTypeName: `${project}Params`,
+    schemaTypeName: `${project}Schema`,
+    localeTypeName: `${project}Locale`
+  };
+}
 
 // src/codegen/codegen-config-schema.ts
 var localeFallbackSchema = z.record(z.string(), z.union([z.string(), z.null()]));
 var deliveryArtifactsSchema = z.record(z.string(), z.array(z.string().min(1)));
-var DELIVERY_MODES = ["canonical", "split-by-locale", "custom"];
+var DELIVERY_MODES = ["split-by-locale", "custom"];
+var LOADER_STRATEGIES = ["import", "fetch"];
+var PROJECT_NAME_PATTERN = /^[A-Z][a-zA-Z0-9]*$/;
 var codegenConfigShape = {
-  dictionary: z.string().min(1).optional(),
-  namespaces: z.record(z.string(), z.string().min(1)).optional(),
-  defaultNamespace: z.string().min(1).optional(),
-  typesOutput: z.string().min(1),
-  dictionaryOutput: z.string().min(1).optional().describe(
-    'Output path for dictionary.generated.ts when emitted (canonical, or split/custom with eager namespaces). Omitted in split/custom when every namespace is lazy \u2014 defaults to "{dirname(typesOutput)}/dictionary.generated.ts" for stale-file cleanup only.'
-  ),
-  instanceOutput: z.string().min(1),
-  dictionarySchemaOutput: z.string().min(1).optional(),
-  loadOnInit: z.array(z.string().min(1)).optional(),
-  namespaceLoadersOutput: z.string().min(1).optional(),
-  importExtension: z.enum(SUPPORTED_IMPORT_EXTENSIONS).optional(),
-  paramsTypeName: z.string().min(1),
-  schemaTypeName: z.string().min(1),
-  localeTypeName: z.string().min(1).optional(),
-  localeFallbackConstName: z.string().min(1).optional(),
+  /** PascalCase project id — generates `{project}Params`, `{project}Schema`, `{project}Locale`. */
+  projectName: z.string().min(1).regex(PROJECT_NAME_PATTERN, 'projectName must be PascalCase (e.g. "MyApp")'),
+  namespaces: z.record(z.string(), z.string().min(1)),
+  /**
+   * Directory for generated TypeScript modules:
+   * `i18n-types.generated.ts`, `instance.generated.ts`,
+   * `namespace-loaders.generated.ts`, `dictionary-schema.generated.ts`.
+   */
+  codegenPath: z.string().min(1),
   localeFallback: localeFallbackSchema.optional(),
-  factoryName: z.string().min(1).optional(),
-  delivery: z.enum(DELIVERY_MODES).optional().default("canonical"),
+  delivery: z.enum(DELIVERY_MODES).optional().default("split-by-locale"),
   deliveryArtifacts: deliveryArtifactsSchema.optional(),
-  deliveryOutput: z.string().min(1).optional()
+  /** Directory for delivery JSON (`translations/`). Defaults to {@link codegenPath}. */
+  artifactsPath: z.string().min(1).optional(),
+  /**
+   * How generated `namespaceLoaders` resolve artifacts.
+   * - `import` (default): dynamic `import()` — JSON is bundled; content updates need a rebuild.
+   * - `fetch`: runtime `fetchImpl({ locale, namespace, area? })` via required `createI18n({ fetchImpl })`.
+   *   Codegen does not know URLs — mapping id → transport is an application concern.
+   */
+  loaderStrategy: z.enum(LOADER_STRATEGIES).optional().default("import")
 };
 var codegenConfigKeys = Object.keys(
   codegenConfigShape
 );
-z.object(codegenConfigShape).strict().superRefine((config, ctx) => {
-  const hasDictionary = config.dictionary !== void 0;
-  const hasNamespaces = config.namespaces !== void 0;
-  if (hasDictionary === hasNamespaces) {
-    ctx.addIssue({
-      code: "custom",
-      message: 'Specify exactly one of "dictionary" or "namespaces".'
-    });
-  }
-  if (config.namespaces) {
-    for (const namespace of Object.keys(config.namespaces)) {
-      if (!IDENTIFIER_NAME_PATTERN.test(namespace)) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["namespaces", namespace],
-          message: `Invalid namespace name "${namespace}" (${IDENTIFIER_NAME_REQUIREMENT}).`
-        });
-      }
+var codegenConfigSchema = z.object(codegenConfigShape).strict().superRefine((config, ctx) => {
+  for (const namespace of Object.keys(config.namespaces)) {
+    if (!IDENTIFIER_NAME_PATTERN.test(namespace)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["namespaces", namespace],
+        message: `Invalid namespace name "${namespace}" (${IDENTIFIER_NAME_REQUIREMENT}).`
+      });
     }
   }
-  if (config.defaultNamespace !== void 0 && !IDENTIFIER_NAME_PATTERN.test(config.defaultNamespace)) {
-    ctx.addIssue({
-      code: "custom",
-      path: ["defaultNamespace"],
-      message: `Invalid namespace name "${config.defaultNamespace}" (${IDENTIFIER_NAME_REQUIREMENT}).`
-    });
-  }
   if (config.delivery === "custom") {
     if (!config.deliveryArtifacts) {
       ctx.addIssue({
@@ -124,71 +197,1490 @@ z.object(codegenConfigShape).strict().superRefine((config, ctx) => {
       message: 'deliveryArtifacts is only allowed when delivery is "custom".'
     });
   }
-  if (config.loadOnInit !== void 0 && config.delivery !== "canonical") {
-    ctx.addIssue({
-      code: "custom",
-      path: ["loadOnInit"],
-      message: 'loadOnInit is only allowed when delivery is "canonical".'
-    });
-  }
 });
-function resolveDeliveryOutputDir(config) {
-  return config.deliveryOutput ?? path.dirname(config.typesOutput);
+var GENERATED_BASENAMES = {
+  types: "i18n-types.generated.ts",
+  instance: "instance.generated.ts",
+  namespaceLoaders: "namespace-loaders.generated.ts",
+  dictionarySchema: "dictionary-schema.generated.ts"
+};
+var DEFAULT_FACTORY_NAME = "createI18n";
+var DEFAULT_LOCALE_FALLBACK_CONST_NAME = "LOCALE_FALLBACK";
+function resolveCodegenPaths(config) {
+  const typeNames = typeNamesForProject(config.projectName);
+  const codegenPath = config.codegenPath;
+  return {
+    codegenPath,
+    typesOutput: path8.join(codegenPath, GENERATED_BASENAMES.types),
+    instanceOutput: path8.join(codegenPath, GENERATED_BASENAMES.instance),
+    namespaceLoadersOutput: path8.join(codegenPath, GENERATED_BASENAMES.namespaceLoaders),
+    dictionarySchemaOutput: path8.join(codegenPath, GENERATED_BASENAMES.dictionarySchema),
+    artifactsPath: config.artifactsPath ?? codegenPath,
+    paramsTypeName: typeNames.paramsTypeName,
+    schemaTypeName: typeNames.schemaTypeName,
+    localeTypeName: typeNames.localeTypeName,
+    localeFallbackConstName: DEFAULT_LOCALE_FALLBACK_CONST_NAME,
+    factoryName: DEFAULT_FACTORY_NAME,
+    deliveryAreaTypeName: `${config.projectName}DeliveryArea`
+  };
 }
-var DEFAULT_DICTIONARY_BASENAME = "dictionary.generated.ts";
-function resolveDictionaryOutputPath(config) {
-  return config.dictionaryOutput ?? path.join(path.dirname(config.typesOutput), DEFAULT_DICTIONARY_BASENAME);
+function resolveArtifactsPath(config) {
+  return config.artifactsPath ?? config.codegenPath;
 }
-
-// src/codegen-config/type-names.ts
-function inferProjectName(dirName) {
-  const parts = dirName.split(/[-_]+/).filter(Boolean);
-  if (parts.length === 0) {
-    return "App";
+function formatCodegenConfigIssues(error) {
+  const issueLines = error.issues.map((issue) => {
+    const path10 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    return `  - ${path10}: ${issue.message}`;
+  });
+  return [
+    "[Codegen Error] Invalid i18n.codegen.json:",
+    ...issueLines,
+    "",
+    `Allowed keys: ${codegenConfigKeys.join(", ")}`
+  ].join("\n");
+}
+function loadConfig(configPath) {
+  let raw;
+  try {
+    raw = JSON.parse(fs3.readFileSync(configPath, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`[Codegen Error] Failed to parse config JSON (${configPath}): ${message}`);
   }
-  return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  const result = codegenConfigSchema.safeParse(raw);
+  if (!result.success) {
+    throw new Error(formatCodegenConfigIssues(result.error));
+  }
+  return result.data;
 }
-function typeNamesForProject(project) {
-  return {
-    paramsTypeName: `${project}Params`,
-    schemaTypeName: `${project}Schema`,
-    localeTypeName: `${project}Locale`
-  };
+function resolveNamespaces(config) {
+  return Object.entries(config.namespaces).map(([namespace, filePath]) => ({
+    namespace,
+    filePath
+  }));
 }
 
 // src/codegen-config/build-config.ts
 var GENERATED_DIR = "generated";
 var TRANSLATIONS_DIR = "translations";
-function buildCodegenConfig(mode, project) {
-  const typeNames = typeNamesForProject(project);
-  const base = {
-    typesOutput: `${GENERATED_DIR}/i18n-types.generated.ts`,
-    dictionaryOutput: `${GENERATED_DIR}/dictionary.generated.ts`,
-    instanceOutput: `${GENERATED_DIR}/instance.generated.ts`,
-    paramsTypeName: typeNames.paramsTypeName,
-    schemaTypeName: typeNames.schemaTypeName,
-    localeTypeName: typeNames.localeTypeName,
-    factoryName: "createI18n"
-  };
-  if (mode === "single") {
-    return {
-      dictionary: `${TRANSLATIONS_DIR}/translations.json`,
-      ...base
-    };
-  }
+function buildCodegenConfig(project) {
   return {
+    projectName: project,
     namespaces: {
       default: `${TRANSLATIONS_DIR}/default.json`
     },
-    ...base
+    delivery: "split-by-locale",
+    codegenPath: GENERATED_DIR
   };
 }
 function writeCodegenConfig(configPath, config) {
-  fs.mkdirSync(path.dirname(configPath), { recursive: true });
-  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+  fs3.mkdirSync(path8.dirname(configPath), { recursive: true });
+  fs3.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`);
+}
+var GENERATED_FILE_BANNER = "// Automatically generated code. Do not edit manually.\n";
+var DEFAULT_IMPORT_EXTENSION = "none";
+function reportCodegenIssues(issues) {
+  for (const issue of issues) {
+    console.error(`[Codegen Error] ${issue.message}`);
+  }
+}
+function toImportPath(fromFile, toFile) {
+  const relative = path8.relative(path8.dirname(fromFile), toFile).replace(/\\/g, "/");
+  const withoutExt = relative.replace(/\.(json|ya?ml)$/i, "");
+  return withoutExt.startsWith(".") ? withoutExt : `./${withoutExt}`;
+}
+function toModuleBasename(filePath) {
+  return path8.basename(filePath).replace(/\.ts$/, "");
+}
+function importExtensionSuffix(importExtension) {
+  return importExtension === "none" ? "" : importExtension;
+}
+function toRelativeModuleImport(moduleBasename, importExtension) {
+  return `./${moduleBasename}${importExtensionSuffix(importExtension)}`;
+}
+
+// src/codegen/emit/dictionary-schema-file.ts
+function formatVariableSpecObject(spec) {
+  const entries = Object.entries(spec);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  const lines = entries.map(
+    ([name, type]) => `      ${JSON.stringify(name)}: ${JSON.stringify(type)},`
+  );
+  return `{
+${lines.join("\n")}
+    }`;
+}
+function formatDictionarySpecBlock(entries, argsSpecByNamespace) {
+  const requiredKeysLines = entries.map((entry) => {
+    const keys = Object.keys(argsSpecByNamespace[entry.namespace] ?? {}).map((key) => JSON.stringify(key)).join(", ");
+    return `    ${JSON.stringify(entry.namespace)}: [${keys}] as const,`;
+  }).join("\n");
+  const argsByKeyLines = entries.map((entry) => {
+    const argsByKey = argsSpecByNamespace[entry.namespace] ?? {};
+    const keyLines = Object.entries(argsByKey).map(([key, spec]) => `      ${JSON.stringify(key)}: ${formatVariableSpecObject(spec)},`).join("\n");
+    return `    ${JSON.stringify(entry.namespace)}: {
+${keyLines}
+    },`;
+  }).join("\n");
+  return `export const DICTIONARY_SPEC = {
+  mode: 'multi' as const,
+  requiredKeys: {
+${requiredKeysLines}
+  },
+  argsByKey: {
+${argsByKeyLines}
+  },
+} satisfies DictionarySpec;
+`;
+}
+function formatDictionarySchemaFile(schemaTypeName, typesModule, dictionarySpecBlock, importExtension) {
+  const typesImport = toRelativeModuleImport(typesModule, importExtension);
+  const partialImport = `  validateExternalDictionaryPartial as validateExternalDictionaryPartialCore,
+  validateExternalNamespacePartial as validateExternalNamespacePartialCore,
+  validateExternalKey as validateExternalKeyCore,
+`;
+  const multiValidators = `export function validateExternalNamespacePartial<NS extends keyof ${schemaTypeName}>(
+  namespace: NS,
+  input: unknown,
+): ValidationResult<Partial<${schemaTypeName}[NS]>> {
+  return validateExternalNamespacePartialCore<Partial<${schemaTypeName}[NS]>>(
+    namespace as string,
+    input,
+    DICTIONARY_SPEC,
+  );
+}
+
+export function validateExternalKey<
+  NS extends keyof ${schemaTypeName},
+  K extends keyof ${schemaTypeName}[NS],
+>(
+  namespace: NS,
+  key: K,
+  input: unknown,
+): ValidationResult<Pick<${schemaTypeName}[NS], K>> {
+  return validateExternalKeyCore<Pick<${schemaTypeName}[NS], K>>(
+    namespace as string,
+    key as string,
+    input,
+    DICTIONARY_SPEC,
+  );
+}
+
+`;
+  return `${GENERATED_FILE_BANNER}import {
+` + partialImport + `  type DictionarySpec,
+  type ValidationResult,
+} from '@xndrjs/i18n/validation';
+import type { ${schemaTypeName} } from '${typesImport}';
+
+${dictionarySpecBlock}
+export function validateExternalDictionaryPartial(
+  input: unknown,
+): ValidationResult<Partial<${schemaTypeName}>> {
+  return validateExternalDictionaryPartialCore<Partial<${schemaTypeName}>>(
+    input,
+    DICTIONARY_SPEC,
+  );
+}
+
+` + multiValidators;
+}
+
+// src/codegen/emit/instance-file.ts
+var STATE_TYPE = `{ dictionary: InitialSchema; resources?: readonly (readonly [string, string])[] }`;
+function formatInstanceFile(options) {
+  const {
+    typesOutputPath,
+    namespaceLoadersOutputPath,
+    paramsTypeName,
+    schemaTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    factoryName,
+    hasLocaleFallback,
+    hasLocaleType,
+    importExtension,
+    delivery,
+    localeDeliveryAreaConstName = "LOCALE_DELIVERY_AREA",
+    loaderStrategy = "import"
+  } = options;
+  const providerClass = "IcuTranslationProviderMulti";
+  const typesModule = toModuleBasename(typesOutputPath);
+  const typesImport = toRelativeModuleImport(typesModule, importExtension);
+  const loadersModule = toModuleBasename(namespaceLoadersOutputPath);
+  const loadersImport = toRelativeModuleImport(loadersModule, importExtension);
+  const schemaTypesImport = `import type { ${paramsTypeName}, ${schemaTypeName}, InitialSchema } from '${typesImport}';
+`;
+  const typesImportLine = formatTypesValueImport({
+    hasLocaleType,
+    hasLocaleFallback,
+    localeTypeName,
+    localeFallbackConstName,
+    localeDeliveryAreaConstName,
+    delivery,
+    typesImport
+  });
+  const packageImports = formatPackageImports(providerClass, loaderStrategy);
+  const loadersImportLine = loaderStrategy === "fetch" ? `import { createNamespaceLoaders } from '${loadersImport}';
+` : `import { namespaceLoaders } from '${loadersImport}';
+`;
+  const createFactoryBlock = formatCreateI18nFactory({
+    providerClass,
+    schemaTypeName,
+    paramsTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    factoryName,
+    hasLocaleFallback,
+    delivery,
+    localeDeliveryAreaConstName,
+    loaderStrategy
+  });
+  return `${GENERATED_FILE_BANNER}import {
+  ${packageImports},
+} from '@xndrjs/i18n';
+` + schemaTypesImport + typesImportLine + loadersImportLine + `
+` + createFactoryBlock;
+}
+function formatTypesValueImport(options) {
+  const {
+    hasLocaleType,
+    hasLocaleFallback,
+    localeTypeName,
+    localeFallbackConstName,
+    localeDeliveryAreaConstName,
+    delivery,
+    typesImport
+  } = options;
+  if (!hasLocaleType && delivery !== "custom") {
+    return "";
+  }
+  const valueNames = [];
+  if (hasLocaleFallback) {
+    valueNames.push(localeFallbackConstName);
+  }
+  if (delivery === "custom") {
+    valueNames.push(localeDeliveryAreaConstName);
+  }
+  if (valueNames.length > 0 && hasLocaleType) {
+    return `import { ${valueNames.join(", ")}, type ${localeTypeName} } from '${typesImport}';
+`;
+  }
+  if (valueNames.length > 0) {
+    return `import { ${valueNames.join(", ")} } from '${typesImport}';
+`;
+  }
+  if (hasLocaleType) {
+    return `import type { ${localeTypeName} } from '${typesImport}';
+`;
+  }
+  return "";
+}
+function formatCreateI18nFactory(options) {
+  const {
+    providerClass,
+    schemaTypeName,
+    paramsTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    factoryName,
+    hasLocaleFallback,
+    delivery,
+    localeDeliveryAreaConstName,
+    loaderStrategy
+  } = options;
+  const providerTypeArgs = hasLocaleFallback ? `${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}, typeof ${localeFallbackConstName}` : `${schemaTypeName}, ${paramsTypeName}`;
+  const handleReturnType = `I18nHandle<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}>`;
+  const handleTypeArgs = `<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}>`;
+  const partitionForLocale = delivery === "custom" ? `    partitionForLocale: (locale) => ${localeDeliveryAreaConstName}[locale],
+` : `    partitionForLocale: (locale) => locale,
+`;
+  const optionsType = loaderStrategy === "fetch" ? `{ fetchImpl: FetchArtifact; state?: ${STATE_TYPE}; onMissing?: OnMissingTranslation }` : `{ state?: ${STATE_TYPE}; onMissing?: OnMissingTranslation }`;
+  const optionsParam = loaderStrategy === "fetch" ? `  options: ${optionsType},
+` : `  options?: ${optionsType},
+`;
+  const namespaceLoadersLine = loaderStrategy === "fetch" ? `    namespaceLoaders: createNamespaceLoaders(fetchImpl),
+` : `    namespaceLoaders,
+`;
+  return `export function ${factoryName}(
+` + optionsParam + `): ${handleReturnType} {
+` + formatBody({
+    providerClass,
+    providerTypeArgs,
+    hasLocaleFallback,
+    localeFallbackConstName,
+    loaderStrategy
+  }) + `  engine.seedBuilderResources(normalized.resources);
+  return createI18nHandle${handleTypeArgs}(engine, {
+` + namespaceLoadersLine + partitionForLocale + `  } as I18nHandleOptions<${schemaTypeName}, ${localeTypeName}>);
+}
+`;
+}
+function formatBody(options) {
+  const {
+    providerClass,
+    providerTypeArgs,
+    hasLocaleFallback,
+    localeFallbackConstName,
+    loaderStrategy
+  } = options;
+  if (loaderStrategy === "fetch") {
+    const engineBlock2 = hasLocaleFallback ? `  const engine = new ${providerClass}<${providerTypeArgs}>(normalized.dictionary, {
+    localeFallback: ${localeFallbackConstName},
+    ...providerOptions,
+  });
+` : `  const engine = new ${providerClass}<${providerTypeArgs}>(normalized.dictionary, providerOptions);
+`;
+    return `  const { fetchImpl, state, ...providerOptions } = options;
+  const normalized = normalizeI18nCreateInput(state);
+` + engineBlock2;
+  }
+  const engineBlock = hasLocaleFallback ? `  const engine = new ${providerClass}<${providerTypeArgs}>(normalized.dictionary, {
+    localeFallback: ${localeFallbackConstName},
+    ...providerOptions,
+  });
+` : `  const engine = new ${providerClass}<${providerTypeArgs}>(normalized.dictionary, providerOptions);
+`;
+  return `  const { state, ...providerOptions } = options ?? {};
+  const normalized = normalizeI18nCreateInput(state);
+` + engineBlock;
+}
+function formatPackageImports(providerClass, loaderStrategy) {
+  const names = [
+    providerClass,
+    "createI18nHandle",
+    "normalizeI18nCreateInput",
+    "type I18nHandle",
+    "type I18nHandleOptions",
+    "type OnMissingTranslation"
+  ];
+  if (loaderStrategy === "fetch") {
+    names.push("type FetchArtifact");
+  }
+  return names.join(",\n  ");
+}
+function formatDefaultNamespacesLiteral(lazyEntries) {
+  return [...lazyEntries].map((entry) => entry.namespace).sort().map((namespace) => JSON.stringify(namespace)).join(", ");
+}
+function formatPartitionedTypesImport(options, paramTypeName) {
+  const { schemaTypeName, typesModule, importExtension } = options;
+  return `import type { ${schemaTypeName}, LazyNamespace, ${paramTypeName} } from '${toRelativeModuleImport(typesModule, importExtension)}';
+
+`;
+}
+function formatImportCase(loadersOutputPath, projectRoot, splitRelativePath) {
+  const importPath = toImportPath(loadersOutputPath, path8.resolve(projectRoot, splitRelativePath));
+  return `return import('${importPath}.json').then((m) => m.default);`;
+}
+function indentBlock(text, spaces) {
+  const pad = " ".repeat(spaces);
+  return text.split("\n").map((line) => line.length === 0 ? line : `${pad}${line}`).join("\n");
+}
+function formatImportNamespaceLoaderEntry(options) {
+  const {
+    namespace,
+    paramName,
+    partitionKeys,
+    splitPathsByNamespace,
+    loadersOutputPath,
+    projectRoot
+  } = options;
+  const caseBodies = partitionKeys.map((partitionKey) => {
+    const splitRelativePath = splitPathsByNamespace[namespace]?.[partitionKey];
+    if (!splitRelativePath) {
+      throw new Error(
+        `[Codegen Error] Missing split path for namespace "${namespace}", ${paramName} "${partitionKey}".`
+      );
+    }
+    const body = formatImportCase(loadersOutputPath, projectRoot, splitRelativePath);
+    return [`case ${JSON.stringify(partitionKey)}:`, `  ${body}`].join("\n");
+  });
+  const switchBody = [
+    ...caseBodies,
+    `default:`,
+    `  throw new Error(\`[i18n] No translation artifact for namespace ${JSON.stringify(namespace)} and ${paramName} "\${String(${paramName})}".\`);`
+  ].join("\n");
+  const entry = [
+    `${namespace}: (${paramName}) => {`,
+    `  switch (${paramName}) {`,
+    indentBlock(switchBody, 4),
+    `  }`,
+    `},`
+  ].join("\n");
+  return indentBlock(entry, 2);
+}
+function formatFetchNamespaceLoaderEntry(options) {
+  const { namespace, paramName, schemaTypeName, delivery } = options;
+  const nsLiteral = JSON.stringify(namespace);
+  const resourceId = delivery === "custom" ? `{ locale, namespace: ${nsLiteral}, area }` : `{ locale, namespace: ${nsLiteral} }`;
+  const signature = delivery === "custom" ? `(${paramName}, { locale })` : `(${paramName})`;
+  return indentBlock(
+    `${namespace}: ${signature} =>
+  fetchImpl(${resourceId}) as Promise<${schemaTypeName}[${nsLiteral}]>,`,
+    4
+  );
+}
+function formatPartitionedNamespaceLoadersFile(options, params) {
+  const { partitionKeys, paramName, paramTypeName } = params;
+  const {
+    loadersOutputPath,
+    lazyEntries,
+    schemaTypeName,
+    projectRoot,
+    delivery,
+    splitPathsByNamespace = {}
+  } = options;
+  const loaderStrategy = options.loaderStrategy ?? "import";
+  const loaderValueType = `${schemaTypeName}[K]`;
+  const typesImport = formatPartitionedTypesImport(options, paramTypeName);
+  if (loaderStrategy === "fetch") {
+    const fetchLoadersType = `{
+  [K in LazyNamespace]: (${delivery === "custom" ? `${paramName}: ${paramTypeName}, context: { locale: string }` : `${paramName}: ${paramTypeName}`}) => Promise<${loaderValueType}>;
+}`;
+    const loaderEntries2 = lazyEntries.map(
+      (entry) => formatFetchNamespaceLoaderEntry({
+        namespace: entry.namespace,
+        paramName,
+        schemaTypeName,
+        delivery
+      })
+    ).join("\n");
+    return `${GENERATED_FILE_BANNER}import type { FetchArtifact } from '@xndrjs/i18n';
+` + typesImport + `export type NamespaceLoaders = ${fetchLoadersType};
+
+/** Build loaders that resolve artifacts via the injected {@link FetchArtifact} (resource id only). */
+export function createNamespaceLoaders(fetchImpl: FetchArtifact): NamespaceLoaders {
+  return {
+${loaderEntries2}
+  };
+}
+
+export const defaultLazyNamespaces = [${formatDefaultNamespacesLiteral(lazyEntries)}] as const;
+`;
+  }
+  const loaderEntries = lazyEntries.map(
+    (entry) => formatImportNamespaceLoaderEntry({
+      namespace: entry.namespace,
+      paramName,
+      partitionKeys,
+      splitPathsByNamespace,
+      loadersOutputPath,
+      projectRoot
+    })
+  ).join("\n");
+  const importLoadersType = `{
+  [K in LazyNamespace]: (${paramName}: ${paramTypeName}) => Promise<${loaderValueType}>;
+}`;
+  return `${GENERATED_FILE_BANNER}` + typesImport + `export const namespaceLoaders: ${importLoadersType} = {
+${loaderEntries}
+};
+
+export const defaultLazyNamespaces = [${formatDefaultNamespacesLiteral(lazyEntries)}] as const;
+`;
+}
+function formatNamespaceLoadersFile(options) {
+  if (options.delivery === "split-by-locale") {
+    return formatPartitionedNamespaceLoadersFile(options, {
+      partitionKeys: options.requestLocales ?? [],
+      paramName: "locale",
+      paramTypeName: options.localeTypeName
+    });
+  }
+  if (!options.deliveryAreaTypeName) {
+    throw new Error("[Codegen Error] deliveryAreaTypeName is required for custom delivery.");
+  }
+  return formatPartitionedNamespaceLoadersFile(options, {
+    partitionKeys: options.deliveryAreaNames ?? [],
+    paramName: "area",
+    paramTypeName: options.deliveryAreaTypeName
+  });
+}
+
+// src/resolve-locale.ts
+function validateLocaleFallback(map) {
+  for (const startLocale of Object.keys(map)) {
+    const visited = /* @__PURE__ */ new Set();
+    let current = startLocale;
+    while (current !== void 0) {
+      if (visited.has(current)) {
+        throw new Error(`[i18n] Circular locale fallback detected involving "${current}"`);
+      }
+      visited.add(current);
+      const next = map[current];
+      if (next === void 0 || next === null) {
+        break;
+      }
+      current = next;
+    }
+  }
+}
+function resolveLocaleTemplate(localeByKey, requestedLocale, fallbackMap) {
+  const chain = [requestedLocale];
+  let currentLocale = requestedLocale;
+  while (true) {
+    const template = localeByKey?.[currentLocale];
+    if (template !== void 0) {
+      return { template, resolvedLocale: currentLocale, fallbackChain: chain };
+    }
+    if (!fallbackMap) {
+      return void 0;
+    }
+    const fallback = fallbackMap[currentLocale];
+    if (fallback === void 0 || fallback === null) {
+      return void 0;
+    }
+    if (chain.includes(fallback)) {
+      throw new Error(
+        `[i18n] Circular locale fallback detected: ${[...chain, fallback].join(" \u2192 ")}`
+      );
+    }
+    chain.push(fallback);
+    currentLocale = fallback;
+  }
+}
+
+// src/codegen/locale-fallback.ts
+function collectRequestLocales(dictionaryLocales, fallback) {
+  const all = new Set(dictionaryLocales);
+  if (!fallback) {
+    return all;
+  }
+  for (const [locale, target] of Object.entries(fallback)) {
+    all.add(locale);
+    if (target !== null) {
+      all.add(target);
+    }
+  }
+  return all;
+}
+function getCodegenLocaleFallbackIssues(fallback, dictionaryLocales) {
+  const issues = [];
+  try {
+    validateLocaleFallback(fallback);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    issues.push({ path: ["localeFallback"], message });
+  }
+  for (const [locale, target] of Object.entries(fallback)) {
+    if (target !== null && !(target in fallback) && !dictionaryLocales.has(target)) {
+      issues.push({
+        path: ["localeFallback", locale],
+        message: `localeFallback: "${locale}" points to "${target}" which is not defined in the fallback map or dictionary locales`
+      });
+    }
+  }
+  return issues;
+}
+function formatLocaleFallbackBlock(fallback, constName, typeName) {
+  const lines = Object.entries(fallback).map(
+    ([locale, target]) => `  ${JSON.stringify(locale)}: ${target === null ? "null" : JSON.stringify(target)},`
+  ).join("\n");
+  return `export const ${constName} = {
+${lines}
+} as const satisfies Record<string, string | null>;
+
+export type ${typeName} = typeof ${constName};
+
+`;
+}
+
+// src/codegen/emit/types-file.ts
+function formatLazyTypesBlock(lazyEntries) {
+  const lazyUnion = lazyEntries.length > 0 ? lazyEntries.map((entry) => `'${entry.namespace}'`).join(" | ") : "never";
+  return `export type LazyNamespace = ${lazyUnion};
+/** Empty cold-start schema \u2014 namespaces arrive via \`namespaceLoaders\`. */
+export type InitialSchema = Record<string, never>;
+
+`;
+}
+function formatLocaleTemplateType(localeTypeName, hasLocaleUnion) {
+  if (!hasLocaleUnion) {
+    return "Partial<Record<string, string>>";
+  }
+  return `Partial<Record<${localeTypeName}, string>>`;
+}
+function formatTypesFile(options) {
+  const {
+    entries,
+    paramsTypeName,
+    schemaTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    localeFallbackTypeName,
+    localeFallback,
+    paramsByNamespace,
+    requestLocales,
+    deliveryAreaTypeName,
+    deliveryAreaNames,
+    deliveryArtifacts,
+    localeDeliveryAreaConstName = "LOCALE_DELIVERY_AREA",
+    lazyEntries
+  } = options;
+  const hasLocaleUnion = requestLocales.length > 0;
+  const localeTemplateType = formatLocaleTemplateType(localeTypeName, hasLocaleUnion);
+  const localesConstName = `${localeTypeName}s`;
+  const localeBlock = hasLocaleUnion ? `${localeFallback ? formatLocaleFallbackBlock(localeFallback, localeFallbackConstName, localeFallbackTypeName) : ""}export const ${localesConstName} = [${requestLocales.map((locale) => JSON.stringify(locale)).join(", ")}] as const;
+export type ${localeTypeName} = (typeof ${localesConstName})[number];
+
+` : "";
+  const deliveryAreasConstName = deliveryAreaTypeName ? `${deliveryAreaTypeName}s` : void 0;
+  const deliveryAreaBlock = deliveryAreaTypeName && deliveryAreasConstName && deliveryAreaNames && deliveryAreaNames.length > 0 ? `export const ${deliveryAreasConstName} = [${deliveryAreaNames.map((area) => JSON.stringify(area)).join(", ")}] as const;
+export type ${deliveryAreaTypeName} = (typeof ${deliveryAreasConstName})[number];
+
+` + (deliveryArtifacts ? formatDeliveryArtifactsBlock(
+    deliveryArtifacts,
+    "DELIVERY_ARTIFACTS",
+    localeTypeName,
+    deliveryAreaTypeName
+  ) + formatLocaleDeliveryAreaBlock(
+    deliveryArtifacts,
+    localeDeliveryAreaConstName,
+    localeTypeName,
+    deliveryAreaTypeName
+  ) : "") : "";
+  const namespaceBlocks = entries.map((entry) => {
+    const keyTypes = paramsByNamespace[entry.namespace] ?? {};
+    const lines = Object.entries(keyTypes).map(([key, type]) => `    ${key}: ${type};`).join("\n");
+    return `  ${entry.namespace}: {
+${lines}
+  };`;
+  }).join("\n");
+  const paramsBlock = `export type ${paramsTypeName} = {
+${namespaceBlocks}
+};`;
+  const schemaLines = entries.map((entry) => {
+    const keyTypes = paramsByNamespace[entry.namespace] ?? {};
+    const lines = Object.keys(keyTypes).map((key) => `    ${key}: ${localeTemplateType};`).join("\n");
+    return `  ${entry.namespace}: {
+${lines}
+  };`;
+  }).join("\n");
+  const schemaBlock = `export type ${schemaTypeName} = {
+${schemaLines}
+};`;
+  const lazyTypesBlock = formatLazyTypesBlock(lazyEntries);
+  return `${GENERATED_FILE_BANNER}export const I18N_MODE = 'multi' as const;
+
+${localeBlock}${deliveryAreaBlock}${paramsBlock}
+
+${schemaBlock}
+${lazyTypesBlock}`;
+}
+
+// src/icu/extract-variables.ts
+function isPluralOrOrdinalNode(node) {
+  return node.type === 6 && "pluralType" in node && Boolean(node.pluralType);
+}
+function hasVariableName(node) {
+  return "value" in node && typeof node.value === "string";
+}
+function addVariableMeta(variables, name, type, role) {
+  const existing = variables[name];
+  if (!existing) {
+    variables[name] = { type, roles: /* @__PURE__ */ new Set([role]) };
+    return;
+  }
+  existing.roles.add(role);
+  existing.type = mergeVariableTypes(existing.type, type);
+}
+function mergeVariableTypes(left, right) {
+  if (left === right) {
+    return left;
+  }
+  if (left === "string" && right === "number" || left === "number" && right === "string") {
+    return "number";
+  }
+  return right;
+}
+function extractVariableMeta(nodes) {
+  const variables = {};
+  const walk = (walkNodes) => {
+    for (const node of walkNodes) {
+      if (node.type === 1 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "string", "simple");
+      } else if (node.type === 2 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "number", "number");
+      } else if (isPluralOrOrdinalNode(node) && hasVariableName(node)) {
+        const role = node.pluralType === "ordinal" ? "selectordinal" : "plural";
+        addVariableMeta(variables, node.value, "number", role);
+      } else if (node.type === 3 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "date", "date");
+      } else if (node.type === 4 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "date", "time");
+      } else if (node.type === 5 && hasVariableName(node)) {
+        addVariableMeta(variables, node.value, "string", "select");
+      }
+      if ("options" in node && node.options) {
+        for (const option of Object.values(node.options)) {
+          walk(option.value);
+        }
+      }
+      if ("children" in node && Array.isArray(node.children)) {
+        walk(node.children);
+      }
+    }
+  };
+  walk(nodes);
+  return variables;
+}
+function inferMergedVariableType(roles) {
+  const hasPlural = roles.has("plural");
+  const hasSelectordinal = roles.has("selectordinal");
+  const hasSelect = roles.has("select");
+  const hasSimple = roles.has("simple");
+  const hasNumber = roles.has("number");
+  const hasDate = roles.has("date");
+  const hasTime = roles.has("time");
+  if (hasPlural && hasSelectordinal) {
+    return "CONFLICT";
+  }
+  if (hasSelect && (hasPlural || hasSelectordinal || hasNumber)) {
+    return "CONFLICT";
+  }
+  if (hasPlural && hasSelect) {
+    return "CONFLICT";
+  }
+  if (hasSelectordinal && hasSelect) {
+    return "CONFLICT";
+  }
+  if (hasDate || hasTime) {
+    if (hasPlural || hasSelect || hasSelectordinal || hasSimple || hasNumber) {
+      return "CONFLICT";
+    }
+    return "date";
+  }
+  if (hasPlural || hasSelectordinal || hasNumber) {
+    return "number";
+  }
+  if (hasSelect || hasSimple) {
+    return "string";
+  }
+  return "string";
+}
+function mergeVariableMetaAcrossLocales(localeMetas) {
+  const keySignatures = localeMetas.map((meta) => Object.keys(meta).sort().join(","));
+  if (new Set(keySignatures).size > 1) {
+    return {
+      ok: false,
+      message: `Inconsistent ICU variable names across locales (keys: ${keySignatures.join(" vs ")})`
+    };
+  }
+  const merged = {};
+  const variableNames = new Set(localeMetas.flatMap((meta) => Object.keys(meta)));
+  for (const variableName of variableNames) {
+    const combinedRoles = /* @__PURE__ */ new Set();
+    for (const meta of localeMetas) {
+      for (const role of meta[variableName]?.roles ?? []) {
+        combinedRoles.add(role);
+      }
+    }
+    const mergedType = inferMergedVariableType(combinedRoles);
+    if (mergedType === "CONFLICT") {
+      const rolesByLocale = localeMetas.map((meta) => {
+        const entry = meta[variableName];
+        if (!entry) {
+          return null;
+        }
+        return [...entry.roles].sort().join("|");
+      }).filter((value) => value !== null);
+      return {
+        ok: false,
+        message: `Incompatible ICU variable "${variableName}" across locales (roles: ${rolesByLocale.join(" vs ")})`
+      };
+    }
+    merged[variableName] = mergedType;
+  }
+  return { ok: true, merged };
+}
+
+// src/project-locales.ts
+function classifyAreaLocales(areaLocales, localeFallback) {
+  const areaSet = new Set(areaLocales);
+  const full = [];
+  const preserve = [];
+  for (const locale of areaLocales) {
+    const fallback = localeFallback?.[locale];
+    if (fallback !== null && fallback !== void 0 && areaSet.has(fallback)) {
+      preserve.push(locale);
+    } else {
+      full.push(locale);
+    }
+  }
+  return { full, preserve };
+}
+function projectKeyDictionary(dictionary, locales, localeFallback) {
+  const targetLocales = [...new Set(locales)];
+  const result = {};
+  for (const [key, localesByKey] of Object.entries(dictionary)) {
+    const projected = {};
+    for (const locale of targetLocales) {
+      const resolved = resolveLocaleTemplate(localesByKey, locale, localeFallback);
+      if (resolved !== void 0) {
+        projected[locale] = resolved.template;
+      }
+    }
+    if (Object.keys(projected).length > 0) {
+      result[key] = projected;
+    }
+  }
+  return result;
+}
+function projectNamespaceLocalesCore(dictionary, locales, localeFallback) {
+  return projectKeyDictionary(dictionary, locales, localeFallback);
+}
+function projectNamespaceForDeliveryAreaCore(dictionary, areaLocales, localeFallback) {
+  const { full, preserve } = classifyAreaLocales(areaLocales, localeFallback);
+  const fullProjection = full.length > 0 ? projectKeyDictionary(dictionary, full, localeFallback) : void 0;
+  const result = {};
+  for (const [key, localesByKey] of Object.entries(dictionary)) {
+    const projected = {};
+    if (fullProjection !== void 0) {
+      const fullEntry = fullProjection[key];
+      if (fullEntry !== void 0) {
+        Object.assign(projected, fullEntry);
+      }
+    }
+    for (const locale of preserve) {
+      const template = localesByKey[locale];
+      if (template !== void 0) {
+        projected[locale] = template;
+      }
+    }
+    if (Object.keys(projected).length > 0) {
+      result[key] = projected;
+    }
+  }
+  return result;
+}
+function writeFileIfChanged(absolutePath, content) {
+  if (fs3.existsSync(absolutePath)) {
+    const currentContent = fs3.readFileSync(absolutePath, "utf8");
+    if (currentContent === content) {
+      return false;
+    }
+  }
+  fs3.mkdirSync(path8.dirname(absolutePath), { recursive: true });
+  fs3.writeFileSync(absolutePath, content);
+  return true;
+}
+
+// src/codegen/read-dictionary.ts
+function getDictionaryFormat(filePath) {
+  const extension = path8.extname(filePath).toLowerCase();
+  if (extension === ".json") {
+    return "json";
+  }
+  if (extension === ".yaml" || extension === ".yml") {
+    return "yaml";
+  }
+  return null;
+}
+function resolveSplitJsonPath(sourcePath, locale, generatedDirRelative) {
+  const baseName = path8.basename(sourcePath, path8.extname(sourcePath));
+  return path8.join(generatedDirRelative, "translations", `${baseName}.${locale}.json`).replace(/\\/g, "/");
+}
+function resolveAreaJsonPath(sourcePath, area, generatedDirRelative) {
+  const baseName = path8.basename(sourcePath, path8.extname(sourcePath));
+  return path8.join(generatedDirRelative, "translations", `${baseName}.${area}.json`).replace(/\\/g, "/");
+}
+function splitDictionaryByLocale(dictionary, locales, localeFallback) {
+  const byLocale = {};
+  for (const locale of locales) {
+    byLocale[locale] = projectNamespaceLocalesCore(dictionary, [locale], localeFallback);
+  }
+  return byLocale;
+}
+function splitDictionaryByDeliveryArea(dictionary, deliveryArtifacts, localeFallback) {
+  const byArea = {};
+  for (const [area, areaLocales] of Object.entries(deliveryArtifacts)) {
+    byArea[area] = projectNamespaceForDeliveryAreaCore(dictionary, areaLocales, localeFallback);
+  }
+  return byArea;
+}
+function assertDictionaryShape(value, context) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`[Codegen Error] ${context} must be a plain object.`);
+  }
+  for (const [key, localesByKey] of Object.entries(value)) {
+    if (!IDENTIFIER_NAME_PATTERN.test(key)) {
+      throw new Error(
+        `[Codegen Error] ${context}: invalid key "${key}" (${IDENTIFIER_NAME_REQUIREMENT}).`
+      );
+    }
+    if (localesByKey === null || typeof localesByKey !== "object" || Array.isArray(localesByKey)) {
+      throw new Error(`[Codegen Error] ${context}: key "${key}" must map locales to strings.`);
+    }
+    for (const [locale, template] of Object.entries(localesByKey)) {
+      if (typeof template !== "string") {
+        throw new Error(
+          `[Codegen Error] ${context}: key "${key}", locale "${locale}" must be a string.`
+        );
+      }
+    }
+  }
+}
+function readDictionaryFile(absolutePath) {
+  const format = getDictionaryFormat(absolutePath);
+  if (!format) {
+    throw new Error(
+      `[Codegen Error] Unsupported dictionary format "${path8.extname(absolutePath)}" for ${absolutePath}. Use .json, .yaml, or .yml.`
+    );
+  }
+  const source = fs3.readFileSync(absolutePath, "utf8");
+  let parsed;
+  try {
+    parsed = format === "json" ? JSON.parse(source) : parse$1(source);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`[Codegen Error] Failed to parse dictionary ${absolutePath}: ${message}`);
+  }
+  assertDictionaryShape(parsed, `Dictionary file ${absolutePath}`);
+  return parsed;
+}
+function writeCompiledJson(absoluteJsonPath, dictionary) {
+  return writeFileIfChanged(absoluteJsonPath, `${JSON.stringify(dictionary, null, 2)}
 `);
 }
+function prepareDictionaryEntries(projectRoot, entries, generatedDirRelative, options) {
+  const delivery = options.delivery;
+  const { dictionariesByNamespace, localeFallback, requestLocales, deliveryArtifacts } = options;
+  const resolvedEntries = [];
+  const splitPathsByNamespace = {};
+  const compiledFiles = [];
+  if (delivery === "split-by-locale" && (!requestLocales || requestLocales.length === 0)) {
+    throw new Error(
+      "[Codegen Error] split-by-locale delivery requires at least one request locale."
+    );
+  }
+  if (delivery === "custom" && (!deliveryArtifacts || Object.keys(deliveryArtifacts).length === 0)) {
+    throw new Error("[Codegen Error] custom delivery requires deliveryArtifacts.");
+  }
+  for (const entry of entries) {
+    const sourceAbsolutePath = path8.resolve(projectRoot, entry.filePath);
+    const format = getDictionaryFormat(entry.filePath);
+    if (!format) {
+      throw new Error(
+        `[Codegen Error] Namespace "${entry.namespace}" uses unsupported dictionary extension in "${entry.filePath}". Use .json, .yaml, or .yml.`
+      );
+    }
+    const dictionary = dictionariesByNamespace[entry.namespace];
+    if (!dictionary) {
+      throw new Error(
+        `[Codegen Error] Missing parsed dictionary for namespace "${entry.namespace}".`
+      );
+    }
+    if (delivery === "split-by-locale") {
+      const splitPaths2 = {};
+      const dictionariesByLocale = splitDictionaryByLocale(
+        dictionary,
+        requestLocales,
+        localeFallback
+      );
+      for (const locale of requestLocales) {
+        const splitRelativePath = resolveSplitJsonPath(
+          entry.filePath,
+          locale,
+          generatedDirRelative
+        );
+        const splitAbsolutePath = path8.resolve(projectRoot, splitRelativePath);
+        const wroteFile = writeCompiledJson(splitAbsolutePath, dictionariesByLocale[locale]);
+        if (wroteFile) {
+          compiledFiles.push(
+            `${path8.relative(projectRoot, sourceAbsolutePath)} \u2192 ${splitRelativePath}`
+          );
+        }
+        splitPaths2[locale] = splitRelativePath;
+      }
+      splitPathsByNamespace[entry.namespace] = splitPaths2;
+      resolvedEntries.push(entry);
+      continue;
+    }
+    const splitPaths = {};
+    const dictionariesByArea = splitDictionaryByDeliveryArea(
+      dictionary,
+      deliveryArtifacts,
+      localeFallback
+    );
+    for (const area of Object.keys(deliveryArtifacts).sort()) {
+      const areaRelativePath = resolveAreaJsonPath(entry.filePath, area, generatedDirRelative);
+      const areaAbsolutePath = path8.resolve(projectRoot, areaRelativePath);
+      const wroteFile = writeCompiledJson(areaAbsolutePath, dictionariesByArea[area]);
+      if (wroteFile) {
+        compiledFiles.push(
+          `${path8.relative(projectRoot, sourceAbsolutePath)} \u2192 ${areaRelativePath}`
+        );
+      }
+      splitPaths[area] = areaRelativePath;
+    }
+    splitPathsByNamespace[entry.namespace] = splitPaths;
+    resolvedEntries.push(entry);
+  }
+  return { resolvedEntries, splitPathsByNamespace, compiledFiles };
+}
+
+// src/codegen/icu-analysis.ts
+function paramsTypeForVariables(variables) {
+  const keys = Object.keys(variables);
+  if (keys.length === 0) {
+    return "never";
+  }
+  const props = keys.map((key) => {
+    const type = variables[key] === "date" ? "Date | number" : variables[key];
+    return `${key}: ${type}`;
+  });
+  return `{ ${props.join("; ")} }`;
+}
+function analyzeDictionaries(projectRoot, entries) {
+  const paramsByNamespace = {};
+  const argsSpecByNamespace = {};
+  const locales = /* @__PURE__ */ new Set();
+  const dictionariesByNamespace = {};
+  let hasErrors = false;
+  for (const entry of entries) {
+    const absolutePath = path8.resolve(projectRoot, entry.filePath);
+    if (!fs3.existsSync(absolutePath)) {
+      console.error(
+        `[Codegen Error] Dictionary file not found for namespace "${entry.namespace}": ${absolutePath}`
+      );
+      hasErrors = true;
+      continue;
+    }
+    const dictionary = readDictionaryFile(absolutePath);
+    dictionariesByNamespace[entry.namespace] = dictionary;
+    paramsByNamespace[entry.namespace] = {};
+    argsSpecByNamespace[entry.namespace] = {};
+    for (const [key, localesByKey] of Object.entries(dictionary)) {
+      const localeMetas = [];
+      for (const locale of Object.keys(localesByKey)) {
+        locales.add(locale);
+      }
+      for (const [locale, template] of Object.entries(localesByKey)) {
+        try {
+          const ast = parse(template);
+          localeMetas.push(extractVariableMeta(ast));
+        } catch (error) {
+          hasErrors = true;
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(
+            `[Codegen Error] ICU syntax error \u2014 namespace "${entry.namespace}", key "${key}", locale "${locale}": ${message}`
+          );
+        }
+      }
+      if (localeMetas.length === 0) {
+        continue;
+      }
+      const mergedVariables = mergeVariableMetaAcrossLocales(localeMetas);
+      if (!mergedVariables.ok) {
+        hasErrors = true;
+        console.error(
+          `[Codegen Error] ${mergedVariables.message} \u2014 namespace "${entry.namespace}", key "${key}"`
+        );
+        continue;
+      }
+      const variables = mergedVariables.merged;
+      paramsByNamespace[entry.namespace][key] = paramsTypeForVariables(variables);
+      argsSpecByNamespace[entry.namespace][key] = variables;
+    }
+  }
+  if (hasErrors) {
+    return { ok: false };
+  }
+  return {
+    ok: true,
+    analysis: { paramsByNamespace, argsSpecByNamespace, locales, dictionariesByNamespace }
+  };
+}
+
+// src/codegen/locale-policy.ts
+function buildRequiredLocales(dictionaryLocales, configFallback) {
+  return [...collectRequestLocales(dictionaryLocales, configFallback)].sort();
+}
+function enrichLocaleFallback(dictionaryLocales, configFallback) {
+  const enriched = { ...configFallback };
+  for (const locale of buildRequiredLocales(dictionaryLocales, configFallback)) {
+    if (!(locale in enriched)) {
+      enriched[locale] = null;
+    }
+  }
+  const sortedEntries = Object.entries(enriched).sort(
+    ([left], [right]) => left.localeCompare(right)
+  );
+  return Object.fromEntries(sortedEntries);
+}
+
+// src/codegen/run-codegen.ts
+function resolveRunCodegenInput(input) {
+  if (typeof input === "string" || input === void 0) {
+    const configPath2 = path8.resolve(
+      process.cwd(),
+      typeof input === "string" ? input : "i18n/i18n.codegen.json"
+    );
+    if (!fs3.existsSync(configPath2)) {
+      throw new Error(`[Codegen Error] Config file not found: ${configPath2}`);
+    }
+    return {
+      projectRoot: path8.dirname(configPath2),
+      config: loadConfig(configPath2),
+      log: true
+    };
+  }
+  const log = input.log !== false;
+  if (input.config !== void 0) {
+    const projectRoot = path8.resolve(input.projectRoot ?? process.cwd());
+    return { projectRoot, config: input.config, log };
+  }
+  const configPath = path8.resolve(process.cwd(), input.configPath ?? "i18n/i18n.codegen.json");
+  if (!fs3.existsSync(configPath)) {
+    throw new Error(`[Codegen Error] Config file not found: ${configPath}`);
+  }
+  return {
+    projectRoot: path8.dirname(configPath),
+    config: loadConfig(configPath),
+    log
+  };
+}
+function runCodegen(input) {
+  const { projectRoot, config, log } = resolveRunCodegenInput(input);
+  const sourceEntries = resolveNamespaces(config);
+  const artifactsPathRelative = resolveArtifactsPath(config);
+  const delivery = config.delivery ?? "split-by-locale";
+  const loaderStrategy = config.loaderStrategy ?? "import";
+  const analysisResult = analyzeDictionaries(projectRoot, sourceEntries);
+  if (!analysisResult.ok) {
+    throw new Error("[Codegen Error] Dictionary ICU analysis failed. See messages above.");
+  }
+  const { paramsByNamespace, argsSpecByNamespace, locales, dictionariesByNamespace } = analysisResult.analysis;
+  if (config.localeFallback) {
+    const localeFallbackIssues = getCodegenLocaleFallbackIssues(config.localeFallback, locales);
+    if (localeFallbackIssues.length > 0) {
+      reportCodegenIssues(localeFallbackIssues);
+      throw new Error("[Codegen Error] Invalid localeFallback configuration.");
+    }
+  }
+  const paths = resolveCodegenPaths(config);
+  const {
+    paramsTypeName,
+    schemaTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    factoryName,
+    deliveryAreaTypeName: resolvedDeliveryAreaTypeName
+  } = paths;
+  const localeFallbackTypeName = `${localeTypeName}Fallback`;
+  const importExtension = DEFAULT_IMPORT_EXTENSION;
+  const requestLocales = collectRequestLocales(locales, config.localeFallback);
+  const requestLocalesList = [...requestLocales].sort();
+  if (delivery === "custom" && config.deliveryArtifacts) {
+    const deliveryArtifactsIssues = getDeliveryArtifactsIssues(
+      config.deliveryArtifacts,
+      requestLocales
+    );
+    if (deliveryArtifactsIssues.length > 0) {
+      reportCodegenIssues(deliveryArtifactsIssues);
+      throw new Error("[Codegen Error] Invalid deliveryArtifacts configuration.");
+    }
+  }
+  const {
+    resolvedEntries: entries,
+    splitPathsByNamespace,
+    compiledFiles
+  } = prepareDictionaryEntries(projectRoot, sourceEntries, artifactsPathRelative, {
+    dictionariesByNamespace,
+    delivery,
+    localeFallback: config.localeFallback,
+    requestLocales: delivery === "split-by-locale" ? requestLocalesList : void 0,
+    deliveryArtifacts: delivery === "custom" ? config.deliveryArtifacts : void 0
+  });
+  const typesOutputPath = path8.resolve(projectRoot, paths.typesOutput);
+  const instanceOutputPath = path8.resolve(projectRoot, paths.instanceOutput);
+  const namespaceLoadersOutputPath = path8.resolve(projectRoot, paths.namespaceLoadersOutput);
+  const dictionarySchemaOutputPath = path8.resolve(projectRoot, paths.dictionarySchemaOutput);
+  const typesModule = toModuleBasename(typesOutputPath);
+  const deliveryAreaNames = delivery === "custom" && config.deliveryArtifacts ? Object.keys(config.deliveryArtifacts).sort() : void 0;
+  const deliveryAreaTypeName = delivery === "custom" ? resolvedDeliveryAreaTypeName : void 0;
+  const localeFallbackForEmit = config.localeFallback ? enrichLocaleFallback(locales, config.localeFallback) : void 0;
+  const typesContent = formatTypesFile({
+    entries,
+    paramsTypeName,
+    schemaTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    localeFallbackTypeName,
+    localeFallback: localeFallbackForEmit,
+    paramsByNamespace,
+    requestLocales: requestLocalesList,
+    ...deliveryAreaTypeName && deliveryAreaNames ? {
+      deliveryAreaTypeName,
+      deliveryAreaNames,
+      ...delivery === "custom" && config.deliveryArtifacts ? { deliveryArtifacts: config.deliveryArtifacts } : {}
+    } : {},
+    lazyEntries: entries
+  });
+  const instanceContent = formatInstanceFile({
+    typesOutputPath,
+    namespaceLoadersOutputPath,
+    paramsTypeName,
+    schemaTypeName,
+    localeTypeName,
+    localeFallbackConstName,
+    factoryName,
+    hasLocaleFallback: Boolean(config.localeFallback),
+    hasLocaleType: requestLocalesList.length > 0,
+    importExtension,
+    delivery,
+    loaderStrategy,
+    ...delivery === "custom" ? { localeDeliveryAreaConstName: "LOCALE_DELIVERY_AREA" } : {}
+  });
+  writeFileIfChanged(typesOutputPath, typesContent);
+  const generatedFiles = [
+    path8.relative(projectRoot, typesOutputPath),
+    path8.relative(projectRoot, instanceOutputPath)
+  ];
+  writeFileIfChanged(instanceOutputPath, instanceContent);
+  const dictionarySpecBlock = formatDictionarySpecBlock(entries, argsSpecByNamespace);
+  const dictionarySchemaContent = formatDictionarySchemaFile(
+    schemaTypeName,
+    typesModule,
+    dictionarySpecBlock,
+    importExtension
+  );
+  writeFileIfChanged(dictionarySchemaOutputPath, dictionarySchemaContent);
+  generatedFiles.push(path8.relative(projectRoot, dictionarySchemaOutputPath));
+  const lazyEntriesWithPaths = entries.map((entry) => ({
+    ...entry,
+    absolutePath: path8.resolve(projectRoot, entry.filePath)
+  }));
+  const namespaceLoadersContent = formatNamespaceLoadersFile({
+    loadersOutputPath: namespaceLoadersOutputPath,
+    lazyEntries: lazyEntriesWithPaths,
+    schemaTypeName,
+    localeTypeName,
+    typesModule,
+    importExtension,
+    projectRoot,
+    delivery,
+    splitPathsByNamespace,
+    loaderStrategy,
+    ...delivery === "split-by-locale" ? { requestLocales: requestLocalesList } : {},
+    ...delivery === "custom" && deliveryAreaTypeName && deliveryAreaNames ? { deliveryAreaTypeName, deliveryAreaNames } : {}
+  });
+  writeFileIfChanged(namespaceLoadersOutputPath, namespaceLoadersContent);
+  generatedFiles.push(path8.relative(projectRoot, namespaceLoadersOutputPath));
+  if (log) {
+    console.log(`\u2705 Generated: ${generatedFiles.join(", ")}`);
+    if (compiledFiles.length > 0) {
+      console.log(`\u2705 Compiled: ${compiledFiles.join(", ")}`);
+    }
+  }
+  return { projectRoot, generatedFiles, compiledFiles };
+}
+function buildDictionarySpecFromAnalysis(entries, argsSpecByNamespace) {
+  const requiredKeys = {};
+  const argsByKey = {};
+  for (const entry of entries) {
+    const argsByKeyForNs = argsSpecByNamespace[entry.namespace] ?? {};
+    requiredKeys[entry.namespace] = Object.keys(argsByKeyForNs).sort();
+    argsByKey[entry.namespace] = argsByKeyForNs;
+  }
+  return {
+    mode: "multi",
+    requiredKeys,
+    argsByKey
+  };
+}
+function loadDictionarySpecFromSchemaFile(absoluteSchemaPath) {
+  if (!fs3.existsSync(absoluteSchemaPath)) {
+    throw new Error(
+      `[Codegen Error] Missing dictionary schema at ${absoluteSchemaPath}. Run runCodegen first.`
+    );
+  }
+  const source = fs3.readFileSync(absoluteSchemaPath, "utf8");
+  const match = source.match(
+    /export const DICTIONARY_SPEC = (\{[\s\S]*?\n\}) satisfies DictionarySpec;/
+  );
+  if (!match?.[1]) {
+    throw new Error(
+      `[Codegen Error] Could not parse DICTIONARY_SPEC from ${absoluteSchemaPath}. Re-run runCodegen.`
+    );
+  }
+  const cleaned = match[1].replace(/ as const/g, "");
+  let parsed;
+  try {
+    parsed = new Function(`"use strict"; return (${cleaned});`)();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `[Codegen Error] Failed to evaluate DICTIONARY_SPEC from ${absoluteSchemaPath}: ${message}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || parsed.mode !== "multi" || !("requiredKeys" in parsed) || !("argsByKey" in parsed)) {
+    throw new Error(
+      `[Codegen Error] DICTIONARY_SPEC in ${absoluteSchemaPath} is not a multi-mode DictionarySpec.`
+    );
+  }
+  return parsed;
+}
+function sortedKeys(keys) {
+  return [...keys].sort();
+}
+function variableSpecsEqual(a, b) {
+  const aKeys = Object.keys(a).sort();
+  const bKeys = Object.keys(b).sort();
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  for (let i = 0; i < aKeys.length; i++) {
+    const key = aKeys[i];
+    if (key !== bKeys[i] || a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function namespaceArgsEqual(a, b) {
+  const aKeys = Object.keys(a ?? {}).sort();
+  const bKeys = Object.keys(b ?? {}).sort();
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  for (const key of aKeys) {
+    if (!bKeys.includes(key)) {
+      return false;
+    }
+    if (!variableSpecsEqual(a[key], b[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+function namespaceContractsMatch(namespaces, current, established) {
+  for (const namespace of namespaces) {
+    const currentKeys = sortedKeys(current.requiredKeys[namespace] ?? []);
+    const establishedKeys = sortedKeys(established.requiredKeys[namespace] ?? []);
+    if (currentKeys.length !== establishedKeys.length || currentKeys.some((key, index) => key !== establishedKeys[index])) {
+      return false;
+    }
+    if (!namespaceArgsEqual(current.argsByKey[namespace], established.argsByKey[namespace])) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/codegen/regenerate-namespaces.ts
+function resolveRegenerateInput(input) {
+  const log = input.log !== false;
+  const namespaces = input.namespaces;
+  if (input.config !== void 0) {
+    return {
+      projectRoot: path8.resolve(input.projectRoot ?? process.cwd()),
+      config: input.config,
+      namespaces,
+      log
+    };
+  }
+  const configPath = path8.resolve(process.cwd(), input.configPath ?? "i18n/i18n.codegen.json");
+  if (!fs3.existsSync(configPath)) {
+    throw new Error(`[Codegen Error] Config file not found: ${configPath}`);
+  }
+  return {
+    projectRoot: path8.dirname(configPath),
+    config: loadConfig(configPath),
+    namespaces,
+    log
+  };
+}
+function regenerateNamespaces(input) {
+  const { projectRoot, config, namespaces, log } = resolveRegenerateInput(input);
+  if (namespaces.length === 0) {
+    throw new Error("[Codegen Error] regenerateNamespaces requires a non-empty namespaces list.");
+  }
+  const sourceEntries = resolveNamespaces(config);
+  const known = new Set(sourceEntries.map((entry) => entry.namespace));
+  const unknown = namespaces.filter((namespace) => !known.has(namespace));
+  if (unknown.length > 0) {
+    throw new Error(
+      `[Codegen Error] Unknown namespace(s) for regenerateNamespaces: ${unknown.join(", ")}.`
+    );
+  }
+  const requested = new Set(namespaces);
+  const selectedEntries = sourceEntries.filter((entry) => requested.has(entry.namespace));
+  const paths = resolveCodegenPaths(config);
+  const schemaPath = path8.resolve(projectRoot, paths.dictionarySchemaOutput);
+  const established = loadDictionarySpecFromSchemaFile(schemaPath);
+  const artifactsPathRelative = resolveArtifactsPath(config);
+  const delivery = config.delivery ?? "split-by-locale";
+  const analysisResult = analyzeDictionaries(projectRoot, sourceEntries);
+  if (!analysisResult.ok) {
+    throw new Error(
+      "[Codegen Error] Dictionary ICU analysis failed while regenerating namespaces."
+    );
+  }
+  const {
+    argsSpecByNamespace,
+    locales,
+    dictionariesByNamespace: sourceDictionaries
+  } = analysisResult.analysis;
+  const current = buildDictionarySpecFromAnalysis(selectedEntries, argsSpecByNamespace);
+  if (!namespaceContractsMatch(namespaces, current, established)) {
+    throw new Error(
+      "[Codegen Error] Namespace ICU contract changed (keys or params). Contract change requires runCodegen."
+    );
+  }
+  if (config.localeFallback) {
+    const localeFallbackIssues = getCodegenLocaleFallbackIssues(config.localeFallback, locales);
+    if (localeFallbackIssues.length > 0) {
+      reportCodegenIssues(localeFallbackIssues);
+      throw new Error("[Codegen Error] Invalid localeFallback configuration.");
+    }
+  }
+  const requestLocales = collectRequestLocales(locales, config.localeFallback);
+  const requestLocalesList = [...requestLocales].sort();
+  if (delivery === "custom" && config.deliveryArtifacts) {
+    const deliveryArtifactsIssues = getDeliveryArtifactsIssues(
+      config.deliveryArtifacts,
+      requestLocales
+    );
+    if (deliveryArtifactsIssues.length > 0) {
+      reportCodegenIssues(deliveryArtifactsIssues);
+      throw new Error("[Codegen Error] Invalid deliveryArtifacts configuration.");
+    }
+  }
+  const dictionariesByNamespace = {};
+  for (const entry of selectedEntries) {
+    const dictionary = sourceDictionaries[entry.namespace];
+    if (!dictionary) {
+      throw new Error(
+        `[Codegen Error] Missing parsed dictionary for namespace "${entry.namespace}".`
+      );
+    }
+    dictionariesByNamespace[entry.namespace] = dictionary;
+  }
+  const { splitPathsByNamespace, compiledFiles } = prepareDictionaryEntries(
+    projectRoot,
+    selectedEntries,
+    artifactsPathRelative,
+    {
+      dictionariesByNamespace,
+      delivery,
+      localeFallback: config.localeFallback,
+      requestLocales: delivery === "split-by-locale" ? requestLocalesList : void 0,
+      deliveryArtifacts: delivery === "custom" ? config.deliveryArtifacts : void 0
+    }
+  );
+  if (log) {
+    if (compiledFiles.length > 0) {
+      console.log(`\u2705 Regenerated delivery artifacts: ${compiledFiles.join(", ")}`);
+    } else {
+      console.log("\u2705 Regenerated delivery artifacts: unchanged");
+    }
+  }
+  return { projectRoot, compiledFiles, splitPathsByNamespace };
+}
 
-export { DELIVERY_MODES, SUPPORTED_IMPORT_EXTENSIONS, buildCodegenConfig, codegenConfigKeys, inferProjectName, resolveDeliveryOutputDir, resolveDictionaryOutputPath, typeNamesForProject, writeCodegenConfig };
+export { DEFAULT_FACTORY_NAME, DEFAULT_LOCALE_FALLBACK_CONST_NAME, DELIVERY_MODES, GENERATED_BASENAMES, LOADER_STRATEGIES, SUPPORTED_IMPORT_EXTENSIONS, buildCodegenConfig, codegenConfigKeys, formatCodegenConfigIssues, inferProjectName, loadConfig, regenerateNamespaces, resolveArtifactsPath, resolveCodegenPaths, resolveNamespaces, runCodegen, typeNamesForProject, writeCodegenConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map