@prosopo/locale 3.4.3 → 3.6.0

package/src/tests/i18nMiddleware.unit.test.ts

@@ -25,6 +25,8 @@ interface Harness {
 	instance: i18n;
 	handleCalls: [i18n, HandleOptions | undefined][];
 	handler: Handler;
+	/** True once loadI18next has resolved — handle() must not run before then. */
+	loaded: () => boolean;
 }
 
 const load = async (options: {
@@ -38,6 +40,11 @@ const load = async (options: {
 	const instance = asI18n({ name: "the singleton" });
 	const handleCalls: [i18n, HandleOptions | undefined][] = [];
 	const handler = ((): void => {}) as unknown as Handler;
+	let loaded = false;
+
+	// The middleware takes the i18next singleton directly: handle() needs the
+	// real instance, not the narrow Ti18n loadI18next hands back.
+	vi.doMock("i18next", () => ({ default: instance }));
 
 	vi.doMock("i18next-http-middleware", () => ({
 		handle: (i18next: i18n, opts?: HandleOptions): Handler => {
@@ -50,6 +57,7 @@ const load = async (options: {
 			if (options.loadRejects) {
 				throw new Error("i18n failed to load");
 			}
+			loaded = true;
 			return instance;
 		},
 	}));
@@ -57,7 +65,7 @@ const load = async (options: {
 	const imported = await import("../i18nMiddleware.js");
 	return {
 		i18nMiddleware: imported.default,
-		harness: { instance, handleCalls, handler },
+		harness: { instance, handleCalls, handler, loaded: (): boolean => loaded },
 	};
 };
 
@@ -65,10 +73,11 @@ afterEach(() => {
 	vi.resetModules();
 	vi.doUnmock("i18next-http-middleware");
 	vi.doUnmock("../loadI18next.js");
+	vi.doUnmock("i18next");
 });
 
 describe("i18nMiddleware", () => {
-	test("builds the handler from the loaded i18next instance", async () => {
+	test("builds the handler from the i18next singleton", async () => {
 		const { i18nMiddleware, harness } = await load({});
 
 		const handler = await i18nMiddleware({});
@@ -78,6 +87,16 @@ describe("i18nMiddleware", () => {
 		expect(handler).toBe(harness.handler);
 	});
 
+	test("waits for the resources before handing the instance over", async () => {
+		// handle() reads the instance's language list when it is built, so an
+		// uninitialised singleton would produce a middleware that detects nothing.
+		const { i18nMiddleware, harness } = await load({});
+
+		await i18nMiddleware({});
+
+		expect(harness.loaded()).toBe(true);
+	});
+
 	test("forwards the caller's options", async () => {
 		const { i18nMiddleware, harness } = await load({});
 		const options: HandleOptions = { ignoreRoutes: ["/healthz"] };

package/src/tests/loadI18next.unit.test.ts

@@ -12,27 +12,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import type { i18n } from "i18next";
 import { afterEach, describe, expect, test, vi } from "vitest";
+import type { Ti18n } from "../types.js";
 
 // loadI18next keeps a module-level singleton, so every test re-imports it
-// under a fresh registry. The two i18n implementations are mocked out: they
-// pull in i18next, its plugins and the filesystem, none of which this module's
-// own logic depends on.
+// under a fresh registry. The two i18n implementations are mocked out: one
+// fetches catalogues over the network, the other pulls in i18next and the
+// filesystem, and neither is what this module's own logic does.
 
-/** The slice of the i18next instance loadI18next actually touches. */
+/** The slice of an i18n instance loadI18next actually touches. */
 interface FakeI18n {
 	language: string;
 	changeLanguage: (lng: string) => Promise<unknown>;
 }
 
 /** One cast, confined here, so the mocked module keeps the real signature. */
-const asI18n = (fake: FakeI18n): i18n => fake as unknown as i18n;
+const asI18n = (fake: FakeI18n): Ti18n => fake as unknown as Ti18n;
 
 type InitializeI18n = (
-	callback?: (instance: i18n) => void,
+	callback?: (instance: Ti18n) => void,
 	lng?: string,
-) => i18n;
+) => Ti18n;
 
 interface Harness {
 	instance: FakeI18n;
@@ -79,7 +79,7 @@ const install = (
 };
 
 const loadModule = async (): Promise<
-	(backend: boolean, lng?: string) => Promise<i18n>
+	(backend: boolean, lng?: string) => Promise<Ti18n>
 > => {
 	const imported = await import("../loadI18next.js");
 	return imported.default;
@@ -352,7 +352,7 @@ describe("loadI18next, timeout", () => {
 		// Without the one-shot latch a later emission would call resolve again
 		// and leave the timer armed.
 		vi.useFakeTimers();
-		let fire: ((instance: i18n) => void) | undefined;
+		let fire: ((instance: Ti18n) => void) | undefined;
 		const instance: FakeI18n = {
 			language: "en",
 			changeLanguage: async (): Promise<unknown> => undefined,
@@ -382,7 +382,7 @@ describe("loadI18next, timeout", () => {
 		// the degraded instance. Calling reject then would produce an unhandled
 		// rejection on an already-settled promise.
 		vi.useFakeTimers();
-		let fire: ((instance: i18n) => void) | undefined;
+		let fire: ((instance: Ti18n) => void) | undefined;
 		const instance: FakeI18n = {
 			language: "en",
 			changeLanguage: async (): Promise<unknown> => {

package/src/tests/locale.test-d.ts

@@ -18,22 +18,24 @@
 
 import { assertType, describe, expectTypeOf, it } from "vitest";
 import {
-	LanguageSchema,
+	type Language,
+	LanguageCodes,
 	Languages,
 	type Ti18n,
 	type TranslationKey,
-	TranslationKeysSchema,
+	createTranslator,
 	i18nMiddleware,
 	isClientSide,
+	isLanguage,
 	loadI18next,
-	useTranslation,
+	translationKeys,
 } from "../index.js";
 
 describe("Languages", () => {
 	it("is a frozen const map of name to code, not a widened record", () => {
-		// `as const` is what lets LanguageSchema derive its enum. Widening this
-		// to Record<string, string> would silently turn the schema into a
-		// runtime-only constraint.
+		// `as const` is what lets `Language` be the union of the codes.
+		// Widening this to Record<string, string> would silently reduce it to
+		// `string`.
 		expectTypeOf(Languages.english).toEqualTypeOf<"en">();
 		expectTypeOf(Languages.chinese).toEqualTypeOf<"zh-CN">();
 	});
@@ -49,28 +51,24 @@ describe("Languages", () => {
 	});
 });
 
-describe("LanguageSchema", () => {
-	it("parses to a string", () => {
-		// The enum is built from a runtime `Object.values` cast, so the parsed
-		// type is string rather than the union of codes. Pinned deliberately:
-		// a consumer must not assume narrowing it does not get.
-		expectTypeOf(LanguageSchema.parse("en")).toEqualTypeOf<string>();
+describe("isLanguage", () => {
+	it("narrows an arbitrary string to a declared code", () => {
+		expectTypeOf(isLanguage).guards.toEqualTypeOf<Language>();
 	});
 
-	it("exposes .enum as a lookup of codes", () => {
-		expectTypeOf(LanguageSchema.enum).toExtend<Record<string, string>>();
+	it("accepts any string at the boundary — input is untrusted markup", () => {
+		expectTypeOf(isLanguage).toBeCallableWith("anything");
 	});
 
-	it("accepts unknown input at the parse boundary", () => {
-		expectTypeOf(LanguageSchema.parse).toBeCallableWith("anything");
+	it("is the union of the declared codes, not a widened string", () => {
+		expectTypeOf<Language>().toExtend<string>();
+		assertType<Language>("en");
 	});
 });
 
 describe("TranslationKey", () => {
-	it("is inferred from the schema", () => {
-		expectTypeOf<TranslationKey>().toEqualTypeOf<
-			ReturnType<typeof TranslationKeysSchema.parse>
-		>();
+	it("is a plain string — keys are read from JSON, never narrowed", () => {
+		expectTypeOf<TranslationKey>().toEqualTypeOf<string>();
 	});
 
 	it("accepts a key literal, so error call sites need no cast", () => {
@@ -79,10 +77,13 @@ describe("TranslationKey", () => {
 		assertType<TranslationKey>("API.UNKNOWN");
 	});
 
-	it("exposes the derived keys as an array of options", () => {
-		// A non-empty tuple, which is what z.enum requires and what the mongoose
-		// schemas in types-database spread into their `enum` fields.
-		expectTypeOf(TranslationKeysSchema.options).toExtend<readonly string[]>();
+	it("exposes the derived keys as an array", () => {
+		// What the mongoose schemas in types-database put in their `enum` fields.
+		expectTypeOf(translationKeys).toExtend<readonly string[]>();
+	});
+
+	it("exposes the declared language codes as an array", () => {
+		expectTypeOf(LanguageCodes).toExtend<readonly string[]>();
 	});
 });
 
@@ -140,17 +141,20 @@ describe("i18nMiddleware", () => {
 	});
 });
 
-describe("useTranslation", () => {
-	it("is callable with no options", () => {
-		expectTypeOf(useTranslation).toBeCallableWith();
+describe("createTranslator", () => {
+	it("is callable with no instance, so a standalone widget can boot one", () => {
+		expectTypeOf(createTranslator).toBeCallableWith();
 	});
 
-	it("returns a t function", () => {
-		expectTypeOf(useTranslation).returns.toHaveProperty("t");
+	it("returns the translator surface the widgets render against", () => {
+		expectTypeOf(createTranslator).returns.toHaveProperty("t");
+		expectTypeOf(createTranslator).returns.toHaveProperty("isReady");
+		expectTypeOf(createTranslator).returns.toHaveProperty("subscribe");
+		expectTypeOf(createTranslator).returns.toHaveProperty("i18n");
 	});
 
-	it("rejects an unknown option", () => {
-		// @ts-expect-error notAnOption is not a UseTranslationOptions field
-		useTranslation({ notAnOption: 1 });
+	it("rejects anything that is not an i18next instance", () => {
+		// @ts-expect-error the only parameter is an existing i18next instance
+		createTranslator({ notAnInstance: 1 });
 	});
 });

package/src/tests/translationKey.unit.test.ts

@@ -17,9 +17,9 @@ import translationEn from "../locales/en/translation.json" with {
 	type: "json",
 };
 import {
-	TranslationKeysSchema,
 	type TranslationNode,
 	getLeafFieldPath,
+	translationKeys,
 } from "../translationKey.js";
 
 describe("getLeafFieldPath", () => {
@@ -34,7 +34,7 @@ describe("getLeafFieldPath", () => {
 	// The string is the leaf, so the path ends at its key. This used to yield
 	// [] — the recursion returned nothing for a string and the parent mapped
 	// over that empty list — which made the whole function return [] for every
-	// input and left TranslationKeysSchema an empty enum.
+	// input and left `translationKeys` empty.
 	test("emits a top-level string value under its own key", () => {
 		expect(getLeafFieldPath({ topLevel: "value" })).toEqual(["topLevel"]);
 	});
@@ -112,55 +112,29 @@ describe("getLeafFieldPath", () => {
 	});
 });
 
-describe("TranslationKeysSchema", () => {
+describe("translationKeys", () => {
 	const keys = getLeafFieldPath(translationEn as TranslationNode);
 
-	test("is non-empty — an empty z.enum would throw at module load", () => {
+	test("is non-empty — mongoose validates against an empty enum too", () => {
 		expect(keys.length).toBeGreaterThan(0);
 	});
 
-	test("accepts every key derived from the English translation", () => {
-		for (const key of keys) {
-			expect(TranslationKeysSchema.parse(key)).toBe(key);
-		}
+	test("is exactly the set of keys derived from the English translation", () => {
+		expect(new Set(translationKeys)).toEqual(new Set(keys));
 	});
 
-	test("rejects a key that is not in the English translation", () => {
-		expect(() => TranslationKeysSchema.parse("no.such.key")).toThrow();
-	});
-
-	test("rejects the empty string", () => {
-		expect(() => TranslationKeysSchema.parse("")).toThrow();
-	});
-
-	test("rejects a section name on its own — only leaves are valid keys", () => {
+	test("holds leaves, not section names", () => {
 		const [firstKey] = keys;
 		expect(firstKey).toBeDefined();
 		const section = String(firstKey).split(".")[0];
-		expect(() => TranslationKeysSchema.parse(section)).toThrow();
-	});
-
-	test("rejects non-string input", () => {
-		expect(() => TranslationKeysSchema.parse(42)).toThrow();
-		expect(() => TranslationKeysSchema.parse(null)).toThrow();
-		expect(() => TranslationKeysSchema.parse(undefined)).toThrow();
-	});
-
-	test("safeParse reports failure without throwing", () => {
-		const result = TranslationKeysSchema.safeParse("no.such.key");
-		expect(result.success).toBe(false);
+		expect(translationKeys).not.toContain(section);
 	});
 
-	test("is case sensitive", () => {
-		const [firstKey] = keys;
-		expect(firstKey).toBeDefined();
-		const upper = String(firstKey).toUpperCase();
-		if (upper !== firstKey) {
-			expect(() => TranslationKeysSchema.parse(upper)).toThrow();
-		}
+	test("does not contain a key absent from the English translation", () => {
+		expect(translationKeys).not.toContain("no.such.key");
 	});
 
-	test("exposes exactly the derived keys as enum options", () => {
-		expect(new Set(TranslationKeysSchema.options)).toEqual(new Set(keys));
+	test("does not contain the empty string", () => {
+		expect(translationKeys).not.toContain("");
 	});
 });

package/src/tests/translations.unit.test.ts

@@ -15,7 +15,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { describe, expect, test } from "vitest";
-import { LanguageSchema, Languages } from "../translations.js";
+import { LanguageCodes, Languages, isLanguage } from "../translations.js";
 
 const codes: string[] = Object.values(Languages);
 
@@ -34,9 +34,8 @@ describe("Languages", () => {
 		expect(codes).toContain("en");
 	});
 
-	// A duplicated code would silently shrink LanguageSchema's enum and make
-	// one of the language names unreachable, while the locales-folder count
-	// test would still pass.
+	// A duplicated code would silently make one of the language names
+	// unreachable, while the locales-folder count test would still pass.
 	test("has no duplicate codes", () => {
 		expect(new Set(codes).size).toBe(codes.length);
 	});
@@ -62,49 +61,37 @@ describe("Languages", () => {
 	});
 });
 
-describe("LanguageSchema", () => {
+describe("isLanguage", () => {
 	test("accepts every declared code", () => {
 		for (const code of codes) {
-			expect(LanguageSchema.parse(code)).toBe(code);
+			expect(isLanguage(code)).toBe(true);
 		}
 	});
 
-	test("exposes each code on .enum for use as a constant", () => {
-		expect(LanguageSchema.enum.en).toBe("en");
+	test("every declared code is in LanguageCodes", () => {
+		expect(new Set(LanguageCodes)).toEqual(new Set(codes));
+	});
+
+	test("exposes each code as a constant for use in code", () => {
+		expect(Languages.english).toBe("en");
 	});
 
 	test("rejects an undeclared language code", () => {
-		expect(() => LanguageSchema.parse("xx")).toThrow();
+		expect(isLanguage("xx")).toBe(false);
 	});
 
 	test("rejects the empty string", () => {
-		expect(() => LanguageSchema.parse("")).toThrow();
+		expect(isLanguage("")).toBe(false);
 	});
 
-	// i18next treats `en-GB` as a region of `en`, but the schema is a plain
-	// enum with `nonExplicitSupportedLngs: false` alongside it, so a regional
-	// variant of a supported language is *not* itself valid input.
+	// i18next treated `en-GB` as a region of `en`, and the browser i18n resolves
+	// a regional tag to its base language before asking — so a regional variant
+	// is deliberately not itself a declared code.
 	test("rejects a regional variant of a supported language", () => {
-		expect(() => LanguageSchema.parse("en-GB")).toThrow();
+		expect(isLanguage("en-GB")).toBe(false);
 	});
 
 	test("is case sensitive — `EN` is not `en`", () => {
-		expect(() => LanguageSchema.parse("EN")).toThrow();
-	});
-
-	test("rejects non-string input", () => {
-		expect(() => LanguageSchema.parse(1)).toThrow();
-		expect(() => LanguageSchema.parse(null)).toThrow();
-		expect(() => LanguageSchema.parse(undefined)).toThrow();
-		expect(() => LanguageSchema.parse(["en"])).toThrow();
-	});
-
-	test("safeParse reports failure without throwing", () => {
-		expect(LanguageSchema.safeParse("xx").success).toBe(false);
-		expect(LanguageSchema.safeParse("en").success).toBe(true);
-	});
-
-	test("its options are exactly the declared codes", () => {
-		expect(new Set(LanguageSchema.options)).toEqual(new Set(codes));
+		expect(isLanguage("EN")).toBe(false);
 	});
 });

package/src/tests/translator.unit.test.ts

@@ -0,0 +1,213 @@
+// Copyright 2021-2026 Prosopo (UK) Ltd.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import type { i18n } from "i18next";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import type { Translator } from "../translator.js";
+
+// The translator is a thin wrapper: it forces the package's own i18next
+// instance in rather than letting a host app's provider decide, and exposes the
+// three events that used to drive a React re-render. i18next itself is mocked
+// so the tests observe the wiring rather than i18next's own behaviour.
+
+interface FakeI18n {
+	readonly instance: i18n;
+	readonly handlers: Map<string, Set<() => void>>;
+	isInitialized: boolean;
+	loadedNamespaces: string[];
+	translations: Record<string, string>;
+}
+
+const fakeI18n = (): FakeI18n => {
+	const handlers = new Map<string, Set<() => void>>();
+	const fake: FakeI18n = {
+		handlers,
+		isInitialized: true,
+		loadedNamespaces: ["translation"],
+		translations: {},
+		instance: {
+			t: (key: string): string => fake.translations[key] ?? key,
+			get isInitialized(): boolean {
+				return fake.isInitialized;
+			},
+			hasLoadedNamespace: (namespace: string): boolean =>
+				fake.loadedNamespaces.includes(namespace),
+			on: (event: string, listener: () => void): void => {
+				const existing = handlers.get(event) ?? new Set<() => void>();
+				existing.add(listener);
+				handlers.set(event, existing);
+			},
+			off: (event: string, listener: () => void): void => {
+				handlers.get(event)?.delete(listener);
+			},
+		} as unknown as i18n,
+	};
+	return fake;
+};
+
+const emit = (fake: FakeI18n, event: string): void => {
+	for (const listener of fake.handlers.get(event) ?? []) {
+		listener();
+	}
+};
+
+const load = async (): Promise<{
+	createTranslator: (existing?: i18n) => Translator;
+	packageInstance: i18n;
+	initCount: () => number;
+}> => {
+	vi.resetModules();
+
+	const packageInstance = fakeI18n().instance;
+	let initCalls = 0;
+
+	vi.doMock("../i18nFrontend.js", () => ({
+		default: (): i18n => {
+			initCalls += 1;
+			return packageInstance;
+		},
+	}));
+
+	const imported = await import("../translator.js");
+	return {
+		createTranslator: imported.createTranslator,
+		packageInstance,
+		initCount: (): number => initCalls,
+	};
+};
+
+afterEach(() => {
+	vi.resetModules();
+	vi.doUnmock("../i18nFrontend.js");
+});
+
+describe("which i18next instance the translator talks to", () => {
+	test("initialises the package's own instance when given none", async () => {
+		// Without this, a host application running its own i18next would capture
+		// the widget's translations and render its keys instead.
+		const { createTranslator, packageInstance, initCount } = await load();
+
+		const translator = createTranslator();
+
+		expect(translator.i18n).toBe(packageInstance);
+		expect(initCount()).toBe(1);
+	});
+
+	test("adopts an instance the caller already has", async () => {
+		// The bundle loads i18next once and hands the same instance to every
+		// widget on the page, so a second init would be wasted work.
+		const { createTranslator, initCount } = await load();
+		const existing = fakeI18n().instance;
+
+		const translator = createTranslator(existing);
+
+		expect(translator.i18n).toBe(existing);
+		expect(initCount()).toBe(0);
+	});
+});
+
+describe("translating", () => {
+	test("delegates to the instance", async () => {
+		const { createTranslator } = await load();
+		const fake = fakeI18n();
+		fake.translations = { "WIDGET.SUBMIT": "Submit" };
+
+		expect(createTranslator(fake.instance).t("WIDGET.SUBMIT")).toBe("Submit");
+	});
+
+	test("reads the instance at call time, not at creation time", async () => {
+		// A language switch mutates the instance in place; a translator that
+		// cached `t` would keep serving the previous language.
+		const { createTranslator } = await load();
+		const fake = fakeI18n();
+		const translator = createTranslator(fake.instance);
+
+		fake.translations = { "WIDGET.SUBMIT": "Envoyer" };
+
+		expect(translator.t("WIDGET.SUBMIT")).toBe("Envoyer");
+	});
+});
+
+describe("readiness", () => {
+	test("is ready once the instance has loaded the translation namespace", async () => {
+		const { createTranslator } = await load();
+		const fake = fakeI18n();
+
+		expect(createTranslator(fake.instance).isReady()).toBe(true);
+	});
+
+	test("is not ready before initialisation", async () => {
+		const { createTranslator } = await load();
+		const fake = fakeI18n();
+		fake.isInitialized = false;
+
+		expect(createTranslator(fake.instance).isReady()).toBe(false);
+	});
+
+	test("is not ready while the namespace is still loading", async () => {
+		// Widgets render an empty label until this flips, rather than flashing a
+		// raw translation key at the user.
+		const { createTranslator } = await load();
+		const fake = fakeI18n();
+		fake.loadedNamespaces = [];
+
+		expect(createTranslator(fake.instance).isReady()).toBe(false);
+	});
+});
+
+describe("subscribing", () => {
+	test.each(["initialized", "loaded", "languageChanged"])(
+		"notifies the listener on %s",
+		async (event: string) => {
+			const { createTranslator } = await load();
+			const fake = fakeI18n();
+			const listener = vi.fn<() => void>();
+
+			createTranslator(fake.instance).subscribe(listener);
+			emit(fake, event);
+
+			expect(listener).toHaveBeenCalledTimes(1);
+		},
+	);
+
+	test("stops notifying once unsubscribed", async () => {
+		// Widgets unsubscribe on destroy; a leaked listener would keep a torn-down
+		// widget alive for the lifetime of the page.
+		const { createTranslator } = await load();
+		const fake = fakeI18n();
+		const listener = vi.fn<() => void>();
+
+		const unsubscribe = createTranslator(fake.instance).subscribe(listener);
+		unsubscribe();
+		emit(fake, "languageChanged");
+
+		expect(listener).not.toHaveBeenCalled();
+	});
+
+	test("keeps independent subscriptions apart", async () => {
+		const { createTranslator } = await load();
+		const fake = fakeI18n();
+		const first = vi.fn<() => void>();
+		const second = vi.fn<() => void>();
+		const translator = createTranslator(fake.instance);
+
+		const unsubscribeFirst = translator.subscribe(first);
+		translator.subscribe(second);
+		unsubscribeFirst();
+		emit(fake, "loaded");
+
+		expect(first).not.toHaveBeenCalled();
+		expect(second).toHaveBeenCalledTimes(1);
+	});
+});

package/src/translationKey.ts

@@ -12,7 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import { z } from "zod";
 import translationEn from "./locales/en/translation.json" with { type: "json" };
 
 export type TranslationNode =
@@ -38,10 +37,10 @@ export function getLeafFieldPath(obj: TranslationNode): string[] {
 		// A string value IS the leaf, so the path ends here. Recursing into it
 		// returns [] and the `children.map` below then contributes nothing,
 		// which is how this function used to return an empty array for every
-		// input — leaving TranslationKeysSchema an empty z.enum. That enum is
-		// spread into three mongoose `reason` fields (types-database
-		// provider.ts), and mongoose registers its enum validator even for an
-		// empty list, so every non-null reason failed validation.
+		// input — leaving `translationKeys` empty. That list is spread into
+		// three mongoose `reason` fields (types-database provider.ts), and
+		// mongoose registers its enum validator even for an empty list, so
+		// every non-null reason failed validation.
 		if (typeof value === "string") {
 			return arr.concat(key);
 		}
@@ -56,8 +55,10 @@ export function getLeafFieldPath(obj: TranslationNode): string[] {
 	}, [] as string[]);
 }
 
-export const TranslationKeysSchema = z.enum(
-	getLeafFieldPath(translationEn) as [string, ...string[]],
-);
+export const translationKeys: string[] = getLeafFieldPath(translationEn);
 
-export type TranslationKey = z.infer<typeof TranslationKeysSchema>;
+/**
+ * Any leaf path in the English catalogue. Not narrowed to those paths: they are
+ * read from JSON at runtime, so the compiler only ever knew them as `string`.
+ */
+export type TranslationKey = string;