@pithy-sh/i18n 0.1.2 → 0.1.3

package/dist/resolve/browser.d.ts

@@ -0,0 +1,69 @@
+import type { BrowserResolver } from "../config/config";
+import { type LocaleSet, type ResolvedLocale } from "./chain";
+/**
+ * What the browser side of this package reads: the languages, the chain order, and the two names a page
+ * looks itself up by.
+ *
+ * **The shape `I18nClientProjection` and `I18nConfig` both already are.** The browser holds the
+ * projection — locale metadata and nothing else, no catalogs, no cookie name, no server chain — so
+ * asking a page for an `I18nConfig` asks it for three fields it has no business knowing, and every
+ * adopter widens one into the other the same five ways. Declaring what is actually read costs nothing
+ * on the server, where the resolved config satisfies it as it stands.
+ *
+ * `browserResolvers` is `readonly string[]` for the same reason the projection's is: the ambient
+ * declaration `pithy ui add react` copies into an adopter's Worker cannot name a type it does not
+ * import. The chain is walked by name — see {@link recognizedResolvers}.
+ */
+export interface BrowserChain extends LocaleSet {
+    /** The query parameter an explicit choice arrives on — `?lang=es`. */
+    readonly queryParam: string;
+    /** The `localStorage` key this device's remembered locale is written under. */
+    readonly storageKey: string;
+    /** The browser chain, in the order it is asked. Names this build does not know contribute nothing. */
+    readonly browserResolvers: readonly string[];
+}
+/**
+ * The links of `names` this build recognizes, in the order given, dropping the rest.
+ *
+ * The browser walks its chain by name because that is how the projection carries it, so a link this
+ * build has never heard of — a project one release ahead of the SPA bundle it is serving — contributes
+ * nothing rather than throwing. The links around it are still asked, each in its own place.
+ */
+export declare function recognizedResolvers(names: readonly string[]): BrowserResolver[];
+/**
+ * What a browser knows about the reader's language.
+ *
+ * A separate chain from the server's, because half the server's links do not exist here and half of
+ * these do not exist there: `localStorage` is absent from a Worker, and `navigator.language` inside
+ * workerd is the constant `"en"`, carrying no request information at all.
+ */
+export interface BrowserLocaleSignals {
+    /** An explicit choice on the URL — `?lang=es`. */
+    readonly query?: string | null;
+    /** The signed-in reader's own preference, as the app already holds it. */
+    readonly account?: string | null;
+    /** What this device remembers, from `localStorage`. */
+    readonly storage?: string | null;
+    /**
+     * The reader's own browser languages, most-wanted first, from `navigator.languages`.
+     *
+     * The browser's equivalent of `Accept-Language`, and the only link that answers for a first-time
+     * visitor who has chosen nothing and is signed in to nothing. A list rather than one tag, because
+     * `navigator.languages` is one and the whole of it is a preference order worth honoring.
+     */
+    readonly navigator?: readonly string[] | null;
+    /** What the server negotiated for the document, off `<html lang>`. */
+    readonly server?: string | null;
+}
+/**
+ * The reader's locale, by the configured browser chain.
+ *
+ * Default order: `?lang=`, the account, local storage, the server's answer, the project default.
+ *
+ * **The account outranks the device.** `pithy_auth_users.locale` is where a person's locale lives, so a
+ * signed-in reader who picks a language on one device must not silently be reading another language on
+ * the next. A `?lang=` choice by a signed-in reader is written through to their account rather than
+ * only to `localStorage`, which is what keeps the fact in one home; `docs/I18N.md` states it once.
+ */
+export declare function resolveBrowserLocale(signals: BrowserLocaleSignals, config: BrowserChain): ResolvedLocale;
+//# sourceMappingURL=browser.d.ts.map

package/dist/resolve/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/resolve/browser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,cAAc,EAA4C,MAAM,SAAS,CAAC;AAExG;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAa,SAAQ,SAAS;IAC7C,sEAAsE;IACtE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,sGAAsG;IACtG,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9C;AAuBD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,eAAe,EAAE,CAE/E;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,kDAAkD;IAClD,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,uDAAuD;IACvD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC9C,sEAAsE;IACtE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,oBAAoB,EAAE,MAAM,EAAE,YAAY,GAAG,cAAc,CAIxG"}

package/dist/resolve/browser.js

@@ -0,0 +1,62 @@
+import { resolveChain, tagLink } from "./chain.js";
+//#region src/resolve/browser.ts
+/**
+* Every link this build knows, as a record rather than a list.
+*
+* **A record so a new `BrowserResolver` cannot be forgotten here.** Adding a member to the enum leaves
+* this object missing a property, which is a red build — the same guarantee the exhaustive switch in
+* {@link linkFor} gives, in the one place a `string[]` has to be turned back into enum members.
+*
+* Written out rather than read off `BrowserResolver.options`, and that is a bundle decision, not a
+* preference. `config/config.ts` is a Zod module, and everything under `src/browser/**` and
+* `src/react/**` imports the config type-only precisely so that no scaffolded SPA ships Zod to walk a
+* chain of six names. A value import here would put it in every adopter's main chunk.
+*/
+const KNOWN_RESOLVERS = {
+	query: true,
+	account: true,
+	storage: true,
+	navigator: true,
+	server: true,
+	default: true
+};
+/**
+* The links of `names` this build recognizes, in the order given, dropping the rest.
+*
+* The browser walks its chain by name because that is how the projection carries it, so a link this
+* build has never heard of — a project one release ahead of the SPA bundle it is serving — contributes
+* nothing rather than throwing. The links around it are still asked, each in its own place.
+*/
+function recognizedResolvers(names) {
+	return names.filter((name) => Object.hasOwn(KNOWN_RESOLVERS, name));
+}
+/**
+* The reader's locale, by the configured browser chain.
+*
+* Default order: `?lang=`, the account, local storage, the server's answer, the project default.
+*
+* **The account outranks the device.** `pithy_auth_users.locale` is where a person's locale lives, so a
+* signed-in reader who picks a language on one device must not silently be reading another language on
+* the next. A `?lang=` choice by a signed-in reader is written through to their account rather than
+* only to `localStorage`, which is what keeps the fact in one home; `docs/I18N.md` states it once.
+*/
+function resolveBrowserLocale(signals, config) {
+	const links = recognizedResolvers(config.browserResolvers).map((resolver) => linkFor(resolver, signals, config));
+	return resolveChain(links, config);
+}
+/** One link, by name. A standalone function so the switch stays exhaustive under `verbatimModuleSyntax`. */
+function linkFor(resolver, signals, config) {
+	switch (resolver) {
+		case "query": return tagLink(resolver, signals.query);
+		case "account": return tagLink(resolver, signals.account);
+		case "storage": return tagLink(resolver, signals.storage);
+		case "navigator": return {
+			name: resolver,
+			ranges: (signals.navigator ?? []).filter((tag) => tag.trim().length > 0)
+		};
+		case "server": return tagLink(resolver, signals.server);
+		case "default": return tagLink(resolver, config.defaultLocale);
+	}
+}
+//#endregion
+export { recognizedResolvers, resolveBrowserLocale };

package/dist/resolve/chain.d.ts

@@ -0,0 +1,52 @@
+import type { LocaleContext } from "@pithy-sh/core/src/i18n/locale";
+import type { LocaleExceptions } from "@pithy-sh/core/src/i18n/match";
+/**
+ * The languages a chain may land on: what it matches against, what it falls back to, and the pairs no
+ * truncation of a tag would reach.
+ *
+ * **Three fields rather than `I18nConfig`, because a browser holds neither the catalogs nor the cookie
+ * name nor the server chain.** `virtual:pithy/i18n` projects locale metadata and nothing else, and this
+ * is the part of it a match is made from — so the projection satisfies this shape as it stands and the
+ * resolved config satisfies it too. Structural on purpose: one type both sides already are beats a
+ * conversion every caller has to work out for itself.
+ */
+export interface LocaleSet {
+    /** Every locale this project serves. A chain answers with one of these or with nothing. */
+    readonly supportedLocales: readonly string[];
+    /** The locale served when no link answers. Always one of `supportedLocales`. */
+    readonly defaultLocale: string;
+    /** Language ranges the matcher cannot derive, as range → supported locale. Usually empty. */
+    readonly exceptions: LocaleExceptions;
+}
+/** One link of a resolver chain: where the ranges came from, and what they were. */
+export interface ResolverLink {
+    /** The link's name, as it appears in `serverResolvers` / `browserResolvers`. */
+    readonly name: string;
+    /** The language ranges this link offers, most-wanted first. Empty when the link has nothing to say. */
+    readonly ranges: readonly string[];
+}
+/** A resolved locale, plus which link answered — so `pithy doctor` and a log can say why. */
+export interface ResolvedLocale extends LocaleContext {
+    /** The chain link that answered, or `"default"` when the chain fell through to the project default. */
+    readonly resolvedBy: string;
+}
+/**
+ * A single tag as a one-element range list, or nothing when there is no tag.
+ *
+ * The links that read a stored or supplied value all have this shape. A blank string is nothing, not a
+ * range: a cookie the browser cleared and a cookie that was never set mean the same thing here.
+ */
+export declare function tagLink(name: string, tag: string | null | undefined): ResolverLink;
+/**
+ * Walk `links` in order and take the first that matches a supported locale.
+ *
+ * **The two locales are decided here, and only one of them falls back.** The catalog locale is what
+ * matched — the words the kit actually has. The formatting locale is the *range the reader sent*, kept
+ * whole when it is a tag `Intl` accepts: an `es-AR` visitor reads the `es` catalog and formats as
+ * `es-AR`, which `Intl` supports natively whether or not anyone wrote a string for it.
+ *
+ * Total. Every construction on the way through is guarded, so a chain fed nothing but malformed input
+ * lands on the project default rather than throwing.
+ */
+export declare function resolveChain(links: readonly ResolverLink[], locales: LocaleSet): ResolvedLocale;
+//# sourceMappingURL=chain.d.ts.map

package/dist/resolve/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../../src/resolve/chain.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAEpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB,2FAA2F;IAC3F,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7C,gFAAgF;IAChF,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,6FAA6F;IAC7F,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;CACvC;AAED,oFAAoF;AACpF,MAAM,WAAW,YAAY;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,uGAAuG;IACvG,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,6FAA6F;AAC7F,MAAM,WAAW,cAAe,SAAQ,aAAa;IACnD,uGAAuG;IACvG,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,YAAY,CAGlF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,EAAE,OAAO,EAAE,SAAS,GAAG,cAAc,CAsB/F"}

package/dist/resolve/chain.js

@@ -0,0 +1,49 @@
+import { formattingLocaleOf, localeDirection } from "@pithy-sh/core/src/i18n/locale";
+import { matchLocale } from "@pithy-sh/core/src/i18n/match";
+//#region src/resolve/chain.ts
+/**
+* A single tag as a one-element range list, or nothing when there is no tag.
+*
+* The links that read a stored or supplied value all have this shape. A blank string is nothing, not a
+* range: a cookie the browser cleared and a cookie that was never set mean the same thing here.
+*/
+function tagLink(name, tag) {
+	const trimmed = tag?.trim();
+	return {
+		name,
+		ranges: trimmed ? [trimmed] : []
+	};
+}
+/**
+* Walk `links` in order and take the first that matches a supported locale.
+*
+* **The two locales are decided here, and only one of them falls back.** The catalog locale is what
+* matched — the words the kit actually has. The formatting locale is the *range the reader sent*, kept
+* whole when it is a tag `Intl` accepts: an `es-AR` visitor reads the `es` catalog and formats as
+* `es-AR`, which `Intl` supports natively whether or not anyone wrote a string for it.
+*
+* Total. Every construction on the way through is guarded, so a chain fed nothing but malformed input
+* lands on the project default rather than throwing.
+*/
+function resolveChain(links, locales) {
+	for (const link of links) {
+		if (link.ranges.length === 0) continue;
+		const match = matchLocale(link.ranges, locales.supportedLocales, locales.exceptions);
+		if (!match) continue;
+		const requested = formattingLocaleOf(match.range);
+		return {
+			catalogLocale: match.locale,
+			formattingLocale: requested ?? match.locale,
+			direction: localeDirection(match.locale),
+			resolvedBy: link.name
+		};
+	}
+	return {
+		catalogLocale: locales.defaultLocale,
+		formattingLocale: locales.defaultLocale,
+		direction: localeDirection(locales.defaultLocale),
+		resolvedBy: "default"
+	};
+}
+//#endregion
+export { resolveChain, tagLink };

package/dist/resolve/server.d.ts

@@ -0,0 +1,31 @@
+import type { I18nConfig } from "../config/config";
+import { type ResolvedLocale } from "./chain";
+/**
+ * What a Worker knows about a request's language, before any of it is trusted.
+ *
+ * Every field is caller-supplied and every one of them is guarded downstream: a `*`, an `en_US`, an
+ * empty token or a fragment still carrying `;q=0.9` falls out of the match instead of reaching
+ * `Intl.Locale` and raising a `RangeError`.
+ */
+export interface ServerLocaleSignals {
+    /** An explicit choice on the query string — `?lang=es`. */
+    readonly param?: string | null;
+    /** The signed-in reader's own preference, from `pithy_auth_users.locale`. */
+    readonly user?: string | null;
+    /** The locale cookie, for a reader who chose one and is not signed in. */
+    readonly cookie?: string | null;
+    /** The raw `Accept-Language` header, q-weights and all. */
+    readonly header?: string | null;
+}
+/**
+ * The request's locale, by the configured server chain.
+ *
+ * Default order: explicit param, the account, the cookie, `Accept-Language`, the project default. An
+ * adopter reorders or shortens it in config; `default` is the last resort whether or not it is listed.
+ *
+ * `Accept-Language` is honored as the **full q-weighted list**, not as its first entry —
+ * `pt-PT;q=1.0, es;q=0.8, en;q=0.5` from a reader with no Portuguese is a request for Spanish, and
+ * reading only the head answers English.
+ */
+export declare function resolveServerLocale(signals: ServerLocaleSignals, config: I18nConfig): ResolvedLocale;
+//# sourceMappingURL=server.d.ts.map

package/dist/resolve/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/resolve/server.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,kBAAkB,CAAC;AACnE,OAAO,EAAE,KAAK,cAAc,EAA4C,MAAM,SAAS,CAAC;AAExF;;;;;;GAMG;AACH,MAAM,WAAW,mBAAmB;IAClC,2DAA2D;IAC3D,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,6EAA6E;IAC7E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,2DAA2D;IAC3D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACjC;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,UAAU,GAAG,cAAc,CAGpG"}

package/dist/resolve/server.js

@@ -0,0 +1,32 @@
+import { resolveChain, tagLink } from "./chain.js";
+import { parseAcceptLanguage } from "@pithy-sh/core/src/i18n/acceptLanguage";
+//#region src/resolve/server.ts
+/**
+* The request's locale, by the configured server chain.
+*
+* Default order: explicit param, the account, the cookie, `Accept-Language`, the project default. An
+* adopter reorders or shortens it in config; `default` is the last resort whether or not it is listed.
+*
+* `Accept-Language` is honored as the **full q-weighted list**, not as its first entry —
+* `pt-PT;q=1.0, es;q=0.8, en;q=0.5` from a reader with no Portuguese is a request for Spanish, and
+* reading only the head answers English.
+*/
+function resolveServerLocale(signals, config) {
+	const links = config.serverResolvers.map((resolver) => linkFor(resolver, signals, config));
+	return resolveChain(links, config);
+}
+/** One link, by name. A standalone function so the switch stays exhaustive under `verbatimModuleSyntax`. */
+function linkFor(resolver, signals, config) {
+	switch (resolver) {
+		case "param": return tagLink(resolver, signals.param);
+		case "user": return tagLink(resolver, signals.user);
+		case "cookie": return tagLink(resolver, signals.cookie);
+		case "header": return {
+			name: resolver,
+			ranges: parseAcceptLanguage(signals.header).map((entry) => entry.range)
+		};
+		case "default": return tagLink(resolver, config.defaultLocale);
+	}
+}
+//#endregion
+export { resolveServerLocale };

package/dist/settings/coverage.d.ts

@@ -0,0 +1,21 @@
+import type { CapabilitySettings } from "@pithy-sh/core/src/capability/settings";
+import type { LocaleCatalogs } from "@pithy-sh/core/src/i18n/catalog";
+import type { I18nConfig } from "../config/config";
+/**
+ * Catalog coverage as `pithy doctor`'s **local** tier — offline, project-file-only, and already fatal
+ * to `doctor`'s exit code.
+ *
+ * This is the whole of what a `pithy i18n check` command would have been, and it costs no new command,
+ * no `docs/commands/` page, and no edit to the five exact-count or byte-pinned CLI gates a new command
+ * moves (`dispatch.test.ts`'s `DECLARED`/`GROUPS`, `binDocs.test.ts`'s byte comparison of `docs/CLI.md`
+ * §4.1 against real `pithy --help`, `doctorDocs.test.ts`'s mandated page sections and `--json` key
+ * register). The seam already exists and this is textbook for it.
+ *
+ * It answers one question: **would a reader in a supported locale meet a sentence nobody wrote?** For
+ * each locale the project serves, every key reachable in the default locale must be reachable in that
+ * one too, through the adopter's own catalog or the kit's translation.
+ *
+ * There is no `account` tier. Nothing about language is a question for the Cloudflare API.
+ */
+export declare function i18nSettings(config: I18nConfig, composed: () => LocaleCatalogs): CapabilitySettings;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/settings/coverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coverage.d.ts","sourceRoot":"","sources":["../../src/settings/coverage.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAmB,MAAM,wCAAwC,CAAC;AAClG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAKnD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,cAAc,GAAG,kBAAkB,CA8BnG"}

package/dist/settings/coverage.js

@@ -0,0 +1,48 @@
+import { KIT_CATALOGS } from "../catalogs/kit.js";
+//#region src/settings/coverage.ts
+/** How many missing keys a finding names before it stops counting out loud. */
+const LISTED_KEYS = 5;
+/**
+* Catalog coverage as `pithy doctor`'s **local** tier — offline, project-file-only, and already fatal
+* to `doctor`'s exit code.
+*
+* This is the whole of what a `pithy i18n check` command would have been, and it costs no new command,
+* no `docs/commands/` page, and no edit to the five exact-count or byte-pinned CLI gates a new command
+* moves (`dispatch.test.ts`'s `DECLARED`/`GROUPS`, `binDocs.test.ts`'s byte comparison of `docs/CLI.md`
+* §4.1 against real `pithy --help`, `doctorDocs.test.ts`'s mandated page sections and `--json` key
+* register). The seam already exists and this is textbook for it.
+*
+* It answers one question: **would a reader in a supported locale meet a sentence nobody wrote?** For
+* each locale the project serves, every key reachable in the default locale must be reachable in that
+* one too, through the adopter's own catalog or the kit's translation.
+*
+* There is no `account` tier. Nothing about language is a question for the Cloudflare API.
+*/
+function i18nSettings(config, composed) {
+	return { local: () => {
+		const findings = [];
+		const capabilityMessages = composed();
+		const baseline = /* @__PURE__ */ new Set([...Object.keys(capabilityMessages[config.defaultLocale] ?? {}), ...Object.keys(config.messages[config.defaultLocale] ?? {})]);
+		for (const locale of config.supportedLocales) {
+			if (locale === config.defaultLocale) continue;
+			const covered = /* @__PURE__ */ new Set([
+				...Object.keys(KIT_CATALOGS[locale] ?? {}),
+				...Object.keys(capabilityMessages[locale] ?? {}),
+				...Object.keys(config.messages[locale] ?? {})
+			]);
+			const missing = [...baseline].filter((key) => !covered.has(key)).sort();
+			if (missing.length === 0) continue;
+			const named = missing.slice(0, LISTED_KEYS).join(", ");
+			const rest = missing.length > LISTED_KEYS ? `, and ${missing.length - LISTED_KEYS} more` : "";
+			findings.push({
+				setting: `i18n.supportedLocales.${locale}`,
+				environment: null,
+				problem: `${missing.length} ${missing.length === 1 ? "message has" : "messages have"} no \`${locale}\` translation, so a reader in that language meets ${config.defaultLocale} instead.`,
+				action: `Add them to \`i18n({ messages: { ${locale}: … } })\` in your \`pithy.config.ts\`: ${named}${rest}.`
+			});
+		}
+		return findings;
+	} };
+}
+//#endregion
+export { i18nSettings };

package/dist/version.generated.d.ts

@@ -0,0 +1,5 @@
+/** This package's npm name — the join key against a release feed. */
+export declare const PACKAGE_NAME = "@pithy-sh/i18n";
+/** This package's version, stamped from its own package.json at generation time. */
+export declare const PACKAGE_VERSION = "0.1.3";
+//# sourceMappingURL=version.generated.d.ts.map

package/dist/version.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.generated.d.ts","sourceRoot":"","sources":["../src/version.generated.ts"],"names":[],"mappings":"AAWA,qEAAqE;AACrE,eAAO,MAAM,YAAY,mBAAmB,CAAC;AAE7C,oFAAoF;AACpF,eAAO,MAAM,eAAe,UAAU,CAAC"}

package/dist/version.generated.js

@@ -0,0 +1,7 @@
+//#region src/version.generated.ts
+/** This package's npm name — the join key against a release feed. */
+const PACKAGE_NAME = "@pithy-sh/i18n";
+/** This package's version, stamped from its own package.json at generation time. */
+const PACKAGE_VERSION = "0.1.3";
+//#endregion
+export { PACKAGE_NAME, PACKAGE_VERSION };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pithy-sh/i18n",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -8,20 +8,25 @@
     "directory": "packages/i18n"
   },
   "files": [
+    "dist",
     "src",
     "pithy.manifest.json",
-    "!src/**/*.test.*"
+    "!src/**/*.test.*",
+    "!dist/**/*.test.*"
   ],
   "type": "module",
   "engines": {
     "node": ">=22"
   },
   "exports": {
-    "./src/react/translator": "./src/react/translator.tsx",
-    "./src/*": "./src/*.ts"
+    "./src/*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    },
+    "./src/react/translator": "./src/react/translator.tsx"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json --noEmit false --outDir dist",
+    "build": "tsdown && tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.browser.json",
     "test": "vitest run",
     "test:node": "vitest run --project=node --project=dom",
@@ -30,12 +35,12 @@
     "reset": "bun run clean && rm -rf node_modules"
   },
   "dependencies": {
-    "@pithy-sh/core": "^0.1.2",
-    "hono": "^4.13.2",
-    "zod": "^4.0.0"
+    "@pithy-sh/core": "^0.1.3"
   },
   "peerDependencies": {
-    "react": "^19.0.0"
+    "hono": "^4.13.2",
+    "react": "^19.0.0",
+    "zod": "^4.4.0"
   },
   "peerDependenciesMeta": {
     "react": {
@@ -52,10 +57,13 @@
     "@types/react-dom": "^19.2.3",
     "@vitest/coverage-v8": "^4.1.0",
     "happy-dom": "^20.11.1",
+    "hono": "^4.13.2",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
+    "tsdown": "^0.23.0",
     "typescript": "^7.0.2",
     "vitest": "^4.1.0",
-    "wrangler": "^4.115.0"
+    "wrangler": "^4.115.0",
+    "zod": "^4.4.0"
   }
 }

package/src/version.generated.ts

@@ -13,4 +13,4 @@
 export const PACKAGE_NAME = "@pithy-sh/i18n";
 
 /** This package's version, stamped from its own package.json at generation time. */
-export const PACKAGE_VERSION = "0.1.2";
+export const PACKAGE_VERSION = "0.1.3";