@menapo/vi18n 0.0.0-stage → 0.1.1

package/dist/locales-DX4MOBFE.js

@@ -0,0 +1,827 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { a as isManualId, s as parseIdScheme } from "./validate-BxpupdAf.js";
+import { C as usableTranslation, S as entryKey, o as catalogLayout } from "./library-D5CWvTQs.js";
+import { r as resolveDuplicates, t as duplicateDiagnostics } from "./duplicates-yuRljQ6h.js";
+import { isAbsolute, relative, sep } from "node:path";
+import { hash } from "node:crypto";
+//#region src/core/compile/hash8.ts
+/**
+* First 8 characters of `base64url(sha256(utf8(text)))` (INTERNALS §2.9.1,
+* §6 D36): the same family as message ids, and safe in URLs, file names and
+* bundle keys without escaping.
+*/
+function hash8(text) {
+	return hash("sha256", text, "base64url").slice(0, 8);
+}
+//#endregion
+//#region src/core/compile/assets.ts
+/**
+* Server catalogs read from static assets (`ssr.catalogs: "assets"`, PLAN
+* §5.11, §5.13; spike S12): the versioned layout that the client build and
+* `vi18n compile --assets` write, the version that namespaces it, and the
+* module that reads it on Workers. Shared by the Vite plugin and the CLI.
+*
+* The reader is generated code rather than part of `@menapo/vi18n/server`:
+* that entry is at its PLAN §6 budget, and only Workers servers need it.
+* `/server` keeps what every registration shares: one load per locale for
+* concurrent scopes, and the least-recently-used bound the runtime config
+* carries (`ssr.maxLoadedLocales`).
+*/
+/** File names inside `vi18n/<version>/<locale>/`. */
+const SERVER_FILES = {
+	/** The locale's complete server catalog (`BundleData`, fallbacks applied). */
+	catalog: "catalog.json",
+	/** A copy of the locale's manifest slice: the bundle hashes payloads name. */
+	slice: "manifest.json"
+};
+/** The directory of one version's server catalogs, relative to the static-assets root. */
+function serverCatalogsDir(version) {
+	return `vi18n/${version}/`;
+}
+/**
+* The version that namespaces the server catalogs (`vi18n/<version>/`).
+* Code-only, like the message-set version `v` (INTERNALS §2.9.3), so a
+* translation-only deploy keeps both the path and the server JS. It covers
+* every id the server catalogs hold and the client's `v`: `v` alone covers
+* client bundles only, and a server-only message whose id changed would
+* otherwise read a catalog without it during a rolling deploy and render
+* the id; the client's `v` covers the bundle keys the manifest slices map.
+*/
+function serverCatalogVersion(input) {
+	const lines = [input.idScheme, input.v ?? "-"];
+	for (const id of [...new Set(input.ids)].sort()) lines.push(id + " " + input.sourceHashOf(id));
+	return hash8(lines.join("\n"));
+}
+/**
+* The module whose default export maps each locale to a loader reading
+* `vi18n/<version>/<locale>/catalog.json` through the Workers static-assets
+* binding `env.ASSETS` (`import { env } from "cloudflare:workers"`, which
+* reaches the binding from any handler without the app passing it: queue
+* consumers and cron jobs that call `withLocale` included). The import is
+* dynamic, so a runtime without it gets vi18n's message at the first read
+* instead of a module-resolution error at startup. Absolute URLs: the
+* binding rejects relative ones and ignores the host.
+*/
+function assetCatalogsModule(options) {
+	const workers = JSON.stringify(options.workers ?? "cloudflare:workers");
+	const deploy = JSON.stringify(options.deploy);
+	const modules = JSON.stringify(options.modules);
+	const loaders = options.locales.map((locale) => `  ${JSON.stringify(locale)}: () => load(${JSON.stringify(locale)}),`);
+	return `${`// Generated by vi18n: server catalogs read from the Workers static-assets
+// binding (ssr.catalogs "assets"). Only the locales requests use are read,
+// and @menapo/vi18n/server keeps at most ssr.maxLoadedLocales of them.
+const fail = (text) => new Error("vi18n: " + text);
+const why = (error) => (error instanceof Error ? error.message : String(error));
+let workers;
+
+async function read(path) {
+  let assets;
+  try {
+    assets = (await (workers ??= import(${workers}))).env?.ASSETS;\n  } catch (error) {\n    workers = undefined;\n    throw fail("catalogs are read from static assets through cloudflare:workers, which this runtime cannot import (" + why(error) + "): run this server on workerd, or " + ${modules});\n  }\n  if (typeof assets?.fetch !== "function") {\n    throw fail('catalogs are read through the static-assets binding env.ASSETS, which this Worker does not have: add "assets": { "binding": "ASSETS" } to its wrangler config');\n  }\n  let response;\n  try {\n    response = await assets.fetch("https://assets.invalid/" + path);\n  } catch (error) {\n    throw fail("reading /" + path + " through env.ASSETS failed: " + why(error));\n  }\n  // A missing file is a 404, or an HTML page under not_found_handling.\n  const type = response.headers.get("content-type") ?? "";\n  if (!response.ok || /html/i.test(type)) {\n    throw fail("/" + path + " is not in the static assets (" + response.status + (response.ok ? " " + type : "") + "): " + ${deploy});\n  }\n  try {\n    return await response.json();\n  } catch (error) {\n    throw fail("/" + path + " is not JSON: " + why(error));\n  }\n}\n`}${options.dir !== null ? `\nconst load = (locale) => read(${JSON.stringify(options.dir)} + locale + "/${SERVER_FILES.catalog}");\n` : `\nconst plan = () => import(${JSON.stringify(options.plan ?? "virtual:vi18n/client-plan")});\n\nasync function load(locale) {\n  const p = (await plan()).default;\n  if (typeof p !== "object" || p === null || typeof p.serverCatalogs !== "string") {\n    throw fail("this server reads its catalogs from static assets, but the client build that writes them did not run (the client plan was never filled in): build the client environment with it, or " + ${modules});\n  }\n  const dir = p.serverCatalogs + locale + "/";\n  // The slice names this deploy's bundle hashes for payloads; server JS\n  // carries none, so it stays the same across translation-only deploys.\n  const [catalog, slice] = await Promise.all([\n    read(dir + "${SERVER_FILES.catalog}"),\n    Object.hasOwn(p.hashes, locale) ? null : read(dir + "${SERVER_FILES.slice}"),\n  ]);\n  if (slice !== null) {\n    if (slice?.v !== p.v) {\n      throw fail("/" + dir + "${SERVER_FILES.slice} is from message set " + slice?.v + ", this server's is " + p.v + ": " + ${deploy});\n    }\n    p.hashes[locale] = slice.bundles;\n  }\n  return catalog;\n}\n`}\nexport default {\n${loaders.join("\n")}\n};\n`;
+}
+//#endregion
+//#region src/runtime/types.ts
+/**
+* Opcodes of the IR. The runtime may inline the literal numbers to save
+* bytes; 9 (`list`) and 10 (MF2 `.match`) are reserved and never emitted in 1.0.
+*/
+const OP = {
+	select: 1,
+	plural: 2,
+	selectordinal: 3,
+	number: 4,
+	date: 5,
+	time: 6,
+	tag: 7,
+	tagStandalone: 8,
+	list: 9,
+	match: 10
+};
+/** The `globalThis[Symbol.for("menapo.vi18n")]` key. */
+const STATE_KEY = "menapo.vi18n";
+//#endregion
+//#region src/core/ir/compile.ts
+/**
+* Compiles a parsed ICU message to the JSON IR the runtime interprets
+* (INTERNALS §2.3, PLAN §5.9).
+*
+* A message of plain text stays a string, which is what most messages are and
+* what the runtime returns without interpretation. Everything else becomes a
+* flat `Part[]` with adjacent text merged, so the runtime never concatenates
+* two literals it could have received as one.
+*/
+function compileMessage(message) {
+	const text = literalText(message);
+	if (text !== null) return text;
+	const parts = [];
+	appendParts(message, parts);
+	return parts;
+}
+/** The concatenated text when every node is a literal, otherwise null. */
+function literalText(nodes) {
+	if (nodes.length === 0) return "";
+	if (nodes.length === 1) {
+		const node = nodes[0];
+		return node.type === "literal" ? node.value : null;
+	}
+	let text = "";
+	for (const node of nodes) {
+		if (node.type !== "literal") return null;
+		text += node.value;
+	}
+	return text;
+}
+function appendParts(nodes, out) {
+	for (const node of nodes) {
+		if (node.type !== "literal") {
+			out.push(compileNode(node));
+			continue;
+		}
+		const last = out.length - 1;
+		if (last >= 0 && typeof out[last] === "string") out[last] = out[last] + node.value;
+		else if (node.value !== "") out.push(node.value);
+	}
+}
+function compileNode(node) {
+	switch (node.type) {
+		case "argument": return [node.name];
+		case "pound": return 0;
+		case "number":
+		case "date":
+		case "time": {
+			const op = node.type === "number" ? OP.number : node.type === "date" ? OP.date : OP.time;
+			const options = copyOptions(node.options);
+			return options === null ? [node.name, op] : [
+				node.name,
+				op,
+				options
+			];
+		}
+		case "select": return [
+			node.name,
+			OP.select,
+			compileCases(node.options)
+		];
+		case "plural": {
+			const op = node.pluralType === "ordinal" ? OP.selectordinal : OP.plural;
+			const cases = compileCases(node.options);
+			return node.offset === 0 ? [
+				node.name,
+				op,
+				cases
+			] : [
+				node.name,
+				op,
+				cases,
+				node.offset
+			];
+		}
+		case "tag": {
+			if (node.children === null) return [node.name, OP.tagStandalone];
+			const part = [node.name, OP.tag];
+			appendTagChildren(node.children, part);
+			return part;
+		}
+	}
+}
+/** Tag children are spread into the tag part after its name and opcode. */
+function appendTagChildren(children, part) {
+	for (const child of children) {
+		if (child.type !== "literal") {
+			part.push(compileNode(child));
+			continue;
+		}
+		const last = part.length - 1;
+		if (last >= 2 && typeof part[last] === "string") part[last] = part[last] + child.value;
+		else if (child.value !== "") part.push(child.value);
+	}
+}
+/**
+* Keys are added in option order, but a plain object lists integer-like keys
+* (`"1"`, not `"01"`) first in ascending order (INTERNALS §2.3). Lookup goes
+* through `Object.hasOwn`, so only the serialized order is affected.
+*/
+function compileCases(options) {
+	const cases = {};
+	for (const option of options) {
+		const value = compileMessage(option.value);
+		if (option.key === "__proto__") Object.defineProperty(cases, option.key, {
+			value,
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+		else cases[option.key] = value;
+	}
+	return cases;
+}
+/**
+* The IR gets its own options object: the codec memoises ASTs, and the runtime
+* keys formatter caches on the options object's identity per message.
+*/
+function copyOptions(options) {
+	if (options === null) return null;
+	let copy = null;
+	for (const key in options) {
+		if (!Object.hasOwn(options, key)) continue;
+		copy ??= {};
+		copy[key] = options[key];
+	}
+	return copy;
+}
+//#endregion
+//#region src/core/ir/pseudo.ts
+/**
+* Accented look-alikes of `A–Z` then `a–z` (one precomposed code point each),
+* readable at a glance yet impossible to mistake for untranslated text.
+*/
+const ACCENTED = "ÁƁÇÐÉƑĜĤÍĴĶĻṀÑÓÞǪŔŠŢÚṼŴẊÝŽáƀçðéƒĝĥíĵķļɱñóþǫŕšţúṽŵẋýž";
+const ACCENTED_BY_CODE = (() => {
+	const table = [];
+	for (let i = 0; i < 26; i++) {
+		table[65 + i] = ACCENTED.charAt(i);
+		table[97 + i] = ACCENTED.charAt(26 + i);
+	}
+	return table;
+})();
+const IS_VOWEL = (() => {
+	const table = [];
+	for (const vowel of "AEIOUaeiou") table[vowel.charCodeAt(0)] = true;
+	return table;
+})();
+/**
+* A pseudo-localised copy of a source message (INTERNALS §2.3).
+*
+* Only literal text changes: arguments, option keys, tags and `#` are kept, so
+* the result has the source's structure and renders with the same values.
+* `en-XA` accents ASCII letters and lengthens each literal that has letters by
+* ⌈35 %⌉ of its length (PLAN §4.7), the typical growth from English to German
+* or French, so layouts meet the overflow real translations cause; `ar-XB` keeps
+* the letters and forces right-to-left display. Both bracket the whole
+* message, so text on screen without brackets was not translated and brackets
+* inside a sentence reveal concatenation (PLAN §5.21).
+*/
+function pseudoLocalize(message, locale) {
+	return locale === "en-XA" ? wrap(mapNodes(message, accent), "[", "]") : wrap(mapNodes(message, identity), "[‮", "‬]");
+}
+/**
+* Rebuilds a node with `text` applied to its literal text. Output nodes carry
+* no `loc`: offsets into the source mean nothing for generated text.
+*/
+function mapNode(node, text) {
+	switch (node.type) {
+		case "literal": return {
+			type: "literal",
+			value: text(node.value)
+		};
+		case "argument": return {
+			type: "argument",
+			name: node.name
+		};
+		case "pound": return { type: "pound" };
+		case "number":
+		case "date":
+		case "time": return {
+			type: node.type,
+			name: node.name,
+			style: node.style === null ? null : { ...node.style },
+			options: node.options === null ? null : { ...node.options }
+		};
+		case "select": return {
+			type: "select",
+			name: node.name,
+			options: mapOptions(node.options, text)
+		};
+		case "plural": return {
+			type: "plural",
+			pluralType: node.pluralType,
+			name: node.name,
+			offset: node.offset,
+			options: mapOptions(node.options, text)
+		};
+		case "tag": return {
+			type: "tag",
+			name: node.name,
+			children: node.children === null ? null : mapNodes(node.children, text)
+		};
+	}
+}
+function mapNodes(nodes, text) {
+	const out = [];
+	for (const node of nodes) out.push(mapNode(node, text));
+	return out;
+}
+function mapOptions(options, text) {
+	const out = [];
+	for (const option of options) out.push({
+		key: option.key,
+		value: mapNodes(option.value, text)
+	});
+	return out;
+}
+function identity(value) {
+	return value;
+}
+/** Extra characters per literal, in percent of its length (PLAN §4.7). */
+const EXPANSION_PERCENT = 35;
+function accent(value) {
+	const chars = Array.from(value);
+	let letters = 0;
+	let vowels = 0;
+	for (const char of chars) {
+		const code = char.charCodeAt(0);
+		if (char.length !== 1 || code >= 128 || ACCENTED_BY_CODE[code] === void 0) continue;
+		letters++;
+		if (IS_VOWEL[code] === true) vowels++;
+	}
+	const extra = letters === 0 ? 0 : Math.ceil(chars.length * EXPANSION_PERCENT / 100);
+	const byVowel = vowels > 0 && extra <= 2 * vowels;
+	const carriers = byVowel ? vowels : letters;
+	let out = "";
+	let seen = 0;
+	for (const char of chars) {
+		const code = char.charCodeAt(0);
+		const mapped = char.length === 1 && code < 128 ? ACCENTED_BY_CODE[code] : void 0;
+		if (mapped === void 0) {
+			out += char;
+			continue;
+		}
+		out += mapped;
+		if (byVowel && IS_VOWEL[code] !== true) continue;
+		const copies = Math.floor((seen + 1) * extra / carriers) - Math.floor(seen * extra / carriers);
+		seen++;
+		if (copies > 0) out += mapped.repeat(copies);
+	}
+	return out;
+}
+/**
+* Adds the brackets as literal text, merged into a literal at either end so
+* the result keeps the AST invariant that adjacent literals are one node.
+*/
+function wrap(nodes, open, close) {
+	const first = nodes[0];
+	if (first?.type === "literal") first.value = open + first.value;
+	else nodes.unshift({
+		type: "literal",
+		value: open
+	});
+	const last = nodes[nodes.length - 1];
+	if (last.type === "literal") last.value += close;
+	else nodes.push({
+		type: "literal",
+		value: close
+	});
+	return nodes;
+}
+//#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
+export { assetCatalogsModule as a, hash8 as c, SERVER_FILES as i, compileMessage as n, serverCatalogVersion as o, STATE_KEY as r, serverCatalogsDir as s, compileLocales as t };