@xndrjs/i18n 0.7.0 → 0.8.0

package/src/scope.test.ts

@@ -1,64 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { IcuTranslationProviderMulti } from "./IcuTranslationProviderMulti.js";
-import { IcuTranslationProviderSingle } from "./IcuTranslationProviderSingle.js";
-import type { LocaleOfMulti, LocaleOfSingle } from "./types.js";
-
-type SingleSchema = {
-  login_button: { en: string; it: string };
-  welcome: { en: string; it: string };
-  empty_label: { en: string };
-  broken: { en: string };
-  invoice_count: { en: string; it: string };
-  dashboard_status: { en: string; it: string };
-  inbox_owner: { en: string; it: string };
-  ranking_position: { en: string; it: string };
-  account_balance: { en: string; it: string };
-  appointment_summary: { en: string; it: string };
-};
-
-type SingleParams = {
-  login_button: never;
-  welcome: { name: string };
-  empty_label: never;
-  broken: { name: string };
-  invoice_count: { count: number };
-  dashboard_status: { msgCount: number; chatCount: number };
-  inbox_owner: { gender: string; name: string };
-  ranking_position: { position: number };
-  account_balance: { amount: number };
-  appointment_summary: { dueDate: Date | number; startTime: Date | number };
-};
-
-const singleDictionary: SingleSchema = {
-  login_button: { en: "Login", it: "Accedi" },
-  welcome: { en: "Welcome {name}!", it: "Benvenuto {name}!" },
-  empty_label: { en: "" },
-  broken: { en: "Hi {name" },
-  invoice_count: {
-    en: "You have {count, plural, one {1 invoice} other {{count} invoices}}",
-    it: "Hai {count, plural, one {1 fattura} other {{count} fatture}}",
-  },
-  dashboard_status: {
-    en: "You have {msgCount, plural, one {1 message} other {{msgCount} messages}} in {chatCount, plural, one {one chat} other {{chatCount} chats}}",
-    it: "Hai {msgCount, plural, one {1 messaggio} other {{msgCount} messaggi}} in {chatCount, plural, one {una chat} other {{chatCount} chat}}",
-  },
-  inbox_owner: {
-    en: "{gender, select, female {{name} owns her inbox} male {{name} owns his inbox} other {{name} owns their inbox}}",
-    it: "{gender, select, other {{name} gestisce la propria casella}}",
-  },
-  ranking_position: {
-    en: "You finished {position, selectordinal, one {#st} two {#nd} few {#rd} other {#th}}",
-    it: "Hai concluso al {position, selectordinal, one {#°} other {#°}} posto",
-  },
-  account_balance: {
-    en: "Balance: {amount, number, ::currency/EUR}",
-    it: "Saldo: {amount, number, ::currency/EUR}",
-  },
-  appointment_summary: {
-    en: "Due {dueDate, date, short} at {startTime, time, short}",
-    it: "Scade il {dueDate, date, short} alle {startTime, time, short}",
-  },
-};
+import type { LocaleOfMulti } from "./types.js";
 
 type MultiSchema = {
   default: {
@@ -126,169 +68,6 @@ const multiDictionary: MultiSchema = {
   },
 };
 
-describe("I18nScope single", () => {
-  const engine = new IcuTranslationProviderSingle<SingleSchema, SingleParams>(singleDictionary);
-  const view = engine.toScope();
-
-  it("translates with t(key, locale)", () => {
-    expect(view.t("login_button", "it")).toBe("Accedi");
-    expect(view.t("welcome", "en", { name: "Ada" })).toBe("Welcome Ada!");
-  });
-
-  it("formats ICU plurals and nested plurals", () => {
-    expect(view.t("invoice_count", "en", { count: 1 })).toBe("You have 1 invoice");
-    expect(view.t("invoice_count", "en", { count: 5 })).toBe("You have 5 invoices");
-    expect(view.t("dashboard_status", "en", { msgCount: 3, chatCount: 2 })).toBe(
-      "You have 3 messages in 2 chats"
-    );
-  });
-
-  it("binds locale via forLocale", () => {
-    const en = view.forLocale("en");
-
-    expect(en.locale).toBe("en");
-    expect(en.t("login_button")).toBe("Login");
-    expect(en.t("welcome", { name: "Ada" })).toBe("Welcome Ada!");
-  });
-
-  it("binds locale via toScope({ locale })", () => {
-    const it = engine.toScope({ locale: "it" });
-
-    expect(it.locale).toBe("it");
-    expect(it.t("login_button")).toBe("Accedi");
-    expect(it.t("welcome", { name: "Ada" })).toBe("Benvenuto Ada!");
-  });
-
-  it("supports destructuring t and set from locale-bound scopes", () => {
-    const { t, set } = engine.toScope().forLocale("en");
-
-    expect(t("login_button")).toBe("Login");
-    set("login_button", "Sign in");
-    expect(t("login_button")).toBe("Sign in");
-  });
-
-  it("throws when key or locale is missing", () => {
-    expect(() => view.t("login_button", "fr" as unknown as LocaleOfSingle<SingleSchema>)).toThrow(
-      '[i18n] Missing key or locale: "login_button" [fr] (fallback chain: fr)'
-    );
-    expect(() => view.t("missing_key" as "login_button", "en")).toThrow(
-      '[i18n] Missing key or locale: "missing_key" [en] (fallback chain: en)'
-    );
-  });
-
-  describe("locale fallback", () => {
-    const fallbackMap = {
-      en: null,
-      "de-DE": "en",
-      "de-CH": "de-DE",
-      it: "en",
-    } as const;
-
-    const fallbackEngine = new IcuTranslationProviderSingle<
-      SingleSchema,
-      SingleParams,
-      keyof typeof fallbackMap | LocaleOfSingle<SingleSchema>,
-      typeof fallbackMap
-    >(singleDictionary, { localeFallback: fallbackMap });
-    const fallbackView = fallbackEngine.toScope();
-
-    it("resolves a locale through the fallback chain", () => {
-      expect(fallbackView.t("login_button", "de-CH")).toBe("Login");
-    });
-  });
-
-  describe("onMissing", () => {
-    it('returns the key itself with onMissing: "key"', () => {
-      const local = new IcuTranslationProviderSingle<SingleSchema, SingleParams>(singleDictionary, {
-        onMissing: "key",
-      });
-      expect(local.toScope().t("missing_key" as "login_button", "en")).toBe("missing_key");
-    });
-
-    it("applies onMissing through forLocale wrappers", () => {
-      const local = new IcuTranslationProviderSingle<SingleSchema, SingleParams>(singleDictionary, {
-        onMissing: "key",
-      });
-      expect(
-        local
-          .toScope()
-          .forLocale("en")
-          .t("missing_key" as "login_button")
-      ).toBe("missing_key");
-    });
-  });
-
-  describe("set()", () => {
-    it("patches a preloaded key after load merge", () => {
-      const local = new IcuTranslationProviderSingle<SingleSchema, SingleParams>({
-        login_button: { en: "Login", it: "Accedi" },
-        welcome: { en: "Welcome {name}!", it: "benvenuto {name}..." },
-        empty_label: { en: "" },
-        broken: { en: "Hi {name" },
-        invoice_count: singleDictionary.invoice_count,
-        dashboard_status: singleDictionary.dashboard_status,
-        inbox_owner: singleDictionary.inbox_owner,
-        ranking_position: singleDictionary.ranking_position,
-        account_balance: singleDictionary.account_balance,
-        appointment_summary: singleDictionary.appointment_summary,
-      });
-      local.applyLoadMergeSingle({
-        welcome: { it: "Benvenuto {name}!" },
-      });
-
-      const enScope = local.toScope().forLocale("en");
-      enScope.set("login_button", "Sign in");
-
-      const itScope = local.toScope().forLocale("it");
-
-      expect(enScope.t("login_button")).toBe("Sign in");
-      expect(itScope.t("login_button")).toBe("Accedi");
-
-      expect(itScope.t("welcome", { name: "Mario" })).toBe("Benvenuto Mario!");
-    });
-
-    it("throws when patching a key that was not preloaded", () => {
-      const local = new IcuTranslationProviderSingle<SingleSchema, SingleParams>({
-        // @ts-expect-error missing it
-        login_button: { en: "Login" },
-        welcome: { en: "Welcome {name}!", it: "" },
-        empty_label: { en: "" },
-        broken: { en: "Hi {name" },
-        invoice_count: singleDictionary.invoice_count,
-        dashboard_status: singleDictionary.dashboard_status,
-        inbox_owner: singleDictionary.inbox_owner,
-        ranking_position: singleDictionary.ranking_position,
-        account_balance: singleDictionary.account_balance,
-        appointment_summary: singleDictionary.appointment_summary,
-      });
-
-      expect(() => local.toScope().forLocale("it").set("login_button", "Accedi")).toThrow(
-        "[i18n] Key not preloaded: login_button (it)"
-      );
-    });
-
-    it("invalidates compiled cache after set()", () => {
-      const local = new IcuTranslationProviderSingle<SingleSchema, SingleParams>(singleDictionary);
-      const en = local.toScope().forLocale("en");
-
-      expect(en.t("welcome", { name: "Ada" })).toBe("Welcome Ada!");
-
-      en.set("welcome", "Hi {name}!");
-
-      expect(en.t("welcome", { name: "Ada" })).toBe("Hi Ada!");
-    });
-
-    it("throws on ICU args mismatch against other locales", () => {
-      const local = new IcuTranslationProviderSingle<SingleSchema, SingleParams>(singleDictionary);
-      const en = local.toScope().forLocale("en");
-
-      expect(() => en.set("invoice_count", "{count, select, other {{count}}}")).toThrow(
-        "[i18n] ICU args mismatch on patch:"
-      );
-    });
-  });
-});
-
 describe("I18nScope multi", () => {
   const engine = new IcuTranslationProviderMulti<MultiSchema, MultiParams>(multiDictionary);
 
@@ -329,20 +108,12 @@ describe("I18nScope multi", () => {
     );
   });
 
-  it("supports destructuring t and set from locale-bound scopes", () => {
-    const { t, set } = engine.toScope({ namespaces: ["billing"] }).forLocale("en");
+  it("supports destructuring t from locale-bound scopes", () => {
+    const { t } = engine.toScope({ namespaces: ["billing"] }).forLocale("en");
 
     expect(t("billing", "invoice_summary", { count: 1, name: "Ada" })).toBe(
       "You have 1 invoice for Ada"
     );
-    set(
-      "billing",
-      "invoice_summary",
-      "You have {count, plural, one {1 invoice only} other {{count} invoices only}} for {name}"
-    );
-    expect(t("billing", "invoice_summary", { count: 1, name: "Ada" })).toBe(
-      "You have 1 invoice only for Ada"
-    );
   });
 
   it("reflects partial applyLoadMergeNamespace via a fresh toScope", () => {
@@ -398,84 +169,4 @@ describe("I18nScope multi", () => {
       expect(view.t("default", "login_button", "de-CH")).toBe("Login");
     });
   });
-
-  describe("set()", () => {
-    it("patches a preloaded key after load merge", () => {
-      const local = new IcuTranslationProviderMulti<MultiSchema, MultiParams>({
-        billing: {
-          invoice_summary: {
-            en: "You have {count, plural, one {1 invoice} other {{count} invoices}} for {name}",
-          },
-        },
-      });
-      local.applyLoadMergeNamespace("billing", {
-        invoice_summary: {
-          it: "Hai {count, plural, one {1 fattura} other {{count} fatture}} per {name}",
-        },
-      });
-
-      const en = local.toScope({ namespaces: ["billing"] }).forLocale("en");
-      en.set(
-        "billing",
-        "invoice_summary",
-        "You have {count, plural, one {1 invoice only} other {{count} invoices only}} for {name}"
-      );
-
-      expect(en.t("billing", "invoice_summary", { count: 1, name: "Ada" })).toBe(
-        "You have 1 invoice only for Ada"
-      );
-      expect(
-        local
-          .toScope({ namespaces: ["billing"], locale: "it" })
-          .t("billing", "invoice_summary", { count: 2, name: "Bob" })
-      ).toBe("Hai 2 fatture per Bob");
-    });
-
-    it("throws when patching a key that was not preloaded", () => {
-      const local = new IcuTranslationProviderMulti<MultiSchema, MultiParams>({
-        billing: {
-          invoice_summary: {
-            en: "You have {count, plural, one {1 invoice} other {{count} invoices}} for {name}",
-          },
-        },
-      });
-
-      expect(() =>
-        local
-          .toScope({ namespaces: ["billing"] })
-          .forLocale("it")
-          .set(
-            "billing",
-            "invoice_summary",
-            "Hai {count, plural, one {1 fattura} other {{count} fatture}} per {name}"
-          )
-      ).toThrow("[i18n] Key not preloaded: billing.invoice_summary (it)");
-    });
-
-    it("invalidates compiled cache after set()", () => {
-      const local = new IcuTranslationProviderMulti<MultiSchema, MultiParams>(multiDictionary);
-      const en = local.toScope({ namespaces: ["billing"] }).forLocale("en");
-
-      expect(en.t("billing", "invoice_summary", { count: 2, name: "Bob" })).toBe(
-        "You have 2 invoices for Bob"
-      );
-
-      en.set(
-        "billing",
-        "invoice_summary",
-        "{count, plural, one {1 bill} other {{count} bills}} for {name}"
-      );
-
-      expect(en.t("billing", "invoice_summary", { count: 2, name: "Bob" })).toBe("2 bills for Bob");
-    });
-
-    it("throws on ICU args mismatch against other locales", () => {
-      const local = new IcuTranslationProviderMulti<MultiSchema, MultiParams>(multiDictionary);
-      const en = local.toScope({ namespaces: ["billing"] }).forLocale("en");
-
-      expect(() =>
-        en.set("billing", "invoice_summary", "{count, select, other {{count}}}")
-      ).toThrow("[i18n] ICU args mismatch on patch:");
-    });
-  });
 });

package/src/serialized-state.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it, vi } from "vitest";
+import { createI18nHandle } from "./builder.js";
+import { IcuTranslationProviderMulti } from "./IcuTranslationProviderMulti.js";
+import { normalizeI18nCreateInput } from "./serialized-state.js";
+
+type MultiSchema = {
+  default: { greeting: { en: string; it: string } };
+  billing: { invoice: { en: string; it: string } };
+};
+type MultiParams = {
+  default: { greeting: never };
+  billing: { invoice: never };
+};
+
+describe("serialize / createI18n({ state })", () => {
+  it("normalizeI18nCreateInput defaults missing state to empty dictionary and [] resources", () => {
+    expect(normalizeI18nCreateInput()).toEqual({
+      dictionary: {},
+      resources: [],
+    });
+  });
+
+  it("normalizeI18nCreateInput defaults missing resources to []", () => {
+    expect(normalizeI18nCreateInput({ dictionary: { greeting: { en: "Hi" } } })).toEqual({
+      dictionary: { greeting: { en: "Hi" } },
+      resources: [],
+    });
+  });
+
+  it("serialize after load → fresh handle skips loaders for marked resources", async () => {
+    const defaultLoader = vi.fn(async (locale: string) => ({
+      greeting: { [locale]: locale === "it" ? "Ciao" : "Hello" },
+    }));
+    const billingLoader = vi.fn(async (locale: string) => ({
+      invoice: { [locale]: locale === "it" ? "Fattura" : "Invoice" },
+    }));
+
+    const ssrEngine = new IcuTranslationProviderMulti<MultiSchema, MultiParams>({});
+    const ssr = createI18nHandle(ssrEngine, {
+      namespaceLoaders: {
+        default: defaultLoader,
+        billing: billingLoader,
+      },
+    });
+
+    await ssr.load({ namespaces: ["default", "billing"], locale: "it" });
+    expect(defaultLoader).toHaveBeenCalledTimes(1);
+    expect(billingLoader).toHaveBeenCalledTimes(1);
+
+    const serialized = ssr.serialize();
+    expect(serialized.resources).toEqual(
+      expect.arrayContaining([
+        ["default", "it"],
+        ["billing", "it"],
+      ])
+    );
+    expect(serialized.dictionary.default?.greeting?.it).toBe("Ciao");
+
+    const csrEngine = new IcuTranslationProviderMulti<MultiSchema, MultiParams>(
+      serialized.dictionary
+    );
+    csrEngine.seedBuilderResources(serialized.resources);
+    const csr = createI18nHandle(csrEngine, {
+      namespaceLoaders: {
+        default: defaultLoader,
+        billing: billingLoader,
+      },
+    });
+
+    expect(csrEngine.hasBuilderResourceLoaded("default", "it")).toBe(true);
+    expect(csrEngine.hasBuilderResourceLoaded("billing", "it")).toBe(true);
+
+    await csr.load({ namespaces: ["default", "billing"], locale: "it" });
+    expect(defaultLoader).toHaveBeenCalledTimes(1);
+    expect(billingLoader).toHaveBeenCalledTimes(1);
+
+    const scope = csr.peek({ namespaces: ["default", "billing"], locale: "it" });
+    expect(scope).not.toBeNull();
+    expect(scope!.t("default", "greeting")).toBe("Ciao");
+    expect(scope!.t("billing", "invoice")).toBe("Fattura");
+  });
+
+  it("peek returns scope after hydrate seed without invoking loaders", async () => {
+    const defaultLoader = vi.fn(async (locale: string) => ({
+      greeting: { [locale]: "Hello" },
+    }));
+    const billingLoader = vi.fn(async (locale: string) => ({
+      invoice: { [locale]: "Invoice" },
+    }));
+
+    const ssrEngine = new IcuTranslationProviderMulti<MultiSchema, MultiParams>({});
+    const ssr = createI18nHandle(ssrEngine, {
+      namespaceLoaders: { default: defaultLoader, billing: billingLoader },
+    });
+    await ssr.load({ namespaces: ["default", "billing"], locale: "en" });
+    const serialized = ssr.serialize();
+
+    const csrEngine = new IcuTranslationProviderMulti<MultiSchema, MultiParams>(
+      serialized.dictionary
+    );
+    csrEngine.seedBuilderResources(serialized.resources);
+    const csr = createI18nHandle(csrEngine, {
+      namespaceLoaders: { default: defaultLoader, billing: billingLoader },
+    });
+
+    const sync = csr.peek({ namespaces: ["default", "billing"], locale: "en" });
+    expect(sync).not.toBeNull();
+    expect(sync!.t("default", "greeting")).toBe("Hello");
+    expect(defaultLoader).toHaveBeenCalledTimes(1);
+    expect(billingLoader).toHaveBeenCalledTimes(1);
+
+    expect(csr.peek({ namespaces: ["default"], locale: "it" })).toBeNull();
+  });
+});

package/src/serialized-state.ts

@@ -0,0 +1,28 @@
+import type { BuilderResourceEntry } from "./builder-load-registry.js";
+
+/**
+ * Portable i18n instance state after `serialize()`: dictionary strings + which
+ * builder resources are already loaded (namespace × partition).
+ */
+export interface I18nSerializedState<Dictionary = Record<string, unknown>> {
+  dictionary: Dictionary;
+  resources: readonly BuilderResourceEntry[];
+}
+
+/**
+ * Input nested under generated `createI18n({ state? })`. Omitted `state` defaults to an empty
+ * dictionary (lazy cold start). `resources` may be omitted or `[]`.
+ */
+export type I18nCreateInput<Dictionary = Record<string, unknown>> = {
+  dictionary: Dictionary;
+  resources?: readonly BuilderResourceEntry[];
+};
+
+export function normalizeI18nCreateInput<Dictionary>(
+  value?: I18nCreateInput<Dictionary>
+): I18nSerializedState<Dictionary> {
+  return {
+    dictionary: value?.dictionary ?? ({} as Dictionary),
+    resources: value?.resources ?? [],
+  };
+}

package/src/setup/setup-i18n.test.ts

@@ -30,51 +30,40 @@ describe("setup-i18n", () => {
     }
   });
 
-  it("parses single and multi CLI args", () => {
-    expect(parseSetupArgs(["single", ".", "--project", "MyApp"])).toEqual({
-      mode: "single",
-      targetDir: ".",
-      project: "MyApp",
-      force: false,
-    });
+  it("accepts multi alias or positional targetDir", () => {
     expect(parseSetupArgs(["multi", "apps/myapp", "--project", "MyApp", "--force"])).toEqual({
-      mode: "multi",
       targetDir: "apps/myapp",
       project: "MyApp",
       force: true,
     });
+    expect(parseSetupArgs([".", "--project", "MyApp"])).toEqual({
+      targetDir: ".",
+      project: "MyApp",
+      force: false,
+    });
   });
 
-  it("scaffolds single mode with MyApp type names", () => {
-    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-setup-"));
-    const result = runSetup({ mode: "single", targetDir: tempDir, project: "MyApp" });
-
-    const config = JSON.parse(readFileSync(join(tempDir, "i18n/i18n.codegen.json"), "utf8"));
-    expect(config.dictionary).toBe("translations/translations.json");
-    expect(config.paramsTypeName).toBe("MyAppParams");
-    expect(config.schemaTypeName).toBe("MyAppSchema");
-    expect(config.localeTypeName).toBe("MyAppLocale");
-    expect(existsSync(join(tempDir, "i18n/translations/translations.json"))).toBe(true);
-    expect(existsSync(join(tempDir, "i18n/index.ts"))).toBe(true);
-    expect(existsSync(join(tempDir, "src"))).toBe(false);
-    expect(result.created).toContain("i18n/i18n.codegen.json");
-  });
-
-  it("scaffolds multi mode with default namespace only", () => {
+  it("scaffolds multi mode with projectName and codegenPath", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-setup-"));
-    runSetup({ mode: "multi", targetDir: tempDir, project: "MyApp" });
+    const result = runSetup({ targetDir: tempDir, project: "MyApp" });
 
     const config = JSON.parse(readFileSync(join(tempDir, "i18n/i18n.codegen.json"), "utf8"));
     expect(config.namespaces).toEqual({
       default: "translations/default.json",
     });
+    expect(config.projectName).toBe("MyApp");
+    expect(config.codegenPath).toBe("generated");
+    expect(config).not.toHaveProperty("paramsTypeName");
     expect(existsSync(join(tempDir, "i18n/translations/default.json"))).toBe(true);
+    expect(existsSync(join(tempDir, "i18n/index.ts"))).toBe(true);
+    expect(existsSync(join(tempDir, "src"))).toBe(false);
+    expect(result.created).toContain("i18n/i18n.codegen.json");
   });
 
   it("scaffolds under src/i18n when targetDir is src", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-setup-"));
     const srcDir = join(tempDir, "src");
-    runSetup({ mode: "single", targetDir: srcDir, project: "MyApp" });
+    runSetup({ targetDir: srcDir, project: "MyApp" });
 
     expect(existsSync(join(srcDir, "i18n/i18n.codegen.json"))).toBe(true);
     expect(existsSync(join(tempDir, "i18n"))).toBe(false);
@@ -82,15 +71,15 @@ describe("setup-i18n", () => {
 
   it("refuses to overwrite an existing config without --force", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-setup-"));
-    runSetup({ mode: "single", targetDir: tempDir, project: "MyApp" });
+    runSetup({ targetDir: tempDir, project: "MyApp" });
 
-    expect(() => runSetup({ mode: "single", targetDir: tempDir, project: "MyApp" })).toThrow(
-      "already exists"
-    );
+    expect(() => runSetup({ targetDir: tempDir, project: "MyApp" })).toThrow("already exists");
   });
 
-  it("buildCodegenConfig omits lazy and validation keys by default", () => {
-    expect(buildCodegenConfig("multi", "MyApp")).not.toHaveProperty("loadOnInit");
-    expect(buildCodegenConfig("multi", "MyApp")).not.toHaveProperty("dictionarySchemaOutput");
+  it("buildCodegenConfig defaults to split-by-locale", () => {
+    const config = buildCodegenConfig("MyApp");
+    expect(config.delivery).toBe("split-by-locale");
+    expect(config.codegenPath).toBe("generated");
+    expect(config.projectName).toBe("MyApp");
   });
 });

package/src/setup/setup-i18n.ts

@@ -1,16 +1,14 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { buildCodegenConfig, type SetupMode } from "../codegen-config/build-config.js";
+import { buildCodegenConfig } from "../codegen-config/build-config.js";
 import { inferProjectName } from "../codegen-config/type-names.js";
 import { writeCodegenConfig } from "../codegen-config/write-config.js";
 import { DEFAULT_IMPORT_EXTENSION, importExtensionSuffix } from "../codegen/paths.js";
 
-export type { SetupMode } from "../codegen-config/build-config.js";
 export { buildCodegenConfig } from "../codegen-config/build-config.js";
 
 export interface SetupOptions {
-  mode: SetupMode;
   targetDir: string;
   project?: string | undefined;
   force?: boolean | undefined;
@@ -35,12 +33,11 @@ const DEFAULT_STARTER = {
 const DEFAULT_IMPORT_SUFFIX = importExtensionSuffix(DEFAULT_IMPORT_EXTENSION);
 
 const INDEX_TS =
-  `import { createI18n } from "./generated/instance.generated${DEFAULT_IMPORT_SUFFIX}";\n` +
-  `import { defaultDictionary } from "./generated/dictionary.generated${DEFAULT_IMPORT_SUFFIX}";\n\n` +
+  `import { createI18n } from "./generated/instance.generated${DEFAULT_IMPORT_SUFFIX}";\n\n` +
   `export * from "./generated/instance.generated${DEFAULT_IMPORT_SUFFIX}";\n` +
-  `export * from "./generated/dictionary.generated${DEFAULT_IMPORT_SUFFIX}";\n` +
-  `export * from "./generated/i18n-types.generated${DEFAULT_IMPORT_SUFFIX}";\n\n` +
-  `export const i18n = createI18n(defaultDictionary);\n`;
+  `export * from "./generated/i18n-types.generated${DEFAULT_IMPORT_SUFFIX}";\n` +
+  `export * from "./generated/namespace-loaders.generated${DEFAULT_IMPORT_SUFFIX}";\n\n` +
+  `export const i18n = createI18n();\n`;
 
 function writeJson(filePath: string, value: unknown): void {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -76,18 +73,12 @@ export function runSetup(options: SetupOptions): SetupResult {
 
   const created: string[] = [];
 
-  writeCodegenConfig(configPath, buildCodegenConfig(options.mode, project));
+  writeCodegenConfig(configPath, buildCodegenConfig(project));
   created.push(relative(targetDir, configPath));
 
-  if (options.mode === "single") {
-    const translationsPath = path.join(targetDir, I18N_ROOT, TRANSLATIONS_DIR, "translations.json");
-    writeJson(translationsPath, DEFAULT_STARTER);
-    created.push(relative(targetDir, translationsPath));
-  } else {
-    const defaultPath = path.join(targetDir, I18N_ROOT, TRANSLATIONS_DIR, "default.json");
-    writeJson(defaultPath, DEFAULT_STARTER);
-    created.push(relative(targetDir, defaultPath));
-  }
+  const defaultPath = path.join(targetDir, I18N_ROOT, TRANSLATIONS_DIR, "default.json");
+  writeJson(defaultPath, DEFAULT_STARTER);
+  created.push(relative(targetDir, defaultPath));
 
   const indexPath = path.join(targetDir, I18N_ROOT, "index.ts");
   writeText(indexPath, INDEX_TS);
@@ -99,18 +90,22 @@ export function runSetup(options: SetupOptions): SetupResult {
 }
 
 export function parseSetupArgs(argv: string[]): SetupOptions {
-  const mode = argv[0];
-  if (mode !== "single" && mode !== "multi") {
-    throw new Error(
-      `[Setup Error] Usage: xndrjs-i18n-setup <single|multi> [targetDir] [--project MyApp] [--force]`
-    );
-  }
+  const first = argv[0];
 
   let targetDir = ".";
   let project: string | undefined;
   let force = false;
+  let startIndex = 0;
+
+  if (first === "multi") {
+    startIndex = 1;
+  } else if (first !== undefined && !first.startsWith("-")) {
+    // positional targetDir without mode
+  } else if (first === undefined || first.startsWith("-")) {
+    // flags only / empty
+  }
 
-  for (let index = 1; index < argv.length; index++) {
+  for (let index = startIndex; index < argv.length; index++) {
     const arg = argv[index]!;
     if (arg === "--project") {
       project = argv[++index];
@@ -129,7 +124,7 @@ export function parseSetupArgs(argv: string[]): SetupOptions {
     targetDir = arg;
   }
 
-  return { mode, targetDir, project, force };
+  return { targetDir, project, force };
 }
 
 function main() {
@@ -137,7 +132,7 @@ function main() {
     const options = parseSetupArgs(process.argv.slice(2));
     const result = runSetup(options);
 
-    console.log(`✅ Setup ${options.mode} i18n in ${result.targetDir}`);
+    console.log(`✅ Setup i18n in ${result.targetDir}`);
     console.log(
       `   Project types: ${result.project}Params, ${result.project}Schema, ${result.project}Locale`
     );