@xndrjs/i18n 0.6.0 → 0.7.0-alpha.0

package/src/codegen/emit/dictionary-schema-file.ts

@@ -79,58 +79,71 @@ export function formatDictionarySchemaFile(
   importExtension: ImportExtension
 ): string {
   const typesImport = toRelativeModuleImport(typesModule, importExtension);
-  const namespaceImport = isSingle
-    ? ""
-    : `  validateExternalNamespace as validateExternalNamespaceCore,\n`;
-  const namespaceValidator = isSingle
-    ? ""
-    : `export function validateExternalNamespace<NS extends keyof ${schemaTypeName}>(\n` +
-      `  namespace: NS,\n` +
-      `  input: unknown,\n` +
-      `) {\n` +
-      `  return validateExternalNamespaceCore<${schemaTypeName}[NS]>(\n` +
-      `    namespace as string,\n` +
-      `    input,\n` +
-      `    DICTIONARY_SPEC,\n` +
-      `  );\n` +
-      `}\n\n`;
+  const partialImport = isSingle
+    ? `  validateExternalDictionaryPartial as validateExternalDictionaryPartialCore,\n` +
+      `  validateExternalKey as validateExternalKeyCore,\n`
+    : `  validateExternalDictionaryPartial as validateExternalDictionaryPartialCore,\n` +
+      `  validateExternalNamespacePartial as validateExternalNamespacePartialCore,\n` +
+      `  validateExternalKey as validateExternalKeyCore,\n`;
+
+  const singleKeyValidator =
+    `export function validateExternalKey<K extends keyof ${schemaTypeName}>(\n` +
+    `  key: K,\n` +
+    `  input: unknown,\n` +
+    `): ValidationResult<Pick<${schemaTypeName}, K>> {\n` +
+    `  return validateExternalKeyCore<Pick<${schemaTypeName}, K>>(\n` +
+    `    key as string,\n` +
+    `    input,\n` +
+    `    DICTIONARY_SPEC,\n` +
+    `  );\n` +
+    `}\n\n`;
+
+  const multiValidators =
+    `export function validateExternalNamespacePartial<NS extends keyof ${schemaTypeName}>(\n` +
+    `  namespace: NS,\n` +
+    `  input: unknown,\n` +
+    `): ValidationResult<Partial<${schemaTypeName}[NS]>> {\n` +
+    `  return validateExternalNamespacePartialCore<Partial<${schemaTypeName}[NS]>>(\n` +
+    `    namespace as string,\n` +
+    `    input,\n` +
+    `    DICTIONARY_SPEC,\n` +
+    `  );\n` +
+    `}\n\n` +
+    `export function validateExternalKey<\n` +
+    `  NS extends keyof ${schemaTypeName},\n` +
+    `  K extends keyof ${schemaTypeName}[NS],\n` +
+    `>(\n` +
+    `  namespace: NS,\n` +
+    `  key: K,\n` +
+    `  input: unknown,\n` +
+    `): ValidationResult<Pick<${schemaTypeName}[NS], K>> {\n` +
+    `  return validateExternalKeyCore<Pick<${schemaTypeName}[NS], K>>(\n` +
+    `    namespace as string,\n` +
+    `    key as string,\n` +
+    `    input,\n` +
+    `    DICTIONARY_SPEC,\n` +
+    `  );\n` +
+    `}\n\n`;
+
+  const keyValidator = isSingle ? singleKeyValidator : multiValidators;
 
   return (
     `${GENERATED_FILE_BANNER}` +
     `import {\n` +
-    `  normalizeDictionary,\n` +
-    `  validateNormalizedDictionary,\n` +
-    namespaceImport +
-    `  toDictionary,\n` +
+    partialImport +
     `  type DictionarySpec,\n` +
-    `  type NormalizedDictionary,\n` +
     `  type ValidationResult,\n` +
     `} from '@xndrjs/i18n/validation';\n` +
     `import type { ${schemaTypeName} } from '${typesImport}';\n\n` +
     `${dictionarySpecBlock}\n` +
-    `export function normalizeExternalDictionary(\n` +
-    `  input: unknown,\n` +
-    `): ValidationResult<NormalizedDictionary> {\n` +
-    `  return normalizeDictionary(input, DICTIONARY_SPEC);\n` +
-    `}\n\n` +
-    `export function validateNormalizedExternalDictionary(\n` +
-    `  normalized: NormalizedDictionary,\n` +
-    `): ValidationResult<NormalizedDictionary> {\n` +
-    `  return validateNormalizedDictionary(normalized, DICTIONARY_SPEC);\n` +
-    `}\n\n` +
-    `export function validateExternalDictionary(\n` +
+    `export function validateExternalDictionaryPartial(\n` +
     `  input: unknown,\n` +
-    `): ValidationResult<${schemaTypeName}> {\n` +
-    `  const step1 = normalizeExternalDictionary(input);\n` +
-    `  if (!step1.ok) {\n` +
-    `    return step1;\n` +
-    `  }\n\n` +
-    `  const step2 = validateNormalizedExternalDictionary(step1.data);\n` +
-    `  if (!step2.ok) {\n` +
-    `    return step2;\n` +
-    `  }\n\n` +
-    `  return { ok: true, data: toDictionary(step2.data) as ${schemaTypeName} };\n` +
+    `): ValidationResult<Partial<${schemaTypeName}>> {\n` +
+    `  return validateExternalDictionaryPartialCore<Partial<${schemaTypeName}>>(\n` +
+    `    input,\n` +
+    `    DICTIONARY_SPEC,\n` +
+    `  );\n` +
     `}\n\n` +
-    namespaceValidator
+    keyValidator
   );
 }

package/src/codegen/emit/instance-file.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { formatInstanceFile, type InstanceFileOptions } from "./instance-file.js";
+
+function baseOptions(overrides: Partial<InstanceFileOptions> = {}): InstanceFileOptions {
+  return {
+    isSingle: false,
+    hasLazy: false,
+    typesOutputPath: "src/i18n/i18n-types.generated.ts",
+    paramsTypeName: "AppParams",
+    schemaTypeName: "AppSchema",
+    localeTypeName: "AppLocale",
+    localeFallbackConstName: "LOCALE_FALLBACK",
+    factoryName: "createI18n",
+    hasLocaleFallback: true,
+    hasLocaleType: true,
+    namespaceNames: ["default", "billing"],
+    importExtension: "none",
+    delivery: "canonical",
+    ...overrides,
+  };
+}
+
+function packageImportBlock(output: string): string {
+  const match = output.match(/import \{([\s\S]*?)\} from '@xndrjs\/i18n'/);
+  return match?.[1] ?? "";
+}
+
+describe("formatInstanceFile package imports", () => {
+  it("emits only single-scope symbols for single eager projects", () => {
+    const imports = packageImportBlock(formatInstanceFile(baseOptions({ isSingle: true })));
+
+    expect(imports).toContain("IcuTranslationProviderSingle");
+    expect(imports).toContain("projectNamespaceLocalesCore");
+    expect(imports).toContain("type I18nScopeSingle");
+    expect(imports).toContain("type OnMissingTranslation");
+    expect(imports).not.toContain("createI18nBuilder");
+    expect(imports).not.toContain("createI18nMultiBuilder");
+    expect(imports).not.toContain("I18nBuilderMultiInitial");
+    expect(imports).not.toContain("I18nBuilderMultiOptions");
+    expect(imports).not.toContain("I18nBuilderMultiPartitioned");
+    expect(imports).not.toContain("I18nScopeMulti");
+    expect(imports).not.toContain("projectDictionaryLocalesCore");
+  });
+
+  it("emits multi eager scope symbols without builder imports", () => {
+    const imports = packageImportBlock(formatInstanceFile(baseOptions()));
+
+    expect(imports).toContain("IcuTranslationProviderMulti");
+    expect(imports).toContain("projectDictionaryLocalesCore");
+    expect(imports).toContain("type I18nScopeMulti");
+    expect(imports).not.toContain("createI18nMultiBuilder");
+    expect(imports).not.toContain("I18nBuilderMultiInitial");
+    expect(imports).not.toContain("I18nScopeSingle");
+  });
+
+  it("emits lazy multi builder symbols instead of I18nScopeMulti", () => {
+    const imports = packageImportBlock(
+      formatInstanceFile(
+        baseOptions({
+          hasLazy: true,
+          namespaceLoadersOutputPath: "src/i18n/namespace-loaders.generated.ts",
+        })
+      )
+    );
+
+    expect(imports).toContain("createI18nMultiBuilder");
+    expect(imports).toContain("type I18nBuilderMultiInitial");
+    expect(imports).toContain("type I18nBuilderMultiOptions");
+    expect(imports).not.toContain("type I18nScopeMulti");
+    expect(imports).not.toContain("createI18nBuilder");
+    expect(imports).not.toContain("I18nBuilderMultiPartitioned");
+  });
+
+  it("includes delivery-area projection helpers when delivery is custom", () => {
+    const imports = packageImportBlock(
+      formatInstanceFile(
+        baseOptions({
+          delivery: "custom",
+          deliveryAreaTypeName: "AppDeliveryArea",
+          deliveryArtifactsTypeName: "AppDeliveryArtifacts",
+        })
+      )
+    );
+
+    expect(imports).toContain("projectNamespaceForDeliveryAreaCore");
+    expect(imports).toContain("projectDictionaryForDeliveryAreaCore");
+  });
+});

package/src/codegen/emit/instance-file.ts

@@ -10,6 +10,7 @@ export interface InstanceFileOptions {
   isSingle: boolean;
   hasLazy: boolean;
   typesOutputPath: string;
+  namespaceLoadersOutputPath?: string;
   paramsTypeName: string;
   schemaTypeName: string;
   localeTypeName: string;
@@ -20,6 +21,8 @@ export interface InstanceFileOptions {
   namespaceNames: string[];
   importExtension: ImportExtension;
   delivery: DeliveryMode;
+  deliveryAreaTypeName?: string;
+  deliveryArtifactsTypeName?: string;
 }
 
 export function formatInstanceFile(options: InstanceFileOptions): string {
@@ -27,6 +30,7 @@ export function formatInstanceFile(options: InstanceFileOptions): string {
     isSingle,
     hasLazy,
     typesOutputPath,
+    namespaceLoadersOutputPath,
     paramsTypeName,
     schemaTypeName,
     localeTypeName,
@@ -37,16 +41,28 @@ export function formatInstanceFile(options: InstanceFileOptions): string {
     namespaceNames,
     importExtension,
     delivery,
+    deliveryAreaTypeName,
+    deliveryArtifactsTypeName,
   } = options;
 
   const emitDeliveryAreaHelpers = delivery === "custom";
   const providerClass = isSingle ? "IcuTranslationProviderSingle" : "IcuTranslationProviderMulti";
   const typesModule = toModuleBasename(typesOutputPath);
   const typesImport = toRelativeModuleImport(typesModule, importExtension);
+  const loadersModule = namespaceLoadersOutputPath
+    ? toModuleBasename(namespaceLoadersOutputPath)
+    : null;
+  const loadersImport =
+    loadersModule && namespaceLoadersOutputPath
+      ? toRelativeModuleImport(loadersModule, importExtension)
+      : null;
   const dictionaryParamType = hasLazy ? "InitialSchema" : schemaTypeName;
-  const schemaTypesImport = hasLazy
-    ? `import type { ${paramsTypeName}, ${schemaTypeName}, InitialSchema } from '${typesImport}';\n`
-    : `import type { ${paramsTypeName}, ${schemaTypeName} } from '${typesImport}';\n`;
+  const schemaTypesImport =
+    hasLazy && delivery === "custom" && deliveryAreaTypeName && deliveryArtifactsTypeName
+      ? `import type { ${paramsTypeName}, ${schemaTypeName}, InitialSchema, ${deliveryAreaTypeName}, ${deliveryArtifactsTypeName} } from '${typesImport}';\n`
+      : hasLazy
+        ? `import type { ${paramsTypeName}, ${schemaTypeName}, InitialSchema } from '${typesImport}';\n`
+        : `import type { ${paramsTypeName}, ${schemaTypeName} } from '${typesImport}';\n`;
   const providerTypeArgs = hasLocaleFallback
     ? `${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}, typeof ${localeFallbackConstName}`
     : `${schemaTypeName}, ${paramsTypeName}`;
@@ -60,7 +76,12 @@ export function formatInstanceFile(options: InstanceFileOptions): string {
     : "";
   const localesParamType = hasLocaleType ? `readonly ${localeTypeName}[]` : "readonly string[]";
   const fallbackArg = hasLocaleFallback ? `, ${localeFallbackConstName}` : "";
-  const coreImports = formatCoreImports(isSingle, emitDeliveryAreaHelpers);
+  const packageImports = formatPackageImports(
+    providerClass,
+    isSingle,
+    hasLazy,
+    emitDeliveryAreaHelpers
+  );
   const projectionBlock = isSingle
     ? formatSingleProjectionBlock(
         schemaTypeName,
@@ -76,36 +97,162 @@ export function formatInstanceFile(options: InstanceFileOptions): string {
         emitDeliveryAreaHelpers
       );
 
+  const createFactoryBlock = formatCreateI18nFactory({
+    isSingle,
+    hasLazy,
+    hasLocaleFallback,
+    providerClass,
+    providerTypeArgs,
+    providerOptions,
+    factoryName,
+    dictionaryParamType,
+    schemaTypeName,
+    paramsTypeName,
+    localeTypeName,
+    namespaceNames,
+    loadersImport,
+    delivery,
+    ...(deliveryAreaTypeName !== undefined ? { deliveryAreaTypeName } : {}),
+    ...(deliveryArtifactsTypeName !== undefined ? { deliveryArtifactsTypeName } : {}),
+  });
+
   return (
     `${GENERATED_FILE_BANNER}` +
-    `import { ${providerClass}, ${coreImports}, type OnMissingTranslation } from '@xndrjs/i18n';\n` +
+    `import {\n` +
+    `  ${packageImports},\n` +
+    `} from '@xndrjs/i18n';\n` +
     schemaTypesImport +
     typesImportLine +
+    (hasLazy && loadersImport ? `import { namespaceLoaders } from '${loadersImport}';\n` : "") +
     `\n` +
+    createFactoryBlock +
+    projectionBlock
+  );
+}
+
+function formatCreateI18nFactory(options: {
+  isSingle: boolean;
+  hasLazy: boolean;
+  hasLocaleFallback: boolean;
+  providerClass: string;
+  providerTypeArgs: string;
+  providerOptions: string;
+  factoryName: string;
+  dictionaryParamType: string;
+  schemaTypeName: string;
+  paramsTypeName: string;
+  localeTypeName: string;
+  namespaceNames: string[];
+  loadersImport: string | null;
+  delivery: DeliveryMode;
+  deliveryAreaTypeName?: string;
+  deliveryArtifactsTypeName?: string;
+}): string {
+  const {
+    isSingle,
+    hasLazy,
+    providerClass,
+    providerTypeArgs,
+    providerOptions,
+    factoryName,
+    dictionaryParamType,
+    schemaTypeName,
+    paramsTypeName,
+    localeTypeName,
+    namespaceNames,
+    loadersImport,
+    delivery,
+    deliveryAreaTypeName,
+    deliveryArtifactsTypeName,
+  } = options;
+
+  if (isSingle) {
+    return (
+      `export function ${factoryName}(\n` +
+      `  dictionary: ${dictionaryParamType},\n` +
+      `  options?: { onMissing?: OnMissingTranslation },\n` +
+      `): I18nScopeSingle<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}> {\n` +
+      `  return new ${providerClass}<${providerTypeArgs}>(dictionary${providerOptions}).toScope();\n` +
+      `}\n`
+    );
+  }
+
+  if (!hasLazy) {
+    const namespacesLiteral = `[${namespaceNames
+      .slice()
+      .sort()
+      .map((ns) => JSON.stringify(ns))
+      .join(", ")}] as const`;
+    return (
+      `export function ${factoryName}(\n` +
+      `  dictionary: ${dictionaryParamType},\n` +
+      `  options?: { onMissing?: OnMissingTranslation },\n` +
+      `): I18nScopeMulti<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}> {\n` +
+      `  const engine = new ${providerClass}<${providerTypeArgs}>(dictionary${providerOptions});\n` +
+      `  return engine.toScope({ namespaces: ${namespacesLiteral} });\n` +
+      `}\n`
+    );
+  }
+
+  if (!loadersImport) {
+    throw new Error("[Codegen Error] namespaceLoadersOutputPath is required when hasLazy is true.");
+  }
+
+  const builderReturnType =
+    delivery === "custom" && deliveryAreaTypeName && deliveryArtifactsTypeName
+      ? `I18nBuilderMultiInitial<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}, ${localeTypeName}, ${deliveryAreaTypeName}, ${deliveryArtifactsTypeName}>`
+      : `I18nBuilderMultiInitial<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}>`;
+
+  const multiBuilderTypeArgs =
+    delivery === "custom" && deliveryAreaTypeName && deliveryArtifactsTypeName
+      ? `<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}, ${deliveryAreaTypeName}, ${deliveryArtifactsTypeName}>`
+      : `<${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}>`;
+
+  return (
     `export function ${factoryName}(\n` +
     `  dictionary: ${dictionaryParamType},\n` +
     `  options?: { onMissing?: OnMissingTranslation },\n` +
-    `) {\n` +
-    `  return new ${providerClass}<${providerTypeArgs}>(dictionary${providerOptions});\n` +
-    `}\n` +
-    projectionBlock
+    `): ${builderReturnType} {\n` +
+    `  const engine = new ${providerClass}<${providerTypeArgs}>(dictionary${providerOptions});\n` +
+    `  return createI18nMultiBuilder${multiBuilderTypeArgs}(engine, {\n` +
+    `    namespaceLoaders,\n` +
+    `  } as I18nBuilderMultiOptions<${schemaTypeName}, ${localeTypeName}>);\n` +
+    `}\n`
   );
 }
 
-function formatCoreImports(isSingle: boolean, emitDeliveryAreaHelpers: boolean): string {
+function formatPackageImports(
+  providerClass: string,
+  isSingle: boolean,
+  hasLazy: boolean,
+  emitDeliveryAreaHelpers: boolean
+): string {
+  const imports = [providerClass];
+
   if (isSingle) {
-    const imports = ["projectNamespaceLocalesCore"];
+    imports.push("projectNamespaceLocalesCore");
     if (emitDeliveryAreaHelpers) {
       imports.push("projectNamespaceForDeliveryAreaCore");
     }
-    return imports.join(", ");
+    imports.push("type I18nScopeSingle");
+  } else {
+    imports.push("projectNamespaceLocalesCore", "projectDictionaryLocalesCore");
+    if (emitDeliveryAreaHelpers) {
+      imports.push("projectNamespaceForDeliveryAreaCore", "projectDictionaryForDeliveryAreaCore");
+    }
+    if (hasLazy) {
+      imports.push(
+        "createI18nMultiBuilder",
+        "type I18nBuilderMultiInitial",
+        "type I18nBuilderMultiOptions"
+      );
+    } else {
+      imports.push("type I18nScopeMulti");
+    }
   }
 
-  const imports = ["projectNamespaceLocalesCore", "projectDictionaryLocalesCore"];
-  if (emitDeliveryAreaHelpers) {
-    imports.push("projectNamespaceForDeliveryAreaCore", "projectDictionaryForDeliveryAreaCore");
-  }
-  return imports.join(", ");
+  imports.push("type OnMissingTranslation");
+  return imports.join(",\n  ");
 }
 
 function formatSingleProjectionBlock(

package/src/codegen/emit/namespace-loaders-file.test.ts

@@ -31,8 +31,6 @@ describe("formatNamespaceLoadersFile", () => {
     expect(output).toContain(
       "billing: () => import('./translations/billing.json').then((m) => m.default),"
     );
-    expect(output).not.toContain("AppLocale");
-    expect(output).not.toContain("ensureNamespacesLoadedForLocale");
   });
 
   it("emits ns(locale) loaders in split mode", () => {
@@ -97,16 +95,45 @@ describe("formatNamespaceLoadersFile", () => {
       "return import('./generated/translations/billing.en.json').then((m) => m.default);"
     );
     expect(output).toContain("user: (locale) => {");
-    expect(output).not.toContain("billing: {");
-    expect(output).not.toContain("import('./translations/billing.json')");
-    expect(output).toContain("export async function ensureNamespacesLoadedForLocale(");
-    expect(output).toContain("i18n: I18nMultiInstance,");
     expect(output).toContain(
-      'namespaces: readonly LazyNamespace[] = ["billing", "default", "user"] as const,'
+      'export const defaultLazyNamespaces = ["billing", "default", "user"] as const;'
     );
     expect(output.match(/from '\.\/i18n-types\.generated'/g)?.length).toBe(1);
   });
 
+  it("emits locale-scoped loaders for single mode in split delivery", () => {
+    const output = formatNamespaceLoadersFile({
+      loadersOutputPath,
+      lazyEntries: [
+        {
+          namespace: "default",
+          filePath: "src/i18n/translations/translations.json",
+          absolutePath: path.join(projectRoot, "src/i18n/translations/translations.json"),
+        },
+      ],
+      schemaTypeName: "AppSchema",
+      paramsTypeName: "AppParams",
+      localeTypeName: "AppLocale",
+      localeFallbackConstName: "LOCALE_FALLBACK",
+      hasLocaleFallback: true,
+      typesModule: "i18n-types.generated",
+      importExtension: "none",
+      projectRoot,
+      isSingle: true,
+      delivery: "split-by-locale",
+      requestLocales: ["en", "it"],
+      splitPathsByNamespace: {
+        default: {
+          en: "src/i18n/generated/translations/translations.en.json",
+          it: "src/i18n/generated/translations/translations.it.json",
+        },
+      },
+    });
+
+    expect(output).toContain("[K in LazyNamespace]: (locale: AppLocale) => Promise<AppSchema>;");
+    expect(output).toContain('export const defaultLazyNamespaces = ["default"] as const;');
+  });
+
   it("throws when a split path is missing", () => {
     expect(() =>
       formatNamespaceLoadersFile({
@@ -188,10 +215,8 @@ describe("formatNamespaceLoadersFile", () => {
     expect(output).toContain(
       "return import('./generated/translations/billing.eu.json').then((m) => m.default);"
     );
-    expect(output).not.toContain("import('./translations/billing.json')");
-    expect(output).toContain("export async function ensureNamespacesLoadedForArea(");
     expect(output).toContain(
-      'namespaces: readonly LazyNamespace[] = ["billing", "default"] as const,'
+      'export const defaultLazyNamespaces = ["billing", "default"] as const;'
     );
   });
 

package/src/codegen/emit/namespace-loaders-file.ts

@@ -30,23 +30,6 @@ interface PartitionedNamespaceLoadersParams {
   partitionKeys: readonly string[];
   paramName: string;
   paramTypeName: string;
-  loadNamespacesFunctionName: string;
-}
-
-function formatI18nMultiInstanceType(options: NamespaceLoadersFileOptions): string {
-  const {
-    schemaTypeName,
-    paramsTypeName,
-    localeTypeName,
-    localeFallbackConstName,
-    hasLocaleFallback,
-  } = options;
-
-  const typeArgs = hasLocaleFallback
-    ? `${schemaTypeName}, ${paramsTypeName}, ${localeTypeName}, typeof ${localeFallbackConstName}`
-    : `${schemaTypeName}, ${paramsTypeName}`;
-
-  return `IcuTranslationProviderMulti<${typeArgs}>`;
 }
 
 function formatDefaultNamespacesLiteral(lazyEntries: NamespaceEntry[]): string {
@@ -57,54 +40,19 @@ function formatDefaultNamespacesLiteral(lazyEntries: NamespaceEntry[]): string {
     .join(", ");
 }
 
-function formatLoadNamespacesHelper(
-  options: NamespaceLoadersFileOptions,
-  { paramName, paramTypeName, loadNamespacesFunctionName }: PartitionedNamespaceLoadersParams
-): string {
-  const { lazyEntries } = options;
-  const defaultNamespaces = formatDefaultNamespacesLiteral(lazyEntries);
-
-  return (
-    `\ntype I18nMultiInstance = ${formatI18nMultiInstanceType(options)};\n\n` +
-    `export async function ${loadNamespacesFunctionName}(\n` +
-    `  i18n: I18nMultiInstance,\n` +
-    `  ${paramName}: ${paramTypeName},\n` +
-    `  namespaces: readonly LazyNamespace[] = [${defaultNamespaces}] as const,\n` +
-    `): Promise<void> {\n` +
-    `  await Promise.all(\n` +
-    `    namespaces.map(async (namespace) => {\n` +
-    `      i18n.setNamespace(namespace, await namespaceLoaders[namespace](${paramName}));\n` +
-    `    }),\n` +
-    `  );\n` +
-    `}\n`
-  );
-}
-
 function formatPartitionedTypesImport(
   options: NamespaceLoadersFileOptions,
   paramTypeName: string
 ): string {
-  const {
-    schemaTypeName,
-    paramsTypeName,
-    localeTypeName,
-    localeFallbackConstName,
-    hasLocaleFallback,
-    typesModule,
-    importExtension,
-    isSingle,
-  } = options;
+  const { schemaTypeName, paramsTypeName, localeTypeName, typesModule, importExtension, isSingle } =
+    options;
 
   if (isSingle) {
-    return `import type { ${schemaTypeName}, LazyNamespace, ${paramTypeName} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`;
+    return `import type { ${schemaTypeName}, LazyNamespace, ${paramTypeName}, ${localeTypeName} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`;
   }
 
-  const fallbackImport = hasLocaleFallback ? `${localeFallbackConstName}, ` : "";
-  const paramTypeImport = paramTypeName === localeTypeName ? "" : `, type ${paramTypeName}`;
-  return (
-    `import { IcuTranslationProviderMulti } from '@xndrjs/i18n';\n` +
-    `import { ${fallbackImport}type ${localeTypeName}, type ${paramsTypeName}, type ${schemaTypeName}, type LazyNamespace${paramTypeImport} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`
-  );
+  const paramTypeImport = paramTypeName === localeTypeName ? "" : `, ${paramTypeName}`;
+  return `import type { ${localeTypeName}, ${paramsTypeName}, ${schemaTypeName}, LazyNamespace${paramTypeImport} } from '${toRelativeModuleImport(typesModule, importExtension)}';\n\n`;
 }
 
 function formatSwitchDefaultCase(namespace: string, paramName: string): string {
@@ -129,8 +77,11 @@ function formatPartitionedNamespaceLoadersFile(
     schemaTypeName,
     projectRoot,
     splitPathsByNamespace = {},
+    isSingle = false,
   } = options;
 
+  const loaderValueType = isSingle ? schemaTypeName : `${schemaTypeName}[K]`;
+
   const typesImport = formatPartitionedTypesImport(options, paramTypeName);
   const loaderEntries = lazyEntries
     .map((entry) => {
@@ -167,9 +118,10 @@ function formatPartitionedNamespaceLoadersFile(
     `${GENERATED_FILE_BANNER}` +
     typesImport +
     `export const namespaceLoaders: {\n` +
-    `  [K in LazyNamespace]: (${paramName}: ${paramTypeName}) => Promise<${schemaTypeName}[K]>;\n` +
+    `  [K in LazyNamespace]: (${paramName}: ${paramTypeName}) => Promise<${loaderValueType}>;\n` +
     `} = {\n${loaderEntries}\n};\n` +
-    (options.isSingle ? "" : formatLoadNamespacesHelper(options, params))
+    `\n` +
+    `export const defaultLazyNamespaces = [${formatDefaultNamespacesLiteral(lazyEntries)}] as const;\n`
   );
 }
 
@@ -204,7 +156,6 @@ export function formatNamespaceLoadersFile(options: NamespaceLoadersFileOptions)
       partitionKeys: options.requestLocales ?? [],
       paramName: "locale",
       paramTypeName: options.localeTypeName,
-      loadNamespacesFunctionName: "ensureNamespacesLoadedForLocale",
     });
   }
   if (delivery === "custom") {
@@ -215,7 +166,6 @@ export function formatNamespaceLoadersFile(options: NamespaceLoadersFileOptions)
       partitionKeys: options.deliveryAreaNames ?? [],
       paramName: "area",
       paramTypeName: options.deliveryAreaTypeName,
-      loadNamespacesFunctionName: "ensureNamespacesLoadedForArea",
     });
   }
   return formatCanonicalNamespaceLoadersFile(options);

package/src/codegen/emit/types-file.test.ts

@@ -37,7 +37,6 @@ describe("formatTypesFile", () => {
 
     expect(output).toContain("login_button: Partial<Record<AppLocale, string>>;");
     expect(output).toContain("invoice_summary: Partial<Record<AppLocale, string>>;");
-    expect(output).not.toContain("typeof import");
   });
 
   it("emits explicit Partial schema types for single-file mode", () => {
@@ -65,7 +64,6 @@ describe("formatTypesFile", () => {
     expect(output).toContain(
       "export type AppSchema = {\n  welcome: Partial<Record<AppLocale, string>>;\n};"
     );
-    expect(output).not.toContain("typeof import");
   });
 
   it("emits delivery area type for custom delivery", () => {