@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/load-CQRz4PpM.js

@@ -0,0 +1,2950 @@
+import { a as printICU, d as diagnosticError, f as isDiagnosticError, i as normalizeSource, r as isPlainText, s as parseSource, t as compileMessage } from "./compile-Cc97JaW2.js";
+import { n as validateTranslation } from "./validate-D6DJepZv.js";
+import { t as pseudoLocalize } from "./pseudo-DRv30iN5.js";
+import { hash } from "node:crypto";
+import { readFile, stat } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { pathToFileURL } from "node:url";
+import { z } from "zod";
+//#region src/core/catalog/validity.ts
+function sourceMatches(entry, layout, message, codec) {
+	if (layout === "id") return entry.label !== null && entry.label === message.label;
+	const source = entry.source;
+	if (source === null) return false;
+	if (source === message.canonical) return true;
+	return entryCanonical(entry, codec) === message.canonical;
+}
+//#endregion
+//#region src/core/catalog/model.ts
+/**
+* The catalog model shared by every reader, writer and consumer (INTERNALS
+* §2.6.2, §2.6.5, §2.6.7): how an entry is keyed, how entries sort, and when
+* a translation may ship. Formats (`po.ts`, `json.ts`) and files (`io.ts`)
+* build on these; nothing here touches the file system.
+*/
+const canonicals = /* @__PURE__ */ new WeakMap();
+/**
+* `codec.canonicalize(entry.source)`, memoised on the entry (catalog load,
+* the store's index, duplicate resolution and compilation each need it for
+* every entry); null for an entry without a source or whose source is not
+* valid ICU. Canonical forms do not depend on the codec's id length.
+*/
+function entryCanonical(entry, codec) {
+	const source = entry.source;
+	if (source === null) return null;
+	const memo = canonicals.get(entry);
+	if (memo !== void 0 && memo.source === source) return memo.canonical;
+	let canonical;
+	try {
+		canonical = codec.canonicalize(source);
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		canonical = null;
+	}
+	canonicals.set(entry, {
+		source,
+		canonical
+	});
+	return canonical;
+}
+/**
+* The key that joins an entry to code. Null for foreign contexts (never
+* matched) and for `"source"`-layout entries whose source does not parse,
+* which consumers report on the source instead.
+*/
+function entryKey(entry, layout, codec) {
+	if (entry.foreignContext !== null) return null;
+	if (entry.manualId !== null) return entry.manualId;
+	if (layout !== "source") return entry.label;
+	const canonical = entryCanonical(entry, codec);
+	return canonical === null ? null : codec.label(canonical);
+}
+/** Splits a JSON `context` (notes joined with `"\n"`) back into single-line notes. */
+function splitContexts(context) {
+	if (context === "") return [];
+	return context.split("\n");
+}
+/**
+* The one definition of "this entry's translation may ship" (INTERNALS
+* §2.6.7), shared by compilation, AI planning, `check` and `status`. Steps
+* run in contract order and the first failure names the reason.
+* `scheme-mismatch` and `no-entry` are decided by callers.
+*/
+function usableTranslation(entry, layout, message, codec, locale) {
+	if (!sourceMatches(entry, layout, message, codec)) return {
+		ok: false,
+		reason: "source-mismatch",
+		diagnostics: []
+	};
+	if (entry.translation === "") return {
+		ok: false,
+		reason: "untranslated",
+		diagnostics: []
+	};
+	if (entry.fuzzy) return {
+		ok: false,
+		reason: "fuzzy",
+		diagnostics: []
+	};
+	let parsed;
+	try {
+		parsed = codec.parse(entry.translation);
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		return {
+			ok: false,
+			reason: "invalid",
+			diagnostics: [withSubject(error.diagnostic, locale, message.id, entry.line)]
+		};
+	}
+	const found = validateTranslation(parsed, codec.parse(message.canonical), {
+		locale,
+		text: entry.translation
+	});
+	let errors = null;
+	for (const diagnostic of found) if (diagnostic.severity === "error") (errors ??= []).push(withSubject(diagnostic, locale, message.id, entry.line));
+	return errors === null ? {
+		ok: true,
+		parsed
+	} : {
+		ok: false,
+		reason: "invalid",
+		diagnostics: errors
+	};
+}
+/**
+* ICU diagnostics locate problems inside the message text; for a catalog the
+* useful position is the entry's line, and the locale and id say which entry.
+*/
+function withSubject(diagnostic, locale, id, line) {
+	const located = {
+		...diagnostic,
+		locale: diagnostic.locale ?? locale,
+		id: diagnostic.id ?? id
+	};
+	delete located.line;
+	delete located.column;
+	if (line > 0) located.line = line;
+	return located;
+}
+//#endregion
+//#region src/core/catalog/json.ts
+/** Top-level keys the reader maps onto the header; anything else is preserved in `extra`. */
+const OWNED_KEYS = /* @__PURE__ */ new Set([
+	"$schema",
+	"locale",
+	"sourceLocale",
+	"idScheme",
+	"aiModel",
+	"messages"
+]);
+/** Per-message fields with a model field; anything else is preserved in `extra`. */
+const MESSAGE_FIELDS = /* @__PURE__ */ new Set([
+	"context",
+	"fuzzy",
+	"maxLength",
+	"flags",
+	"refs",
+	"state",
+	"source",
+	"translation"
+]);
+const STATES = /* @__PURE__ */ new Set([
+	"untranslated",
+	"ai",
+	"translated"
+]);
+function skipBlank(text, i) {
+	while (i < text.length) {
+		const code = text.charCodeAt(i);
+		if (code !== 32 && code !== 10 && code !== 13 && code !== 9) break;
+		i++;
+	}
+	return i;
+}
+/** Index just past the string starting at `i` (which is `"`). */
+function skipString(text, i) {
+	i++;
+	while (i < text.length) {
+		const code = text.charCodeAt(i);
+		if (code === 92) i += 2;
+		else if (code === 34) return i + 1;
+		else i++;
+	}
+	return i;
+}
+/** Index just past the value starting at `i`. The text is known to be valid JSON. */
+function skipValue(text, i) {
+	const code = text.charCodeAt(i);
+	if (code === 34) return skipString(text, i);
+	if (code === 123 || code === 91) {
+		let depth = 0;
+		while (i < text.length) {
+			const c = text.charCodeAt(i);
+			if (c === 34) {
+				i = skipString(text, i);
+				continue;
+			}
+			if (c === 123 || c === 91) depth++;
+			else if (c === 125 || c === 93) {
+				depth--;
+				if (depth === 0) return i + 1;
+			}
+			i++;
+		}
+		return i;
+	}
+	while (i < text.length) {
+		const c = text.charCodeAt(i);
+		if (c === 44 || c === 125 || c === 93 || c === 32 || c === 10 || c === 13 || c === 9) break;
+		i++;
+	}
+	return i;
+}
+/**
+* The members of the top-level `messages` object in text order, duplicates
+* included. Null when there is no `messages` object.
+*/
+function scanMessages(text) {
+	let line = 1;
+	let counted = 0;
+	const lineAt = (offset) => {
+		for (let i = counted; i < offset; i++) if (text.charCodeAt(i) === 10) line++;
+		counted = offset;
+		return line;
+	};
+	let i = skipBlank(text, text.charCodeAt(0) === 65279 ? 1 : 0);
+	if (text.charCodeAt(i) !== 123) return null;
+	i = skipBlank(text, i + 1);
+	while (i < text.length && text.charCodeAt(i) === 34) {
+		const keyEnd = skipString(text, i);
+		const key = JSON.parse(text.slice(i, keyEnd));
+		i = skipBlank(text, keyEnd);
+		i = skipBlank(text, i + 1);
+		const valueEnd = skipValue(text, i);
+		if (key === "messages" && text.charCodeAt(i) === 123) {
+			const members = [];
+			let j = skipBlank(text, i + 1);
+			while (j < valueEnd && text.charCodeAt(j) === 34) {
+				const memberKeyEnd = skipString(text, j);
+				const memberLine = lineAt(j);
+				const memberKey = JSON.parse(text.slice(j, memberKeyEnd));
+				j = skipBlank(text, memberKeyEnd);
+				j = skipBlank(text, j + 1);
+				const end = skipValue(text, j);
+				members.push({
+					key: memberKey,
+					line: memberLine,
+					start: j,
+					end
+				});
+				j = skipBlank(text, end);
+				if (text.charCodeAt(j) === 44) j = skipBlank(text, j + 1);
+			}
+			return members;
+		}
+		i = skipBlank(text, valueEnd);
+		if (text.charCodeAt(i) === 44) i = skipBlank(text, i + 1);
+	}
+	return null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function sortedUnique$1(values) {
+	return [...new Set(values)].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+}
+/** Line and column of a `JSON.parse` error, when V8 names a position. */
+function errorPosition(text, error) {
+	const match = /position (\d+)/.exec(error instanceof Error ? error.message : "");
+	if (match === null) return {};
+	const offset = Number(match[1]);
+	let line = 1;
+	let lineStart = 0;
+	for (let i = 0; i < offset && i < text.length; i++) if (text.charCodeAt(i) === 10) {
+		line++;
+		lineStart = i + 1;
+	}
+	return {
+		line,
+		column: offset - lineStart + 1
+	};
+}
+function readEntry(key, value, line, isSourceLocale) {
+	if (!isRecord(value)) return { error: `message ${JSON.stringify(key)} must be an object` };
+	const { context, fuzzy, maxLength, flags, refs, state, source, translation } = value;
+	if (context !== void 0 && typeof context !== "string") return { error: `${key}: context must be a string` };
+	if (fuzzy !== void 0 && typeof fuzzy !== "boolean") return { error: `${key}: fuzzy must be true or absent` };
+	if (maxLength !== void 0 && !(Number.isInteger(maxLength) && maxLength > 0)) return { error: `${key}: maxLength must be a positive integer` };
+	if (flags !== void 0 && !isStringArray(flags)) return { error: `${key}: flags must be an array of strings` };
+	if (refs !== void 0 && !isStringArray(refs)) return { error: `${key}: refs must be an array of strings` };
+	if (state !== void 0 && (typeof state !== "string" || !STATES.has(state))) return { error: `${key}: state must be "untranslated", "ai" or "translated"` };
+	if (source !== void 0 && source !== null && typeof source !== "string") return { error: `${key}: source must be a string` };
+	if (translation !== void 0 && typeof translation !== "string") return { error: `${key}: translation must be a string` };
+	const text = isSourceLocale ? "" : translation ?? "";
+	const entryState = text === "" ? "untranslated" : state === "ai" ? "ai" : "translated";
+	let extra;
+	for (const field of Object.keys(value)) if (!MESSAGE_FIELDS.has(field)) Object.defineProperty(extra ??= {}, field, {
+		value: value[field],
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	const manual = key.includes(".");
+	const entry = {
+		manualId: manual ? key : null,
+		foreignContext: null,
+		label: manual ? null : key,
+		source: typeof source === "string" ? source : null,
+		translation: text,
+		state: entryState,
+		fuzzy: fuzzy === true,
+		contexts: typeof context === "string" ? splitContexts(context) : [],
+		comments: [],
+		refs: refs === void 0 ? [] : sortedUnique$1(refs),
+		maxLength: maxLength === void 0 ? null : maxLength,
+		flags: flags === void 0 ? [] : [...new Set(flags)].map((name) => ({
+			name,
+			line: "#,"
+		})),
+		line,
+		wrapped: false
+	};
+	if (extra !== void 0) entry.extra = extra;
+	return { entry };
+}
+function parseJsonCatalog(text, options) {
+	const { locale, isSourceLocale } = options;
+	const diagnostics = [];
+	const header = {
+		language: locale,
+		idScheme: null,
+		sourceLocale: null,
+		aiModel: null,
+		extra: []
+	};
+	const catalog = {
+		locale,
+		layout: "json",
+		header,
+		entries: [],
+		obsolete: [],
+		droppedObsolete: 0
+	};
+	const fail = (message, line) => {
+		const diagnostic = {
+			code: "catalog-parse",
+			severity: "error",
+			message
+		};
+		if (line !== void 0) diagnostic.line = line;
+		diagnostics.push(diagnostic);
+	};
+	let root;
+	try {
+		root = JSON.parse(text.charCodeAt(0) === 65279 ? text.slice(1) : text);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		diagnostics.push({
+			code: "catalog-parse",
+			severity: "error",
+			message,
+			...errorPosition(text, error)
+		});
+		return {
+			catalog,
+			diagnostics
+		};
+	}
+	if (!isRecord(root)) {
+		fail("a JSON catalog must be an object", 1);
+		return {
+			catalog,
+			diagnostics
+		};
+	}
+	for (const [key, value] of Object.entries(root)) switch (key) {
+		case "$schema":
+		case "messages": break;
+		case "locale":
+			if (typeof value === "string" && value !== "") header.language = value;
+			else fail("locale must be a string");
+			break;
+		case "sourceLocale":
+		case "idScheme":
+		case "aiModel":
+			if (typeof value === "string") header[key] = value;
+			else if (value !== null) fail(`${key} must be a string`);
+			break;
+		default: if (!OWNED_KEYS.has(key)) header.extra.push([key, value]);
+	}
+	const messages = root.messages;
+	if (messages === void 0) return {
+		catalog,
+		diagnostics
+	};
+	if (!isRecord(messages)) {
+		fail("messages must be an object");
+		return {
+			catalog,
+			diagnostics
+		};
+	}
+	const members = scanMessages(text) ?? [];
+	const seen = /* @__PURE__ */ new Set();
+	let duplicates = null;
+	for (const member of members) if (seen.has(member.key)) (duplicates ??= /* @__PURE__ */ new Set()).add(member.key);
+	else seen.add(member.key);
+	for (const member of members) {
+		const value = duplicates !== null && duplicates.has(member.key) ? JSON.parse(text.slice(member.start, member.end)) : messages[member.key];
+		const read = readEntry(member.key, value, member.line, isSourceLocale);
+		if ("error" in read) fail(read.error, member.line);
+		else catalog.entries.push(read.entry);
+	}
+	return {
+		catalog,
+		diagnostics
+	};
+}
+//#endregion
+//#region src/core/extract/dependencies.ts
+/**
+* `extraction.dependencies` (PLAN §4.5, §5.24; INTERNALS §2.5.7): published
+* packages the app opts in. Each name resolves from the config root the way
+* Node resolves a package directory (`node_modules/<name>` in the root or a
+* directory above it), by realpath, which is what Vite hands the plugin under
+* pnpm's links. Their files are extracted and rewritten like the app's,
+* except the package's own `node_modules`, tests and declarations, and their
+* catalog references read `<name>/<path in the package>`, the same on every
+* machine and package manager and across the package's versions.
+*/
+/** As `files.ts` has it (which imports this module). */
+const toPosix$1 = (path) => sep === "/" ? path : path.replaceAll("\\", "/");
+const resolved = /* @__PURE__ */ new WeakMap();
+/**
+* Every `extraction.dependencies` package, resolved once per config. A
+* name that does not resolve is a `config-invalid` error: its strings would
+* otherwise ship untranslated and unreported.
+*/
+function dependenciesOf(config) {
+	let list = resolved.get(config.extraction);
+	if (list !== void 0) return list;
+	list = [];
+	for (const name of config.extraction.dependencies) {
+		const dir = packageDir(config.root, name);
+		if (dir === null) throw diagnosticError({
+			code: "config-invalid",
+			severity: "error",
+			message: `extraction.dependencies: ${name} is not installed (no node_modules/${name} from ${toPosix$1(config.root)} up); add it to the app's dependencies`
+		});
+		list.push({
+			name,
+			dir,
+			messages: messagesFile(dir)
+		});
+	}
+	resolved.set(config.extraction, list);
+	return list;
+}
+/** The package directory as Node finds it from `root`, by realpath; null when not installed. */
+function packageDir(root, name) {
+	let dir = resolve(root);
+	for (;;) {
+		const candidate = join(dir, "node_modules", name);
+		if (existsSync(join(candidate, "package.json"))) return toPosix$1(realpathSync(candidate)).replace(/\/+$/, "");
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+/** `package.json#vi18n.messages`, absolute; null without one (or an unreadable manifest). */
+function messagesFile(dir) {
+	try {
+		const path = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).vi18n?.messages;
+		return typeof path === "string" && path !== "" ? toPosix$1(resolve(dir, path)) : null;
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/core/catalog/library.ts
+/**
+* Library mode, the app's side (PLAN §4.7, §5.24; INTERNALS §2.6.11): what an
+* opted-in package ships next to its code. Its `vi18n.messages.json` (written
+* by its own `build.lib` build) lists its messages and its catalogs, and
+* `package.json#vi18n.messages` points at it. Each catalog loads under the
+* app's catalog for the same locale (`LoadedCatalog.libraries`), its entries
+* joined to the app's ids by canonical source or manual id, never by label:
+* a library built with another `ids.length`, or another msgid layout, still
+* matches. Precedence is app catalog, then library catalogs in
+* `extraction.dependencies` order, then the source, at each step of a
+* fallback chain.
+*/
+const manifests = /* @__PURE__ */ new WeakMap();
+/** Every opted-in package's manifest (those with `package.json#vi18n.messages`), read once per config. */
+function libraryManifests(config) {
+	let list = manifests.get(config.extraction);
+	if (list !== void 0) return list;
+	list = [];
+	for (const dependency of dependenciesOf(config)) {
+		if (dependency.messages === null) continue;
+		list.push({
+			name: dependency.name,
+			file: dependency.messages,
+			...readManifest(dependency.messages, config.root)
+		});
+	}
+	manifests.set(config.extraction, list);
+	return list;
+}
+function readManifest(file, root) {
+	const shown = displayPath$2(root, file);
+	let data;
+	try {
+		data = JSON.parse(readFileSync(file, "utf8"));
+	} catch (error) {
+		return {
+			manifest: null,
+			diagnostic: {
+				code: "catalog-parse",
+				severity: "warning",
+				message: `${shown} cannot be read (${error.message}); the package's translations are left out`,
+				file: shown
+			}
+		};
+	}
+	const manifest = data;
+	if (manifest === null || typeof manifest !== "object" || manifest.vi18n !== 1 || !Array.isArray(manifest.messages)) return {
+		manifest: null,
+		diagnostic: {
+			code: "catalog-parse",
+			severity: "warning",
+			message: `${shown} is not a vi18n.messages.json of version 1; the package's translations are left out`,
+			file: shown
+		}
+	};
+	return {
+		manifest,
+		diagnostic: null
+	};
+}
+/**
+* Loads the opted-in packages' catalogs for `locales` under the app's
+* (`LoadedCatalog.libraries`), normalised for joining (below). The source
+* locale compiles from the code, so its library catalogs are read only for a
+* package written in another language: its texts are not the app's source
+* language, and its catalog for that language is what those pages show.
+*/
+async function attachLibraryCatalogs(set, config, codec, locales) {
+	const diagnostics = [];
+	if (config.extraction.dependencies.length === 0) return diagnostics;
+	const layout = catalogLayout(config);
+	for (const loaded of libraryManifests(config)) {
+		if (loaded.diagnostic !== null) diagnostics.push(loaded.diagnostic);
+		const catalogs = loaded.manifest?.catalogs;
+		if (catalogs == null || typeof catalogs.files !== "object") continue;
+		const from = catalogs.format === "json" ? "json" : catalogs.msgid === "id" ? "id" : "source";
+		const foreign = typeof loaded.manifest?.sourceLocale === "string" && loaded.manifest.sourceLocale !== config.sourceLocale;
+		for (const locale of locales) {
+			if (locale === config.sourceLocale && !foreign) continue;
+			const own = set.get(locale);
+			const relativePath = Object.hasOwn(catalogs.files, locale) ? catalogs.files[locale] : void 0;
+			if (locale === config.sourceLocale && typeof relativePath !== "string") {
+				diagnostics.push({
+					code: "catalog-parse",
+					severity: "warning",
+					message: `${loaded.name} is written in ${loaded.manifest?.sourceLocale} and ships no ${locale} catalog; its messages show in ${loaded.manifest?.sourceLocale} on ${locale} pages`,
+					file: displayPath$2(config.root, loaded.file),
+					locale
+				});
+				continue;
+			}
+			if (own === void 0 || typeof relativePath !== "string") continue;
+			const path = resolve(dirname(loaded.file), relativePath);
+			let text;
+			try {
+				text = await readFile(path, "utf8");
+			} catch {
+				diagnostics.push({
+					code: "catalog-parse",
+					severity: "warning",
+					message: `${loaded.name} lists a ${locale} catalog it does not ship (${relativePath}); its ${locale} translations are left out`,
+					file: displayPath$2(config.root, loaded.file),
+					locale
+				});
+				continue;
+			}
+			const read = parseCatalog(text, {
+				locale,
+				layout: from,
+				isSourceLocale: false
+			});
+			for (const diagnostic of read.diagnostics) diagnostics.push({
+				...diagnostic,
+				severity: diagnostic.severity === "error" ? "warning" : diagnostic.severity,
+				file: diagnostic.file ?? displayPath$2(config.root, path),
+				locale
+			});
+			const library = {
+				locale,
+				path,
+				catalog: joined(read.catalog, layout, codec),
+				hash: contentHash(text),
+				library: true,
+				...foreign ? { librarySource: loaded.manifest?.sourceLocale } : {}
+			};
+			set.set(locale, {
+				...own,
+				libraries: [...own.libraries ?? [], library]
+			});
+		}
+	}
+	return diagnostics;
+}
+/**
+* A library catalog in the app's terms: the app's layout, no recorded
+* scheme, and every entry's `label` computed from its source by the app's
+* codec, so `entryKey`, `sourceMatches` and duplicates join by canonical
+* source (generated ids) or manual id whatever the library's `ids.length`
+* and layout. Entries without a source that parses cannot join and are
+* left out.
+*/
+function joined(catalog, layout, codec) {
+	const entries = [];
+	for (const entry of catalog.entries) {
+		if (entry.foreignContext !== null) continue;
+		const canonical = entryCanonical(entry, codec);
+		if (canonical === null) continue;
+		entries.push({
+			...entry,
+			source: canonical,
+			label: codec.label(canonical)
+		});
+	}
+	return {
+		...catalog,
+		layout,
+		header: {
+			...catalog.header,
+			idScheme: null
+		},
+		entries,
+		obsolete: [],
+		droppedObsolete: 0
+	};
+}
+function displayPath$2(root, file) {
+	const rel = relative(root, file);
+	if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return file.split(sep).join("/");
+	return rel.split(sep).join("/");
+}
+//#endregion
+//#region src/core/catalog/plural-forms.ts
+/**
+* The PO `Plural-Forms` header (PLAN §4.4 P1, INTERNALS §2.6.3). vi18n never
+* evaluates it: an ICU message carries its own plural cases, and vi18n never
+* writes gettext plurals. PO editors and `msgfmt -c` expect a real one, so the
+* writer emits the GNU gettext manual's formula for the file's language (the
+* "Plural forms" table of gettext.texi, plus Chinese), and keeps a formula a
+* tool already wrote, so vi18n and Poedit or Weblate never rewrite each
+* other's spelling of the same rule.
+*/
+const ONE = "nplurals=1; plural=0;";
+const NOT_ONE = "nplurals=2; plural=n != 1;";
+const OVER_ONE = "nplurals=2; plural=n>1;";
+const EAST_SLAVIC = "nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;";
+/** Lower-case BCP 47 tags; a region-specific row wins over its language's. */
+const FORMULAS = {
+	ja: ONE,
+	ko: ONE,
+	th: ONE,
+	vi: ONE,
+	zh: ONE,
+	bg: NOT_ONE,
+	da: NOT_ONE,
+	de: NOT_ONE,
+	el: NOT_ONE,
+	en: NOT_ONE,
+	eo: NOT_ONE,
+	es: NOT_ONE,
+	et: NOT_ONE,
+	fi: NOT_ONE,
+	fo: NOT_ONE,
+	he: NOT_ONE,
+	hu: NOT_ONE,
+	id: NOT_ONE,
+	it: NOT_ONE,
+	nb: NOT_ONE,
+	nl: NOT_ONE,
+	nn: NOT_ONE,
+	no: NOT_ONE,
+	pt: NOT_ONE,
+	sv: NOT_ONE,
+	tr: NOT_ONE,
+	fr: OVER_ONE,
+	"pt-br": OVER_ONE,
+	lv: "nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2;",
+	ga: "nplurals=3; plural=n==1 ? 0 : n==2 ? 1 : 2;",
+	ro: "nplurals=3; plural=n==1 ? 0 : (n==0 || (n%100 > 0 && n%100 < 20)) ? 1 : 2;",
+	lt: "nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2;",
+	be: EAST_SLAVIC,
+	hr: EAST_SLAVIC,
+	ru: EAST_SLAVIC,
+	sr: EAST_SLAVIC,
+	uk: EAST_SLAVIC,
+	cs: "nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;",
+	sk: "nplurals=3; plural=(n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2;",
+	pl: "nplurals=3; plural=n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;",
+	sl: "nplurals=4; plural=n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3;",
+	ar: "nplurals=6; plural=n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=11 ? 4 : 5;"
+};
+/** The formula for a language tag (`pt-BR`, `pt_BR`, `de`), or null when the table has none. */
+function pluralFormsFor(language) {
+	const subtags = language.trim().toLowerCase().replaceAll("_", "-").split("-");
+	for (let length = subtags.length; length > 0; length--) {
+		const formula = FORMULAS[subtags.slice(0, length).join("-")];
+		if (formula !== void 0) return formula;
+	}
+	return null;
+}
+//#endregion
+//#region src/core/catalog/po.ts
+/**
+* Header fields the writer always emits itself; keeping them in `extra` would
+* write them twice.
+*/
+const OWNED_HEADER_FIELDS = /* @__PURE__ */ new Set([
+	"language",
+	"content-type",
+	"x-generator",
+	"x-vi18n-id",
+	"x-vi18n-ai-model"
+]);
+const FSI = "⁨";
+const PDI = "⁩";
+const ESCAPED_SOURCE_LIKE = /^\\+source:/;
+const SIMPLE_ESCAPES = {
+	"\\": "\\",
+	"\"": "\"",
+	n: "\n",
+	t: "	",
+	r: "\r",
+	a: "\x07",
+	b: "\b",
+	f: "\f",
+	v: "\v",
+	"'": "'",
+	"?": "?"
+};
+function isOctal(code) {
+	return code >= 48 && code <= 55;
+}
+function hexValue(code) {
+	if (code >= 48 && code <= 57) return code - 48;
+	if (code >= 97 && code <= 102) return code - 87;
+	if (code >= 65 && code <= 70) return code - 55;
+	return -1;
+}
+/**
+* Decodes a PO string body (C escapes). Octal and hex escapes are bytes, so
+* runs of them are decoded together as UTF-8 (`\303\251` is `é`). Returns
+* null on an invalid escape.
+*/
+function unescapePo(body) {
+	if (!body.includes("\\")) return body;
+	let out = "";
+	let bytes = null;
+	const flush = () => {
+		if (bytes !== null) {
+			out += Buffer.from(bytes).toString("utf8");
+			bytes = null;
+		}
+	};
+	let i = 0;
+	while (i < body.length) {
+		if (body[i] !== "\\") {
+			flush();
+			const next = body.indexOf("\\", i);
+			const end = next === -1 ? body.length : next;
+			out += body.slice(i, end);
+			i = end;
+			continue;
+		}
+		const escape = body[i + 1];
+		if (escape === void 0) return null;
+		if (Object.hasOwn(SIMPLE_ESCAPES, escape)) {
+			flush();
+			out += SIMPLE_ESCAPES[escape];
+			i += 2;
+			continue;
+		}
+		if (isOctal(escape.charCodeAt(0))) {
+			let value = 0;
+			let j = i + 1;
+			while (j < body.length && j < i + 4 && isOctal(body.charCodeAt(j))) value = value * 8 + body.charCodeAt(j++) - 48;
+			(bytes ??= []).push(value & 255);
+			i = j;
+			continue;
+		}
+		if (escape === "x") {
+			let value = 0;
+			let j = i + 2;
+			while (j < body.length && j < i + 4 && hexValue(body.charCodeAt(j)) !== -1) value = value * 16 + hexValue(body.charCodeAt(j++));
+			if (j === i + 2) return null;
+			(bytes ??= []).push(value);
+			i = j;
+			continue;
+		}
+		return null;
+	}
+	flush();
+	return out;
+}
+/** Parses `"…"` (trailing blanks allowed); null when the token is not exactly one string. */
+function readString(text, from) {
+	let start = from;
+	while (start < text.length && (text[start] === " " || text[start] === "	")) start++;
+	if (text[start] !== "\"") return null;
+	let i = start + 1;
+	while (i < text.length) {
+		const ch = text[i];
+		if (ch === "\\") i += 2;
+		else if (ch === "\"") break;
+		else i++;
+	}
+	if (i >= text.length) return null;
+	for (let j = i + 1; j < text.length; j++) if (text[j] !== " " && text[j] !== "	") return null;
+	return unescapePo(text.slice(start + 1, i));
+}
+function newDraft() {
+	return {
+		raw: [],
+		comments: [],
+		contexts: [],
+		sourceNote: null,
+		refs: [],
+		flags: [],
+		flagKeys: null,
+		fuzzy: false,
+		ai: false,
+		maxLength: null,
+		msgctxt: null,
+		msgid: null,
+		plural: false,
+		msgstr: null,
+		field: null,
+		wrapped: false,
+		line: 0,
+		firstLine: 0,
+		error: null
+	};
+}
+function hasKeywords(draft) {
+	return draft.field !== null;
+}
+function parseError(line, message) {
+	return {
+		code: "catalog-parse",
+		severity: "error",
+		message,
+		line
+	};
+}
+/**
+* `#:` references: whitespace-separated, GNU's FSI…PDI isolation for names
+* with spaces, and `:line` suffixes dropped (vi18n references files only).
+*/
+function readRefs(text, into) {
+	let i = 0;
+	while (i < text.length) {
+		const ch = text[i];
+		if (ch === " " || ch === "	") {
+			i++;
+			continue;
+		}
+		let token;
+		if (ch === FSI) {
+			const end = text.indexOf(PDI, i + 1);
+			const stop = end === -1 ? text.length : end;
+			token = text.slice(i + 1, stop);
+			i = stop + 1;
+			while (i < text.length && text[i] !== " " && text[i] !== "	") i++;
+		} else {
+			let end = i;
+			while (end < text.length && text[end] !== " " && text[end] !== "	") end++;
+			token = text.slice(i, end).replace(/:\d+$/, "");
+			i = end;
+		}
+		if (token !== "") into.push(token);
+	}
+}
+function readFlags(text, line, draft) {
+	for (const part of text.split(",")) {
+		const name = part.trim();
+		if (name === "") continue;
+		if (name === "fuzzy") draft.fuzzy = true;
+		else if (name === "ai") draft.ai = true;
+		else if (name.startsWith("max-length:") && /^max-length:[1-9]\d*$/.test(name)) {
+			const value = Number(name.slice(11));
+			draft.maxLength = draft.maxLength === null ? value : Math.min(draft.maxLength, value);
+		} else {
+			const key = line + name;
+			const keys = draft.flagKeys ??= /* @__PURE__ */ new Set();
+			if (!keys.has(key)) {
+				keys.add(key);
+				draft.flags.push({
+					name,
+					line
+				});
+			}
+		}
+	}
+}
+function sortedUnique(values) {
+	if (values.length < 2) return values;
+	const sorted = values.slice().sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	let w = 1;
+	for (let r = 1; r < sorted.length; r++) if (sorted[r] !== sorted[w - 1]) sorted[w++] = sorted[r];
+	sorted.length = w;
+	return sorted;
+}
+function readHeader(msgstr, locale) {
+	const header = {
+		language: locale,
+		idScheme: null,
+		sourceLocale: null,
+		aiModel: null,
+		extra: []
+	};
+	for (const field of msgstr.split("\n")) {
+		const colon = field.indexOf(":");
+		if (colon <= 0) continue;
+		const name = field.slice(0, colon).trim();
+		const value = field.slice(colon + 1).trim();
+		const lower = name.toLowerCase();
+		if (lower === "language") {
+			if (value !== "") header.language = value;
+		} else if (lower === "x-vi18n-id") header.idScheme = value === "" ? null : value;
+		else if (lower === "x-vi18n-ai-model") header.aiModel = value === "" ? null : value;
+		else if (!OWNED_HEADER_FIELDS.has(lower)) header.extra.push([name, value]);
+	}
+	const derived = pluralFormsFor(header.language);
+	if (derived !== null) header.extra = header.extra.filter(([name, value]) => name.toLowerCase() !== "plural-forms" || value !== derived);
+	return header;
+}
+function parsePo(text, options) {
+	const { locale, layout, isSourceLocale } = options;
+	const diagnostics = [];
+	const entries = [];
+	const obsolete = [];
+	let header = null;
+	let draft = newDraft();
+	let block = null;
+	let blockHasMsgstr = false;
+	const closeBlock = () => {
+		if (block !== null) {
+			obsolete.push(block.join("\n"));
+			block = null;
+			blockHasMsgstr = false;
+		}
+	};
+	const finish = () => {
+		const done = draft;
+		if (!hasKeywords(done)) return;
+		draft = newDraft();
+		if (done.error !== null) {
+			diagnostics.push(done.error);
+			return;
+		}
+		if (done.msgid === null) {
+			diagnostics.push(parseError(done.firstLine, "entry without msgid"));
+			return;
+		}
+		if (done.plural) {
+			diagnostics.push(parseError(done.line, "gettext plural entries (msgid_plural) are not supported: write the plural as ICU in the source text"));
+			return;
+		}
+		if (done.msgstr === null) {
+			diagnostics.push(parseError(done.line, "msgid without msgstr"));
+			return;
+		}
+		if (done.msgid === "" && done.msgctxt === null && header === null && entries.length === 0) {
+			header = readHeader(done.msgstr, locale);
+			return;
+		}
+		const manual = done.msgctxt !== null && done.msgctxt.includes(".");
+		const translation = isSourceLocale ? "" : done.msgstr;
+		let source;
+		let label = null;
+		if (layout === "source") source = done.msgid;
+		else {
+			label = done.msgid;
+			source = isSourceLocale ? done.msgstr : done.sourceNote;
+		}
+		const state = translation === "" ? "untranslated" : done.ai ? "ai" : "translated";
+		entries.push({
+			manualId: manual ? done.msgctxt : null,
+			foreignContext: manual ? null : done.msgctxt,
+			label,
+			source,
+			translation,
+			state,
+			fuzzy: done.fuzzy,
+			contexts: done.contexts,
+			comments: done.comments,
+			refs: sortedUnique(done.refs),
+			maxLength: done.maxLength,
+			flags: done.flags,
+			line: done.line,
+			wrapped: done.wrapped
+		});
+	};
+	const fail = (line, message) => {
+		draft.error ??= parseError(line, message);
+	};
+	const start = text.charCodeAt(0) === 65279 ? 1 : 0;
+	const lines = (start === 0 ? text : text.slice(start)).split("\n");
+	for (let index = 0; index < lines.length; index++) {
+		const lineNo = index + 1;
+		let raw = lines[index];
+		if (raw.endsWith("\r")) raw = raw.slice(0, -1);
+		let s = 0;
+		while (s < raw.length && (raw[s] === " " || raw[s] === "	")) s++;
+		if (s === raw.length) {
+			finish();
+			closeBlock();
+			continue;
+		}
+		const line = s === 0 ? raw : raw.slice(s);
+		if (line.startsWith("#~")) {
+			finish();
+			const body = line.slice(2).trimStart();
+			const startsEntry = body.startsWith("msgid") || body.startsWith("msgctxt");
+			if (block !== null && blockHasMsgstr && startsEntry) closeBlock();
+			if (block === null) {
+				block = draft.raw;
+				draft = newDraft();
+			}
+			block.push(raw);
+			if (body.startsWith("msgstr")) blockHasMsgstr = true;
+			continue;
+		}
+		closeBlock();
+		if (line.charCodeAt(0) === 35) {
+			if (hasKeywords(draft)) finish();
+			if (draft.firstLine === 0) draft.firstLine = lineNo;
+			draft.raw.push(raw);
+			const kind = line[1];
+			const rest = line.slice(2);
+			const content = rest.startsWith(" ") ? rest.slice(1) : rest;
+			if (kind === ".") {
+				if (layout === "id" && content.startsWith("source:")) {
+					if (!isSourceLocale) {
+						const body = content.slice(content.startsWith("source: ") ? 8 : 7);
+						const note = unescapePo(body);
+						if (note === null) diagnostics.push({
+							code: "catalog-parse",
+							severity: "warning",
+							message: "invalid escape in #. source:; the note is kept as written",
+							line: lineNo
+						});
+						draft.sourceNote = note ?? body;
+					}
+				} else draft.contexts.push(layout === "id" && ESCAPED_SOURCE_LIKE.test(content) ? content.slice(1) : content);
+			} else if (kind === ":") readRefs(content, draft.refs);
+			else if (kind === ",") readFlags(content, "#,", draft);
+			else if (kind === "=") readFlags(content, "#=", draft);
+			else if (kind === "|") {} else {
+				const body = line.slice(1);
+				draft.comments.push(body.startsWith(" ") ? body.slice(1) : body);
+			}
+			continue;
+		}
+		if (line.charCodeAt(0) === 34) {
+			const value = readString(line, 0);
+			if (draft.field === null) {
+				fail(lineNo, "string continuation without a keyword");
+				draft.firstLine ||= lineNo;
+				draft.field = "msgstr";
+				continue;
+			}
+			if (value === null) {
+				fail(lineNo, "malformed string");
+				continue;
+			}
+			switch (draft.field) {
+				case "msgctxt":
+					draft.msgctxt = (draft.msgctxt ?? "") + value;
+					break;
+				case "msgid":
+					draft.msgid = (draft.msgid ?? "") + value;
+					draft.wrapped = true;
+					break;
+				case "msgstr":
+					draft.msgstr = (draft.msgstr ?? "") + value;
+					draft.wrapped = true;
+			}
+			continue;
+		}
+		const keyword = /^(msgctxt|msgid_plural|msgid|msgstr\[\d+\]|msgstr)(?=[\s"])/.exec(line);
+		if (keyword === null) {
+			if (!hasKeywords(draft)) draft.firstLine ||= lineNo;
+			draft.field ??= "msgstr";
+			fail(lineNo, `unexpected line: ${line.length > 40 ? `${line.slice(0, 40)}…` : line}`);
+			continue;
+		}
+		const word = keyword[1];
+		const field = word.startsWith("msgstr[") ? "msgstr[]" : word;
+		if ((field === "msgctxt" || field === "msgid") && (draft.msgstr !== null || draft.plural)) finish();
+		if (draft.firstLine === 0) draft.firstLine = lineNo;
+		const value = readString(line, word.length);
+		draft.field = field;
+		if (value === null) {
+			fail(lineNo, `malformed ${word} string`);
+			continue;
+		}
+		switch (field) {
+			case "msgctxt":
+				if (draft.msgctxt !== null || draft.msgid !== null) fail(lineNo, "msgctxt must come first, once");
+				draft.msgctxt = value;
+				break;
+			case "msgid":
+				if (draft.msgid !== null) fail(lineNo, "duplicate msgid");
+				draft.msgid = value;
+				draft.line = lineNo;
+				break;
+			case "msgid_plural":
+				draft.plural = true;
+				break;
+			case "msgstr":
+				if (draft.msgid === null) fail(lineNo, "msgstr without msgid");
+				if (draft.msgstr !== null) fail(lineNo, "duplicate msgstr");
+				draft.msgstr = value;
+				break;
+			case "msgstr[]": if (!draft.plural) fail(lineNo, `${word} without msgid_plural`);
+		}
+	}
+	finish();
+	closeBlock();
+	return {
+		catalog: {
+			locale,
+			layout,
+			header: header ?? {
+				language: locale,
+				idScheme: null,
+				sourceLocale: null,
+				aiModel: null,
+				extra: []
+			},
+			entries,
+			obsolete,
+			droppedObsolete: obsolete.length
+		},
+		diagnostics
+	};
+}
+//#endregion
+//#region src/core/catalog/io.ts
+/**
+* Catalog files (INTERNALS §2.6.1, §2.6.6, PLAN §5.6): one per locale,
+* source locale included. Every writer (dev, extract, translate, import,
+* restore) goes through `updateCatalogFile`, a compare-and-swap over an
+* atomic rename, so concurrent writers re-apply their change instead of
+* losing each other's.
+*/
+function catalogPath(config, locale) {
+	return config.catalogs.path.replaceAll("{locale}", locale);
+}
+/** The layout a config's catalogs use. */
+function catalogLayout(config) {
+	return config.catalogs.format === "json" ? "json" : config.catalogs.msgid;
+}
+function parseCatalog(text, options) {
+	if (options.layout === "json") return parseJsonCatalog(text, options);
+	return parsePo(text, {
+		locale: options.locale,
+		layout: options.layout,
+		isSourceLocale: options.isSourceLocale
+	});
+}
+/** sha256 hex of a file's bytes: the compare-and-swap token. */
+function contentHash(data) {
+	return hash("sha256", data, "hex");
+}
+function displayPath$1(root, file) {
+	const rel = relative(root, file);
+	if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return file.split(sep).join("/");
+	return rel.split(sep).join("/");
+}
+function isMissing(error) {
+	return error?.code === "ENOENT";
+}
+async function readOptional(path) {
+	try {
+		return await readFile(path);
+	} catch (error) {
+		if (isMissing(error)) return null;
+		throw diagnosticError({
+			code: "catalog-parse",
+			severity: "error",
+			message: `cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`,
+			file: path
+		});
+	}
+}
+const UTF8 = new TextDecoder("utf-8", { fatal: true });
+/** Labels that mean UTF-8; `CHARSET` is the placeholder of an unfilled POT header. */
+const UTF8_LABELS = /* @__PURE__ */ new Set([
+	"utf-8",
+	"utf8",
+	"unicode-1-1-utf-8",
+	"charset"
+]);
+/**
+* The charset a PO header declares. GNU tools only write ASCII-compatible
+* charsets, so the header can be read as latin1 before the encoding is known.
+*/
+function poCharset(bytes) {
+	const head = Buffer.from(bytes.buffer, bytes.byteOffset, Math.min(bytes.length, 8192)).toString("latin1").split(/\r?\n[ \t]*\r?\n/, 1)[0];
+	if (!/^[ \t]*msgid[ \t]+""/m.test(head)) return null;
+	return /^[ \t]*"Content-Type:[^"\n]*?charset=([^"\s;\\]+)/im.exec(head)?.[1] ?? null;
+}
+/** 1-based line of the first byte sequence that is not UTF-8 (`\n` never occurs inside one). */
+function firstInvalidLine(bytes) {
+	let start = 0;
+	for (let line = 1;; line++) {
+		const end = bytes.indexOf(10, start);
+		const stop = end === -1 ? bytes.length : end;
+		try {
+			UTF8.decode(bytes.subarray(start, stop));
+		} catch {
+			return line;
+		}
+		if (end === -1) return line;
+		start = end + 1;
+	}
+}
+/**
+* Catalog bytes as text. A PO file in another charset that GNU tools wrote
+* is transcoded, and the next write saves it as UTF-8. Bytes that do not
+* decode come back as a `catalog-parse` error with lossily decoded text: the
+* text keeps the rest of the file readable, the error stops any write that
+* would persist the replacement characters.
+*/
+function decodeCatalog(bytes, layout) {
+	const charset = layout === "json" ? null : poCharset(bytes);
+	const lossy = () => Buffer.from(bytes.buffer, bytes.byteOffset, bytes.length).toString("utf8");
+	if (charset === null || UTF8_LABELS.has(charset.toLowerCase())) try {
+		return {
+			text: UTF8.decode(bytes),
+			diagnostic: null
+		};
+	} catch {
+		return {
+			text: lossy(),
+			diagnostic: {
+				code: "catalog-parse",
+				severity: "error",
+				message: "the file is not valid UTF-8; re-save it as UTF-8",
+				line: firstInvalidLine(bytes)
+			}
+		};
+	}
+	let decoder;
+	try {
+		decoder = new TextDecoder(charset, { fatal: true });
+	} catch {
+		return {
+			text: lossy(),
+			diagnostic: {
+				code: "catalog-parse",
+				severity: "error",
+				message: `unsupported charset ${charset} in Content-Type; convert the file to UTF-8`
+			}
+		};
+	}
+	try {
+		return {
+			text: decoder.decode(bytes),
+			diagnostic: null
+		};
+	} catch {
+		return {
+			text: lossy(),
+			diagnostic: {
+				code: "catalog-parse",
+				severity: "error",
+				message: `the file is not valid ${charset} as its Content-Type declares; fix its encoding`
+			}
+		};
+	}
+}
+function severityOf$1(level) {
+	return level === "off" ? null : level === "warn" ? "warning" : "error";
+}
+/**
+* Sources that do not parse leave their entry without a key (INTERNALS
+* §2.6.2); they are reported here, once per load, on the entry's line. The
+* advice is what clears the report in every case: `vi18n extract` keeps a
+* generated entry it cannot match to code, and an `extraction.keep` id's.
+*/
+function invalidSources(catalog, codec, isSourceLocale, severity) {
+	if (catalog.layout === "id" && !isSourceLocale) return [];
+	const found = [];
+	for (const entry of catalog.entries) {
+		if (entry.source === null || entry.foreignContext !== null) continue;
+		if (entryCanonical(entry, codec) !== null) continue;
+		try {
+			codec.canonicalize(entry.source);
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			const diagnostic = {
+				code: "catalog-invalid-translation",
+				severity,
+				message: `the source ${JSON.stringify(entry.source)} is not valid ICU (${reason}); fix its source or delete the entry`,
+				locale: catalog.locale
+			};
+			if (entry.manualId !== null) diagnostic.id = entry.manualId;
+			if (entry.line > 0) diagnostic.line = entry.line;
+			found.push(diagnostic);
+		}
+	}
+	return found;
+}
+/**
+* Reads every locale's catalog (default: `config.locales`). Missing files
+* load as `catalog: null`. Entries are returned as read, duplicates
+* included: `resolveDuplicates` is the read-side pick.
+*/
+async function loadCatalogSet(config, codec, locales) {
+	const layout = catalogLayout(config);
+	const wanted = locales ?? config.locales;
+	const invalid = severityOf$1(config.strict.invalid);
+	const loaded = await Promise.all(wanted.map(async (locale) => {
+		const path = catalogPath(config, locale);
+		const bytes = await readOptional(path);
+		if (bytes === null) return {
+			catalog: {
+				locale,
+				path,
+				catalog: null,
+				hash: null
+			},
+			diagnostics: []
+		};
+		const isSourceLocale = locale === config.sourceLocale;
+		const decoded = decodeCatalog(bytes, layout);
+		const read = parseCatalog(decoded.text, {
+			locale,
+			layout,
+			isSourceLocale
+		});
+		const diagnostics = read.diagnostics;
+		if (decoded.diagnostic !== null) diagnostics.unshift(decoded.diagnostic);
+		if (invalid !== null) diagnostics.push(...invalidSources(read.catalog, codec, isSourceLocale, invalid));
+		const file = displayPath$1(config.root, path);
+		for (const diagnostic of diagnostics) {
+			diagnostic.file ??= file;
+			diagnostic.locale ??= locale;
+		}
+		return {
+			catalog: {
+				locale,
+				path,
+				catalog: read.catalog,
+				hash: contentHash(bytes)
+			},
+			diagnostics
+		};
+	}));
+	const set = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	for (const item of loaded) {
+		set.set(item.catalog.locale, item.catalog);
+		diagnostics.push(...item.diagnostics);
+	}
+	if (config.extraction.dependencies.length > 0) diagnostics.push(...await attachLibraryCatalogs(set, config, codec, wanted));
+	return {
+		set,
+		diagnostics
+	};
+}
+//#endregion
+//#region src/core/id/hash.ts
+/**
+* Ids (INTERNALS §2.2.1, §2.2.3, PLAN §5.5). An id depends only on its own
+* canonical text and `ids.length`, so every process computes it alone and
+* nothing is ever recorded. Frozen by the golden vectors: changing anything
+* here re-keys every catalog.
+*/
+/**
+* Lingui's construction with an empty context (`text + "\u001F"`), so a Lingui
+* 6 id of the same canonical text is a prefix of the vi18n id.
+*/
+function sourceHash(canonical) {
+	return hash("sha256", canonical + "", "base64url");
+}
+function idScheme(length) {
+	return `sha256-b64u-${length}-v2`;
+}
+const SCHEME = /^sha256-b64u-(8|9|1[0-6])-v2$/;
+/** The id length a catalog header records, or null for anything vi18n did not write. */
+function parseIdScheme(tag) {
+	const match = SCHEME.exec(tag);
+	return match === null ? null : {
+		length: Number(match[1]),
+		version: 2
+	};
+}
+/** The base64url alphabet has no `.`, so a `.` is what marks a manual id. */
+function isManualId(id) {
+	return id.includes(".");
+}
+/** Characters that need no escaping in JS, JSON, PO, file names or URLs, with at least one `.`. */
+const MANUAL_ID = /^[A-Za-z0-9_:-]+(\.[A-Za-z0-9_:-]+)+$/;
+function isValidManualId(id) {
+	return MANUAL_ID.test(id);
+}
+//#endregion
+//#region src/core/codec.ts
+/**
+* The one place that turns source text into ids (INTERNALS §2.2). Extract,
+* catalogs and compilation see the same message many times per run, so parses,
+* canonical forms and hashes are memoised per string.
+*/
+/**
+* Memo entries past this count are dropped all at once: a long dev session
+* sees every edit of every message, while one scan of a large project needs
+* the whole set warm.
+*/
+const MEMO_LIMIT = 2e5;
+function createCodec(idLength) {
+	if (!Number.isInteger(idLength) || idLength < 8 || idLength > 16) throw diagnosticError({
+		code: "config-invalid",
+		severity: "error",
+		message: `ids.length must be an integer from 8 to 16, not ${String(idLength)}`
+	});
+	const parsed = /* @__PURE__ */ new Map();
+	const hashes = /* @__PURE__ */ new Map();
+	const entry = (source) => {
+		let found = parsed.get(source);
+		if (found === void 0) {
+			found = {
+				ast: null,
+				error: null,
+				canonical: null
+			};
+			try {
+				const normalized = normalizeSource(source);
+				found.ast = isPlainText(normalized) ? normalized === "" ? [] : [{
+					type: "literal",
+					value: normalized
+				}] : parseSource(normalized);
+			} catch (error) {
+				if (!isDiagnosticError(error)) throw error;
+				found.error = error;
+			}
+			if (parsed.size >= MEMO_LIMIT) parsed.clear();
+			parsed.set(source, found);
+		}
+		return found;
+	};
+	const hashOf = (canonical) => {
+		let found = hashes.get(canonical);
+		if (found === void 0) {
+			found = sourceHash(canonical);
+			if (hashes.size >= MEMO_LIMIT) hashes.clear();
+			hashes.set(canonical, found);
+		}
+		return found;
+	};
+	return {
+		idLength,
+		idScheme: idScheme(idLength),
+		canonicalize(source) {
+			const found = parsed.get(source);
+			if (found === void 0) {
+				const normalized = normalizeSource(source);
+				if (isPlainText(normalized)) return normalized;
+			}
+			const memo = found ?? entry(source);
+			if (memo.error !== null) throw memo.error;
+			return memo.canonical ??= printICU(memo.ast);
+		},
+		parse(source) {
+			const memo = entry(source);
+			if (memo.error !== null) throw memo.error;
+			return memo.ast;
+		},
+		sourceHash: hashOf,
+		label(canonical) {
+			return hashOf(canonical).slice(0, idLength);
+		}
+	};
+}
+//#endregion
+//#region src/core/catalog/duplicates.ts
+const RANK = {
+	translated: 2,
+	ai: 1,
+	untranslated: 0
+};
+/** Entries grouped by key; only keys seen more than once. Null when there are none. */
+function duplicateGroups(catalog, codec) {
+	const first = /* @__PURE__ */ new Map();
+	let groups = null;
+	const entries = catalog.entries;
+	for (let i = 0; i < entries.length; i++) {
+		const key = entryKey(entries[i], catalog.layout, codec);
+		if (key === null) continue;
+		const seen = first.get(key);
+		if (seen === void 0) {
+			first.set(key, i);
+			continue;
+		}
+		groups ??= /* @__PURE__ */ new Map();
+		const group = groups.get(key);
+		if (group === void 0) groups.set(key, [seen, i]);
+		else group.push(i);
+	}
+	return groups;
+}
+/** `translated` over `ai` over `untranslated`, then the first in the file. */
+function winnerOf(entries, indexes) {
+	let best = indexes[0];
+	for (const index of indexes) if (RANK[entries[index].state] > RANK[entries[best].state]) best = index;
+	return best;
+}
+/**
+* The read-side pick: one entry per key, the losers dropped. Returns the
+* input catalog itself when it has no duplicates, so the common case
+* allocates nothing.
+*/
+function resolveDuplicates(catalog, codec) {
+	const groups = duplicateGroups(catalog, codec);
+	if (groups === null) return {
+		catalog,
+		duplicates: []
+	};
+	const entries = catalog.entries;
+	const dropped = /* @__PURE__ */ new Set();
+	const duplicates = [];
+	for (const [key, indexes] of groups) {
+		const winner = winnerOf(entries, indexes);
+		const lines = [entries[winner].line];
+		for (const index of indexes) {
+			if (index === winner) continue;
+			dropped.add(index);
+			lines.push(entries[index].line);
+		}
+		duplicates.push({
+			locale: catalog.locale,
+			key,
+			lines
+		});
+	}
+	return {
+		catalog: {
+			...catalog,
+			entries: entries.filter((_, index) => !dropped.has(index))
+		},
+		duplicates
+	};
+}
+/**
+* The `catalog-duplicate` warnings for {@link resolveDuplicates}' reports,
+* for callers that surface them (`compileLocales`, `check`, `status`).
+*/
+function duplicateDiagnostics(duplicates, file) {
+	return duplicates.map((duplicate) => {
+		const [winner, ...others] = duplicate.lines;
+		const diagnostic = {
+			code: "catalog-duplicate",
+			severity: "warning",
+			message: `${duplicate.key} appears ${duplicate.lines.length} times; the entry on line ${winner} is used and vi18n extract merges the copies (other lines: ${others.join(", ")})`,
+			locale: duplicate.locale,
+			id: duplicate.key
+		};
+		if (file !== void 0) diagnostic.file = file;
+		if (winner !== void 0 && winner > 0) diagnostic.line = winner;
+		return diagnostic;
+	});
+}
+//#endregion
+//#region src/core/compile/fallback.ts
+const PSEUDO_LOCALES$1 = /* @__PURE__ */ new Set(["en-XA", "ar-XB"]);
+/**
+* The locales whose catalogs supply `locale`'s messages, most specific first
+* and always ending with `sourceLocale` (INTERNALS §2.8.1).
+*
+* Order: `locale`; its truncations at `-` boundaries that are configured
+* (`zh-Hant-TW` → `zh-Hant` → `zh`); then, for each of those in order, its
+* configured `fallbacks`; then `sourceLocale`. Duplicates keep their first
+* position, except `sourceLocale`, which only ever comes last: its messages
+* compile from code and are always complete, so a locale written after it in
+* `fallbacks` (`de: ["en", "fr"]`) would be unreachable for any consumer that
+* stops at the source, while `compileLocales` would still consult it. The
+* source locale's own chain is itself alone. Configured fallbacks are not
+* followed transitively: the chain is what the user wrote for the locale and
+* its ancestors, nothing they have to trace through other entries.
+*/
+function fallbackChain(locale, config) {
+	const source = config.sourceLocale;
+	if (locale === source) return [locale];
+	if (PSEUDO_LOCALES$1.has(locale)) return [locale, source];
+	const chain = [locale];
+	for (let end = locale.lastIndexOf("-"); end > 0; end = locale.lastIndexOf("-", end - 1)) {
+		const ancestor = locale.slice(0, end);
+		if (ancestor !== source && config.locales.includes(ancestor) && !chain.includes(ancestor)) chain.push(ancestor);
+	}
+	const derived = chain.length;
+	for (let i = 0; i < derived; i++) {
+		const member = chain[i];
+		if (!Object.hasOwn(config.fallbacks, member)) continue;
+		for (const next of config.fallbacks[member]) if (next !== source && !chain.includes(next)) chain.push(next);
+	}
+	chain.push(source);
+	return chain;
+}
+//#endregion
+//#region src/core/compile/locales.ts
+/**
+* Locale compilation (INTERNALS §2.8.2, PLAN §5.5 D10, §5.9): catalogs and
+* code messages become one IR map per locale, fallbacks applied, with the
+* reason every untranslated id fell back. The build, `vi18n compile`, dev
+* catalog modules, `check` and `status` all read translations through here,
+* so "what ships" has one definition.
+*/
+const PSEUDO_LOCALES = /* @__PURE__ */ new Set(["en-XA", "ar-XB"]);
+/** Ids listed in `catalog-missing-translation`; the rest are only counted. */
+const MISSING_LISTED = 20;
+const NO_ENTRY = {
+	ok: false,
+	reason: "no-entry"
+};
+const SCHEME_MISMATCH = {
+	ok: false,
+	reason: "scheme-mismatch"
+};
+function compileLocales(input) {
+	const { config, codec, messages, catalogs } = input;
+	const sourceFallback = input.sourceFallback ?? true;
+	const layout = catalogLayout(config);
+	const sourceLocale = config.sourceLocale;
+	const invalidSeverity = severityOf(config.strict.invalid);
+	const missingSeverity = severityOf(config.strict.missing);
+	const prepared = /* @__PURE__ */ new Map();
+	const prepare = (locale) => {
+		let found = prepared.get(locale);
+		if (found === void 0) {
+			found = prepareCatalog(catalogs, locale, layout, codec, config.root);
+			prepared.set(locale, found);
+		}
+		return found;
+	};
+	let sink = [];
+	const report = (catalog) => {
+		if (catalog !== null && catalog.pending !== null) {
+			for (const diagnostic of catalog.pending) sink.push(diagnostic);
+			catalog.pending = null;
+		}
+		return catalog;
+	};
+	const lookup = (catalog, id, message) => {
+		if (catalog === null) return NO_ENTRY;
+		const cached = catalog.lookups.get(id);
+		if (cached !== void 0) return cached;
+		const result = evaluate(catalog, id, message);
+		catalog.lookups.set(id, result);
+		return result;
+	};
+	const libraries = /* @__PURE__ */ new Map();
+	/** A package's language, for its catalogs that differ from the app's (§2.6.11). */
+	const librarySource = /* @__PURE__ */ new Map();
+	const librariesOf = (locale) => {
+		let found = libraries.get(locale);
+		if (found === void 0) {
+			found = [];
+			for (const loaded of catalogs.get(locale)?.libraries ?? []) {
+				const one = prepareCatalog(/* @__PURE__ */ new Map([[locale, loaded]]), locale, layout, codec, config.root);
+				if (one === null) continue;
+				const prepared = {
+					...one,
+					pending: null,
+					library: true
+				};
+				if (loaded.librarySource !== void 0) librarySource.set(prepared, loaded.librarySource);
+				found.push(prepared);
+			}
+			libraries.set(locale, found);
+		}
+		return found;
+	};
+	/** A chain step: the app's catalog, then each library's for the same locale. */
+	const step = (catalog, locale, id, message) => {
+		const own = lookup(catalog, id, message);
+		if (own.ok) return own;
+		for (const library of librariesOf(locale)) {
+			const found = lookup(library, id, message);
+			if (found.ok) return found;
+		}
+		return own;
+	};
+	const evaluate = (catalog, id, message) => {
+		if (catalog.schemeMismatch && (layout === "id" || !message.manual)) return SCHEME_MISMATCH;
+		const entry = catalog.index.get(id);
+		if (entry === void 0) return NO_ENTRY;
+		const usable = usableTranslation(entry, layout, message, codec, catalog.locale);
+		if (usable.ok) return {
+			ok: true,
+			ir: compileMessage(usable.parsed),
+			state: entry.state === "ai" ? "ai" : "translated"
+		};
+		if (catalog.library) return {
+			ok: false,
+			reason: usable.reason
+		};
+		if (usable.reason === "invalid" && invalidSeverity !== null) sink.push(invalidDiagnostic(catalog, entry, id, usable.diagnostics, invalidSeverity));
+		else if (usable.reason === "source-mismatch" && entry.manualId !== null) sink.push(sourceMismatchDiagnostic(catalog, entry, id, message, layout));
+		return {
+			ok: false,
+			reason: usable.reason
+		};
+	};
+	const sourceIRs = /* @__PURE__ */ new Map();
+	const sourceIR = (id, message) => {
+		let ir = sourceIRs.get(id);
+		if (ir === void 0) {
+			ir = parseOrReport(codec, message, sink, (ast) => compileMessage(ast));
+			sourceIRs.set(id, ir);
+		}
+		return ir;
+	};
+	const all = withKeep(messages, input.keep ?? config.extraction.keep, {
+		config,
+		codec,
+		layout,
+		catalogs,
+		prepare,
+		sink: (diagnostic) => sink.push(diagnostic)
+	});
+	const keepSet = new Set(input.keep ?? config.extraction.keep);
+	const preamble = sink;
+	const result = /* @__PURE__ */ new Map();
+	for (const locale of input.locales) {
+		const chain = fallbackChain(locale, config);
+		const compiled = {
+			locale,
+			chain,
+			messages: /* @__PURE__ */ new Map(),
+			status: /* @__PURE__ */ new Map(),
+			labels: /* @__PURE__ */ new Map(),
+			diagnostics: result.size === 0 ? preamble : []
+		};
+		sink = compiled.diagnostics;
+		result.set(locale, compiled);
+		if (PSEUDO_LOCALES.has(locale)) {
+			compilePseudo(compiled, locale, all, codec);
+			continue;
+		}
+		if (locale === sourceLocale) {
+			report(prepare(locale));
+			const status = {
+				state: "translated",
+				from: sourceLocale
+			};
+			const foreign = librariesOf(locale);
+			for (const [id, message] of all) {
+				let ir = null;
+				for (const library of foreign) {
+					const found = lookup(library, id, message);
+					if (found.ok) {
+						ir = found.ir;
+						break;
+					}
+				}
+				ir ??= sourceIR(id, message);
+				if (ir === null) continue;
+				compiled.messages.set(id, ir);
+				compiled.status.set(id, status);
+				if (message.manual) compiled.labels.set(id, message.label);
+			}
+			continue;
+		}
+		const own = report(prepare(locale));
+		const walk = [];
+		for (let i = 1; i < chain.length; i++) {
+			const member = chain[i];
+			if (member !== sourceLocale) walk.push(report(prepare(member)));
+		}
+		const walkLocales = chain.slice(1).filter((member) => member !== sourceLocale);
+		const translated = {
+			state: "translated",
+			from: locale
+		};
+		const ai = {
+			state: "ai",
+			from: locale
+		};
+		const missing = /* @__PURE__ */ new Map();
+		let missingCount = 0;
+		const missingIds = [];
+		for (const [id, message] of all) {
+			const mine = step(own, locale, id, message);
+			if (mine.ok) {
+				compiled.messages.set(id, mine.ir);
+				compiled.status.set(id, mine.state === "ai" ? ai : translated);
+				if (message.manual) compiled.labels.set(id, message.label);
+				continue;
+			}
+			missingCount++;
+			if (missingIds.length < MISSING_LISTED) missingIds.push(id);
+			let from = sourceLocale;
+			let ir = null;
+			for (let i = 0; i < walk.length; i++) {
+				const found = step(walk[i], walkLocales[i], id, message);
+				if (found.ok) {
+					ir = found.ir;
+					from = walkLocales[i];
+					break;
+				}
+			}
+			if (ir === null) for (const library of librariesOf(sourceLocale)) {
+				if (librarySource.get(library) === locale) continue;
+				const found = lookup(library, id, message);
+				if (found.ok) {
+					ir = found.ir;
+					break;
+				}
+			}
+			const suppliedByEntry = ir !== null;
+			if (ir === null && (sourceFallback || keepSet.has(id))) ir = sourceIR(id, message);
+			if (ir !== null) compiled.messages.set(id, ir);
+			const statusKey = `${from}\0${mine.reason}`;
+			let status = missing.get(statusKey);
+			if (status === void 0) {
+				status = {
+					state: "missing",
+					from,
+					reason: mine.reason
+				};
+				missing.set(statusKey, status);
+			}
+			compiled.status.set(id, status);
+			if (message.manual) {
+				const label = suppliedByEntry ? message.label : ownLabel(own, id, layout, codec);
+				if (label !== null) compiled.labels.set(id, label);
+				else if (ir !== null) compiled.labels.set(id, message.label);
+			}
+		}
+		if (missingCount > 0 && missingSeverity !== null) {
+			const more = missingCount > missingIds.length ? ", …" : "";
+			compiled.diagnostics.push({
+				code: "catalog-missing-translation",
+				severity: missingSeverity,
+				message: `${missingCount} ${missingCount === 1 ? "message has" : "messages have"} no usable ${locale} translation (${missingIds.join(", ")}${more}); ${missingCount === 1 ? "it falls" : "they fall"} back along ${chain.join(" → ")}`,
+				locale,
+				...own === null ? {} : { file: own.file }
+			});
+		}
+	}
+	return result;
+}
+function compilePseudo(compiled, locale, messages, codec) {
+	const status = {
+		state: "translated",
+		from: locale
+	};
+	for (const [id, message] of messages) {
+		const ir = parseOrReport(codec, message, compiled.diagnostics, (ast) => compileMessage(pseudoLocalize(ast, locale)));
+		if (ir === null) continue;
+		compiled.messages.set(id, ir);
+		compiled.status.set(id, status);
+		if (message.manual) compiled.labels.set(id, message.label);
+	}
+}
+function parseOrReport(codec, message, sink, build) {
+	try {
+		return build(codec.parse(message.canonical));
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+		sink.push({
+			...error.diagnostic,
+			id: error.diagnostic.id ?? message.id
+		});
+		return null;
+	}
+}
+function severityOf(level) {
+	return level === "off" ? null : level === "warn" ? "warning" : "error";
+}
+function displayPath(root, file) {
+	const rel = relative(root, file);
+	if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return file.split(sep).join("/");
+	return rel.split(sep).join("/");
+}
+function prepareCatalog(catalogs, locale, layout, codec, root) {
+	const loaded = catalogs.get(locale);
+	if (loaded === void 0 || loaded.catalog === null) return null;
+	const file = displayPath(root, loaded.path);
+	const { catalog, duplicates } = resolveDuplicates(loaded.catalog, codec);
+	const pending = duplicateDiagnostics(duplicates, file);
+	const index = /* @__PURE__ */ new Map();
+	for (const entry of catalog.entries) {
+		const key = entryKey(entry, layout, codec);
+		if (key !== null) index.set(key, entry);
+	}
+	const recorded = catalog.header.idScheme;
+	const schemeMismatch = layout !== "source" && recorded !== null && recorded !== codec.idScheme;
+	if (schemeMismatch) pending.push(schemeDiagnostic(recorded, codec, layout, locale, file));
+	return {
+		locale,
+		file,
+		index,
+		schemeMismatch,
+		pending: pending.length > 0 ? pending : null,
+		lookups: /* @__PURE__ */ new Map(),
+		library: false
+	};
+}
+function schemeDiagnostic(recorded, codec, layout, locale, file) {
+	const old = parseIdScheme(recorded);
+	return {
+		code: "id-scheme-mismatch",
+		severity: "error",
+		message: old !== null ? `ids.length changed from ${old.length} to ${codec.idLength}: run vi18n extract to re-key` : `${layout === "json" ? "idScheme" : "X-Vi18n-Id"} is ${JSON.stringify(recorded)}, not ${codec.idScheme}: run vi18n extract to re-key`,
+		locale,
+		file
+	};
+}
+function invalidDiagnostic(catalog, entry, id, found, severity) {
+	const first = found[0];
+	const reason = first === void 0 ? "it does not validate" : found.length === 1 ? first.message : `${first.message}, and ${found.length - 1} more`;
+	const diagnostic = {
+		code: "catalog-invalid-translation",
+		severity,
+		message: `${id}: the ${catalog.locale} translation is not used (${reason}); fix it or clear it`,
+		file: catalog.file,
+		locale: catalog.locale,
+		id
+	};
+	if (entry.line > 0) diagnostic.line = entry.line;
+	if (found.length > 0) diagnostic.related = found.map((inner) => ({
+		file: catalog.file,
+		...inner.line === void 0 ? {} : { line: inner.line },
+		message: `${inner.code}: ${inner.message}`
+	}));
+	return diagnostic;
+}
+function sourceMismatchDiagnostic(catalog, entry, id, message, layout) {
+	const old = entry.source ?? (layout === "id" ? entry.label : null);
+	const was = old === null ? "" : ` is for ${JSON.stringify(old)}`;
+	const diagnostic = {
+		code: "catalog-source-mismatch",
+		severity: "info",
+		message: `${id}: the ${catalog.locale} translation${was}, the code says ${JSON.stringify(message.canonical)}; run vi18n extract`,
+		file: catalog.file,
+		locale: catalog.locale,
+		id
+	};
+	if (entry.line > 0) diagnostic.line = entry.line;
+	return diagnostic;
+}
+/** The label of the source a locale's own manual entry was made from, valid or not. */
+function ownLabel(own, id, layout, codec) {
+	const entry = own?.index.get(id);
+	if (entry === void 0) return null;
+	if (layout === "id") return entry.label;
+	if (entry.source === null) return null;
+	try {
+		return codec.label(codec.canonicalize(entry.source));
+	} catch (error) {
+		if (isDiagnosticError(error)) return null;
+		throw error;
+	}
+}
+/**
+* The messages plus `keep` ids no message declares, whose identity comes from
+* their catalog entries (INTERNALS §2.8.2): the source locale's entry first
+* (in the `"id"` layout its `msgstr` is the only real source), then the other
+* locales in config order. A keep id without any entry is `keep-missing-entry`.
+*/
+function withKeep(messages, keep, context) {
+	let undeclared = null;
+	for (const id of keep) if (!messages.has(id) && (undeclared === null || !undeclared.includes(id))) (undeclared ??= []).push(id);
+	if (undeclared === null) return messages;
+	const { config, codec, catalogs } = context;
+	const sourceCatalog = catalogs.get(config.sourceLocale);
+	const sourceFile = sourceCatalog === void 0 ? void 0 : displayPath(config.root, sourceCatalog.path);
+	const all = new Map(messages);
+	const order = [config.sourceLocale, ...config.locales.filter((l) => l !== config.sourceLocale)];
+	for (const id of undeclared) {
+		let found = false;
+		let identity = null;
+		for (const locale of order) {
+			const entry = context.prepare(locale)?.index.get(id);
+			if (entry === void 0) continue;
+			found = true;
+			if (entry.source === null) continue;
+			identity = keepIdentity(id, entry.source, codec);
+			if (identity !== null) break;
+		}
+		if (identity !== null) {
+			all.set(id, identity);
+			continue;
+		}
+		context.sink({
+			code: "keep-missing-entry",
+			severity: "error",
+			message: found ? `extraction.keep lists ${id}, but no catalog entry for it has valid source text; run vi18n extract or fix the entry` : `extraction.keep lists ${id}, but no catalog has an entry for it; declare it with msg() in code or add it to the ${config.sourceLocale} catalog`,
+			id,
+			...sourceFile === void 0 ? {} : { file: sourceFile }
+		});
+	}
+	return all;
+}
+function keepIdentity(id, source, codec) {
+	let canonical;
+	try {
+		canonical = codec.canonicalize(source);
+	} catch (error) {
+		if (isDiagnosticError(error)) return null;
+		throw error;
+	}
+	const sourceHash = codec.sourceHash(canonical);
+	return {
+		id,
+		manual: isManualId(id),
+		canonical,
+		sourceHash,
+		label: sourceHash.slice(0, codec.idLength)
+	};
+}
+//#endregion
+//#region src/config/types.ts
+/** The only config file name (revision 4.2). */
+const CONFIG_FILE = "vi18n.config.ts";
+/** Import sources that always apply; `extraction.importSources` is appended to them. */
+const DEFAULT_IMPORT_SOURCES = ["@menapo/vi18n", "@menapo/vi18n/server"];
+/** Valid range of `ids.length`. */
+const ID_LENGTH = {
+	min: 8,
+	max: 16,
+	default: 12
+};
+/**
+* Defaults (PLAN §5.7). Relative paths here are resolved against the config
+* directory; `catalogs.path` becomes `locales/{locale}.json` when only
+* `format: "json"` is given.
+*/
+const DEFAULT_CONFIG = {
+	sourceLocale: "en",
+	locales: ["en"],
+	pseudoLocales: [],
+	fallbacks: {},
+	project: {
+		include: ["src"],
+		extensions: [
+			".js",
+			".jsx",
+			".mjs",
+			".ts",
+			".tsx",
+			".mts",
+			".svelte",
+			".vue",
+			".astro",
+			".mdx"
+		],
+		exclude: [
+			"node_modules",
+			"/dist",
+			"/build",
+			"**/*.test.*",
+			"**/*.spec.*",
+			"**/__tests__/**"
+		]
+	},
+	extraction: {
+		importSources: [...DEFAULT_IMPORT_SOURCES],
+		aliases: [],
+		globals: [],
+		keep: [],
+		dependencies: []
+	},
+	ids: { length: ID_LENGTH.default },
+	catalogs: {
+		format: "po",
+		path: "locales/{locale}.po",
+		msgid: "source",
+		icuFlag: false
+	},
+	output: {
+		split: {
+			shared: "per-set",
+			dupBelow: 1024,
+			minBytes: 1024,
+			maxBundlesPerRoot: null
+		},
+		guard: "auto",
+		manifestPath: "vi18n/{locale}/manifest.json",
+		manifest: "data",
+		baseEntries: [],
+		compactIds: false,
+		perLocale: false
+	},
+	routing: {
+		strategy: [
+			"url",
+			"cookie",
+			"header",
+			"default"
+		],
+		routeStrategies: {},
+		url: "prefix_except_default",
+		redirectRoot: false,
+		propagate: "header",
+		switch: "in-place",
+		cookie: {
+			name: "vi18n_locale",
+			maxAge: 31536e3
+		},
+		base: null,
+		paths: {},
+		domains: {}
+	},
+	ssr: {
+		timeZone: "UTC",
+		timeZoneFrom: {},
+		payload: "bundles",
+		catalogs: "auto",
+		maxLoadedLocales: 8,
+		normalizeSpaces: true
+	},
+	ai: {
+		provider: "gemini",
+		model: "gemini-3.8-flash",
+		exclude: [],
+		glossary: {},
+		doNotTranslate: [],
+		tone: {},
+		description: null,
+		apiKeyEnv: "GEMINI_API_KEY",
+		batchSize: 60,
+		concurrency: 4,
+		dev: false
+	},
+	defaults: { tags: {} },
+	devtools: false,
+	strict: {
+		missing: "warn",
+		invalid: "error",
+		moduleScope: "warn"
+	}
+};
+//#endregion
+//#region src/core/config/exclude.ts
+/**
+* `ai.exclude` entries (PLAN §4.6, §5.20; INTERNALS §2.15): a configured
+* locale, a message id, or a glob over the config-relative files that use a
+* message. One list keeps the config short, so the kind is read from the
+* entry: the loader rejects what fits none, and `vi18n translate` matches
+* with the same reading.
+*/
+/** Everything a message id may hold: base64url, plus a manual id's `.` and `:`. */
+const ID_CHARACTERS = /^[A-Za-z0-9_:.-]+$/;
+const BASE64URL = /^[A-Za-z0-9_-]+$/;
+/**
+* The kind of an entry, or null when it is none. A glob is anything with a
+* character no id or locale has, and must contain `/`, `*` or `?`: a bare
+* `legal.tsx` reads as the manual id it also is, so a file at the root is
+* written `./legal.tsx` or `**\/legal.tsx`.
+*/
+function excludeKind(entry, locales, idLength) {
+	if (!ID_CHARACTERS.test(entry)) return /[/*?]/.test(entry) ? "glob" : null;
+	if (locales.includes(entry)) return "locale";
+	if (isValidManualId(entry)) return "id";
+	return entry.length === idLength && BASE64URL.test(entry) ? "id" : null;
+}
+//#endregion
+//#region src/core/config/schema.ts
+/**
+* The zod 4 schema of `vi18n.config.ts` (PLAN §5.7, INTERNALS §2.7.1). It
+* checks shapes and per-field rules only; rules that relate two keys
+* (`sourceLocale` ∈ `locales`, fallbacks, pseudo-locales, `ai.exclude`) need
+* the defaults applied first and live in `crossFieldProblems`, so a config
+* that leaves `locales` out is judged against `[sourceLocale]`.
+*
+* Every key is optional: defaults are applied by `resolveConfig`, never by
+* zod, so the parsed value still tells which keys the user wrote.
+*/
+/**
+* `TIME_ZONE_COOKIE` of `src/server/types.ts`, which core may not import
+* (INTERNALS §0); the schema tests check the two agree.
+*/
+const TIME_ZONE_COOKIE = "vi18n_tz";
+/** Problem with a locale tag, or null when it is valid and canonical. */
+function localeProblem(tag) {
+	let canonical;
+	try {
+		canonical = Intl.getCanonicalLocales(tag)[0];
+	} catch {
+		return `${JSON.stringify(tag)} is not a valid BCP 47 locale tag`;
+	}
+	if (canonical !== tag) return `${JSON.stringify(tag)} is not canonical (write ${JSON.stringify(canonical)})`;
+	return null;
+}
+const IANA_ZONE = "an IANA time zone name such as \"Europe/Berlin\"";
+/**
+* Problem with `ssr.timeZone`, or null. The rule is `isTimeZone` of
+* `src/server/catalogs.ts`, which core may not import (the schema tests check
+* the two agree): a name starts with a letter, has at most 64 characters and
+* Intl accepts it. UTC offsets, which Intl accepts too, are refused there
+* (each spelling would get its own formatter in caches keyed by zone), so a
+* config naming one must fail here rather than in `registerCatalogs()`.
+*/
+function timeZoneProblem(zone) {
+	if (/^[+\-\d]/.test(zone) || zone.charCodeAt(0) === 8722) return `must be ${IANA_ZONE}, not a UTC offset`;
+	const problem = `must be ${IANA_ZONE} that Intl.DateTimeFormat accepts`;
+	if (zone.length > 64 || !/^[a-z]/i.test(zone)) return problem;
+	try {
+		new Intl.DateTimeFormat("en", { timeZone: zone });
+		return null;
+	} catch {
+		return problem;
+	}
+}
+function isProvider(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const provider = value;
+	return typeof provider.name === "string" && provider.name !== "" && typeof provider.model === "string" && typeof provider.translate === "function";
+}
+/** `defaults.tags` keys: the message tag names FormatJS parses, ASCII only. */
+const TAG_NAME = /^[A-Za-z][\w.-]*$/;
+const ATTRIBUTE_NAME = /^[A-Za-z][\w:.-]*$/;
+/**
+* Elements whose content HTML does not parse as text: escaped translator
+* text inside `<script>` or `<style>` would still run (INTERNALS §6 D205).
+*/
+const RAW_TEXT = /* @__PURE__ */ new Set([
+	"script",
+	"style",
+	"iframe",
+	"noembed",
+	"noframes",
+	"noscript",
+	"plaintext",
+	"xmp"
+]);
+const element = z.string().regex(/^[a-z][a-z\d-]*$/, { error: "an HTML element name in lower case" }).refine((name) => !RAW_TEXT.has(name), { error: "must render its children as text (not script, style, iframe or noscript)" });
+/** PLAN §5.20: batches of 40–80 items. */
+const BATCH_SIZE_RANGE = "must be an integer from 40 to 80";
+const text = z.string().min(1, { error: "must be a non-empty string" });
+const locale = z.string().superRefine((value, ctx) => {
+	const problem = localeProblem(value);
+	if (problem !== null) ctx.addIssue({
+		code: "custom",
+		message: problem
+	});
+});
+const positiveInt = z.number({ error: "must be a positive integer" }).int({ error: "must be a positive integer" }).positive({ error: "must be a positive integer" });
+const withLocale = z.string().includes("{locale}", { error: "must contain {locale}" });
+const manifestPath = withLocale.refine((path) => path.indexOf("{locale}", path.indexOf("{locale}") + 1) < 0, { error: "must contain {locale} exactly once" });
+const routePattern = z.string().startsWith("/", { error: "route patterns start with /" });
+const strategy = z.enum([
+	"url",
+	"cookie",
+	"header",
+	"localStorage",
+	"default"
+]);
+const level = z.enum([
+	"off",
+	"warn",
+	"error"
+]);
+const outputSchema = z.strictObject({
+	split: z.strictObject({
+		shared: z.enum(["per-set", "single"]).optional(),
+		dupBelow: positiveInt.optional(),
+		minBytes: positiveInt.optional(),
+		maxBundlesPerRoot: positiveInt.nullable().optional()
+	}).optional(),
+	guard: z.enum([
+		"auto",
+		"always",
+		"off"
+	]).optional(),
+	manifestPath: manifestPath.optional(),
+	manifest: z.enum(["data", "module"]).optional(),
+	baseEntries: z.array(text).optional(),
+	compactIds: z.boolean().optional(),
+	perLocale: z.boolean().optional()
+});
+const configSchema = z.strictObject({
+	sourceLocale: locale.optional(),
+	locales: z.array(locale).min(1, { error: "must list at least one locale" }).optional(),
+	pseudoLocales: z.array(z.enum(["en-XA", "ar-XB"])).optional(),
+	fallbacks: z.record(locale, z.array(locale)).optional(),
+	project: z.strictObject({
+		include: z.array(text).optional(),
+		extensions: z.array(z.string().regex(/^\.[^./\\]+$/, { error: "must look like \".tsx\"" })).optional(),
+		exclude: z.array(text).optional()
+	}).optional(),
+	extraction: z.strictObject({
+		importSources: z.array(text).optional(),
+		aliases: z.array(text).optional(),
+		globals: z.array(text).optional(),
+		keep: z.array(text).optional(),
+		dependencies: z.array(z.string().regex(/^(?:@[a-z0-9][\w.~-]*\/)?[a-z0-9][\w.~-]*$/, { error: "must be a package name, like \"@acme/ui\"" })).refine((names) => new Set(names).size === names.length, { error: "lists a package twice" }).optional()
+	}).optional(),
+	ids: z.strictObject({ length: z.number({ error: `must be an integer from ${ID_LENGTH.min} to ${ID_LENGTH.max}` }).int({ error: `must be an integer from ${ID_LENGTH.min} to ${ID_LENGTH.max}` }).min(ID_LENGTH.min, { error: `must be an integer from ${ID_LENGTH.min} to ${ID_LENGTH.max}` }).max(ID_LENGTH.max, { error: `must be an integer from ${ID_LENGTH.min} to ${ID_LENGTH.max}` }).optional() }).optional(),
+	catalogs: z.strictObject({
+		format: z.enum(["po", "json"]).optional(),
+		path: withLocale.optional(),
+		msgid: z.enum(["source", "id"]).optional(),
+		icuFlag: z.boolean().optional()
+	}).refine((catalogs) => !(catalogs.icuFlag === true && catalogs.format === "json"), {
+		error: "is a PO flag; JSON catalogs have no #, line to carry it",
+		path: ["icuFlag"]
+	}).optional(),
+	output: outputSchema.optional(),
+	routing: z.strictObject({
+		strategy: z.array(strategy).optional(),
+		routeStrategies: z.record(routePattern, z.array(strategy)).optional(),
+		url: z.enum([
+			"prefix_except_default",
+			"prefix",
+			"prefix_and_default",
+			"no_prefix"
+		]).optional(),
+		redirectRoot: z.boolean().optional(),
+		propagate: z.union([z.literal("header"), z.literal(false)], { error: "must be \"header\" or false" }).optional(),
+		switch: z.enum(["in-place", "navigate"]).optional(),
+		cookie: z.strictObject({
+			name: z.string().regex(/^[!#$%&'*+\-.^`|~\w]+$/, { error: "must be a valid cookie name" }).refine((name) => name !== TIME_ZONE_COOKIE, { error: `${JSON.stringify(TIME_ZONE_COOKIE)} is reserved for the time-zone cookie` }).optional(),
+			maxAge: positiveInt.optional()
+		}).optional(),
+		base: z.string().regex(/^\/(?!\/)/, { error: "must be a path starting with \"/\"" }).nullable().optional(),
+		paths: z.record(z.string(), z.record(z.string(), z.string())).optional(),
+		domains: z.record(z.string(), z.string()).optional()
+	}).optional(),
+	ssr: z.strictObject({
+		timeZone: z.string().superRefine((value, ctx) => {
+			const problem = timeZoneProblem(value);
+			if (problem !== null) ctx.addIssue({
+				code: "custom",
+				message: problem
+			});
+		}).optional(),
+		timeZoneFrom: z.record(routePattern, z.enum(["config", "request"])).optional(),
+		payload: z.enum(["bundles", "preload"]).optional(),
+		catalogs: z.enum([
+			"auto",
+			"modules",
+			"assets"
+		]).optional(),
+		maxLoadedLocales: positiveInt.optional(),
+		normalizeSpaces: z.boolean().optional()
+	}).optional(),
+	ai: z.strictObject({
+		provider: z.custom((value) => value === "gemini" || isProvider(value), { error: "must be \"gemini\" or a provider object with name, model and translate()" }).optional(),
+		model: text.optional(),
+		exclude: z.array(z.string()).optional(),
+		glossary: z.record(text, z.record(z.string(), text)).optional(),
+		doNotTranslate: z.array(text).optional(),
+		tone: z.record(z.string(), z.string()).optional(),
+		description: z.string().optional(),
+		apiKeyEnv: z.string().regex(/^[A-Za-z_]\w*$/, { error: "must be an environment variable name" }).optional(),
+		batchSize: z.number({ error: BATCH_SIZE_RANGE }).int({ error: BATCH_SIZE_RANGE }).min(40, { error: BATCH_SIZE_RANGE }).max(80, { error: BATCH_SIZE_RANGE }).optional(),
+		concurrency: positiveInt.optional(),
+		dev: z.boolean().optional()
+	}).optional(),
+	defaults: z.strictObject({ tags: z.custom((tags) => typeof tags !== "object" || tags === null || !Object.hasOwn(tags, "__proto__"), { error: "\"__proto__\" is not a message tag name" }).pipe(z.record(z.string().regex(TAG_NAME, { error: "a message tag name (letters, digits, _ and -)" }), z.union([element, z.strictObject({
+		element,
+		attributes: z.record(z.string().regex(ATTRIBUTE_NAME, { error: "an HTML attribute name" }), z.string()).optional()
+	})]))).optional() }).optional(),
+	devtools: z.boolean().optional(),
+	strict: z.union([z.boolean(), z.strictObject({
+		missing: level.optional(),
+		invalid: level.optional(),
+		moduleScope: level.optional()
+	})], { error: "must be a boolean or { missing, invalid, moduleScope }" }).optional()
+});
+/** `a.b["pt-BR"][0]`: the key path as a user would write it. */
+function formatPath(path) {
+	let out = "";
+	for (const key of path) if (typeof key === "number") out += `[${key}]`;
+	else if (typeof key === "string" && /^[A-Za-z_$][\w$]*$/.test(key)) out += out === "" ? key : `.${key}`;
+	else out += `[${JSON.stringify(String(key))}]`;
+	return out;
+}
+/**
+* One `<key path>: <problem>` line per zod issue, nested union and key
+* issues flattened. `label` names the object the paths start from.
+*/
+function issueLines(issues, prefix = [], label = "") {
+	const lines = [];
+	const line = (path, message) => {
+		const key = formatPath(path);
+		const at = label === "" ? key || "config" : key === "" ? label : `${label}${key.startsWith("[") ? "" : "."}${key}`;
+		lines.push(`${at}: ${message}`);
+	};
+	for (const issue of issues) {
+		const path = [...prefix, ...issue.path];
+		switch (issue.code) {
+			case "unrecognized_keys":
+				for (const key of issue.keys) line([...path, key], "unknown key");
+				break;
+			case "invalid_key":
+				lines.push(...issueLines(issue.issues, path, label));
+				break;
+			case "invalid_union": {
+				const deep = issue.errors.filter((branch) => branch.some((inner) => inner.path.length > 0));
+				if (deep.length === 1) lines.push(...issueLines(deep[0], path, label));
+				else line(path, issue.message);
+				break;
+			}
+			default: line(path, issue.message.replace(/^Invalid (?:input|option): /, ""));
+		}
+	}
+	return lines;
+}
+//#endregion
+//#region src/core/config/routing.ts
+/** Segments of a validated path as a pathname spells them (`*` and `**` stay). */
+const segmentsOf = (path) => new URL(path, "http://h").pathname.split("/").slice(1);
+/**
+* What is wrong with a `routing.paths` key or value, or null. A route path
+* as routers spell it: from the root, no empty, `.` or `..` segment, no
+* query, fragment or backslash, no trailing slash; `*` stands for one whole
+* segment and a final `**` for any number, and one segment at least is fixed.
+*/
+function pathProblem(path) {
+	if (!path.startsWith("/")) return "must start with /";
+	if (path === "/") return "the root is not translated";
+	if (/[?#\\]/.test(path)) return "must be a path without ?, # or \\";
+	const segments = path.slice(1).split("/");
+	for (const [i, s] of segments.entries()) {
+		if (s === "") return "must not have empty segments or a trailing slash";
+		if (s === "." || s === "..") return "must not have . or .. segments";
+		if (s.includes("*") && s !== "*" && s !== "**") return "a wildcard is a whole segment: * or **";
+		if (s === "**" && i !== segments.length - 1) return "** must be the last segment";
+	}
+	if (segments.every((s) => s.startsWith("*"))) return "must have a segment that is not a wildcard";
+	return null;
+}
+/** The wildcard sequence of a path: what a translation must keep, in order. */
+const wildcards = (path) => path.split("/").filter((s) => s === "*" || s === "**").join("/");
+/** Whether some pathname matches both patterns. */
+function overlap(a, b) {
+	for (let i = 0;; i++) {
+		const x = a[i];
+		const y = b[i];
+		if (x === "**" || y === "**") return true;
+		if (x === void 0 || y === void 0) return x === y;
+		if (x !== y && x !== "*" && y !== "*") return false;
+	}
+}
+/** Host and port of a `routing.domains` key in origin form, or null when it is no plain origin. */
+function domainOrigin(key) {
+	const withScheme = key.includes("://") ? key : "https://" + key;
+	let url;
+	try {
+		url = new URL(withScheme);
+	} catch {
+		return null;
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") return null;
+	if (url.username || url.password || url.search || url.hash || url.pathname !== "/") return null;
+	if (withScheme.replace(/^[a-z]+:\/\//i, "").includes("/")) return null;
+	return url.origin;
+}
+/** `routing.domains` with every key as `https://host[:port]` (or its `http:` origin). */
+function resolveDomains(domains) {
+	const out = {};
+	for (const [key, locale] of Object.entries(domains)) out[domainOrigin(key)] = locale;
+	return out;
+}
+/**
+* Rules between `routing.paths`, `routing.domains` and the other keys. Only
+* configured locales (never pseudo-locales, which are not advertised) may
+* have a path or a host.
+*/
+function routingProblems(routing, sourceLocale, locales) {
+	const problems = [];
+	const url = routing?.url ?? "prefix_except_default";
+	const paths = routing?.paths ?? {};
+	const domains = routing?.domains ?? {};
+	const hasDomains = Object.keys(domains).length > 0;
+	const at = (...keys) => formatPath(["routing", ...keys]);
+	if (hasDomains && url !== "prefix_except_default") problems.push(`${at("domains")}: needs routing.url "prefix_except_default" (a host's locale is its unprefixed one, every other host's prefix is redirected to that host)`);
+	const seen = /* @__PURE__ */ new Map();
+	for (const [key, locale] of Object.entries(domains)) {
+		const origin = domainOrigin(key);
+		if (origin === null) {
+			problems.push(`${at("domains", key)}: must be a host such as "example.de" or an origin such as "http://localhost:5173"`);
+			continue;
+		}
+		const other = seen.get(origin);
+		if (other !== void 0) problems.push(`${at("domains", key)}: the same host as "${other}"`);
+		seen.set(origin, key);
+		if (!locales.includes(locale)) problems.push(`${at("domains", key)}: ${JSON.stringify(locale)} is not in locales`);
+	}
+	if (hasDomains) {
+		const served = new Set(Object.values(domains));
+		for (const l of locales) if (!served.has(l)) problems.push(`${at("domains")}: no host serves ${JSON.stringify(l)} (every locale needs one)`);
+	}
+	const keys = Object.keys(paths);
+	if (keys.length > 0 && url === "no_prefix") problems.push(`${at("paths")}: needs URLs that name their locale (a routing.url other than "no_prefix")`);
+	const valid = [];
+	for (const key of keys) {
+		const problem = pathProblem(key);
+		if (problem !== null) {
+			problems.push(`${at("paths", key)}: ${problem}`);
+			continue;
+		}
+		let ok = true;
+		for (const [locale, value] of Object.entries(paths[key])) {
+			const where = at("paths", key, locale);
+			if (!locales.includes(locale)) {
+				problems.push(`${where}: ${JSON.stringify(locale)} is not in locales`);
+				ok = false;
+			}
+			const p = pathProblem(value);
+			if (p !== null) {
+				problems.push(`${where}: ${p}`);
+				ok = false;
+			} else if (wildcards(value) !== wildcards(key)) {
+				problems.push(`${where}: must keep the wildcards of ${JSON.stringify(key)}, in order`);
+				ok = false;
+			}
+		}
+		if (ok) valid.push(key);
+	}
+	const form = (key, l) => Object.hasOwn(paths[key], l) ? paths[key][l] : key;
+	const seg = new Map(valid.map((k) => [k, segmentsOf(k)]));
+	const segOf = (p) => seg.get(p) ?? segmentsOf(p);
+	const unprefixed = url === "prefix" || url === "no_prefix" ? [] : hasDomains ? locales : [sourceLocale];
+	for (const l of locales) {
+		for (let i = 0; i < valid.length; i++) {
+			const a = valid[i];
+			const fa = form(a, l);
+			for (let j = i + 1; j < valid.length; j++) {
+				const b = valid[j];
+				const fb = form(b, l);
+				const where = at("paths", Object.hasOwn(paths[b], l) ? b : a, l);
+				if (fa === fb) problems.push(`${where}: ${JSON.stringify(a)} and ${JSON.stringify(b)} share the path ${JSON.stringify(fa)} in ${l}`);
+				else if (overlap(segOf(fa), segOf(fb)) && !overlap(segOf(a), segOf(b))) problems.push(`${where}: ${JSON.stringify(fa)} and ${JSON.stringify(fb)} overlap in ${l}, but ${JSON.stringify(a)} and ${JSON.stringify(b)} do not`);
+			}
+		}
+		if (!unprefixed.includes(l)) continue;
+		for (const a of valid) for (const b of valid) {
+			if (a === b || !Object.hasOwn(paths[b], l)) continue;
+			if (overlap(segOf(a), segOf(paths[b][l]))) problems.push(`${at("paths", b, l)}: ${JSON.stringify(paths[b][l])} would read as the route ${JSON.stringify(a)} where ${l} is unprefixed`);
+		}
+	}
+	return problems;
+}
+//#endregion
+//#region src/core/config/load.ts
+/**
+* Finding, loading and resolving `vi18n.config.ts` (PLAN §5.7, INTERNALS
+* §2.7.1, spike S8). The plugin and the CLI both come through `loadConfig`,
+* so they can never disagree about a project's config.
+*/
+const JSON_CATALOG_PATH = "locales/{locale}.json";
+/**
+* Walks up from `from` to the workspace root (inclusive) and returns the
+* first `vi18n.config.ts`. Stopping at the workspace root keeps a project
+* from picking up a config that belongs to an unrelated checkout above it.
+*/
+async function findConfigFile(from) {
+	let dir = resolve(from);
+	for (;;) {
+		const candidate = join(dir, CONFIG_FILE);
+		if (await isFile(candidate)) return candidate;
+		if (await isWorkspaceRoot(dir)) return null;
+		const parent = dirname(dir);
+		if (parent === dir) return null;
+		dir = parent;
+	}
+}
+async function isWorkspaceRoot(dir) {
+	if (await exists(join(dir, ".git"))) return true;
+	if (await isFile(join(dir, "pnpm-workspace.yaml"))) return true;
+	let manifest;
+	try {
+		manifest = JSON.parse((await readFile(join(dir, "package.json"), "utf8")).replace(/^\uFEFF/, ""));
+	} catch {
+		return false;
+	}
+	return typeof manifest === "object" && manifest !== null && manifest.workspaces != null;
+}
+async function exists(file) {
+	try {
+		await stat(file);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function isFile(file) {
+	try {
+		return (await stat(file)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function loadConfig(options) {
+	const cwd = resolve(options.cwd);
+	let file;
+	if (options.configFile != null) {
+		file = resolve(cwd, options.configFile);
+		if (!await isFile(file)) throw diagnosticError({
+			code: "config-not-found",
+			severity: "error",
+			message: `Config file ${file} not found`,
+			file: toPosix(file)
+		});
+		if (!/\.m?ts$/.test(file)) throw invalid(basename(file), `${basename(file)}: only a TypeScript module (vi18n.config.ts) is supported as a config`);
+	} else file = await findConfigFile(cwd);
+	const inline = options.output === void 0 ? void 0 : parseInlineOutput(options.output);
+	if (file === null) return resolveWith({}, cwd, null, inline);
+	return resolveWith(await importConfig(file), dirname(file), file, inline);
+}
+/**
+* Error codes of a native `import()` that a Vite transform can fix:
+* non-erasable TypeScript, extensionless or aliased specifiers, `.ts` inside
+* `node_modules`, JSON without an import attribute. Anything else was thrown
+* by the config's own code and would only be thrown again.
+*/
+const TRANSFORMABLE = /* @__PURE__ */ new Set([
+	"ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX",
+	"ERR_INVALID_TYPESCRIPT_SYNTAX",
+	"ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING",
+	"ERR_UNKNOWN_FILE_EXTENSION",
+	"ERR_MODULE_NOT_FOUND",
+	"ERR_UNSUPPORTED_DIR_IMPORT",
+	"ERR_PACKAGE_IMPORT_NOT_DEFINED",
+	"ERR_IMPORT_ATTRIBUTE_MISSING",
+	"ERR_IMPORT_ASSERTION_TYPE_MISSING"
+]);
+function needsTransform(error) {
+	if (!(error instanceof Error) || thrownByEvaluatedCode(error)) return false;
+	const code = error.code;
+	if (typeof code === "string") return TRANSFORMABLE.has(code);
+	return error.name === "SyntaxError";
+}
+/**
+* Parse, resolution and link errors are raised by Node's loader before any
+* module body runs, so all their synchronous frames are `node:` internals.
+* An error with a synchronous frame in a `file:` module was thrown while the
+* config or one of its imports ran: retrying would run their side effects a
+* second time and throw again (a runtime `JSON.parse` SyntaxError, say).
+* `at async` frames are skipped because they are callers such as this loader.
+*/
+function thrownByEvaluatedCode(error) {
+	return /^\s*at (?!async )(?:.*\()?file:\/\//m.test(error.stack ?? "");
+}
+/**
+* Configs this process has already imported natively. Node caches ESM by URL
+* for the life of the process and the `?t=` query busts only the config
+* itself, so a reload would see stale versions of the modules it imports;
+* the runner evaluates the whole graph afresh, so reloads go through it.
+*/
+const importedNatively = /* @__PURE__ */ new Set();
+async function importConfig(file) {
+	const rel = basename(file);
+	let module;
+	const vite = importedNatively.has(file) ? await loadVite() : null;
+	if (vite !== null) module = await runnerImport(vite, file, rel);
+	else {
+		importedNatively.add(file);
+		try {
+			const { mtimeMs } = await stat(file);
+			module = await import(pathToFileURL(file).href + "?t=" + Math.trunc(mtimeMs * 1e3));
+		} catch (nativeError) {
+			if (!needsTransform(nativeError)) throw loadError(rel, nativeError);
+			const fallback = await loadVite();
+			if (fallback === null) throw invalid(rel, `${rel} needs a transform Node cannot apply (${firstLine(nativeError)}); install vite or use erasable TypeScript only`);
+			module = await runnerImport(fallback, file, rel);
+		}
+	}
+	if (!("default" in module) || module.default === void 0) throw invalid(rel, `${rel} has no default export; export default defineConfig({ … })`);
+	try {
+		return await (typeof module.default === "function" ? module.default() : module.default);
+	} catch (error) {
+		throw loadError(rel, error);
+	}
+}
+async function loadVite() {
+	try {
+		return await import("vite");
+	} catch {
+		return null;
+	}
+}
+async function runnerImport(vite, file, rel) {
+	try {
+		const { module } = await vite.runnerImport(file, {
+			root: dirname(file),
+			logLevel: "silent"
+		});
+		return module;
+	} catch (error) {
+		throw loadError(rel, error);
+	}
+}
+function loadError(rel, cause) {
+	const error = invalid(rel, `${rel} could not be loaded: ${firstLine(cause)}`);
+	error.cause = cause;
+	return error;
+}
+function firstLine(error) {
+	return (error instanceof Error ? error.message : String(error)).split("\n", 1)[0].replace(/\.$/, "");
+}
+function invalid(file, message) {
+	return diagnosticError({
+		code: "config-invalid",
+		severity: "error",
+		message,
+		...file === void 0 ? {} : { file }
+	});
+}
+function parseInlineOutput(output) {
+	const result = outputSchema.safeParse(output);
+	if (result.success) return result.data;
+	throw invalid(void 0, issueLines(result.error.issues, [], "vi18n({ output })").join("; "));
+}
+/**
+* `inline` over the file's already validated `output`, `split` merged key by
+* key. Merging after validation means an inline value can never hide an
+* invalid one in the file, which the CLI (no inline options) would reject.
+*/
+function withOutput(file, inline) {
+	const merged = mergeDefined(file ?? {}, inline);
+	if (file?.split !== void 0 && inline.split !== void 0) merged.split = mergeDefined(file.split, inline.split);
+	return merged;
+}
+function mergeDefined(base, over) {
+	const out = { ...base };
+	for (const key of Object.keys(over)) if (over[key] !== void 0) out[key] = over[key];
+	return out;
+}
+function resolveWith(input, root, configFile, inline) {
+	root = resolve(root);
+	const file = configFile === null ? void 0 : toPosix(relativeOrAbsolute(root, configFile));
+	const result = configSchema.safeParse(input);
+	if (!result.success) throw invalid(file, issueLines(result.error.issues).join("; "));
+	const user = inline === void 0 ? result.data : {
+		...result.data,
+		output: withOutput(result.data.output, inline)
+	};
+	const sourceLocale = user.sourceLocale ?? DEFAULT_CONFIG.sourceLocale;
+	const locales = user.locales ? [...user.locales] : [sourceLocale];
+	const problems = crossFieldProblems(user, sourceLocale, locales);
+	if (problems.length > 0) throw invalid(file, problems.join("; "));
+	const d = DEFAULT_CONFIG;
+	const format = user.catalogs?.format ?? d.catalogs.format;
+	const catalogPath = user.catalogs?.path ?? (format === "json" ? JSON_CATALOG_PATH : d.catalogs.path);
+	const provider = user.ai?.provider ?? d.ai.provider;
+	return {
+		root,
+		configFile: configFile === null ? null : resolve(configFile),
+		sourceLocale,
+		locales,
+		pseudoLocales: [...new Set(user.pseudoLocales ?? d.pseudoLocales)],
+		fallbacks: copyRecord(user.fallbacks ?? d.fallbacks, (chain) => [...chain]),
+		project: {
+			include: (user.project?.include ?? d.project.include).map((entry) => resolve(root, entry)),
+			extensions: [...user.project?.extensions ?? d.project.extensions],
+			exclude: [...user.project?.exclude ?? d.project.exclude]
+		},
+		extraction: {
+			importSources: [.../* @__PURE__ */ new Set([...DEFAULT_IMPORT_SOURCES, ...user.extraction?.importSources ?? []])],
+			aliases: [...user.extraction?.aliases ?? d.extraction.aliases],
+			globals: [...user.extraction?.globals ?? d.extraction.globals],
+			keep: [...user.extraction?.keep ?? d.extraction.keep],
+			dependencies: [...user.extraction?.dependencies ?? d.extraction.dependencies]
+		},
+		ids: { length: user.ids?.length ?? d.ids.length },
+		catalogs: {
+			format,
+			path: resolve(root, catalogPath),
+			msgid: user.catalogs?.msgid ?? d.catalogs.msgid,
+			icuFlag: user.catalogs?.icuFlag ?? d.catalogs.icuFlag
+		},
+		output: resolveOutput(user.output),
+		routing: {
+			strategy: [...user.routing?.strategy ?? d.routing.strategy],
+			routeStrategies: copyRecord(user.routing?.routeStrategies ?? d.routing.routeStrategies, (chain) => [...chain]),
+			url: user.routing?.url ?? d.routing.url,
+			redirectRoot: user.routing?.redirectRoot ?? d.routing.redirectRoot,
+			propagate: user.routing?.propagate ?? d.routing.propagate,
+			switch: user.routing?.switch ?? d.routing.switch,
+			cookie: {
+				name: user.routing?.cookie?.name ?? d.routing.cookie.name,
+				maxAge: user.routing?.cookie?.maxAge ?? d.routing.cookie.maxAge
+			},
+			base: user.routing?.base ?? d.routing.base,
+			paths: copyRecord(user.routing?.paths ?? d.routing.paths, (entry) => ({ ...entry })),
+			domains: resolveDomains(user.routing?.domains ?? d.routing.domains)
+		},
+		ssr: {
+			timeZone: user.ssr?.timeZone ?? d.ssr.timeZone,
+			timeZoneFrom: copyRecord(user.ssr?.timeZoneFrom ?? d.ssr.timeZoneFrom, (v) => v),
+			payload: user.ssr?.payload ?? d.ssr.payload,
+			catalogs: user.ssr?.catalogs ?? d.ssr.catalogs,
+			maxLoadedLocales: user.ssr?.maxLoadedLocales ?? d.ssr.maxLoadedLocales,
+			normalizeSpaces: user.ssr?.normalizeSpaces ?? d.ssr.normalizeSpaces
+		},
+		ai: {
+			provider,
+			model: user.ai?.model ?? (typeof provider === "string" ? d.ai.model : provider.model),
+			exclude: [...user.ai?.exclude ?? d.ai.exclude],
+			glossary: copyRecord(user.ai?.glossary ?? d.ai.glossary, (targets) => copyRecord(targets, (v) => v)),
+			doNotTranslate: [...user.ai?.doNotTranslate ?? d.ai.doNotTranslate],
+			tone: copyRecord(user.ai?.tone ?? d.ai.tone, (v) => v),
+			description: user.ai?.description ?? d.ai.description,
+			apiKeyEnv: user.ai?.apiKeyEnv ?? d.ai.apiKeyEnv,
+			batchSize: user.ai?.batchSize ?? d.ai.batchSize,
+			concurrency: user.ai?.concurrency ?? d.ai.concurrency,
+			dev: user.ai?.dev ?? d.ai.dev
+		},
+		defaults: { tags: copyRecord(user.defaults?.tags ?? d.defaults.tags, (spec) => typeof spec === "string" ? spec : {
+			element: spec.element,
+			attributes: { ...spec.attributes }
+		}) },
+		devtools: user.devtools ?? d.devtools,
+		strict: resolveStrict(user.strict)
+	};
+}
+/** Rules between keys, checked once the locale list is known. */
+function crossFieldProblems(user, sourceLocale, locales) {
+	const problems = [];
+	const configured = /* @__PURE__ */ new Set();
+	locales.forEach((tag, index) => {
+		if (configured.has(tag)) problems.push(`locales[${index}]: ${JSON.stringify(tag)} is listed twice`);
+		configured.add(tag);
+	});
+	if (!configured.has(sourceLocale)) problems.push(`sourceLocale: ${JSON.stringify(sourceLocale)} is not in locales (add it to locales)`);
+	for (const [tag, chain] of Object.entries(user.fallbacks ?? {})) chain.forEach((target, index) => {
+		if (!configured.has(target)) problems.push(`${formatPath([
+			"fallbacks",
+			tag,
+			index
+		])}: ${JSON.stringify(target)} is not in locales`);
+	});
+	(user.pseudoLocales ?? []).forEach((tag, index) => {
+		if (configured.has(tag)) problems.push(`pseudoLocales[${index}]: ${JSON.stringify(tag)} is also in locales`);
+	});
+	const idLength = user.ids?.length ?? DEFAULT_CONFIG.ids.length;
+	(user.ai?.exclude ?? []).forEach((entry, index) => {
+		if (excludeKind(entry, locales, idLength) === null) problems.push(`ai.exclude[${index}]: ${JSON.stringify(entry)} is not a configured locale, a message id or a file glob (a glob contains / or *)`);
+	});
+	problems.push(...routingProblems(user.routing, sourceLocale, locales));
+	const languages = new Set(locales.map((tag) => tag.split("-")[0]));
+	for (const [term, targets] of Object.entries(user.ai?.glossary ?? {})) for (const tag of Object.keys(targets)) if (!configured.has(tag) && !languages.has(tag)) problems.push(`${formatPath([
+		"ai",
+		"glossary",
+		term,
+		tag
+	])}: ${JSON.stringify(tag)} is not in locales (nor the language of one)`);
+	return problems;
+}
+function resolveOutput(user) {
+	const d = DEFAULT_CONFIG.output;
+	return {
+		split: {
+			shared: user?.split?.shared ?? d.split.shared,
+			dupBelow: user?.split?.dupBelow ?? d.split.dupBelow,
+			minBytes: user?.split?.minBytes ?? d.split.minBytes,
+			maxBundlesPerRoot: user?.split?.maxBundlesPerRoot === void 0 ? d.split.maxBundlesPerRoot : user.split.maxBundlesPerRoot
+		},
+		guard: user?.guard ?? d.guard,
+		manifestPath: user?.manifestPath ?? d.manifestPath,
+		manifest: user?.manifest ?? d.manifest,
+		baseEntries: [...user?.baseEntries ?? d.baseEntries],
+		compactIds: user?.compactIds ?? d.compactIds,
+		perLocale: user?.perLocale ?? d.perLocale
+	};
+}
+function resolveStrict(strict) {
+	const d = DEFAULT_CONFIG.strict;
+	if (strict === true) return {
+		missing: "error",
+		invalid: "error",
+		moduleScope: "error"
+	};
+	if (strict === void 0 || strict === false) return { ...d };
+	const pick = (value, fallback) => value ?? fallback;
+	return {
+		missing: pick(strict.missing, d.missing),
+		invalid: pick(strict.invalid, d.invalid),
+		moduleScope: pick(strict.moduleScope, d.moduleScope)
+	};
+}
+/**
+* A fresh copy, so resolved configs never share arrays with the input or the
+* defaults. `fromEntries` defines properties, so a `__proto__` key stays a key.
+*/
+function copyRecord(record, copy) {
+	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, copy(value)]));
+}
+function relativeOrAbsolute(root, file) {
+	const rel = relative(root, resolve(file));
+	return rel === "" || rel.startsWith("..") || isAbsolute(rel) ? resolve(file) : rel;
+}
+function toPosix(path) {
+	return sep === "/" ? path : path.split(sep).join("/");
+}
+//#endregion
+//#region src/test/load.ts
+/**
+* The Node half of `loadCatalog`: the config and every catalog file, compiled
+* for one locale by `compileLocales`, the function the build, dev and
+* `vi18n compile` read translations through. The messages are the ids the
+* catalogs hold (as `extraction.keep` ids are found), so the result depends
+* on the files only, never on which modules a test run transformed.
+*/
+async function compileCatalog(locale, root, configFile) {
+	const config = await loadConfig({
+		cwd: root,
+		configFile
+	});
+	if (locale === "en-XA" || locale === "ar-XB") throw new RangeError(`vi18n: ${locale} is a pseudo-locale and has no catalog; use createTestI18n({ mode: "pseudo" })`);
+	if (!config.locales.includes(locale)) throw new RangeError(`vi18n: ${locale} is not a configured locale (${config.locales.join(", ")}) in ${config.configFile ?? config.root}`);
+	const codec = createCodec(config.ids.length);
+	const { set } = await loadCatalogSet(config, codec);
+	const layout = catalogLayout(config);
+	const keep = /* @__PURE__ */ new Set();
+	for (const loaded of set.values()) for (const entry of loaded.catalog?.entries ?? []) try {
+		const key = entryKey(entry, layout, codec);
+		if (key !== null) keep.add(key);
+	} catch (error) {
+		if (!isDiagnosticError(error)) throw error;
+	}
+	const result = compileLocales({
+		config,
+		codec,
+		messages: /* @__PURE__ */ new Map(),
+		keep: [...keep],
+		catalogs: set,
+		locales: [locale],
+		sourceFallback: false
+	}).get(locale);
+	const messages = /* @__PURE__ */ new Map();
+	for (const [id, message] of result.messages) if (result.status.get(id)?.from !== config.sourceLocale) messages.set(id, message);
+	return {
+		locale,
+		messages
+	};
+}
+//#endregion
+export { compileCatalog };