@xndrjs/i18n 0.7.0 → 0.8.0

package/src/codegen/codegen-config-schema.ts

@@ -1,44 +1,45 @@
 import { z } from "zod";
 import path from "node:path";
-import {
-  IDENTIFIER_NAME_PATTERN,
-  IDENTIFIER_NAME_REQUIREMENT,
-  SUPPORTED_IMPORT_EXTENSIONS,
-} from "./constants.js";
+import { IDENTIFIER_NAME_PATTERN, IDENTIFIER_NAME_REQUIREMENT } from "./constants.js";
 import { getDeliveryArtifactsStructureIssues } from "./delivery-artifacts.js";
+import { typeNamesForProject } from "../codegen-config/type-names.js";
 
 const localeFallbackSchema = z.record(z.string(), z.union([z.string(), z.null()]));
 const deliveryArtifactsSchema = z.record(z.string(), z.array(z.string().min(1)));
 
-export const DELIVERY_MODES = ["canonical", "split-by-locale", "custom"] as const;
+export const DELIVERY_MODES = ["split-by-locale", "custom"] as const;
 export type DeliveryMode = (typeof DELIVERY_MODES)[number];
 
+export const LOADER_STRATEGIES = ["import", "fetch"] as const;
+export type LoaderStrategy = (typeof LOADER_STRATEGIES)[number];
+
+const PROJECT_NAME_PATTERN = /^[A-Z][a-zA-Z0-9]*$/;
+
 const 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
+  /** PascalCase project id — generates `{project}Params`, `{project}Schema`, `{project}Locale`. */
+  projectName: 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 — 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(),
+    .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"),
 };
 
 export const codegenConfigKeys = Object.keys(
@@ -49,39 +50,16 @@ export const codegenConfigSchema = z
   .object(codegenConfigShape)
   .strict()
   .superRefine((config, ctx) => {
-    const hasDictionary = config.dictionary !== undefined;
-    const hasNamespaces = config.namespaces !== undefined;
-
-    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}).`,
-          });
-        }
+    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 !== undefined &&
-      !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({
@@ -105,35 +83,62 @@ export const codegenConfigSchema = z
         message: 'deliveryArtifacts is only allowed when delivery is "custom".',
       });
     }
-
-    if (config.loadOnInit !== undefined && config.delivery !== "canonical") {
-      ctx.addIssue({
-        code: "custom",
-        path: ["loadOnInit"],
-        message: 'loadOnInit is only allowed when delivery is "canonical".',
-      });
-    }
   });
 
 export type CodegenConfigInput = z.input<typeof codegenConfigSchema>;
 export type CodegenConfig = z.infer<typeof codegenConfigSchema>;
 
-export function resolveDeliveryOutputDir(
-  config: Pick<CodegenConfig, "typesOutput" | "deliveryOutput">
-): string {
-  return config.deliveryOutput ?? path.dirname(config.typesOutput);
+export const GENERATED_BASENAMES = {
+  types: "i18n-types.generated.ts",
+  instance: "instance.generated.ts",
+  namespaceLoaders: "namespace-loaders.generated.ts",
+  dictionarySchema: "dictionary-schema.generated.ts",
+} as const;
+
+export const DEFAULT_FACTORY_NAME = "createI18n";
+export const DEFAULT_LOCALE_FALLBACK_CONST_NAME = "LOCALE_FALLBACK";
+
+/** Derived paths and symbol names from `projectName` + `codegenPath`. */
+export interface ResolvedCodegenPaths {
+  codegenPath: string;
+  typesOutput: string;
+  instanceOutput: string;
+  namespaceLoadersOutput: string;
+  dictionarySchemaOutput: string;
+  artifactsPath: string;
+  paramsTypeName: string;
+  schemaTypeName: string;
+  localeTypeName: string;
+  localeFallbackConstName: string;
+  factoryName: string;
+  deliveryAreaTypeName: string;
 }
 
-const DEFAULT_DICTIONARY_BASENAME = "dictionary.generated.ts";
+export function resolveCodegenPaths(
+  config: Pick<CodegenConfig, "projectName" | "codegenPath" | "artifactsPath">
+): ResolvedCodegenPaths {
+  const typeNames = typeNamesForProject(config.projectName);
+  const codegenPath = config.codegenPath;
+  return {
+    codegenPath,
+    typesOutput: path.join(codegenPath, GENERATED_BASENAMES.types),
+    instanceOutput: path.join(codegenPath, GENERATED_BASENAMES.instance),
+    namespaceLoadersOutput: path.join(codegenPath, GENERATED_BASENAMES.namespaceLoaders),
+    dictionarySchemaOutput: path.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`,
+  };
+}
 
-/** Resolved path for dictionary.generated.ts (explicit config or default next to typesOutput). */
-export function resolveDictionaryOutputPath(
-  config: Pick<CodegenConfig, "typesOutput" | "dictionaryOutput">
+export function resolveArtifactsPath(
+  config: Pick<CodegenConfig, "codegenPath" | "artifactsPath">
 ): string {
-  return (
-    config.dictionaryOutput ??
-    path.join(path.dirname(config.typesOutput), DEFAULT_DICTIONARY_BASENAME)
-  );
+  return config.artifactsPath ?? config.codegenPath;
 }
 
 export function formatCodegenConfigIssues(error: z.ZodError): string {

package/src/codegen/config.test.ts

@@ -2,9 +2,8 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { codegenConfigKeys, resolveDictionaryOutputPath } from "./codegen-config-schema.js";
-import { loadConfig, resolveDeliveryOutputDir, resolveLoadOnInit } from "./config.js";
-import { resolveImportExtension } from "./paths.js";
+import { codegenConfigKeys, resolveCodegenPaths } from "./codegen-config-schema.js";
+import { loadConfig, resolveArtifactsPath } from "./config.js";
 
 function writeConfig(dir: string, config: Record<string, unknown>) {
   const configPath = join(dir, "i18n.codegen.json");
@@ -13,14 +12,11 @@ function writeConfig(dir: string, config: Record<string, unknown>) {
 }
 
 const validMultiConfig = {
+  projectName: "App",
   namespaces: {
     default: "translations/default.json",
   },
-  typesOutput: "generated/i18n-types.generated.ts",
-  dictionaryOutput: "generated/dictionary.generated.ts",
-  instanceOutput: "generated/instance.generated.ts",
-  paramsTypeName: "AppParams",
-  schemaTypeName: "AppSchema",
+  codegenPath: "generated",
 };
 
 describe("loadConfig", () => {
@@ -32,43 +28,52 @@ describe("loadConfig", () => {
     }
   });
 
-  it("accepts a valid multi-namespace config", () => {
+  it("accepts a valid multi-namespace config and defaults delivery to split-by-locale", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-config-"));
     const configPath = writeConfig(tempDir, validMultiConfig);
 
     expect(loadConfig(configPath)).toEqual({
       ...validMultiConfig,
-      delivery: "canonical",
+      delivery: "split-by-locale",
+      loaderStrategy: "import",
     });
   });
 
-  it("accepts split-by-locale config without dictionaryOutput", () => {
+  it("accepts fetch loaderStrategy", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-config-"));
-    const { dictionaryOutput: _dictionaryOutput, ...configWithoutDictionaryOutput } =
-      validMultiConfig;
     const configPath = writeConfig(tempDir, {
-      ...configWithoutDictionaryOutput,
-      delivery: "split-by-locale",
+      ...validMultiConfig,
+      loaderStrategy: "fetch",
     });
 
-    expect(loadConfig(configPath)).toEqual({
-      ...configWithoutDictionaryOutput,
-      delivery: "split-by-locale",
+    expect(loadConfig(configPath)).toMatchObject({
+      loaderStrategy: "fetch",
     });
   });
 
-  it("resolves dictionaryOutput next to typesOutput when omitted", () => {
-    expect(
-      resolveDictionaryOutputPath({
-        typesOutput: "generated/i18n-types.generated.ts",
-      })
-    ).toBe("generated/dictionary.generated.ts");
-    expect(
-      resolveDictionaryOutputPath({
-        typesOutput: "generated/i18n-types.generated.ts",
-        dictionaryOutput: "custom/dictionary.generated.ts",
-      })
-    ).toBe("custom/dictionary.generated.ts");
+  it("rejects unknown config keys", () => {
+    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-config-"));
+    const configPath = writeConfig(tempDir, {
+      ...validMultiConfig,
+      notARealKey: true,
+    });
+
+    expect(() => loadConfig(configPath)).toThrow();
+  });
+
+  it("resolves code paths and type names from projectName + codegenPath", () => {
+    expect(resolveCodegenPaths(validMultiConfig)).toMatchObject({
+      typesOutput: "generated/i18n-types.generated.ts",
+      instanceOutput: "generated/instance.generated.ts",
+      namespaceLoadersOutput: "generated/namespace-loaders.generated.ts",
+      dictionarySchemaOutput: "generated/dictionary-schema.generated.ts",
+      artifactsPath: "generated",
+      paramsTypeName: "AppParams",
+      schemaTypeName: "AppSchema",
+      localeTypeName: "AppLocale",
+      factoryName: "createI18n",
+      localeFallbackConstName: "LOCALE_FALLBACK",
+    });
   });
 
   it("throws on invalid config JSON", () => {
@@ -94,27 +99,26 @@ describe("loadConfig", () => {
     expect(act).toThrow(`Allowed keys: ${codegenConfigKeys.join(", ")}`);
   });
 
-  it("throws when both dictionary and namespaces are present", () => {
+  it("throws when required fields are missing", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-config-"));
     const configPath = writeConfig(tempDir, {
-      ...validMultiConfig,
-      dictionary: "translations/default.json",
+      namespaces: validMultiConfig.namespaces,
     });
 
-    expect(() => loadConfig(configPath)).toThrow(
-      'Specify exactly one of "dictionary" or "namespaces".'
-    );
+    const act = () => loadConfig(configPath);
+    expect(act).toThrow("projectName");
+    expect(act).toThrow("codegenPath");
+    expect(act).toThrow("Allowed keys:");
   });
 
-  it("throws when required fields are missing", () => {
+  it("throws when projectName is not PascalCase", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-config-"));
     const configPath = writeConfig(tempDir, {
-      namespaces: validMultiConfig.namespaces,
+      ...validMultiConfig,
+      projectName: "my-app",
     });
 
-    const act = () => loadConfig(configPath);
-    expect(act).toThrow("typesOutput");
-    expect(act).toThrow("Allowed keys:");
+    expect(() => loadConfig(configPath)).toThrow("projectName must be PascalCase");
   });
 
   it("throws when a namespace name is not a valid identifier", () => {
@@ -132,41 +136,29 @@ describe("loadConfig", () => {
     );
   });
 
-  it("throws when defaultNamespace is not a valid identifier", () => {
+  it("accepts artifactsPath for custom json artifact directory", () => {
     tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-config-"));
     const configPath = writeConfig(tempDir, {
       ...validMultiConfig,
-      defaultNamespace: "1default",
-    });
-
-    expect(() => loadConfig(configPath)).toThrow(
-      'defaultNamespace: Invalid namespace name "1default"'
-    );
-  });
-
-  it("accepts deliveryOutput for custom json artifact directory", () => {
-    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-config-"));
-    const configPath = writeConfig(tempDir, {
-      ...validMultiConfig,
-      deliveryOutput: "public/i18n",
+      artifactsPath: "public/i18n",
     });
 
     expect(loadConfig(configPath)).toMatchObject({
-      deliveryOutput: "public/i18n",
-      delivery: "canonical",
+      artifactsPath: "public/i18n",
+      delivery: "split-by-locale",
     });
   });
 
-  it("resolveDeliveryOutputDir defaults to dirname(typesOutput)", () => {
+  it("resolveArtifactsPath defaults to codegenPath", () => {
     expect(
-      resolveDeliveryOutputDir({
-        typesOutput: "generated/i18n-types.generated.ts",
+      resolveArtifactsPath({
+        codegenPath: "generated",
       })
     ).toBe("generated");
     expect(
-      resolveDeliveryOutputDir({
-        typesOutput: "generated/i18n-types.generated.ts",
-        deliveryOutput: "public/i18n",
+      resolveArtifactsPath({
+        codegenPath: "generated",
+        artifactsPath: "public/i18n",
       })
     ).toBe("public/i18n");
   });
@@ -236,84 +228,4 @@ describe("loadConfig", () => {
 
     expect(() => loadConfig(configPath)).toThrow('Locale "fr" appears in both "eu" and "us"');
   });
-
-  it("throws when loadOnInit is set for split-by-locale delivery", () => {
-    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-config-"));
-    const configPath = writeConfig(tempDir, {
-      ...validMultiConfig,
-      delivery: "split-by-locale",
-      loadOnInit: ["default"],
-    });
-
-    expect(() => loadConfig(configPath)).toThrow(
-      'loadOnInit is only allowed when delivery is "canonical".'
-    );
-  });
-
-  it("throws when loadOnInit is set for custom delivery", () => {
-    tempDir = mkdtempSync(join(tmpdir(), "xndrjs-i18n-config-"));
-    const configPath = writeConfig(tempDir, {
-      ...validMultiConfig,
-      delivery: "custom",
-      deliveryArtifacts: {
-        eu: ["it"],
-      },
-      loadOnInit: ["default"],
-    });
-
-    expect(() => loadConfig(configPath)).toThrow(
-      'loadOnInit is only allowed when delivery is "canonical".'
-    );
-  });
-});
-
-describe("resolveLoadOnInit", () => {
-  const entries = [
-    { namespace: "default", filePath: "translations/default.json" },
-    { namespace: "billing", filePath: "translations/billing.json" },
-  ];
-
-  it("throws when loadOnInit is used in single mode", () => {
-    const config = { ...validMultiConfig, delivery: "canonical" as const, loadOnInit: ["default"] };
-
-    expect(() => resolveLoadOnInit(config, entries, true)).toThrow(
-      '[Codegen Error] "loadOnInit" is only supported in multi mode (namespaces config).'
-    );
-  });
-
-  it("throws when loadOnInit references an unknown namespace", () => {
-    const config = { ...validMultiConfig, delivery: "canonical" as const, loadOnInit: ["missing"] };
-
-    expect(() => resolveLoadOnInit(config, entries, false)).toThrow(
-      '[Codegen Error] loadOnInit: namespace "missing" is not defined in namespaces config.'
-    );
-  });
-
-  it("treats all namespaces as lazy when delivery is split-by-locale", () => {
-    const config = { ...validMultiConfig, delivery: "split-by-locale" as const };
-
-    expect(resolveLoadOnInit(config, entries, false)).toEqual({
-      loadOnInitSet: new Set(),
-      lazyEntries: entries,
-      hasLazy: true,
-    });
-  });
-
-  it("treats all namespaces as lazy when delivery is custom", () => {
-    const config = { ...validMultiConfig, delivery: "custom" as const };
-
-    expect(resolveLoadOnInit(config, entries, false)).toEqual({
-      loadOnInitSet: new Set(),
-      lazyEntries: entries,
-      hasLazy: true,
-    });
-  });
-});
-
-describe("resolveImportExtension", () => {
-  it("throws on unsupported import extensions", () => {
-    expect(() => resolveImportExtension({ importExtension: ".mjs" as never })).toThrow(
-      '[Codegen Error] importExtension must be "none", ".ts", or ".js", got ".mjs".'
-    );
-  });
 });

package/src/codegen/config.ts

@@ -1,12 +1,18 @@
 import fs from "node:fs";
-import type { LoadOnInitResolution, NamespaceEntry } from "./types.js";
+import type { NamespaceEntry } from "./types.js";
 import {
   CodegenConfig,
   codegenConfigSchema,
   formatCodegenConfigIssues,
 } from "./codegen-config-schema.js";
 
-export { resolveDeliveryOutputDir, resolveDictionaryOutputPath } from "./codegen-config-schema.js";
+export {
+  resolveCodegenPaths,
+  resolveArtifactsPath,
+  GENERATED_BASENAMES,
+  DEFAULT_FACTORY_NAME,
+  DEFAULT_LOCALE_FALLBACK_CONST_NAME,
+} from "./codegen-config-schema.js";
 
 /** Parses and validates `i18n.codegen.json`; first step of the codegen pipeline. */
 export function loadConfig(configPath: string): CodegenConfig {
@@ -27,73 +33,10 @@ export function loadConfig(configPath: string): CodegenConfig {
   return result.data;
 }
 
-/** Maps config to namespace entries (`dictionary` single vs `namespaces` multi). */
+/** Maps config namespaces to namespace entries. */
 export function resolveNamespaces(config: CodegenConfig): NamespaceEntry[] {
-  const hasDictionary = Boolean(config.dictionary);
-  const hasNamespaces = Boolean(config.namespaces);
-
-  if (hasDictionary === hasNamespaces) {
-    throw new Error(
-      '[Codegen Error] Config must specify exactly one of "dictionary" or "namespaces".'
-    );
-  }
-
-  if (hasDictionary) {
-    return [
-      {
-        namespace: config.defaultNamespace ?? "default",
-        filePath: config.dictionary!,
-      },
-    ];
-  }
-
-  return Object.entries(config.namespaces!).map(([namespace, filePath]) => ({
+  return Object.entries(config.namespaces).map(([namespace, filePath]) => ({
     namespace,
     filePath,
   }));
 }
-
-/**
- * Splits namespaces into eager (`loadOnInit`) and lazy sets.
- * Drives `InitialSchema`, `defaultDictionary`, and `namespace-loaders.generated.ts`.
- */
-export function resolveLoadOnInit(
-  config: CodegenConfig,
-  entries: NamespaceEntry[],
-  isSingle: boolean
-): LoadOnInitResolution {
-  if (isSingle) {
-    if (config.loadOnInit) {
-      throw new Error(
-        '[Codegen Error] "loadOnInit" is only supported in multi mode (namespaces config).'
-      );
-    }
-    const all = new Set(entries.map((entry) => entry.namespace));
-    return { loadOnInitSet: all, lazyEntries: [], hasLazy: false };
-  }
-
-  const delivery = config.delivery ?? "canonical";
-  if (delivery !== "canonical") {
-    return {
-      loadOnInitSet: new Set(),
-      lazyEntries: entries,
-      hasLazy: entries.length > 0,
-    };
-  }
-
-  const allNamespaces = new Set(entries.map((entry) => entry.namespace));
-  const loadOnInitSet = config.loadOnInit
-    ? new Set(config.loadOnInit)
-    : new Set(entries.map((entry) => entry.namespace));
-
-  for (const namespace of loadOnInitSet) {
-    if (!allNamespaces.has(namespace)) {
-      throw new Error(
-        `[Codegen Error] loadOnInit: namespace "${namespace}" is not defined in namespaces config.`
-      );
-    }
-  }
-
-  const lazyEntries = entries.filter((entry) => !loadOnInitSet.has(entry.namespace));
-  return { loadOnInitSet, lazyEntries, hasLazy: lazyEntries.length > 0 };
-}

package/src/codegen/dictionary-spec-contract.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from "vitest";
+import {
+  buildDictionarySpecFromAnalysis,
+  namespaceContractsMatch,
+} from "./dictionary-spec-contract.js";
+
+describe("dictionary-spec-contract", () => {
+  it("namespaceContractsMatch compares keys and VariableSpec", () => {
+    const entries = [{ namespace: "default", filePath: "translations/default.json" }];
+    const current = buildDictionarySpecFromAnalysis(entries, {
+      default: { welcome: { name: "string" }, login: {} },
+    });
+    const established = buildDictionarySpecFromAnalysis(entries, {
+      default: { welcome: { name: "string" }, login: {} },
+    });
+    expect(namespaceContractsMatch(["default"], current, established)).toBe(true);
+
+    const changedArgs = buildDictionarySpecFromAnalysis(entries, {
+      default: { welcome: { name: "string", extra: "string" }, login: {} },
+    });
+    expect(namespaceContractsMatch(["default"], changedArgs, established)).toBe(false);
+
+    const changedKeys = buildDictionarySpecFromAnalysis(entries, {
+      default: { welcome: { name: "string" } },
+    });
+    expect(namespaceContractsMatch(["default"], changedKeys, established)).toBe(false);
+  });
+});