prosebook 0.3.0 → 0.5.0

package/dist/{generate-9pR3i5Bj.js → generate-CKv86Iki.js}

@@ -1,11 +1,11 @@
 import { n as chainOf } from "./locale-DpQA1pqH.js";
-import { a as formatsOf, c as parseMessage$1, d as staticLiteral, f as tagsOf, i as formatProblems, l as placeholderOf, n as argsOf, o as numberOptions, p as walk, s as optionArgsOf, t as TYPE$1, u as selectionOf } from "./icu-Dej0mNsF.js";
-import { d as localeModule, l as compileLocale } from "./scan-Bx0_yDSi.js";
-import { p as lint, u as applyEdits } from "./config-BPSmoYel.js";
-import { dirname, join, relative, resolve } from "node:path";
+import { a as formatsOf, c as parseMessage$1, d as staticLiteral, f as tagsOf, i as formatProblems, l as placeholderOf, n as argsOf, o as numberOptions, p as walk, r as dateOptions, s as optionArgsOf, t as TYPE$1, u as selectionOf } from "./icu-Dej0mNsF.js";
+import { d as compileLocale, p as localeModule } from "./scan-C0ap4Mpp.js";
+import { p as lint, u as applyEdits } from "./config-7T4hX_f7.js";
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
 import { SKELETON_TYPE, TYPE, isDateElement, isNumberElement, isTimeElement, parse } from "@formatjs/icu-messageformat-parser";
-import { LineCounter, Scalar, isMap, isScalar, parse as parse$1, parseDocument } from "yaml";
+import { LineCounter, Scalar, isMap, isScalar, parse as parse$1, parseDocument, stringify } from "yaml";
 import { MessageSyntaxError, parseMessage, stringifyMessage, validate } from "messageformat";
 import { createHash } from "node:crypto";
 // src/tools/mf1.ts
@@ -33,7 +33,7 @@ const CATEGORY_ORDER = [
 function print$1(elements, inPlural) {
 	return elements.map((el, i) => {
 		switch (el.type) {
-			case TYPE.literal: return escape(el.value, inPlural, elements[i + 1] === void 0);
+			case TYPE.literal: return escape$3(el.value, inPlural, elements[i + 1] === void 0);
 			case TYPE.argument: return `{${el.value}}`;
 			case TYPE.number:
 			case TYPE.date:
@@ -66,7 +66,7 @@ function print$1(elements, inPlural) {
 * Literal text, quoted where ICU would read it as syntax. An apostrophe starts a quote only before a
 * special character, so one before ordinary text (`don't`) stays single.
 */
-function escape(text, inPlural, last) {
+function escape$3(text, inPlural, last) {
 	const special = (c) => c === "{" || c === "}" || c === "<" || inPlural && c === "#";
 	let out = "";
 	for (let i = 0; i < text.length; i++) {
@@ -1462,7 +1462,7 @@ var CatalogError = class extends Error {
 * in. Keys are read at every call site, so they say what the string is for: `cart.checkout.title`.
 */
 const KEY_PATTERN = /^[a-z0-9]+(?:[-_][a-z0-9]+)*(?:\.[a-z0-9]+(?:[-_][a-z0-9]+)*)+$/;
-const FIELDS = /* @__PURE__ */ new Set([
+const FIELDS$1 = /* @__PURE__ */ new Set([
 	"kind",
 	"surface",
 	"context",
@@ -1541,7 +1541,7 @@ function readEntry$1(key, area, file, value, config, error) {
 		error(message);
 		ok = false;
 	};
-	for (const field of Object.keys(entry)) if (!FIELDS.has(field) && field !== config.source) fail(`"${field}" is not a field: ${[...FIELDS, config.source].join(", ")}`);
+	for (const field of Object.keys(entry)) if (!FIELDS$1.has(field) && field !== config.source) fail(`"${field}" is not a field: ${[...FIELDS$1, config.source].join(", ")}`);
 	const text = entry[config.source];
 	if (typeof text !== "string" || text === "") {
 		fail(`${config.source} is the message, and it is missing`);
@@ -1681,6 +1681,13 @@ function icuError(text, e) {
 	if (/TAG/.test(reason)) return `is not valid ICU (${reason}): a literal < is written '<'`;
 	return `is not valid ICU MessageFormat: ${reason}`;
 }
+/** The first line of a catalog file: the YAML language server finds the schema `generate` writes only through it. */
+const SCHEMA_LINE = "# yaml-language-server: $schema=./catalog.schema.json";
+/** `text` opening with the schema line, unless it opens with a schema line of its own already. */
+function withSchemaLine(text) {
+	if (text.startsWith("# yaml-language-server:")) return text;
+	return `${SCHEMA_LINE}${text.includes("\r\n") ? "\r\n" : "\n"}${text}`;
+}
 function yamlFiles(dir) {
 	return readdirSync(dir).filter((f) => f.endsWith(".yaml")).sort();
 }
@@ -1810,130 +1817,629 @@ function entryLocator(root) {
 function previewOf(message) {
 	return staticLiteral(message.ast) ?? message.text;
 }
-// src/tools/entry.ts
-/**
-* One entry as the dev inspector's dialog edits it, in every locale: as fields, or as the YAML written
-* in its files.
-*
-* An edit is checked as the whole catalog, with the edited files read from memory, before anything is
-* written: a save that would break the build comes back as problems instead, and the dev server never
-* sees it. Fields are written into the parsed document, so comments, order and quoting elsewhere in the
-* file stay as they were; YAML replaces the entry's text as typed. A translation left empty is no
-* translation: one that was there is removed, and the locale falls back.
-*/
-/** The entry for `key`, with its translation in every locale. */
-function readEntry(config, key) {
-	return viewOf(config, loadCatalog(config), key, /* @__PURE__ */ new Map());
+// src/tools/diff.ts
+const TOKEN = /\s+|[\p{L}\p{N}_'’]+|[^\s\p{L}\p{N}_]/gu;
+/** Past this many cells the table costs more than the diff is worth: show the whole change instead. */
+const MAX_CELLS = 25e4;
+function wordDiff(before, after) {
+	const a = before.match(TOKEN) ?? [];
+	const b = after.match(TOKEN) ?? [];
+	if (a.length * b.length > MAX_CELLS) return merge([{
+		op: "del",
+		text: before
+	}, {
+		op: "add",
+		text: after
+	}]);
+	const lcs = Array.from({ length: a.length + 1 }, () => Array.from({ length: b.length + 1 }, () => 0));
+	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+	const parts = [];
+	let i = 0;
+	let j = 0;
+	while (i < a.length && j < b.length) if (a[i] === b[j]) {
+		parts.push({
+			op: "same",
+			text: a[i]
+		});
+		i++;
+		j++;
+	} else if (lcs[i + 1][j] >= lcs[i][j + 1]) parts.push({
+		op: "del",
+		text: a[i++]
+	});
+	else parts.push({
+		op: "add",
+		text: b[j++]
+	});
+	while (i < a.length) parts.push({
+		op: "del",
+		text: a[i++]
+	});
+	while (j < b.length) parts.push({
+		op: "add",
+		text: b[j++]
+	});
+	return merge(parts);
 }
 /**
-* Applies an edit and checks the catalog with it. With `write`, a clean edit is written; without, it
-* only comes back as the view, which is how the dialog turns fields into YAML and back.
+* Adjacent parts of one kind joined, and a space shared by two changes folded into them, so a
+* replaced phrase reads `[-old words-]{+new words+}` rather than alternating word by word.
 */
-function editEntry(config, key, edit, write) {
-	const current = viewOf(config, loadCatalog(config), key, /* @__PURE__ */ new Map());
-	const unsaved = /* @__PURE__ */ new Map();
-	const text = (file) => contentOf(config, file, unsaved);
-	const put = (file, content) => unsaved.set(resolve(config.root, file), content);
-	const translated = [];
-	if ("yaml" in edit) {
-		put(current.files.catalog, withSnippet(text(current.files.catalog), key, edit.yaml.catalog));
-		for (const locale of current.locales) {
-			const yaml = edit.yaml.translations?.[locale]?.trim() ?? current.yaml.translations[locale];
-			if (yaml !== "") translated.push(locale);
-			if (yaml === current.yaml.translations[locale]) continue;
-			put(current.files.translations[locale], withSnippet(text(current.files.translations[locale]), key, yaml));
-		}
-	} else {
-		put(current.files.catalog, withFields(text(current.files.catalog), key, edit.fields, config.source));
-		for (const locale of current.locales) {
-			const next = edit.fields.translations[locale] ?? "";
-			if (next.trim() !== "") translated.push(locale);
-			if (next === current.fields.translations[locale]) continue;
-			put(current.files.translations[locale], withTranslation(text(current.files.translations[locale]), key, next));
+function merge(parts) {
+	const out = [];
+	for (let k = 0; k < parts.length; k++) {
+		const part = parts[k];
+		const prev = out.at(-1);
+		const next = parts[k + 1];
+		if (part.op === "same" && /^\s+$/.test(part.text) && prev && prev.op !== "same" && next && next.op !== "same") {
+			out.push({
+				op: "del",
+				text: part.text
+			}, {
+				op: "add",
+				text: part.text
+			});
+			continue;
 		}
+		out.push({ ...part });
 	}
-	let catalog;
-	try {
-		catalog = loadCatalog(config, unsaved);
-	} catch (e) {
-		if (!(e instanceof CatalogError)) throw e;
-		return { problems: e.problems.filter((p) => p.severity === "error") };
-	}
-	const message = catalog.messages.find((m) => m.key === key);
-	const renamed = [...message === void 0 ? [current.files.catalog] : [], ...translated.filter((l) => message?.translations.has(l) !== true).map((l) => current.files.translations[l])];
-	if (renamed.length > 0) {
-		const problem = `the entry is still ${key}: rename a key in the code and the catalog together`;
-		return { problems: renamed.map((file) => ({
-			severity: "error",
-			file,
-			key,
-			message: problem
-		})) };
-	}
-	if (write) for (const [path, content] of unsaved) {
-		if (existsSync(path) && readFileSync(path, "utf8") === content) continue;
-		mkdirSync(dirname(path), { recursive: true });
-		writeFileSync(path, content);
+	const joined = [];
+	for (const part of out.filter((p) => p.text !== "")) {
+		const last = joined.at(-1);
+		if (last && last.op === part.op) last.text += part.text;
+		else if (part.op === "del" && last?.op === "add" && joined.at(-2)?.op === "del") joined.at(-2).text += part.text;
+		else joined.push({ ...part });
 	}
+	return joined;
+}
+/** The diff as one line: `Save [-the-]{+a+} draft`, the notation of `git diff --word-diff`. */
+function formatDiff(parts) {
+	return parts.map((p) => p.op === "same" ? p.text : p.op === "del" ? `[-${p.text}-]` : `{+${p.text}+}`).join("");
+}
+// src/tools/lock.ts
+/**
+* Stale translations: a translation made from source text that has since changed.
+*
+* The lock records, per translation, a hash of the source it was made from and a hash of the
+* translation itself. Editing the translation re-anchors it to the current source; editing only
+* the source leaves the old anchor in place, which is what marks it stale. Nobody has to remember
+* to flag anything: `prosebook status` lists what is stale, and `prosebook accept` re-anchors a
+* translation that was still right.
+*
+* The lock also keeps the text behind each anchor, once per distinct text, so a stale translation
+* can show its translator what changed rather than only what the source says now.
+*/
+function hash(text) {
+	return createHash("sha256").update(text).digest("hex").slice(0, 10);
+}
+function emptyLock() {
 	return {
-		view: viewOf(config, catalog, key, unsaved),
-		problems: []
+		version: 2,
+		sources: {},
+		translations: {}
+	};
+}
+/** The lock at `path`. A version 1 lock, which held only the translations, reads with no source texts. */
+function readLock(path) {
+	if (!existsSync(path)) return emptyLock();
+	const raw = JSON.parse(readFileSync(path, "utf8"));
+	if (raw.version === 2) return {
+		...emptyLock(),
+		...raw
+	};
+	return {
+		version: 2,
+		sources: {},
+		translations: raw
 	};
 }
+const sortedEntries = (record) => Object.fromEntries(Object.entries(record).sort(([a], [b]) => a < b ? -1 : 1));
+function serializeLock(lock) {
+	const translations = Object.fromEntries(Object.keys(lock.translations).sort().map((locale) => [locale, sortedEntries(lock.translations[locale])]));
+	return `${JSON.stringify({
+		version: 2,
+		sources: sortedEntries(lock.sources),
+		translations
+	}, null, 2)}\n`;
+}
+/** What changed in the source of a stale translation, as a word diff, or why that isn't known. */
+function changeOf(stale) {
+	if (stale.was === void 0) return "the earlier text isn't recorded (the lock predates prosebook 0.2)";
+	return formatDiff(wordDiff(stale.was, stale.now)).replaceAll("\n", " ");
+}
 /**
-* Makes the edits that lint's findings carry, each message in its own file, and writes them only if
-* the catalog they make loads clean: the problems come back instead, and nothing is written.
+* The lock brought up to date with the catalog, and what is stale. `accept` re-anchors the given
+* translations (per locale, keys, or `true` for all of them) to the current source.
 */
-function applyFixes(config, catalog, findings) {
-	const unsaved = /* @__PURE__ */ new Map();
-	const entries = /* @__PURE__ */ new Map();
-	for (const f of findings) {
-		if (f.fix === void 0) continue;
-		const id = `${f.locale}\u0000${f.key}`;
-		const entry = entries.get(id) ?? {
-			file: f.file,
-			key: f.key,
-			locale: f.locale,
-			edits: [],
-			count: 0
-		};
-		entry.edits.push(...f.fix);
-		entry.count += 1;
-		entries.set(id, entry);
-	}
-	let fixed = 0;
-	for (const { file, key, locale, edits, count } of entries.values()) {
-		const message = catalog.messages.find((m) => m.key === key);
-		const written = locale === config.source ? message?.text : message?.translations.get(locale)?.text;
-		if (written === void 0) continue;
-		const next = applyEdits(written, edits);
-		if (next === written) continue;
-		const content = contentOf(config, file, unsaved);
-		unsaved.set(resolve(config.root, file), locale === config.source ? withMessage(content, key, next, config.source) : withTranslation(content, key, next));
-		fixed += count;
-	}
-	try {
-		loadCatalog(config, unsaved);
-	} catch (e) {
-		if (!(e instanceof CatalogError)) throw e;
-		return {
-			fixed: 0,
-			problems: e.problems.filter((p) => p.severity === "error")
-		};
+function reconcile(catalog, previous, accept = /* @__PURE__ */ new Map()) {
+	const lock = emptyLock();
+	const stale = /* @__PURE__ */ new Map();
+	for (const message of catalog.messages) {
+		const source = hash(message.text);
+		for (const [locale, translation] of message.translations) {
+			const text = hash(translation.text);
+			const [anchor, recorded] = (previous.translations[locale]?.[message.key] ?? "").split(":");
+			const accepted = accept.get(locale);
+			const reanchor = anchor === void 0 || anchor === "" || recorded !== text || accepted === true || accepted?.has(message.key) === true;
+			const kept = reanchor ? source : anchor;
+			(lock.translations[locale] ??= {})[message.key] = `${kept}:${text}`;
+			const keptText = kept === source ? message.text : previous.sources[kept];
+			if (keptText !== void 0) lock.sources[kept] = keptText;
+			if (!reanchor && anchor !== source) {
+				let keys = stale.get(locale);
+				if (keys === void 0) stale.set(locale, keys = /* @__PURE__ */ new Map());
+				keys.set(message.key, {
+					was: keptText,
+					now: message.text,
+					translation: translation.text
+				});
+			}
+		}
 	}
-	for (const [path, content] of unsaved) writeFileSync(path, content);
 	return {
-		fixed,
-		problems: []
+		lock,
+		stale
 	};
 }
+// src/tools/todo.ts
 /**
-* Translations into `locale` from `prosebook todo`'s YAML filled in, by a person or a model, each
-* written to the file its locale and area put it in. Text around a fenced block is left aside, as a
-* model's reply has it, and an empty value is one left for later. An entry that would break the
-* catalog is left out with its problem, so a reply with one bad entry still lands the others.
+* `prosebook todo`: a locale's missing and stale entries, each with what a translator needs above it,
+* as the YAML to fill in. `prosebook import` reads it back filled.
+*
+* With `prompt`, it leads with what a model must be told to reply in that form. prosebook writes the
+* prompt and checks the reply; which model answers it, and how, is left to whoever runs it.
 */
-function importTranslations(config, locale, reply) {
+function todoOf(config, catalog, stale, locale, prompt = false) {
+	const wanted = todoMessages(catalog, stale, locale);
+	if (wanted.length === 0) return {
+		count: 0,
+		text: `# ${locale} is complete`
+	};
+	const byArea = /* @__PURE__ */ new Map();
+	for (const m of wanted) {
+		const lines = byArea.get(m.area) ?? [];
+		lines.push("");
+		if (m.context) lines.push(`# ${m.context}`);
+		const what = [m.kind && `kind: ${m.kind}`, m.surface && `surface: ${m.surface}`].filter(Boolean).join(", ");
+		if (what) lines.push(`# ${what}`);
+		for (const [arg, said] of m.argDocs) lines.push(`#   {${arg}}: ${said}`);
+		lines.push(`# ${config.source}: ${m.text.replaceAll("\n", " ")}`);
+		const change = stale.get(m.key);
+		if (change !== void 0) lines.push(`# stale, the source changed: ${changeOf(change)}`);
+		lines.push(stringify({ [m.key]: m.translations.get(locale)?.text ?? "" }, { lineWidth: 0 }).trimEnd());
+		byArea.set(m.area, lines);
+	}
+	const entries = [...byArea].map(([area, lines]) => `\n# ── ${area}.yaml ──\n${lines.join("\n")}`).join("\n");
+	const count = wanted.length;
+	if (prompt) return {
+		count,
+		text: `${promptFor(config, wanted, locale, wanted.some((m) => stale.has(m.key)))}\n${entries.trimStart()}\n\`\`\``
+	};
+	return {
+		count,
+		text: `${`# prosebook todo: ${count} entr${count === 1 ? "y" : "ies"} for ${locale}. Fill them in, then \`prosebook import ${locale} <this file>\`.`}\n${entries}`
+	};
+}
+/** The entries a locale wants a translation of: those it lacks, and those gone stale. */
+function todoMessages(catalog, stale, locale) {
+	return catalog.messages.filter((m) => !m.translations.has(locale) || stale.has(m.key));
+}
+function promptFor(config, wanted, locale, anyStale) {
+	const mf2 = config.messageFormat === 2;
+	const [target, source] = [nameOf(locale), nameOf(config.source)];
+	const plurals = {
+		cardinal: false,
+		ordinal: false
+	};
+	for (const m of wanted) walk(m.ast, (el) => {
+		if (el.type === TYPE$1.plural) plurals[el.pluralType === "ordinal" ? "ordinal" : "cardinal"] = true;
+	});
+	const categories = (type) => {
+		const forms = new Intl.PluralRules(locale, { type }).resolvedOptions().pluralCategories;
+		return forms.length === 1 ? `only the form ${forms[0]}` : `the forms ${new Intl.ListFormat("en").format(forms)}`;
+	};
+	const exact = mf2 ? "`0`" : "`=0`";
+	const rules = [
+		mf2 ? `Each message is in MessageFormat 2. Keep every {$placeholder}, every markup tag ({#b}…{/b}) around the same words, and every .input, .local and .match line; translate the text, not the names.` : `Each message is in ICU MessageFormat. Keep every {placeholder}, and every <tag> around the same words; translate the text inside plural and select arms, not the arm or argument names.`,
+		plurals.cardinal && `A plural in ${target} takes ${categories("cardinal")}: give each its own ${mf2 ? "variant" : "arm"}, and keep exact ones such as ${exact} where the ${source} has them.`,
+		plurals.ordinal && `An ordinal in ${target} takes ${categories("ordinal")}.`,
+		"The comments above an entry say where it appears, what kind of string it is, and what each placeholder holds. Hold each to its kind, as described below: a button stays as short as the source.",
+		anyStale && "An entry marked stale has a translation made from an earlier source. The diff shows what changed in the source ({+added+}, [-removed-]): change the translation only as much as that needs, and give it back unchanged if it still holds.",
+		"Quote a value in single quotes when it starts with { or holds \": \", as YAML needs, and double any single quote inside it."
+	].filter((r) => typeof r === "string");
+	const kinds = new Set(wanted.flatMap((m) => m.kind === void 0 ? [] : [m.kind]));
+	const surfaces = new Set(wanted.flatMap((m) => m.surface === void 0 ? [] : [m.surface]));
+	const legend = [
+		...kinds.size > 0 ? ["", "Kinds of string:"] : [],
+		...[...kinds].map((k) => `- ${k}: ${config.kinds[k]?.doc ?? ""}`),
+		...surfaces.size > 0 ? ["", "Surfaces:"] : [],
+		...[...surfaces].map((s) => `- ${s}: ${config.surfaces[s] ?? ""}`)
+	];
+	return [
+		`Translate the entries below from ${source} (${config.source}) into ${target} (${locale}). They are the text of an app's interface.`,
+		"",
+		"Reply with one YAML code block holding every key below, each with its translation as the value, and nothing else in the block.",
+		"",
+		...rules.map((r) => `- ${r}`),
+		...legend,
+		"",
+		`The entries, in ${SYNTAX_NAME[config.messageFormat]}:`,
+		"",
+		"```yaml"
+	].join("\n");
+}
+function nameOf(locale) {
+	try {
+		return new Intl.DisplayNames(["en"], { type: "language" }).of(locale) ?? locale;
+	} catch {
+		return locale;
+	}
+}
+// src/tools/exchange.ts
+/**
+* `prosebook export`: a locale's entries as XLIFF 2.0 or JSON, for translation tools, and the reader
+* `prosebook import` takes every format back through, todo's YAML and a model's reply included.
+*
+* Messages travel as their ICU or MF2 text, not as XLIFF's inline codes: a plural or a select has no
+* inline form, and the tools that take these files read ICU. A unit carries its source as exported, so
+* a translation of a source that has changed since is refused rather than written as current.
+*/
+/**
+* The entries `todo` would list for `locale`, or every one with `all`, as a file a translation tool
+* reads. The source locale exports every entry, untranslated, for a tool to take as its source.
+*/
+function exportOf(config, catalog, stale, locale, format, all = false) {
+	const isSource = locale === config.source;
+	const messages = all || isSource ? catalog.messages : todoMessages(catalog, stale, locale);
+	if (messages.length === 0) return {
+		count: 0,
+		text: ""
+	};
+	const textOf = (m) => isSource ? m.text : m.translations.get(locale)?.text;
+	if (format === "json") {
+		const json = JSON.stringify(Object.fromEntries(messages.map((m) => [m.key, textOf(m) ?? ""])), null, 2);
+		return {
+			count: messages.length,
+			text: `${json}\n`
+		};
+	}
+	const byArea = /* @__PURE__ */ new Map();
+	for (const m of messages) byArea.set(m.area, [...byArea.get(m.area) ?? [], m]);
+	const lines = ["<?xml version=\"1.0\" encoding=\"UTF-8\"?>", `<xliff xmlns="urn:oasis:names:tc:xliff:document:2.0" version="2.0" srcLang="${escape$2(config.source)}"${isSource ? "" : ` trgLang="${escape$2(locale)}"`}>`];
+	for (const [area, list] of byArea) {
+		lines.push(`  <file id="${escape$2(area)}" original="${escape$2(list[0].file)}" xml:space="preserve">`);
+		for (const m of list) {
+			lines.push(`    <unit id="${m.key}">`);
+			const notes = [
+				["context", m.context],
+				["kind", m.kind],
+				["surface", m.surface],
+				...[...m.argDocs].map(([arg, said]) => ["placeholder", `{${arg}}: ${said}`]),
+				["stale", isSource || !stale.has(m.key) ? void 0 : `the source changed: ${changeOf(stale.get(m.key))}`]
+			].filter((n) => n[1] !== void 0);
+			if (notes.length > 0) {
+				lines.push("      <notes>");
+				for (const [category, text] of notes) lines.push(`        <note category="${category}">${escape$2(text)}</note>`);
+				lines.push("      </notes>");
+			}
+			const target = textOf(m);
+			const state = isSource ? "" : ` state="${target === void 0 || stale.has(m.key) ? "initial" : "translated"}"`;
+			lines.push(`      <segment${state}>`, `        <source>${escape$2(m.text)}</source>`);
+			if (!isSource && target !== void 0) lines.push(`        <target>${escape$2(target)}</target>`);
+			lines.push("      </segment>", "    </unit>");
+		}
+		lines.push("  </file>");
+	}
+	lines.push("</xliff>");
+	return {
+		count: messages.length,
+		text: `${lines.join("\n")}\n`
+	};
+}
+/**
+* The translations in a file `import` was given: XLIFF 2.0 when it starts as XML, otherwise YAML,
+* which reads JSON too. Text around fenced blocks is left aside, as a model's reply has it. A nested
+* mapping, as some tools write JSON, joins its keys with dots.
+*/
+function readReturned(text, locale, source) {
+	if (text.trimStart().startsWith("<")) return readXliff(text, locale, source);
+	const fenced = [...text.matchAll(/^```[^\n]*\n([\s\S]*?)^```/gm)].map((m) => m[1]);
+	const doc = parseDocument(fenced.length > 0 ? fenced.join("\n") : text);
+	if (doc.errors.length > 0 || !(isMap(doc.contents) || doc.contents === null)) return { problem: `the reply isn't YAML or JSON of \`key: translation\` (${doc.errors[0]?.message.split("\n", 1)[0] ?? "it is not a mapping"}): fix it, or ask for one YAML block` };
+	const returned = [];
+	const flatten = (map, prefix) => {
+		for (const pair of map.items) {
+			const key = prefix + (isScalar(pair.key) ? String(pair.key.value) : String(pair.key));
+			if (isMap(pair.value)) flatten(pair.value, `${key}.`);
+			else returned.push({
+				key,
+				value: isScalar(pair.value) ? pair.value.value : pair.value,
+				checked: true
+			});
+		}
+	};
+	if (isMap(doc.contents)) flatten(doc.contents, "");
+	return { returned };
+}
+function readXliff(text, locale, source) {
+	let root;
+	try {
+		root = parseXml(text);
+	} catch (e) {
+		return { problem: `the file isn't XML (${messageOf(e)}): give it back as the tool exported it` };
+	}
+	if (root.name !== "xliff") return { problem: `the file is <${root.name}>, not XLIFF: export it from the tool as XLIFF 2.0` };
+	if (!root.attrs.version?.startsWith("2.")) return { problem: `the file is XLIFF ${root.attrs.version ?? "of no version"}: export it from the tool as XLIFF 2.0` };
+	const { srcLang, trgLang } = root.attrs;
+	if (srcLang !== void 0 && srcLang.toLowerCase() !== source.toLowerCase()) return { problem: `the file translates from ${srcLang}, and the source is ${source}: export it again from prosebook` };
+	if (trgLang === void 0) return { problem: `the file names no trgLang: give it the ${locale} translations, or set trgLang="${locale}"` };
+	if (trgLang.toLowerCase() !== locale.toLowerCase()) return { problem: `the file translates into ${trgLang}, not ${locale}: import it as ${trgLang}` };
+	const returned = [];
+	const units = (el) => elements(el).flatMap((child) => child.name === "unit" ? [child] : child.name === "file" || child.name === "group" ? units(child) : []);
+	for (const unit of units(root)) {
+		const key = unit.attrs.id ?? "";
+		const parts = elements(unit).filter((el) => el.name === "segment" || el.name === "ignorable");
+		const segments = parts.filter((el) => el.name === "segment");
+		const sourceOf = (el) => elements(el).find((c) => c.name === "source");
+		const targetOf = (el) => elements(el).find((c) => c.name === "target");
+		try {
+			const unitSource = parts.map((p) => textOf(sourceOf(p))).join("");
+			const translated = segments.filter((s) => targetOf(s) !== void 0).length;
+			if (translated === 0) {
+				returned.push({
+					key,
+					value: null,
+					checked: false,
+					source: unitSource
+				});
+				continue;
+			}
+			if (translated < segments.length) throw new Error(`${translated} of its ${segments.length} segments are translated: translate the rest`);
+			const value = parts.map((p) => textOf(targetOf(p) ?? sourceOf(p))).join("");
+			const checked = segments.every((s) => (s.attrs.state ?? "initial") !== "initial");
+			returned.push({
+				key,
+				value,
+				checked,
+				source: unitSource
+			});
+		} catch (e) {
+			returned.push({
+				key,
+				value: null,
+				checked: false,
+				problem: messageOf(e)
+			});
+		}
+	}
+	return { returned };
+}
+/** The text of a <source> or <target>, refusing XLIFF's inline codes, which prosebook never writes. */
+function textOf(el) {
+	if (el === void 0) return "";
+	return el.children.map((child) => {
+		if (typeof child === "string") return child;
+		if (child.name === "cp" && child.attrs.hex !== void 0) return String.fromCodePoint(Number.parseInt(child.attrs.hex, 16));
+		throw new Error(`the ${el.name} holds an inline <${child.name}>: have the tool keep placeholders as the text they were exported as`);
+	}).join("");
+}
+const messageOf = (e) => e instanceof Error ? e.message : String(e);
+const escape$2 = (s) => s.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+const elements = (el) => el.children.filter((c) => typeof c !== "string");
+const ENTITIES$1 = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+function decode(s, at) {
+	return s.replace(/&(#x[0-9a-f]+|#[0-9]+|[a-z]+);/gi, (_, ref) => {
+		if (ref.startsWith("#x") || ref.startsWith("#X")) return String.fromCodePoint(Number.parseInt(ref.slice(2), 16));
+		if (ref.startsWith("#")) return String.fromCodePoint(Number.parseInt(ref.slice(1), 10));
+		const char = ENTITIES$1[ref];
+		if (char === void 0) throw new Error(`&${ref}; near offset ${at} is no XML entity`);
+		return char;
+	});
+}
+/**
+* Just enough XML for XLIFF: elements, attributes, text, CDATA and character references. Comments,
+* processing instructions and a doctype are skipped; no DTD is read, so no entity of one is known.
+*/
+function parseXml(text) {
+	const document = {
+		name: "",
+		attrs: {},
+		children: []
+	};
+	const open = [document];
+	let i = 0;
+	const skip = (from, to) => {
+		const end = text.indexOf(to, i + from.length);
+		if (end === -1) throw new Error(`${from} at offset ${i} never ends`);
+		const body = text.slice(i + from.length, end);
+		i = end + to.length;
+		return body;
+	};
+	while (i < text.length) {
+		const lt = text.indexOf("<", i);
+		const parent = open.at(-1);
+		if (lt !== i) {
+			const end = lt === -1 ? text.length : lt;
+			if (open.length > 1) parent.children.push(decode(text.slice(i, end), i));
+			else if (text.slice(i, end).trim() !== "") throw new Error(`text at offset ${i} is outside the root element`);
+			i = end;
+			continue;
+		}
+		if (text.startsWith("<!--", i)) {
+			skip("<!--", "-->");
+			continue;
+		}
+		if (text.startsWith("<?", i)) {
+			skip("<?", "?>");
+			continue;
+		}
+		if (text.startsWith("<![CDATA[", i)) {
+			parent.children.push(skip("<![CDATA[", "]]>"));
+			continue;
+		}
+		if (text.startsWith("<!", i)) {
+			skip("<!", ">");
+			continue;
+		}
+		if (text.startsWith("</", i)) {
+			const at = i;
+			const name = localName(skip("</", ">").trim());
+			if (open.length === 1 || parent.name !== name) throw new Error(`</${name}> at offset ${at} closes nothing open`);
+			open.pop();
+			continue;
+		}
+		TAG.lastIndex = i;
+		const tag = TAG.exec(text);
+		if (tag === null) throw new Error(`the tag at offset ${i} is malformed`);
+		const attrs = {};
+		for (const [, name, double, single] of tag[2].matchAll(/([^\s=]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g)) attrs[localName(name)] = decode(double ?? single ?? "", i);
+		const el = {
+			name: localName(tag[1]),
+			attrs,
+			children: []
+		};
+		if (open.length === 1 && document.children.length > 0) throw new Error(`a second root element at offset ${i}`);
+		parent.children.push(el);
+		if (tag[3] !== "/") open.push(el);
+		i += tag[0].length;
+	}
+	if (open.length > 1) throw new Error(`<${open.at(-1).name}> is never closed`);
+	const root = elements(document)[0];
+	if (root === void 0) throw new Error("there is no element");
+	return root;
+}
+const TAG = /<([^\s/>]+)((?:\s+[^\s=/>]+\s*=\s*(?:"[^"]*"|'[^']*'))*)\s*(\/?)>/y;
+const localName = (name) => name.slice(name.indexOf(":") + 1);
+// src/tools/entry.ts
+/**
+* One entry as the dev inspector's dialog edits it, in every locale: as fields, or as the YAML written
+* in its files.
+*
+* An edit is checked as the whole catalog, with the edited files read from memory, before anything is
+* written: a save that would break the build comes back as problems instead, and the dev server never
+* sees it. Fields are written into the parsed document, so comments, order and quoting elsewhere in the
+* file stay as they were; YAML replaces the entry's text as typed. A translation left empty is no
+* translation: one that was there is removed, and the locale falls back.
+*/
+/** The entry for `key`, with its translation in every locale. */
+function readEntry(config, key) {
+	return viewOf(config, loadCatalog(config), key, /* @__PURE__ */ new Map());
+}
+/**
+* Applies an edit and checks the catalog with it. With `write`, a clean edit is written; without, it
+* only comes back as the view, which is how the dialog turns fields into YAML and back.
+*/
+function editEntry(config, key, edit, write) {
+	const current = viewOf(config, loadCatalog(config), key, /* @__PURE__ */ new Map());
+	const unsaved = /* @__PURE__ */ new Map();
+	const text = (file) => contentOf(config, file, unsaved);
+	const put = (file, content) => unsaved.set(resolve(config.root, file), content);
+	const translated = [];
+	if ("yaml" in edit) {
+		put(current.files.catalog, withSnippet(text(current.files.catalog), key, edit.yaml.catalog));
+		for (const locale of current.locales) {
+			const yaml = edit.yaml.translations?.[locale]?.trim() ?? current.yaml.translations[locale];
+			if (yaml !== "") translated.push(locale);
+			if (yaml === current.yaml.translations[locale]) continue;
+			put(current.files.translations[locale], withSnippet(text(current.files.translations[locale]), key, yaml));
+		}
+	} else {
+		put(current.files.catalog, withFields(text(current.files.catalog), key, edit.fields, config.source));
+		for (const locale of current.locales) {
+			const next = edit.fields.translations[locale] ?? "";
+			if (next.trim() !== "") translated.push(locale);
+			if (next === current.fields.translations[locale]) continue;
+			put(current.files.translations[locale], withTranslation(text(current.files.translations[locale]), key, next));
+		}
+	}
+	let catalog;
+	try {
+		catalog = loadCatalog(config, unsaved);
+	} catch (e) {
+		if (!(e instanceof CatalogError)) throw e;
+		return { problems: e.problems.filter((p) => p.severity === "error") };
+	}
+	const message = catalog.messages.find((m) => m.key === key);
+	const renamed = [...message === void 0 ? [current.files.catalog] : [], ...translated.filter((l) => message?.translations.has(l) !== true).map((l) => current.files.translations[l])];
+	if (renamed.length > 0) {
+		const problem = `the entry is still ${key}: rename a key in the code and the catalog together`;
+		return { problems: renamed.map((file) => ({
+			severity: "error",
+			file,
+			key,
+			message: problem
+		})) };
+	}
+	if (write) for (const [path, content] of unsaved) {
+		if (existsSync(path) && readFileSync(path, "utf8") === content) continue;
+		mkdirSync(dirname(path), { recursive: true });
+		writeFileSync(path, content);
+	}
+	return {
+		view: viewOf(config, catalog, key, unsaved),
+		problems: []
+	};
+}
+/**
+* Makes the edits that lint's findings carry, each message in its own file, and writes them only if
+* the catalog they make loads clean: the problems come back instead, and nothing is written.
+*/
+function applyFixes(config, catalog, findings) {
+	const unsaved = /* @__PURE__ */ new Map();
+	const entries = /* @__PURE__ */ new Map();
+	for (const f of findings) {
+		if (f.fix === void 0) continue;
+		const id = `${f.locale}\u0000${f.key}`;
+		const entry = entries.get(id) ?? {
+			file: f.file,
+			key: f.key,
+			locale: f.locale,
+			edits: [],
+			count: 0
+		};
+		entry.edits.push(...f.fix);
+		entry.count += 1;
+		entries.set(id, entry);
+	}
+	let fixed = 0;
+	for (const { file, key, locale, edits, count } of entries.values()) {
+		const message = catalog.messages.find((m) => m.key === key);
+		const written = locale === config.source ? message?.text : message?.translations.get(locale)?.text;
+		if (written === void 0) continue;
+		const next = applyEdits(written, edits);
+		if (next === written) continue;
+		const content = contentOf(config, file, unsaved);
+		unsaved.set(resolve(config.root, file), locale === config.source ? withMessage(content, key, next, config.source) : withTranslation(content, key, next));
+		fixed += count;
+	}
+	try {
+		loadCatalog(config, unsaved);
+	} catch (e) {
+		if (!(e instanceof CatalogError)) throw e;
+		return {
+			fixed: 0,
+			problems: e.problems.filter((p) => p.severity === "error")
+		};
+	}
+	for (const [path, content] of unsaved) writeFileSync(path, content);
+	return {
+		fixed,
+		problems: []
+	};
+}
+/**
+* Translations into `locale` from `prosebook todo`'s YAML filled in, by a person or a model, or from
+* a translation tool's XLIFF or JSON (`readReturned`), each written to the file its locale and area
+* put it in. An empty value is one left for later. An entry that would break the catalog is left out
+* with its problem, so a reply with one bad entry still lands the others.
+*/
+function importTranslations(config, locale, reply) {
 	const failed = (message, key) => ({
 		severity: "error",
 		key,
@@ -1944,36 +2450,41 @@ function importTranslations(config, locale, reply) {
 		unchanged: [],
 		problems: [failed(`${locale} is the source: import takes translations`)]
 	};
-	const fenced = [...reply.matchAll(/^```[^\n]*\n([\s\S]*?)^```/gm)].map((m) => m[1]);
-	const doc = parseDocument(fenced.length > 0 ? fenced.join("\n") : reply);
-	if (doc.errors.length > 0 || !(isMap(doc.contents) || doc.contents === null)) return {
+	const read = readReturned(reply, locale, config.source);
+	if ("problem" in read) return {
 		written: [],
 		unchanged: [],
-		problems: [failed(`the reply isn't YAML of \`key: translation\` (${doc.errors[0]?.message.split("\n", 1)[0] ?? "it is not a mapping"}): fix it, or ask for one YAML block`)]
+		problems: [failed(read.problem)]
 	};
 	const catalog = loadCatalog(config);
 	const problems = [];
 	const unchanged = [];
 	const pending = /* @__PURE__ */ new Map();
-	for (const pair of isMap(doc.contents) ? doc.contents.items : []) {
-		const key = isScalar(pair.key) ? String(pair.key.value) : String(pair.key);
+	for (const { key, value, checked, source, problem } of read.returned) {
 		const message = catalog.messages.find((m) => m.key === key);
 		if (message === void 0) {
-			problems.push(failed("no entry has this key: translate only the keys `prosebook todo` printed", key));
+			problems.push(failed("no entry has this key: translate only the keys `prosebook todo` or `export` gave out", key));
+			continue;
+		}
+		if (problem !== void 0) {
+			problems.push(failed(problem, key));
 			continue;
 		}
-		const value = isScalar(pair.value) ? pair.value.value : pair.value;
 		if (value === null || value === "") continue;
 		if (typeof value !== "string" && typeof value !== "number") {
 			problems.push(failed("the translation is not text: give the message as one string", key));
 			continue;
 		}
+		if (source !== void 0 && source !== message.text) {
+			problems.push(failed(`the source has changed since it was exported, to "${message.text}": export it again`, key));
+			continue;
+		}
 		const text = String(value);
-		if (text === message.translations.get(locale)?.text) unchanged.push(key);
-		else pending.set(key, {
+		if (text !== message.translations.get(locale)?.text) pending.set(key, {
 			file: translationFile(config, message, locale),
 			text
 		});
+		else if (checked) unchanged.push(key);
 	}
 	for (;;) {
 		const unsaved = /* @__PURE__ */ new Map();
@@ -2145,471 +2656,256 @@ function withMessage(file, key, message, source) {
 }
 function withTranslation(file, key, translation) {
 	const doc = parse$2(file);
-	const node = doc.get(key, true);
-	if (translation.trim() === "") doc.delete(key);
-	else if (isScalar(node)) {
-		node.value = translation;
-		if (translation.includes("\n")) node.type = Scalar.BLOCK_LITERAL;
-	} else doc.set(key, translation);
-	return isMap(doc.contents) && doc.contents.items.length === 0 ? "" : print(doc);
-}
-// src/tools/diff.ts
-const TOKEN = /\s+|[\p{L}\p{N}_'’]+|[^\s\p{L}\p{N}_]/gu;
-/** Past this many cells the table costs more than the diff is worth: show the whole change instead. */
-const MAX_CELLS = 25e4;
-function wordDiff(before, after) {
-	const a = before.match(TOKEN) ?? [];
-	const b = after.match(TOKEN) ?? [];
-	if (a.length * b.length > MAX_CELLS) return merge([{
-		op: "del",
-		text: before
-	}, {
-		op: "add",
-		text: after
-	}]);
-	const lcs = Array.from({ length: a.length + 1 }, () => Array.from({ length: b.length + 1 }, () => 0));
-	for (let i = a.length - 1; i >= 0; i--) for (let j = b.length - 1; j >= 0; j--) lcs[i][j] = a[i] === b[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
-	const parts = [];
-	let i = 0;
-	let j = 0;
-	while (i < a.length && j < b.length) if (a[i] === b[j]) {
-		parts.push({
-			op: "same",
-			text: a[i]
-		});
-		i++;
-		j++;
-	} else if (lcs[i + 1][j] >= lcs[i][j + 1]) parts.push({
-		op: "del",
-		text: a[i++]
-	});
-	else parts.push({
-		op: "add",
-		text: b[j++]
-	});
-	while (i < a.length) parts.push({
-		op: "del",
-		text: a[i++]
-	});
-	while (j < b.length) parts.push({
-		op: "add",
-		text: b[j++]
-	});
-	return merge(parts);
-}
-/**
-* Adjacent parts of one kind joined, and a space shared by two changes folded into them, so a
-* replaced phrase reads `[-old words-]{+new words+}` rather than alternating word by word.
-*/
-function merge(parts) {
-	const out = [];
-	for (let k = 0; k < parts.length; k++) {
-		const part = parts[k];
-		const prev = out.at(-1);
-		const next = parts[k + 1];
-		if (part.op === "same" && /^\s+$/.test(part.text) && prev && prev.op !== "same" && next && next.op !== "same") {
-			out.push({
-				op: "del",
-				text: part.text
-			}, {
-				op: "add",
-				text: part.text
-			});
-			continue;
-		}
-		out.push({ ...part });
-	}
-	const joined = [];
-	for (const part of out.filter((p) => p.text !== "")) {
-		const last = joined.at(-1);
-		if (last && last.op === part.op) last.text += part.text;
-		else if (part.op === "del" && last?.op === "add" && joined.at(-2)?.op === "del") joined.at(-2).text += part.text;
-		else joined.push({ ...part });
-	}
-	return joined;
-}
-/** The diff as one line: `Save [-the-]{+a+} draft`, the notation of `git diff --word-diff`. */
-function formatDiff(parts) {
-	return parts.map((p) => p.op === "same" ? p.text : p.op === "del" ? `[-${p.text}-]` : `{+${p.text}+}`).join("");
-}
-// src/tools/lock.ts
-/**
-* Stale translations: a translation made from source text that has since changed.
-*
-* The lock records, per translation, a hash of the source it was made from and a hash of the
-* translation itself. Editing the translation re-anchors it to the current source; editing only
-* the source leaves the old anchor in place, which is what marks it stale. Nobody has to remember
-* to flag anything: `prosebook status` lists what is stale, and `prosebook accept` re-anchors a
-* translation that was still right.
-*
-* The lock also keeps the text behind each anchor, once per distinct text, so a stale translation
-* can show its translator what changed rather than only what the source says now.
-*/
-function hash(text) {
-	return createHash("sha256").update(text).digest("hex").slice(0, 10);
-}
-function emptyLock() {
-	return {
-		version: 2,
-		sources: {},
-		translations: {}
-	};
-}
-/** The lock at `path`. A version 1 lock, which held only the translations, reads with no source texts. */
-function readLock(path) {
-	if (!existsSync(path)) return emptyLock();
-	const raw = JSON.parse(readFileSync(path, "utf8"));
-	if (raw.version === 2) return {
-		...emptyLock(),
-		...raw
-	};
-	return {
-		version: 2,
-		sources: {},
-		translations: raw
-	};
-}
-const sortedEntries = (record) => Object.fromEntries(Object.entries(record).sort(([a], [b]) => a < b ? -1 : 1));
-function serializeLock(lock) {
-	const translations = Object.fromEntries(Object.keys(lock.translations).sort().map((locale) => [locale, sortedEntries(lock.translations[locale])]));
-	return `${JSON.stringify({
-		version: 2,
-		sources: sortedEntries(lock.sources),
-		translations
-	}, null, 2)}\n`;
-}
-/** What changed in the source of a stale translation, as a word diff, or why that isn't known. */
-function changeOf(stale) {
-	if (stale.was === void 0) return "the earlier text isn't recorded (the lock predates prosebook 0.2)";
-	return formatDiff(wordDiff(stale.was, stale.now)).replaceAll("\n", " ");
-}
-/**
-* The lock brought up to date with the catalog, and what is stale. `accept` re-anchors the given
-* translations (per locale, keys, or `true` for all of them) to the current source.
-*/
-function reconcile(catalog, previous, accept = /* @__PURE__ */ new Map()) {
-	const lock = emptyLock();
-	const stale = /* @__PURE__ */ new Map();
-	for (const message of catalog.messages) {
-		const source = hash(message.text);
-		for (const [locale, translation] of message.translations) {
-			const text = hash(translation.text);
-			const [anchor, recorded] = (previous.translations[locale]?.[message.key] ?? "").split(":");
-			const accepted = accept.get(locale);
-			const reanchor = anchor === void 0 || anchor === "" || recorded !== text || accepted === true || accepted?.has(message.key) === true;
-			const kept = reanchor ? source : anchor;
-			(lock.translations[locale] ??= {})[message.key] = `${kept}:${text}`;
-			const keptText = kept === source ? message.text : previous.sources[kept];
-			if (keptText !== void 0) lock.sources[kept] = keptText;
-			if (!reanchor && anchor !== source) {
-				let keys = stale.get(locale);
-				if (keys === void 0) stale.set(locale, keys = /* @__PURE__ */ new Map());
-				keys.set(message.key, {
-					was: keptText,
-					now: message.text,
-					translation: translation.text
-				});
-			}
-		}
-	}
-	return {
-		lock,
-		stale
-	};
-}
-// src/tools/native/emit.ts
-/** Words from an identifier written any way: `userName`, `user-name` and `user_name` are user, name. */
-function wordsOf(name) {
-	return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((w) => w.toLowerCase());
-}
-const capital = (w) => w.charAt(0).toUpperCase() + w.slice(1);
-const snake = (words) => words.join("_");
-const pascal = (words) => words.map(capital).join("");
-const camel = (words) => words.map((w, i) => i === 0 ? w : capital(w)).join("");
-const upper = (words) => words.join("_").toUpperCase();
-/** An identifier can't start with a digit, so `404.title` is `_404Title`. */
-function leading(name) {
-	return /^[0-9]/.test(name) ? `_${name}` : name;
-}
-/** A double literal every target reads as one: `0.0`, `1.5`, `1e21`. */
-function float(value) {
-	const s = String(value).replace("e+", "e");
-	return /[.e]/.test(s) ? s : `${s}.0`;
-}
-/** Characters that print nothing, or look like a space, written as escapes so the code shows them. */
-const INVISIBLE = /[\u{a0}\u{61c}\u{180e}\u{2000}-\u{200f}\u{2028}-\u{202f}\u{205f}-\u{206f}\u{feff}]/gu;
-/** Text for a doc comment, with what prints nothing written as `\u{…}`: Rust refuses direction marks there. */
-function docText(line) {
-	return line.replace(INVISIBLE, (c) => `\\u{${c.charCodeAt(0).toString(16)}}`);
-}
-/** A string literal: JSON's escapes, `\u{…}` where the target writes them so (Rust, Swift), and `$` escaped in Kotlin. */
-function stringLiteral(value, language) {
-	const json = JSON.stringify(value).replace(INVISIBLE, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
-	if (language === "kotlin") return json.replaceAll("$", "\\$");
-	return json.replace(/\\u([0-9a-f]{4})/g, (_, hex) => `\\u{${hex.replace(/^0+/, "")}}`);
-}
-/**
-* A plural condition as an expression over operands `o`: `field(op)` reads one, `mod` takes a
-* remainder, `within` tests a range as CLDR does (integers only). `&&`, `||` and `!` are every
-* target's.
-*/
-function conditionCode(condition, code) {
-	const ors = condition.map((and) => and.map((r) => {
-		const value = r.mod === void 0 ? code.field(r.operand) : code.mod(code.field(r.operand), float(r.mod));
-		if (r.ranges.length === 1 && r.ranges[0][0] === r.ranges[0][1]) return `${value} ${r.negated ? "!=" : "=="} ${float(r.ranges[0][0])}`;
-		const any = r.ranges.map(([from, to]) => from === to ? `${value} == ${float(from)}` : code.within(value, float(from), float(to))).join(" || ");
-		return r.negated ? `!(${any})` : r.ranges.length > 1 ? `(${any})` : any;
-	}).join(" && "));
-	return ors.length > 1 ? ors.map((o) => o.includes(" && ") ? `(${o})` : o).join(" || ") : ors[0];
-}
-/** Fails with the keys whose names meet, or meet a name the file already has. */
-function checkNames(language, named, taken) {
-	const seen = new Map(taken.map((t) => [t, "a name the file already has"]));
-	for (const [key, name] of named) {
-		const other = seen.get(name);
-		if (other !== void 0) throw new Error(`${language}: ${key} is named ${name}, as ${other} is: rename one, or change the target's keys`);
-		seen.set(name, key);
-	}
-}
-// src/tools/native/kotlin.ts
-const KEYWORDS$2 = new Set("as break class continue do else false for fun if in interface is null object package return super this throw true try typealias typeof val var when while".split(" "));
-const ident$2 = (name) => KEYWORDS$2.has(name) ? `\`${name}\`` : name;
-const lit$2 = (value) => stringLiteral(value, "kotlin");
-const entry = (tag) => leading(upper(wordsOf(tag)));
-const argName$2 = (name) => ident$2(leading(camel(wordsOf(name))));
-function doc$3(lines, indent) {
-	return `${indent}/**\n${lines.map((l) => l.replaceAll("*/", "*\\/")).map((l) => l === "" ? `${indent} *` : `${indent} * ${l}`).join("\n")}\n${indent} */\n`;
-}
-/** The parts as an expression of type `String`, with `rt` the runtime object. */
-function expr$2(parts, indent, rt) {
-	if (parts.length === 0) return "\"\"";
-	return parts.map((p) => p.type === "text" ? lit$2(p.value) : value$2(p, indent, rt)).join(" + ");
-}
-function value$2(part, indent, rt) {
-	const inner = `${indent}    `;
-	if (part.type === "string") return argName$2(part.arg);
-	if (part.type === "number") return `${rt}.number(${part.offset === 0 ? argName$2(part.arg) : `${argName$2(part.arg)} - ${float(part.offset)}`}, ${rt}.F${part.format}, ${lit$2(part.fallback)})`;
-	if (part.type === "select") {
-		const arms = part.arms.map((a) => `${inner}${lit$2(a.key)} -> ${expr$2(a.parts, inner, rt)}\n`).join("");
-		return `when (${argName$2(part.arg)}) {\n${arms}${inner}else -> ${expr$2(part.other, inner, rt)}\n${indent}}`;
-	}
-	if (part.arms.length + part.exact.length === 0) return expr$2(part.other, indent, rt);
-	const arg = argName$2(part.arg);
-	const on = part.on === "round" ? `${rt}.round(${arg})` : part.on === "percent" ? `${arg} * 100.0` : arg;
-	const { minFrac, maxFrac } = part.rounding;
-	const exact = part.exact.map((e) => `${float(e.value)} to ${lit$2(`=${e.value}`)}`).join(", ");
-	const arms = [...part.exact.map((e) => ({
-		key: `=${e.value}`,
-		parts: e.parts
-	})), ...part.arms].map((a) => `${inner}${lit$2(a.key)} -> ${expr$2(a.parts, inner, rt)}\n`).join("");
-	return `when (${`${rt}.plural(${on}, ${float(part.offset)}, listOf(${exact}), ${rt}::r${part.rules}, ${minFrac}, ${maxFrac})`}) {\n${arms}${inner}else -> ${expr$2(part.other, inner, rt)}\n${indent}}`;
-}
-function member$1(m, name, rt) {
-	const branches = m.bodies.map((b) => `            ${b.locales.map(entry).join(", ")} -> ${expr$2(b.parts, "            ", rt)}\n`).join("");
-	const argDocs = m.args.filter((a) => a.doc !== void 0).map((a) => `@param ${argName$2(a.name)} ${a.doc}`);
-	const head = doc$3(argDocs.length > 0 ? [
-		...m.doc,
-		"",
-		...argDocs
-	] : m.doc, "    ");
-	const body = `when (this) {\n${branches}        }`;
-	if (m.args.length === 0) return `${head}    val ${name}: String\n        get() = ${body}\n`;
-	return `${head}    fun ${name}(${m.args.map((a) => `${argName$2(a.name)}: ${a.type === "number" ? "Number" : "String"}`).join(", ")}): String {\n${m.args.filter((a) => a.type === "number").map((a) => `        val ${argName$2(a.name)} = ${argName$2(a.name)}.toDouble()\n`).join("")}        return ${body}\n    }\n`;
-}
-function formatConst$2(spec, i) {
-	const affix = ([prefix, suffix]) => `${lit$2(prefix)} to ${lit$2(suffix)}`;
-	return `    val F${i} = Format(\n${[
-		spec.minInt,
-		spec.minFrac,
-		spec.maxFrac,
-		spec.shift,
-		spec.grouping.primary,
-		spec.grouping.secondary,
-		spec.grouping.min,
-		lit$2(spec.decimal),
-		lit$2(spec.group),
-		spec.digits === void 0 ? "null" : `listOf(${spec.digits.map(lit$2).join(", ")})`,
-		affix(spec.positive),
-		affix(spec.negative),
-		affix(spec.zero),
-		affix(spec.negativeZero),
-		lit$2(spec.infinity),
-		lit$2(spec.negativeInfinity)
-	].map((f) => `        ${f}`).join(",\n")},\n    )\n`;
-}
-const NUMBER$2 = `
-    /** A number format, taken apart when the file was generated. */
-    class Format(
-        val minInt: Int,
-        val minFrac: Int,
-        val maxFrac: Int,
-        val shift: Int,
-        val primary: Int,
-        val secondary: Int,
-        val minGroup: Int,
-        val decimal: String,
-        val group: String,
-        val digits: List<String>?,
-        val positive: Pair<String, String>,
-        val negative: Pair<String, String>,
-        val zero: Pair<String, String>,
-        val negativeZero: Pair<String, String>,
-        val infinity: String,
-        val negativeInfinity: String,
-    )
-
-    /** \`value\` as \`format\` writes it, or \`fallback\` where it isn't a number. */
-    fun number(value: Double, format: Format, fallback: String): String {
-        if (value.isNaN()) return fallback
-        if (value.isInfinite()) return if (value > 0) format.infinity else format.negativeInfinity
-        val (written, frac) = digits(Math.abs(value), format.shift, format.minFrac, format.maxFrac)
-        val zero = (written + frac).all { it == '0' }
-        val negative = value.toRawBits() < 0
-        val (prefix, suffix) = if (zero) (if (negative) format.negativeZero else format.zero) else (if (negative) format.negative else format.positive)
-        val int = written.padStart(maxOf(format.minInt, 1), '0')
-        val grouped = format.minGroup > 0 && int.length >= format.primary + format.minGroup
-        val out = StringBuilder(prefix)
-        for ((i, digit) in int.withIndex()) {
-            val left = int.length - i
-            if (grouped && i > 0 && (left == format.primary || (left > format.primary && (left - format.primary) % format.secondary == 0))) {
-                out.append(format.group)
-            }
-            out.append(shown(digit, format))
-        }
-        if (frac.isNotEmpty()) {
-            out.append(format.decimal)
-            for (digit in frac) out.append(shown(digit, format))
-        }
-        return out.append(suffix).toString()
-    }
-
-    private fun shown(digit: Char, format: Format): String = format.digits?.get(digit - '0') ?: digit.toString()
-
-    /**
-     * The shortest digits that read back as \`value\`, as \`Intl\` rounds them: moved \`shift\` places
-     * right, rounded half away from zero to \`max\` fraction digits, and trailing zeros cut to \`min\`.
-     */
-    fun digits(value: Double, shift: Int, min: Int, max: Int): Pair<String, String> {
-        // \`toString\` writes the shortest digits that read back, with an exponent past a size.
-        val plain = java.math.BigDecimal(value.toString()).toPlainString()
-        val int = plain.substringBefore('.')
-        val all = (int + plain.substringAfter('.', "")).map { it - '0' }.toMutableList()
-        var point = int.length + shift
-        while (all.size <= point + max) all.add(0)
-        val next = all[point + max]
-        while (all.size > point + max) all.removeAt(all.size - 1)
-        if (next >= 5) {
-            var at = all.size - 1
-            while (at >= 0 && all[at] == 9) all[at--] = 0
-            if (at < 0) {
-                all.add(0, 1)
-                point += 1
-            } else {
-                all[at] += 1
-            }
-        }
-        val frac = all.subList(point, all.size).toMutableList()
-        while (frac.size > min && frac.last() == 0) frac.removeAt(frac.size - 1)
-        return all.subList(0, point).dropWhile { it == 0 }.joinToString("") to frac.joinToString("")
-    }
-`;
-const PLURAL$2 = `
-    /** CLDR's plural operands of a number as written. */
-    class Operands(val n: Double, val i: Double, val v: Double, val w: Double, val f: Double, val t: Double, val c: Double, val e: Double)
-
-    /** The arm a plural takes: the \`=N\` that \`value\` equals, else the category of \`value\` less \`offset\`. */
-    fun plural(value: Double, offset: Double, exact: List<Pair<Double, String>>, rules: (Operands) -> String, min: Int, max: Int): String =
-        exact.firstOrNull { it.first == value }?.second ?: category(rules, value - offset, min, max)
-
-    /** The category \`rules\` give \`value\`, rounded to between \`min\` and \`max\` fraction digits. */
-    private fun category(rules: (Operands) -> String, value: Double, min: Int, max: Int): String {
-        if (!value.isFinite()) return "other"
-        val (written, frac) = digits(Math.abs(value), 0, min, max)
-        val int = written.ifEmpty { "0" }
-        val trimmed = frac.trimEnd('0')
-        val read = { s: String -> s.toDoubleOrNull() ?: 0.0 }
-        return rules(
-            Operands(
-                n = read(if (frac.isEmpty()) int else "$int.$frac"),
-                i = read(int),
-                v = frac.length.toDouble(),
-                w = trimmed.length.toDouble(),
-                f = read(frac),
-                t = read(trimmed),
-                c = 0.0,
-                e = 0.0,
-            ),
-        )
-    }
-
-    /** An integer in the range, as CLDR's ranges hold. */
-    private fun within(value: Double, from: Double, to: Double): Boolean = value % 1.0 == 0.0 && value >= from && value <= to
-
-    /** \`Math.round\`: half up, toward positive infinity. */
-    fun round(value: Double): Double {
-        val floor = Math.floor(value)
-        return if (value - floor >= 0.5) floor + 1 else floor
-    }
-`;
-function kotlinFile(model, target, banner) {
-	const name = target.name;
-	const rt = `${name}Runtime`;
-	const names = model.messages.map((m) => [m.key, ident$2(leading(camel(m.words)))]);
-	checkNames("kotlin", names, [
-		"tag",
-		"name",
-		"ordinal",
-		"entries",
-		"negotiate",
-		"SOURCE"
-	]);
-	const entries = model.locales.map((l) => `    /** \`${l}\`${l === model.source ? ", the source" : ""}. */\n    ${entry(l)}(${lit$2(l)})`).join(",\n");
-	const members = model.messages.map((m, i) => member$1(m, names[i][1], rt)).join("\n");
-	const rules = model.rules.map(({ name: rule, rules }, i) => {
-		return `    /** ${rule} */\n    fun r${i}(o: Operands): String {\n${rules.map(([category, condition]) => `        if (${conditionCode(condition, {
-			field: (op) => `o.${op}`,
-			mod: (v, by) => `${v} % ${by}`,
-			within: (v, from, to) => `within(${v}, ${from}, ${to})`
-		})}) return ${lit$2(category)}\n`).join("")}        return "other"\n    }\n`;
-	}).join("\n");
-	const runtime = model.formats.length + model.rules.length === 0 ? "" : `
-/** What formats the messages, generated with them. */
-private object ${rt} {${NUMBER$2}${model.rules.length > 0 ? PLURAL$2 : ""}
-${model.formats.map(formatConst$2).join("\n")}${rules === "" ? "" : `\n${rules}`}}
-`;
-	return `${banner}
-@file:Suppress("unused", "NAME_SHADOWING", "KotlinConstantConditions", "ConvertTwoComparisonsToRangeCheck")
-${target.package === void 0 ? "" : `\npackage ${target.package}\n`}
-/** A locale the catalog is written or translated in, and its messages. */
-enum class ${name}(val tag: String) {
-${entries};
-
-${members}
-    companion object {
-        /** The locale the catalog is written in, which every message falls back to. */
-        val SOURCE: ${name} = ${entry(model.source)}
-
-        /**
-         * The best locale for what was asked, most preferred first: each tag tries an exact match, then
-         * its parents (\`pt-BR\` finds \`pt\`), then any locale of its language. The source if none is.
-         */
-        fun negotiate(requested: List<String>): ${name} {
-            fun language(tag: String) = tag.substringBefore('-').lowercase()
-            for (want in requested) {
-                var tag = want
-                while (true) {
-                    entries.firstOrNull { it.tag.equals(tag, ignoreCase = true) }?.let { return it }
-                    val cut = tag.lastIndexOf('-')
-                    if (cut < 0) break
-                    tag = tag.substring(0, cut)
-                }
-                entries.firstOrNull { language(it.tag) == language(want) }?.let { return it }
-            }
-            return SOURCE
-        }
-    }
+	const node = doc.get(key, true);
+	if (translation.trim() === "") doc.delete(key);
+	else if (isScalar(node)) {
+		node.value = translation;
+		if (translation.includes("\n")) node.type = Scalar.BLOCK_LITERAL;
+	} else doc.set(key, translation);
+	return isMap(doc.contents) && doc.contents.items.length === 0 ? "" : print(doc);
 }
-${runtime}`;
+// src/tools/native/emit.ts
+/** Words from an identifier written any way: `userName`, `user-name` and `user_name` are user, name. */
+function wordsOf(name) {
+	return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean).map((w) => w.toLowerCase());
+}
+const capital = (w) => w.charAt(0).toUpperCase() + w.slice(1);
+const snake = (words) => words.join("_");
+const pascal = (words) => words.map(capital).join("");
+const camel = (words) => words.map((w, i) => i === 0 ? w : capital(w)).join("");
+const upper = (words) => words.join("_").toUpperCase();
+/** An identifier can't start with a digit, so `404.title` is `_404Title`. */
+function leading(name) {
+	return /^[0-9]/.test(name) ? `_${name}` : name;
+}
+/** A double literal every target reads as one: `0.0`, `1.5`, `1e21`. */
+function float(value) {
+	const s = String(value).replace("e+", "e");
+	return /[.e]/.test(s) ? s : `${s}.0`;
+}
+/** Characters that print nothing, or look like a space, written as escapes so the code shows them. */
+const INVISIBLE = /[\u{a0}\u{61c}\u{180e}\u{2000}-\u{200f}\u{2028}-\u{202f}\u{205f}-\u{206f}\u{feff}]/gu;
+/** Text for a doc comment, with what prints nothing written as `\u{…}`: Rust refuses direction marks there. */
+function docText(line) {
+	return line.replace(INVISIBLE, (c) => `\\u{${c.charCodeAt(0).toString(16)}}`);
+}
+/** A string literal: JSON's escapes, `\u{…}` where the target writes them so (Rust, Swift), and `$` escaped in Kotlin. */
+function stringLiteral(value, language) {
+	const json = JSON.stringify(value).replace(INVISIBLE, (c) => `\\u${c.charCodeAt(0).toString(16).padStart(4, "0")}`);
+	if (language === "kotlin") return json.replaceAll("$", "\\$");
+	return json.replace(/\\u([0-9a-f]{4})/g, (_, hex) => `\\u{${hex.replace(/^0+/, "")}}`);
+}
+/**
+* A plural condition as an expression over operands `o`: `field(op)` reads one, `mod` takes a
+* remainder, `within` tests a range as CLDR does (integers only). `&&`, `||` and `!` are every
+* target's.
+*/
+function conditionCode(condition, code) {
+	const ors = condition.map((and) => and.map((r) => {
+		const value = r.mod === void 0 ? code.field(r.operand) : code.mod(code.field(r.operand), float(r.mod));
+		if (r.ranges.length === 1 && r.ranges[0][0] === r.ranges[0][1]) return `${value} ${r.negated ? "!=" : "=="} ${float(r.ranges[0][0])}`;
+		const any = r.ranges.map(([from, to]) => from === to ? `${value} == ${float(from)}` : code.within(value, float(from), float(to))).join(" || ");
+		return r.negated ? `!(${any})` : r.ranges.length > 1 ? `(${any})` : any;
+	}).join(" && "));
+	return ors.length > 1 ? ors.map((o) => o.includes(" && ") ? `(${o})` : o).join(" || ") : ors[0];
+}
+/** Fails with the keys whose names meet, or meet a name the file already has. */
+function checkNames(language, named, taken) {
+	const seen = new Map(taken.map((t) => [t, "a name the file already has"]));
+	for (const [key, name] of named) {
+		const other = seen.get(name);
+		if (other !== void 0) throw new Error(`${language}: ${key} is named ${name}, as ${other} is: rename one, or change the target's keys`);
+		seen.set(name, key);
+	}
+}
+// src/tools/native/date.ts
+/** Dates the spec must format as `Intl` does: every month and weekday, midnight, noon and the hours around them, and two-digit years. */
+const SAMPLES$1 = [
+	Date.UTC(2001, 0, 5, 1, 2, 3),
+	Date.UTC(2001, 10, 25, 13, 42, 53),
+	Date.UTC(1999, 11, 31, 23, 59, 59),
+	Date.UTC(2e3, 1, 29, 0, 0, 0),
+	Date.UTC(2024, 6, 4, 12, 0, 0),
+	Date.UTC(2024, 6, 4, 12, 30, 5),
+	Date.UTC(1970, 0, 1, 0, 0, 0),
+	Date.UTC(2099, 8, 9, 9, 9, 9),
+	Date.UTC(2010, 4, 15, 18, 45, 0),
+	Date.UTC(2026, 2, 10, 6, 15, 30),
+	Date.UTC(2005, 9, 31, 21, 7, 41),
+	...Array.from({ length: 12 }, (_, m) => Date.UTC(2023, m, 1 + m * 2, m * 2, m * 5, m * 4)),
+	...Array.from({ length: 24 }, (_, h) => Date.UTC(2022, 3, 3 + h % 7, h, 30, 0))
+];
+/** The fields of a date in UTC, which the spec is checked in. */
+function fieldsOf(date) {
+	const d = new Date(date);
+	return {
+		year: d.getUTCFullYear(),
+		month: d.getUTCMonth() + 1,
+		day: d.getUTCDate(),
+		hour: d.getUTCHours(),
+		minute: d.getUTCMinutes(),
+		second: d.getUTCSeconds(),
+		weekday: d.getUTCDay()
+	};
+}
+const HOUR_CYCLES = /* @__PURE__ */ new Set([
+	"h11",
+	"h12",
+	"h23",
+	"h24"
+]);
+/**
+* What a format with `options` takes in `locale`. Throws a sentence saying what a native target
+* can't reproduce, which the caller puts in front of a fix.
+*/
+function dateSpec(locale, options = {}) {
+	if (options.timeZone !== void 0) throw new Error(`it names the time zone ${options.timeZone}, which native code can't look up`);
+	const format = new Intl.DateTimeFormat(locale, {
+		...options,
+		timeZone: "UTC"
+	});
+	const resolved = format.resolvedOptions();
+	if (resolved.calendar !== "gregory" && resolved.calendar !== "iso8601") throw new Error(`it counts in the ${resolved.calendar} calendar`);
+	const native = new Intl.NumberFormat(locale, {
+		numberingSystem: resolved.numberingSystem,
+		useGrouping: false
+	});
+	const digits = Array.from({ length: 10 }, (_, d) => native.format(d));
+	const ascii = (text) => text.replace(/./gu, (c) => digits.includes(c) ? String(digits.indexOf(c)) : c);
+	/** The text `type` takes at `date`, in ASCII digits. */
+	const partAt = (date, type) => ascii(format.formatToParts(date).find((p) => p.type === type)?.value ?? "");
+	const isNumber = (text) => /^[0-9]+$/.test(text);
+	const padOf = (date, type) => partAt(date, type).startsWith("0") ? 2 : 1;
+	const pieces = [];
+	for (const part of format.formatToParts(SAMPLES$1[1])) switch (part.type) {
+		case "literal":
+			pieces.push({
+				type: "text",
+				value: part.value
+			});
+			break;
+		case "year":
+			pieces.push(ascii(part.value) === "01" ? {
+				type: "number",
+				field: "year2",
+				pad: 2
+			} : {
+				type: "number",
+				field: "year",
+				pad: 1
+			});
+			break;
+		case "month": {
+			const names = Array.from({ length: 12 }, (_, m) => format.formatToParts(Date.UTC(2023, m, 15, 12)).find((p) => p.type === "month").value);
+			if (names.every((name) => isNumber(ascii(name)))) pieces.push({
+				type: "number",
+				field: "month",
+				pad: padOf(Date.UTC(2023, 0, 15, 12), "month")
+			});
+			else pieces.push({
+				type: "name",
+				field: "month",
+				names
+			});
+			break;
+		}
+		case "day":
+			pieces.push({
+				type: "number",
+				field: "day",
+				pad: padOf(Date.UTC(2023, 0, 5, 12), "day")
+			});
+			break;
+		case "weekday":
+			pieces.push({
+				type: "name",
+				field: "weekday",
+				names: Array.from({ length: 7 }, (_, d) => format.formatToParts(Date.UTC(2023, 0, 1 + d, 12)).find((p) => p.type === "weekday").value)
+			});
+			break;
+		case "hour": {
+			const cycle = resolved.hourCycle;
+			if (cycle === void 0 || !HOUR_CYCLES.has(cycle)) throw new Error("its hours follow no clock native code knows");
+			pieces.push({
+				type: "hour",
+				cycle,
+				pad: padOf(Date.UTC(2023, 0, 5, 1), "hour")
+			});
+			break;
+		}
+		case "minute":
+		case "second":
+			pieces.push({
+				type: "number",
+				field: part.type,
+				pad: padOf(Date.UTC(2023, 0, 5, 1, 5, 5), part.type)
+			});
+			break;
+		case "dayPeriod": {
+			const byHour = Array.from({ length: 24 }, (_, hour) => format.formatToParts(Date.UTC(2023, 0, 5, hour, 30)).find((p) => p.type === "dayPeriod").value);
+			const halves = byHour.every((name, hour) => name === byHour[hour < 12 ? 0 : 12]);
+			pieces.push({
+				type: "name",
+				field: "dayPeriod",
+				names: halves ? [byHour[0], byHour[12]] : byHour
+			});
+			break;
+		}
+		default: throw new Error(`it writes the ${part.type}, which native code can't`);
+	}
+	const spec = {
+		pieces,
+		...digits.join("") !== "0123456789" && { digits }
+	};
+	for (const sample of SAMPLES$1) {
+		const expected = format.format(sample);
+		const actual = formatDate(spec, fieldsOf(sample));
+		if (actual !== expected) throw new Error(`it writes ${new Date(sample).toISOString()} as "${expected}", which native code would write as "${actual}"`);
+	}
+	return spec;
+}
+/** The hour as a clock with `cycle` shows it. */
+function hourOn(cycle, hour) {
+	if (cycle === "h23") return hour;
+	if (cycle === "h24") return hour === 0 ? 24 : hour;
+	if (cycle === "h11") return hour % 12;
+	return (hour + 11) % 12 + 1;
+}
+/**
+* A piece's number, or a name piece's index into its names, as an expression in the integer
+* arithmetic Rust, Swift and Kotlin share. Keep in step with `formatDate`.
+*/
+function pieceExpr(piece, at) {
+	if (piece.type === "hour") {
+		const hour = at("hour");
+		if (piece.cycle === "h23") return hour;
+		if (piece.cycle === "h24") return `(${hour} + 23) % 24 + 1`;
+		return piece.cycle === "h11" ? `${hour} % 12` : `(${hour} + 11) % 12 + 1`;
+	}
+	if (piece.type === "number") return piece.field === "year2" ? `(${at("year")} % 100 + 100) % 100` : at(piece.field);
+	if (piece.field === "month") return `${at("month")} - 1`;
+	if (piece.field === "weekday") return at("weekday");
+	return piece.names.length === 24 ? at("hour") : `${at("hour")} / 12`;
+}
+/** Which of a name piece's `count` names `date` takes. */
+function nameIndex(field, count, date) {
+	if (field === "month") return date.month - 1;
+	if (field === "weekday") return date.weekday;
+	return count === 24 ? date.hour : date.hour < 12 ? 0 : 1;
+}
+/** `date` as the spec writes it: the reference for the code each target generates. */
+function formatDate(spec, date) {
+	const digits = spec.digits;
+	const number = (value, pad) => {
+		const text = String(value).padStart(pad, "0");
+		return digits === void 0 ? text : text.replace(/[0-9]/g, (d) => digits[Number(d)]);
+	};
+	return spec.pieces.map((piece) => {
+		if (piece.type === "text") return piece.value;
+		if (piece.type === "hour") return number(hourOn(piece.cycle, date.hour), piece.pad);
+		if (piece.type === "number") return number(piece.field === "year2" ? (date.year % 100 + 100) % 100 : date[piece.field], piece.pad);
+		return piece.names[nameIndex(piece.field, piece.names.length, date)];
+	}).join("");
 }
 // src/tools/native/number.ts
 const NUMBER_PARTS = /* @__PURE__ */ new Set([
@@ -4015,10 +4311,22 @@ function parseRelation(source) {
 * tree per locale it renders in, with every fallback resolved here, so the generated code has no
 * lookup to do. Number formats and plural rules are read from `Intl` and CLDR once, and numbered.
 */
-/** Whether a target takes `key`, and the prefix that took it in (longest first), which its name leaves out. */
-function prefixOf(target, key) {
-	if (target.keys === void 0) return "";
-	return [...target.keys].sort((a, b) => b.length - a.length).find((p) => key.startsWith(`${p}.`));
+/**
+* The words a target names `key` by, less the prefix that took it in (longest first): `tray.quit-app`
+* is quit, app under `['tray']`. Nothing when the target doesn't take the key.
+*/
+function wordsFor(target, key) {
+	return restOf(target, key)?.split(/[.\-_]/).filter(Boolean);
+}
+/** `key` less the prefix that took it in, as written: `tray.quit-app` is `quit-app` under `['tray']`. */
+function restOf(target, key) {
+	const prefix = target.keys === void 0 ? "" : [...target.keys].sort((a, b) => b.length - a.length).find((p) => key.startsWith(`${p}.`));
+	if (prefix === void 0) return void 0;
+	return key.slice(prefix === "" ? 0 : prefix.length + 1);
+}
+/** The locale whose text `locale` shows for `key`: its own, else the first down its fallback chain that has it. */
+function foundIn(key, locale, locales, asts) {
+	return chainOf(locale, locales, locales[0]).find((l) => asts.get(l)?.has(key));
 }
 /** Values a file declares once each, numbered by what they hold, so locales that format alike share one. */
 var Numbered = class {
@@ -4038,17 +4346,17 @@ function nativeModel(target, catalog, locales, entries) {
 	const source = locales[0];
 	const asts = new Map([...entries].map(([locale, list]) => [locale, new Map(list)]));
 	const formats = new Numbered();
+	const dates = new Numbered();
 	const rules = new Numbered();
 	const problems = [];
 	const messages = [];
 	for (const m of catalog.messages) {
-		const prefix = prefixOf(target, m.key);
-		if (prefix === void 0) continue;
-		const words = m.key.slice(prefix === "" ? 0 : prefix.length + 1).split(/[.\-_]/).filter(Boolean);
+		const words = wordsFor(target, m.key);
+		if (words === void 0) continue;
 		const bodies = /* @__PURE__ */ new Map();
 		let failed = false;
 		for (const locale of locales) {
-			const found = chainOf(locale, locales, source).find((l) => asts.get(l)?.has(m.key));
+			const found = foundIn(m.key, locale, locales, asts);
 			if (found === void 0) continue;
 			const body = bodies.get(found);
 			if (body !== void 0) {
@@ -4058,7 +4366,11 @@ function nativeModel(target, catalog, locales, entries) {
 			try {
 				bodies.set(found, {
 					locales: [locale],
-					parts: parts(asts.get(found).get(m.key), found, formats, rules, null)
+					parts: parts(asts.get(found).get(m.key), found, {
+						formats,
+						dates,
+						rules
+					}, null)
 				});
 			} catch (e) {
 				failed = true;
@@ -4077,7 +4389,7 @@ function nativeModel(target, catalog, locales, entries) {
 			doc: docOf(m),
 			args: [...m.args].map(([name, type]) => ({
 				name,
-				type: type === "number" ? "number" : "string",
+				type: type === "number" ? "number" : type === "Date | number" ? "date" : "string",
 				doc: m.argDocs.has(name) ? docText(m.argDocs.get(name)) : void 0
 			})),
 			bodies: [...bodies.values()]
@@ -4089,6 +4401,7 @@ function nativeModel(target, catalog, locales, entries) {
 			source,
 			messages,
 			formats: formats.list,
+			dates: dates.list,
 			rules: rules.list
 		},
 		problems
@@ -4107,6 +4420,22 @@ function docOf(m) {
 const LEAVE_OUT = "or leave the key out of this target's `keys`";
 /** Specs by locale and options, kept across runs: taking a format apart checks it against `Intl` dozens of times. */
 const SPECS = /* @__PURE__ */ new Map();
+/** Date specs as `SPECS` keeps number specs. */
+const DATE_SPECS = /* @__PURE__ */ new Map();
+function date(dates, locale, options) {
+	const key = JSON.stringify([locale, options ?? {}]);
+	let spec = DATE_SPECS.get(key);
+	if (spec === void 0) {
+		try {
+			spec = dateSpec(locale, options);
+		} catch (e) {
+			spec = new Error(`native code can't format this date in ${locale}: ${e.message}. Format it another way, ${LEAVE_OUT}`, { cause: e });
+		}
+		DATE_SPECS.set(key, spec);
+	}
+	if (spec instanceof Error) throw spec;
+	return dates.add(spec);
+}
 function format(formats, locale, options) {
 	const key = JSON.stringify([locale, options ?? {}]);
 	let spec = SPECS.get(key);
@@ -4121,7 +4450,8 @@ function format(formats, locale, options) {
 	if (spec instanceof Error) throw spec;
 	return formats.add(spec);
 }
-function parts(elements, locale, formats, rules, pound) {
+function parts(elements, locale, declared, pound) {
+	const { formats, dates, rules } = declared;
 	const out = [];
 	const text = (value) => {
 		const last = out.at(-1);
@@ -4139,11 +4469,18 @@ function parts(elements, locale, formats, rules, pound) {
 	};
 	const arms = (options, own) => Object.entries(options).map(([key, option]) => ({
 		key,
-		parts: parts(option.value, locale, formats, rules, own)
+		parts: parts(option.value, locale, declared, own)
 	}));
 	for (const el of elements) {
 		if (Object.keys(optionArgsOf(el) ?? {}).length > 0) throw new Error(`{${"value" in el ? el.value : ""}} takes a formatting option from an argument: native code formats with options the message fixes, ${LEAVE_OUT}`);
-		if (isDateElement(el) || isTimeElement(el)) throw new Error(`{${el.value}} is a date, which native code doesn't format: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`);
+		if (isDateElement(el) || isTimeElement(el)) {
+			placed(el, el.value, {
+				type: "date",
+				arg: el.value,
+				format: date(dates, locale, dateOptions(el))
+			});
+			continue;
+		}
 		if (isNumberElement(el)) {
 			const fallback = placeholderOf(el, el.value).fallback;
 			placed(el, el.value, {
@@ -4228,7 +4565,639 @@ function parts(elements, locale, formats, rules, pound) {
 			default: throw new Error(`prosebook: no native writer for ICU element type ${el.type}`);
 		}
 	}
-	return out;
+	return out;
+}
+// src/tools/native/printf.ts
+/**
+* Messages as printf-style format strings, for the targets whose platform fills values in itself:
+* Android's resources and Apple's `.strings` and `.stringsdict` files. Text and plain `{name}` placeholders, as `%N$s`
+* with N the argument's place in the message's arguments, so a translation can put them in another
+* order; anything `Intl` would format fails with the fix.
+*/
+/** The context and what each argument holds, on one line, for the comment above an entry. */
+function noteOf(m) {
+	return docText([m.context, ...[...m.args.keys()].map((a) => m.argDocs.has(a) ? `${a}: ${m.argDocs.get(a).replace(/\.$/, "")}.` : void 0)].filter((l) => l !== void 0 && l !== "").join(" "));
+}
+/** What a plural's arms may hold as its count: `#`, or the count as a plain `:number` or `:integer`. */
+function isCount(el, count) {
+	if (el.type === TYPE$1.pound) return true;
+	if (!isNumberElement(el) || el.value !== count) return false;
+	const options = Object.entries(numberOptions(el) ?? {});
+	return options.length === 0 || options.length === 1 && options[0][0] === "maximumFractionDigits" && options[0][1] === 0;
+}
+/**
+* Throws, with the fix, where a plural asks for more than a platform's plurals pick on: one count,
+* as an integer, by its cardinal category.
+*/
+function checkPlural(plural, holder) {
+	const named = `{${plural.value}}`;
+	if (plural.pluralType === "ordinal") throw new Error(`${named} is an ordinal, and ${holder.plurals} are cardinal only: write a key per case and pick one in code, ${LEAVE_OUT}`);
+	if (plural.offset !== 0) throw new Error(`${named} has an offset, which ${holder.plurals} don't: count without it, and say the rest in each arm, ${LEAVE_OUT}`);
+	const selection = selectionOf(plural);
+	if (selection !== void 0 && (selection.fn.name !== "integer" || Object.keys(selection.fn.options).length > 0)) throw new Error(`${named} selects with :${selection.fn.name} and its options, and ${holder.platform} selects on the count as an integer: select with a bare :number or :integer, ${LEAVE_OUT}`);
+	const exact = Object.keys(plural.options).filter((k) => k.startsWith("="));
+	if (exact.length > 0) throw new Error(`${named} has the arm ${exact.join(", ")}, and ${holder.plurals} have none for one number${holder.exact}: say it in a category's arm, or write a key for it and pick that in code, ${LEAVE_OUT}`);
+}
+/** `elements` as a format string over `args`; inside a plural, its `count` is `%N$d` (or `lld`). */
+function formatString(elements, args, printf, count) {
+	const formatted = args.length > 0;
+	const place = (el, name, conversion) => {
+		const at = args.indexOf(name);
+		if (at < 0) throw new Error(`{${name}} is not an argument of this message: say it in the source text too`);
+		const { isolate } = placeholderOf(el, name);
+		const spec = `%${at + 1}$${conversion}`;
+		return isolate === void 0 ? spec : `${printf.escape(isolate[0], formatted)}${spec}${printf.escape(isolate[1], formatted)}`;
+	};
+	let out = "";
+	for (const el of elements) {
+		if (count !== void 0 && isCount(el, count)) {
+			out += place(el, count, printf.count);
+			continue;
+		}
+		if (isDateElement(el) || isTimeElement(el)) throw new Error(`{${el.value}} is a date, which ${printf.holder} don't format: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`);
+		if (isNumberElement(el)) throw new Error(`{${el.value}} is a formatted number, and ${printf.platform} fills values in with ${printf.formatter}, not Intl: pass it formatted, as a plain {${el.value}}, ${LEAVE_OUT}`);
+		switch (el.type) {
+			case TYPE$1.literal:
+				out += printf.escape(el.value, formatted);
+				break;
+			case TYPE$1.argument:
+				out += place(el, el.value, printf.string);
+				break;
+			case TYPE$1.pound:
+				out += "#";
+				break;
+			case TYPE$1.select: throw new Error(`{${el.value}} is a select, which ${printf.holder} can't hold: write a key per case and pick one in code, ${LEAVE_OUT}`);
+			case TYPE$1.plural: throw new Error(printf.plural(el.value));
+			case TYPE$1.tag: throw new Error(`<${el.value}> is a tag, and ${printf.holder} here hold plain text: say it without the tag, ${LEAVE_OUT}`);
+			default: throw new Error(`prosebook: no ${printf.platform} writer for ICU element type ${el.type}`);
+		}
+	}
+	return out;
+}
+// src/tools/native/android.ts
+/**
+* The catalog as Android string resources: `values/<name>.xml` for the source and
+* `values-<qualifier>/<name>.xml` for every other locale, each holding what that locale shows, every
+* fallback resolved. An app with the Kotlin target still needs these: its manifest, shortcuts and
+* other XML resources name strings as `@string/…`, which only a resource answers.
+*
+* Android fills values in with `String.format` and picks a plural's arm itself, from its own CLDR
+* rules, so this takes a narrower subset than the other targets, written straight from the ICU tree:
+* text, plain `{name}` placeholders, and one cardinal plural, with the text around it in each arm.
+*/
+const KEYWORDS$3 = new Set("abstract assert boolean break byte case catch char class const continue default do double else enum extends false final finally float for goto if implements import instanceof int interface long native new null package private protected public return short static strictfp super switch synchronized this throw throws transient true try void volatile while".split(" "));
+/**
+* A locale as Android's resource qualifier: `de`, `pt-rBR`, and BCP 47's own form, `b+sr+Latn`,
+* past what the old form holds (a script, a numeric region, a variant).
+*/
+function qualifierOf(locale) {
+	const [language = "", ...rest] = locale.split(/[-_]/);
+	const subtags = [language.toLowerCase(), ...rest.map((s) => s.length === 4 && /^[a-z]+$/i.test(s) ? s.charAt(0).toUpperCase() + s.slice(1).toLowerCase() : s.length === 2 ? s.toUpperCase() : s.toLowerCase())];
+	if (!(/^[a-z]{2,3}$/.test(subtags[0]) && (rest.length === 0 || rest.length === 1 && /^[A-Z]{2}$/.test(subtags[1])))) return `b+${subtags.join("+")}`;
+	return rest.length === 0 ? subtags[0] : `${subtags[0]}-r${subtags[1]}`;
+}
+/** Whitespace as aapt2 reads it: collapsed to one space, and trimmed at the ends, outside double quotes. */
+const LOOSE = /^[ \t\n\v\f\r]|[ \t\n\v\f\r]$|[ \t\n\v\f\r]{2}/;
+/**
+* Text as a resource holds it: XML's escapes, then Android's (`\`, `'`, `"`, a newline or a tab).
+* In a string that is formatted, `%` is doubled, so `String.format` writes one.
+*/
+function escape$1(text, formatted) {
+	const out = text.replaceAll("\\", "\\\\").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("'", "\\'").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("	", "\\t");
+	return formatted ? out.replaceAll("%", "%%") : out;
+}
+/**
+* A whole value: a leading `@` or `?` escaped, since either would make it a reference, and the value
+* quoted where its spaces would otherwise be collapsed or trimmed.
+*/
+function value$3(written) {
+	const out = /^[@?]/.test(written) ? `\\${written}` : written;
+	return LOOSE.test(out) ? `"${out}"` : out;
+}
+const PRINTF$1 = {
+	platform: "Android",
+	formatter: "String.format",
+	holder: "Android resources",
+	string: "s",
+	count: "d",
+	escape: escape$1,
+	plural: (name) => `{${name}} is a second plural in the message, and Android's <plurals> picks on one count: split it into a key per count, ${LEAVE_OUT}`
+};
+const PLURALS$1 = {
+	platform: "Android",
+	plurals: "Android's <plurals>",
+	exact: " (its zero is a category, which most languages never pick)"
+};
+/**
+* A message as `<string>`, or `<plurals>` when it holds a plural. Android's picks between whole
+* messages, so the text around the plural goes into each arm: the pseudo-locale's brackets, or a
+* sentence the plural ends.
+*/
+function resource(name, ast, args) {
+	const at = ast.findIndex((el) => el.type === TYPE$1.plural);
+	const plural = ast[at];
+	if (plural?.type !== TYPE$1.plural) {
+		const written = formatString(ast, args, PRINTF$1);
+		return `    <string name="${name}"${args.length === 0 && written.includes("%") ? " formatted=\"false\"" : ""}>${value$3(written)}</string>`;
+	}
+	const [before, after] = [ast.slice(0, at), ast.slice(at + 1)];
+	checkPlural(plural, PLURALS$1);
+	return `    <plurals name="${name}">\n${Object.entries(plural.options).map(([category, option]) => `        <item quantity="${category}">${value$3(formatString([
+		...before,
+		...option.value,
+		...after
+	], args, PRINTF$1, plural.value))}</item>`).join("\n")}\n    </plurals>`;
+}
+/** The context and what each argument holds, as the comment above an entry. */
+function comment(m) {
+	const said = noteOf(m);
+	return said === "" ? "" : `    <!-- ${said.replace(/-{2,}/g, "-")} -->\n`;
+}
+/** The files `target` writes, by path, or a problem for every message it can't hold. */
+function androidResources(target, catalog, locales, entries, banner) {
+	const source = locales[0];
+	const asts = new Map([...entries].map(([locale, list]) => [locale, new Map(list)]));
+	const taken = catalog.messages.flatMap((m) => {
+		const words = wordsFor(target, m.key);
+		return words === void 0 ? [] : [{
+			m,
+			name: leading(snake(words))
+		}];
+	});
+	checkNames("android", taken.map(({ m, name }) => [m.key, name]), []);
+	const problems = taken.filter((t) => KEYWORDS$3.has(t.name)).map(({ m, name }) => ({
+		severity: "error",
+		file: m.file,
+		key: m.key,
+		message: `android: ${m.key} is named ${name}, which Java keeps for itself: rename it`
+	}));
+	const bodies = new Map(locales.map((l) => [l, []]));
+	const failed = /* @__PURE__ */ new Set();
+	for (const { m, name } of taken) {
+		const args = [...m.args.keys()];
+		const written = /* @__PURE__ */ new Map();
+		for (const locale of locales) {
+			const found = foundIn(m.key, locale, locales, asts);
+			if (failed.has(m.key)) break;
+			if (found === void 0) continue;
+			let entry = written.get(found);
+			if (entry === void 0) {
+				try {
+					entry = `${comment(m)}${resource(name, asts.get(found).get(m.key), args)}`;
+				} catch (e) {
+					failed.add(m.key);
+					problems.push({
+						severity: "error",
+						file: fileOf(m, found, source),
+						key: m.key,
+						message: `android: ${e.message}`
+					});
+					continue;
+				}
+				written.set(found, entry);
+			}
+			bodies.get(locale).push(entry);
+		}
+	}
+	const head = `<!-- ${banner.replace(/^\/\/ /, "")} -->`;
+	return {
+		files: new Map(locales.map((locale) => {
+			const folder = locale === source ? "values" : `values-${qualifierOf(locale)}`;
+			const body = bodies.get(locale).join("\n");
+			const xml = `<?xml version="1.0" encoding="utf-8"?>\n${head}\n<resources>\n${body}${body === "" ? "" : "\n"}</resources>\n`;
+			return [join(target.out, folder, `${target.name}.xml`), xml];
+		})),
+		problems
+	};
+}
+// src/tools/native/apple.ts
+/**
+* The catalog as Apple `.strings` tables: `<locale>.lproj/<name>.strings` per locale, each holding
+* what that locale shows, every fallback resolved. Plain `.strings` and not a String Catalog, which
+* only Xcode compiles: an app bundled by other tools copies these into its `Resources` as they are.
+*
+* The Swift target covers what code shows; these are for what the system reads from a bundle. With
+* `plist`, the table is `InfoPlist`: the permission prompts and names in that Info.plist, an entry
+* per key it has, which its own text must match in the source locale.
+*/
+/** Text inside a `.strings` file's quotes; `%` doubled where the string has arguments. */
+function escape(text, formatted) {
+	const out = text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t");
+	return formatted ? out.replaceAll("%", "%%") : out;
+}
+const PRINTF = {
+	platform: "Apple",
+	formatter: "String(format:)",
+	holder: ".strings files",
+	string: "@",
+	count: "lld",
+	escape,
+	plural: (name) => `{${name}} is a plural inside another, which a .strings file can't hold: say it without, ${LEAVE_OUT}`
+};
+const xml = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const DICT = {
+	...PRINTF,
+	holder: ".stringsdict files",
+	escape: (text, formatted) => formatted ? xml(text).replaceAll("%", "%%") : xml(text),
+	plural: (name) => `{${name}} is a plural inside another plural's arm, which a .stringsdict here can't hold: write a key per case and pick one in code, ${LEAVE_OUT}`
+};
+const PLURALS = {
+	platform: "Apple",
+	plurals: "a .stringsdict's plurals",
+	exact: ""
+};
+/**
+* A message holding plurals as a `.stringsdict` entry: its format, with each plural a variable
+* (`%1$#@count@`) whose arms the system picks by the count's category, from its own CLDR rules.
+*/
+function dictEntry(name, ast, args) {
+	const variables = [];
+	const taken = /* @__PURE__ */ new Map();
+	let format = "";
+	for (const el of ast) {
+		if (el.type !== TYPE$1.plural) {
+			format += formatString([el], args, DICT);
+			continue;
+		}
+		checkPlural(el, PLURALS);
+		const base = el.value.replace(/\W/g, "_");
+		const seen = (taken.get(base) ?? 0) + 1;
+		taken.set(base, seen);
+		const variable = seen === 1 ? base : `${base}${seen}`;
+		format += `%${args.indexOf(el.value) + 1}$#@${variable}@`;
+		const arms = Object.entries(el.options).map(([category, option]) => `            <key>${category}</key>\n            <string>${formatString(option.value, args, DICT, el.value)}</string>\n`);
+		variables.push(`        <key>${variable}</key>\n        <dict>\n            <key>NSStringFormatSpecTypeKey</key>\n            <string>NSStringPluralRuleType</string>\n            <key>NSStringFormatValueTypeKey</key>\n            <string>${DICT.count}</string>\n${arms.join("")}        </dict>\n`);
+	}
+	return `    <key>${xml(name)}</key>\n    <dict>\n        <key>NSStringLocalizedFormatKey</key>\n        <string>${format}</string>\n${variables.join("")}    </dict>\n`;
+}
+const ENTITIES = {
+	amp: "&",
+	lt: "<",
+	gt: ">",
+	quot: "\"",
+	apos: "'"
+};
+/** An XML plist's string values by key, read as its text is: every `<key>` followed by a `<string>`. */
+function plistStrings(xml) {
+	const strings = /* @__PURE__ */ new Map();
+	for (const [, key, value] of xml.matchAll(/<key>([^<]*)<\/key>\s*(?:<string>([^<]*)<\/string>|<string\/>)/g)) strings.set(key, (value ?? "").replace(/&(amp|lt|gt|quot|apos|#x?[0-9a-f]+);/gi, (_, e) => e.startsWith("#") ? String.fromCodePoint(Number.parseInt(e.slice(/x/i.test(e[1]) ? 2 : 1), /x/i.test(e[1]) ? 16 : 10)) : ENTITIES[e.toLowerCase()]));
+	return strings;
+}
+/** The files `target` writes, by path, or a problem for every message it can't hold. */
+function appleStrings(target, root, catalog, locales, entries, banner) {
+	const source = locales[0];
+	const asts = new Map([...entries].map(([locale, list]) => [locale, new Map(list)]));
+	const problems = [];
+	const error = (m, message, file = m.file) => problems.push({
+		severity: "error",
+		file,
+		key: m.key,
+		message: `apple: ${message}`
+	});
+	const plist = target.plist;
+	const shown = plist === void 0 ? "" : relative(root, plist).replaceAll("\\", "/");
+	if (plist !== void 0 && !existsSync(plist)) throw new Error(`apple: ${shown} is missing: name the Info.plist the table translates`);
+	const strings = plist === void 0 ? void 0 : plistStrings(readFileSync(plist, "utf8"));
+	const byLower = new Map([...strings?.keys() ?? []].map((k) => [k.toLowerCase(), k]));
+	const taken = catalog.messages.flatMap((m) => {
+		const rest = restOf(target, m.key);
+		if (rest === void 0) return [];
+		if (strings === void 0) return [{
+			m,
+			name: rest
+		}];
+		const name = byLower.get(wordsFor(target, m.key).join("").toLowerCase());
+		if (name === void 0) {
+			error(m, `${m.key} names no string in ${shown}: spell one of its keys, as ns-camera-usage-description is NSCameraUsageDescription, or add it there`);
+			return [];
+		}
+		return [{
+			m,
+			name
+		}];
+	});
+	checkNames("apple", taken.map(({ m, name }) => [m.key, name]), []);
+	for (const { m, name } of taken) {
+		if (strings === void 0) continue;
+		if (m.args.size > 0) {
+			error(m, `${name} is shown as it is written, with nothing filled in: say it without {${[...m.args.keys()].join("}, {")}}`);
+			continue;
+		}
+		const text = staticLiteral(asts.get(source)?.get(m.key) ?? []);
+		if (text !== void 0 && text !== strings.get(name)) error(m, `${shown} says ${JSON.stringify(strings.get(name))} for ${name}: make it ${JSON.stringify(text)}, as the catalog says`);
+	}
+	const lines = new Map(locales.map((l) => [l, []]));
+	const dicts = new Map(locales.map((l) => [l, []]));
+	const failed = new Set(problems.map((p) => p.key));
+	for (const { m, name } of taken) {
+		if (failed.has(m.key)) continue;
+		const args = [...m.args.keys()];
+		const note = noteOf(m);
+		const head = note === "" ? "" : `/* ${note.replaceAll("*/", "* /")} */\n`;
+		const comment = note === "" ? "" : `    <!-- ${note.replace(/-{2,}/g, "-")} -->\n`;
+		const written = /* @__PURE__ */ new Map();
+		for (const locale of locales) {
+			const found = foundIn(m.key, locale, locales, asts);
+			if (found === void 0) continue;
+			let entry = written.get(found);
+			if (entry === void 0) {
+				const ast = asts.get(found).get(m.key);
+				const dict = ast.some((el) => el.type === TYPE$1.plural);
+				try {
+					entry = dict ? {
+						dict,
+						entry: `${comment}${dictEntry(name, ast, args)}`
+					} : {
+						dict,
+						entry: `${head}"${escape(name, false)}" = "${formatString(ast, args, PRINTF)}";\n`
+					};
+				} catch (e) {
+					error(m, e.message, fileOf(m, found, source));
+					break;
+				}
+				written.set(found, entry);
+			}
+			(entry.dict ? dicts : lines).get(locale).push(entry.entry);
+		}
+	}
+	const said = banner.replace(/^\/\/ /, "");
+	const files = new Map(locales.map((locale) => [join(target.out, `${locale}.lproj`, `${target.name}.strings`), [`/* ${said} */\n`, ...lines.get(locale)].join("\n")]));
+	if ([...dicts.values()].some((d) => d.length > 0)) for (const locale of locales) {
+		const body = dicts.get(locale).join("");
+		files.set(join(target.out, `${locale}.lproj`, `${target.name}.stringsdict`), `<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">\n<!-- ${said.replace(/-{2,}/g, "-")} -->\n<plist version="1.0">\n<dict>\n${body}</dict>\n</plist>\n`);
+	}
+	return {
+		files,
+		problems
+	};
+}
+// src/tools/native/kotlin.ts
+const KEYWORDS$2 = new Set("as break class continue do else false for fun if in interface is null object package return super this throw true try typealias typeof val var when while".split(" "));
+const ident$2 = (name) => KEYWORDS$2.has(name) ? `\`${name}\`` : name;
+const lit$2 = (value) => stringLiteral(value, "kotlin");
+const entry = (tag) => leading(upper(wordsOf(tag)));
+const argName$2 = (name) => ident$2(leading(camel(wordsOf(name))));
+function doc$3(lines, indent) {
+	return `${indent}/**\n${lines.map((l) => l.replaceAll("*/", "*\\/")).map((l) => l === "" ? `${indent} *` : `${indent} * ${l}`).join("\n")}\n${indent} */\n`;
+}
+/** The parts as an expression of type `String`, with `rt` the runtime object. */
+function expr$2(parts, indent, rt) {
+	if (parts.length === 0) return "\"\"";
+	return parts.map((p) => p.type === "text" ? lit$2(p.value) : value$2(p, indent, rt)).join(" + ");
+}
+function value$2(part, indent, rt) {
+	const inner = `${indent}    `;
+	if (part.type === "string") return argName$2(part.arg);
+	if (part.type === "number") return `${rt}.number(${part.offset === 0 ? argName$2(part.arg) : `${argName$2(part.arg)} - ${float(part.offset)}`}, ${rt}.F${part.format}, ${lit$2(part.fallback)})`;
+	if (part.type === "date") return `${rt}.d${part.format}(${argName$2(part.arg)})`;
+	if (part.type === "select") {
+		const arms = part.arms.map((a) => `${inner}${lit$2(a.key)} -> ${expr$2(a.parts, inner, rt)}\n`).join("");
+		return `when (${argName$2(part.arg)}) {\n${arms}${inner}else -> ${expr$2(part.other, inner, rt)}\n${indent}}`;
+	}
+	if (part.arms.length + part.exact.length === 0) return expr$2(part.other, indent, rt);
+	const arg = argName$2(part.arg);
+	const on = part.on === "round" ? `${rt}.round(${arg})` : part.on === "percent" ? `${arg} * 100.0` : arg;
+	const { minFrac, maxFrac } = part.rounding;
+	const exact = part.exact.map((e) => `${float(e.value)} to ${lit$2(`=${e.value}`)}`).join(", ");
+	const arms = [...part.exact.map((e) => ({
+		key: `=${e.value}`,
+		parts: e.parts
+	})), ...part.arms].map((a) => `${inner}${lit$2(a.key)} -> ${expr$2(a.parts, inner, rt)}\n`).join("");
+	return `when (${`${rt}.plural(${on}, ${float(part.offset)}, listOf(${exact}), ${rt}::r${part.rules}, ${minFrac}, ${maxFrac})`}) {\n${arms}${inner}else -> ${expr$2(part.other, inner, rt)}\n${indent}}`;
+}
+function member$1(m, name, rt) {
+	const branches = m.bodies.map((b) => `            ${b.locales.map(entry).join(", ")} -> ${expr$2(b.parts, "            ", rt)}\n`).join("");
+	const argDocs = m.args.filter((a) => a.doc !== void 0).map((a) => `@param ${argName$2(a.name)} ${a.doc}`);
+	const head = doc$3(argDocs.length > 0 ? [
+		...m.doc,
+		"",
+		...argDocs
+	] : m.doc, "    ");
+	const body = `when (this) {\n${branches}        }`;
+	if (m.args.length === 0) return `${head}    val ${name}: String\n        get() = ${body}\n`;
+	return `${head}    fun ${name}(${m.args.map((a) => `${argName$2(a.name)}: ${a.type === "number" ? "Number" : a.type === "date" ? "java.time.Instant" : "String"}`).join(", ")}): String {\n${m.args.map((a) => a.type === "number" ? `        val ${argName$2(a.name)} = ${argName$2(a.name)}.toDouble()\n` : a.type === "date" ? `        val ${argName$2(a.name)} = ${argName$2(a.name)}.atZone(java.time.ZoneId.systemDefault())\n` : "").join("")}        return ${body}\n    }\n`;
+}
+function formatConst$2(spec, i) {
+	const affix = ([prefix, suffix]) => `${lit$2(prefix)} to ${lit$2(suffix)}`;
+	return `    val F${i} = Format(\n${[
+		spec.minInt,
+		spec.minFrac,
+		spec.maxFrac,
+		spec.shift,
+		spec.grouping.primary,
+		spec.grouping.secondary,
+		spec.grouping.min,
+		lit$2(spec.decimal),
+		lit$2(spec.group),
+		spec.digits === void 0 ? "null" : `listOf(${spec.digits.map(lit$2).join(", ")})`,
+		affix(spec.positive),
+		affix(spec.negative),
+		affix(spec.zero),
+		affix(spec.negativeZero),
+		lit$2(spec.infinity),
+		lit$2(spec.negativeInfinity)
+	].map((f) => `        ${f}`).join(",\n")},\n    )\n`;
+}
+const FIELDS = {
+	year: "t.year",
+	month: "t.monthValue",
+	day: "t.dayOfMonth",
+	hour: "t.hour",
+	minute: "t.minute",
+	second: "t.second",
+	weekday: "(t.dayOfWeek.value % 7)"
+};
+/** A date format as a function of the date in the system's time zone. */
+function dateFn$2(spec, i) {
+	const digits = spec.digits === void 0 ? "null" : `G${i}`;
+	const at = (field) => FIELDS[field];
+	const lines = spec.pieces.map((piece) => {
+		if (piece.type === "text") return `append(${lit$2(piece.value)})`;
+		if (piece.type === "name") return `append(arrayOf(${piece.names.map(lit$2).join(", ")})[${pieceExpr(piece, at)}])`;
+		return `append(pad(${pieceExpr(piece, at)}, ${piece.pad}, ${digits}))`;
+	});
+	return `${spec.digits === void 0 ? "" : `    private val G${i} = arrayOf(${spec.digits.map(lit$2).join(", ")})\n`}    fun d${i}(t: java.time.ZonedDateTime): String = buildString {\n${lines.map((l) => `        ${l}\n`).join("")}    }\n`;
+}
+const DATE$2 = `
+    /** \`value\` written with at least \`width\` digits, in \`digits\` where the locale has its own. */
+    private fun pad(value: Int, width: Int, digits: Array<String>?): String {
+        val text = value.toString().padStart(width, '0')
+        return if (digits == null) text else text.map { if (it in '0'..'9') digits[it - '0'] else it.toString() }.joinToString("")
+    }
+`;
+const NUMBER$2 = `
+    /** A number format, taken apart when the file was generated. */
+    class Format(
+        val minInt: Int,
+        val minFrac: Int,
+        val maxFrac: Int,
+        val shift: Int,
+        val primary: Int,
+        val secondary: Int,
+        val minGroup: Int,
+        val decimal: String,
+        val group: String,
+        val digits: List<String>?,
+        val positive: Pair<String, String>,
+        val negative: Pair<String, String>,
+        val zero: Pair<String, String>,
+        val negativeZero: Pair<String, String>,
+        val infinity: String,
+        val negativeInfinity: String,
+    )
+
+    /** \`value\` as \`format\` writes it, or \`fallback\` where it isn't a number. */
+    fun number(value: Double, format: Format, fallback: String): String {
+        if (value.isNaN()) return fallback
+        if (value.isInfinite()) return if (value > 0) format.infinity else format.negativeInfinity
+        val (written, frac) = digits(Math.abs(value), format.shift, format.minFrac, format.maxFrac)
+        val zero = (written + frac).all { it == '0' }
+        val negative = value.toRawBits() < 0
+        val (prefix, suffix) = if (zero) (if (negative) format.negativeZero else format.zero) else (if (negative) format.negative else format.positive)
+        val int = written.padStart(maxOf(format.minInt, 1), '0')
+        val grouped = format.minGroup > 0 && int.length >= format.primary + format.minGroup
+        val out = StringBuilder(prefix)
+        for ((i, digit) in int.withIndex()) {
+            val left = int.length - i
+            if (grouped && i > 0 && (left == format.primary || (left > format.primary && (left - format.primary) % format.secondary == 0))) {
+                out.append(format.group)
+            }
+            out.append(shown(digit, format))
+        }
+        if (frac.isNotEmpty()) {
+            out.append(format.decimal)
+            for (digit in frac) out.append(shown(digit, format))
+        }
+        return out.append(suffix).toString()
+    }
+
+    private fun shown(digit: Char, format: Format): String = format.digits?.get(digit - '0') ?: digit.toString()
+
+    /**
+     * The shortest digits that read back as \`value\`, as \`Intl\` rounds them: moved \`shift\` places
+     * right, rounded half away from zero to \`max\` fraction digits, and trailing zeros cut to \`min\`.
+     */
+    fun digits(value: Double, shift: Int, min: Int, max: Int): Pair<String, String> {
+        // \`toString\` writes the shortest digits that read back, with an exponent past a size.
+        val plain = java.math.BigDecimal(value.toString()).toPlainString()
+        val int = plain.substringBefore('.')
+        val all = (int + plain.substringAfter('.', "")).map { it - '0' }.toMutableList()
+        var point = int.length + shift
+        while (all.size <= point + max) all.add(0)
+        val next = all[point + max]
+        while (all.size > point + max) all.removeAt(all.size - 1)
+        if (next >= 5) {
+            var at = all.size - 1
+            while (at >= 0 && all[at] == 9) all[at--] = 0
+            if (at < 0) {
+                all.add(0, 1)
+                point += 1
+            } else {
+                all[at] += 1
+            }
+        }
+        val frac = all.subList(point, all.size).toMutableList()
+        while (frac.size > min && frac.last() == 0) frac.removeAt(frac.size - 1)
+        return all.subList(0, point).dropWhile { it == 0 }.joinToString("") to frac.joinToString("")
+    }
+`;
+const PLURAL$2 = `
+    /** CLDR's plural operands of a number as written. */
+    class Operands(val n: Double, val i: Double, val v: Double, val w: Double, val f: Double, val t: Double, val c: Double, val e: Double)
+
+    /** The arm a plural takes: the \`=N\` that \`value\` equals, else the category of \`value\` less \`offset\`. */
+    fun plural(value: Double, offset: Double, exact: List<Pair<Double, String>>, rules: (Operands) -> String, min: Int, max: Int): String =
+        exact.firstOrNull { it.first == value }?.second ?: category(rules, value - offset, min, max)
+
+    /** The category \`rules\` give \`value\`, rounded to between \`min\` and \`max\` fraction digits. */
+    private fun category(rules: (Operands) -> String, value: Double, min: Int, max: Int): String {
+        if (!value.isFinite()) return "other"
+        val (written, frac) = digits(Math.abs(value), 0, min, max)
+        val int = written.ifEmpty { "0" }
+        val trimmed = frac.trimEnd('0')
+        val read = { s: String -> s.toDoubleOrNull() ?: 0.0 }
+        return rules(
+            Operands(
+                n = read(if (frac.isEmpty()) int else "$int.$frac"),
+                i = read(int),
+                v = frac.length.toDouble(),
+                w = trimmed.length.toDouble(),
+                f = read(frac),
+                t = read(trimmed),
+                c = 0.0,
+                e = 0.0,
+            ),
+        )
+    }
+
+    /** An integer in the range, as CLDR's ranges hold. */
+    private fun within(value: Double, from: Double, to: Double): Boolean = value % 1.0 == 0.0 && value >= from && value <= to
+
+    /** \`Math.round\`: half up, toward positive infinity. */
+    fun round(value: Double): Double {
+        val floor = Math.floor(value)
+        return if (value - floor >= 0.5) floor + 1 else floor
+    }
+`;
+function kotlinFile(model, target, banner) {
+	const name = target.name;
+	const rt = `${name}Runtime`;
+	const names = model.messages.map((m) => [m.key, ident$2(leading(camel(m.words)))]);
+	checkNames("kotlin", names, [
+		"tag",
+		"name",
+		"ordinal",
+		"entries",
+		"negotiate",
+		"SOURCE"
+	]);
+	const entries = model.locales.map((l) => `    /** \`${l}\`${l === model.source ? ", the source" : ""}. */\n    ${entry(l)}(${lit$2(l)})`).join(",\n");
+	const members = model.messages.map((m, i) => member$1(m, names[i][1], rt)).join("\n");
+	const rules = model.rules.map(({ name: rule, rules }, i) => {
+		return `    /** ${rule} */\n    fun r${i}(o: Operands): String {\n${rules.map(([category, condition]) => `        if (${conditionCode(condition, {
+			field: (op) => `o.${op}`,
+			mod: (v, by) => `${v} % ${by}`,
+			within: (v, from, to) => `within(${v}, ${from}, ${to})`
+		})}) return ${lit$2(category)}\n`).join("")}        return "other"\n    }\n`;
+	}).join("\n");
+	const runtime = model.formats.length + model.rules.length + model.dates.length === 0 ? "" : `
+/** What formats the messages, generated with them. */
+private object ${rt} {${model.formats.length + model.rules.length > 0 ? NUMBER$2 : ""}${model.rules.length > 0 ? PLURAL$2 : ""}${model.dates.length > 0 ? DATE$2 : ""}
+${[...model.formats.map(formatConst$2), ...model.dates.map(dateFn$2)].join("\n")}${rules === "" ? "" : `\n${rules}`}}
+`;
+	return `${banner}
+@file:Suppress("unused", "NAME_SHADOWING", "KotlinConstantConditions", "ConvertTwoComparisonsToRangeCheck")
+${target.package === void 0 ? "" : `\npackage ${target.package}\n`}
+/** A locale the catalog is written or translated in, and its messages. */
+enum class ${name}(val tag: String) {
+${entries};
+
+${members}
+    companion object {
+        /** The locale the catalog is written in, which every message falls back to. */
+        val SOURCE: ${name} = ${entry(model.source)}
+
+        /**
+         * The best locale for what was asked, most preferred first: each tag tries an exact match, then
+         * its parents (\`pt-BR\` finds \`pt\`), then any locale of its language. The source if none is.
+         */
+        fun negotiate(requested: List<String>): ${name} {
+            fun language(tag: String) = tag.substringBefore('-').lowercase()
+            for (want in requested) {
+                var tag = want
+                while (true) {
+                    entries.firstOrNull { it.tag.equals(tag, ignoreCase = true) }?.let { return it }
+                    val cut = tag.lastIndexOf('-')
+                    if (cut < 0) break
+                    tag = tag.substring(0, cut)
+                }
+                entries.firstOrNull { language(it.tag) == language(want) }?.let { return it }
+            }
+            return SOURCE
+        }
+    }
+}
+${runtime}`;
 }
 // src/tools/native/rust.ts
 const KEYWORDS$1 = new Set("as async await break const continue crate dyn else enum extern false fn for if impl in let loop match mod move mut pub ref return self Self static struct super trait true type unsafe use where while abstract become box do final macro override priv try typeof unsized virtual yield gen".split(" "));
@@ -4263,6 +5232,7 @@ function value$1(part, indent) {
 	const inner = `${indent}    `;
 	if (part.type === "string") return argName$1(part.arg);
 	if (part.type === "number") return `rt::number(${part.offset === 0 ? argName$1(part.arg) : `${argName$1(part.arg)} - ${float(part.offset)}`}, &rt::F${part.format}, ${lit$1(part.fallback)})`;
+	if (part.type === "date") return `rt::D${part.format}(&${argName$1(part.arg)})`;
 	if (part.type === "select") {
 		const arms = part.arms.map((a) => `${inner}${lit$1(a.key)} => ${expr$1(a.parts, inner)},\n`).join("");
 		return `match ${argName$1(part.arg)} {\n${arms}${inner}_ => ${expr$1(part.other, inner)},\n${indent}}`;
@@ -4282,7 +5252,7 @@ function method(m, name, enumName) {
 	const head = doc$2(m.doc, "    ");
 	const arms = (render) => m.bodies.map((b) => `            ${b.locales.map((l) => `${enumName}::${variant(l)}`).join(" | ")} => ${render(b.parts)},\n`).join("");
 	if (m.bodies.every((b) => b.parts.every((p) => p.type === "text")) && m.args.length === 0) return `${head}    pub fn ${name}(self) -> &'static str {\n        match self {\n${arms((parts) => lit$1(parts[0]?.type === "text" ? parts[0].value : ""))}        }\n    }\n`;
-	const params = m.args.map((a) => `, ${argName$1(a.name)}: ${a.type === "number" ? "impl Number" : "&str"}`).join("");
+	const params = m.args.map((a) => `, ${argName$1(a.name)}: ${a.type === "number" ? "impl Number" : a.type === "date" ? "DateTime" : "&str"}`).join("");
 	const argDocs = m.args.filter((a) => a.doc !== void 0).map((a) => `* \`${argName$1(a.name)}\`: ${a.doc}`);
 	return `${argDocs.length > 0 ? `${head}    ///\n${doc$2(argDocs, "    ")}` : head}    pub fn ${name}(self${params}) -> String {\n${m.args.filter((a) => a.type === "number").map((a) => `        let ${argName$1(a.name)} = ${argName$1(a.name)}.as_f64();\n`).join("")}        match self {\n${arms((parts) => expr$1(parts, "            "))}        }\n    }\n`;
 }
@@ -4307,6 +5277,76 @@ function formatConst$1(spec, i) {
 		`negative_infinity: ${lit$1(spec.negativeInfinity)}`
 	].map((f) => `        ${f},\n`).join("")}    };\n`;
 }
+/** A date format as a function of the date. */
+function dateFn$1(spec, i) {
+	const digits = spec.digits === void 0 ? "None" : `Some(G${i})`;
+	const at = (field) => field === "weekday" ? "t.weekday() as i64" : `t.${field} as i64`;
+	const lines = spec.pieces.map((piece) => {
+		if (piece.type === "text") return `s += ${lit$1(piece.value)};`;
+		if (piece.type === "name") return `s += [${piece.names.map(lit$1).join(", ")}][(${pieceExpr(piece, at)}) as usize];`;
+		return `s += &pad(${pieceExpr(piece, at)}, ${piece.pad}, ${digits});`;
+	});
+	return `${spec.digits === void 0 ? "" : `    const G${i}: [&str; 10] = [${spec.digits.map(lit$1).join(", ")}];\n`}    pub fn D${i}(t: &super::DateTime) -> String {\n        let mut s = String::new();\n${lines.map((l) => `        ${l}\n`).join("")}        s\n    }\n`;
+}
+const DATE$1 = `
+    /// \`value\` written with at least \`width\` digits, in \`digits\` where the locale has its own.
+    fn pad(value: i64, width: usize, digits: Option<[&'static str; 10]>) -> String {
+        let text = format!("{:0width$}", value, width = width);
+        match digits {
+            Some(digits) => text.bytes().map(|b| if b.is_ascii_digit() { digits[(b - b'0') as usize] } else { "-" }).collect(),
+            None => text,
+        }
+    }
+`;
+const DATE_TIME = `
+/// A date and time as a clock shows it, in the time zone it is shown in.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct DateTime {
+    pub year: i32,
+    /// 1 to 12.
+    pub month: u8,
+    pub day: u8,
+    /// 0 to 23.
+    pub hour: u8,
+    pub minute: u8,
+    pub second: u8,
+}
+
+impl DateTime {
+    /// The time \`seconds\` after the Unix epoch, on a clock \`offset\` seconds ahead of UTC: the
+    /// local time's offset where it is shown, which Rust's standard library can't look up.
+    pub fn from_unix(seconds: i64, offset: i32) -> DateTime {
+        let local = seconds + offset as i64;
+        let (days, time) = (local.div_euclid(86_400), local.rem_euclid(86_400));
+        // Howard Hinnant's civil_from_days: the Gregorian date \`days\` after 1970-01-01.
+        let z = days + 719_468;
+        let (era, doe) = (z.div_euclid(146_097), z.rem_euclid(146_097));
+        let yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365;
+        let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
+        let mp = (5 * doy + 2) / 153;
+        let month = if mp < 10 { mp + 3 } else { mp - 9 };
+        DateTime {
+            year: (yoe + era * 400 + if month <= 2 { 1 } else { 0 }) as i32,
+            month: month as u8,
+            day: (doy - (153 * mp + 2) / 5 + 1) as u8,
+            hour: (time / 3600) as u8,
+            minute: (time / 60 % 60) as u8,
+            second: (time % 60) as u8,
+        }
+    }
+
+    /// The day of the week, 0 for Sunday.
+    pub fn weekday(self) -> u8 {
+        // days_from_civil, its inverse.
+        let m = self.month as i64;
+        let y = self.year as i64 - if m <= 2 { 1 } else { 0 };
+        let (era, yoe) = (y.div_euclid(400), y.rem_euclid(400));
+        let doy = (153 * (if m > 2 { m - 3 } else { m + 9 }) + 2) / 5 + self.day as i64 - 1;
+        let days = era * 146_097 + yoe * 365 + yoe / 4 - yoe / 100 + doy - 719_468;
+        (days + 4).rem_euclid(7) as u8
+    }
+}
+`;
 const NUMBER$1 = `
     /// A number format, taken apart when the file was generated.
     pub struct Format {
@@ -4497,6 +5537,8 @@ function rustModule(model, target, banner) {
 	const tags = model.locales.map((l) => `            ${name}::${variant(l)} => ${lit$1(l)},\n`).join("");
 	const methods = model.messages.map((m, i) => method(m, names[i][1], name)).join("\n");
 	const usesNumbers = model.messages.some((m) => m.args.some((a) => a.type === "number"));
+	const usesDates = model.dates.length > 0;
+	const usesFormats = model.formats.length + model.rules.length > 0;
 	const rules = model.rules.map(({ name: rule, rules }, i) => {
 		const checks = rules.map(([category, condition]) => `        if ${conditionCode(condition, {
 			field: (op) => `o.${op}`,
@@ -4505,14 +5547,14 @@ function rustModule(model, target, banner) {
 		})} {\n            return ${lit$1(category)};\n        }\n`);
 		return `    /// ${rule}\n    pub fn R${i}(${rules.length > 0 ? "o" : "_o"}: &Operands) -> &'static str {\n${checks.join("")}        "other"\n    }\n`;
 	}).join("\n");
-	const runtime = model.formats.length + model.rules.length === 0 ? "" : `
+	const runtime = !usesFormats && !usesDates ? "" : `
 /// What formats the messages, generated with them.
-mod rt {${NUMBER$1}${model.rules.length > 0 ? PLURAL$1 : ""}
-${model.formats.map(formatConst$1).join("\n")}${rules === "" ? "" : `\n${rules}`}}
+mod rt {${usesFormats ? NUMBER$1 : ""}${model.rules.length > 0 ? PLURAL$1 : ""}${usesDates ? DATE$1 : ""}
+${[...model.formats.map(formatConst$1), ...model.dates.map(dateFn$1)].join("\n")}${rules === "" ? "" : `\n${rules}`}}
 `;
 	return `${banner}
 #![allow(dead_code, non_snake_case, clippy::all)]
-${usesNumbers ? NUMBER_TRAIT : ""}
+${usesNumbers ? NUMBER_TRAIT : ""}${usesDates ? DATE_TIME : ""}
 /// A locale the catalog is written or translated in, and its messages.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum ${name} {
@@ -4576,6 +5618,7 @@ function value(part, indent, rt) {
 	const inner = `${indent}    `;
 	if (part.type === "string") return argName(part.arg);
 	if (part.type === "number") return `${rt}.number(${part.offset === 0 ? argName(part.arg) : `${argName(part.arg)} - ${float(part.offset)}`}, ${rt}.f${part.format}, ${lit(part.fallback)})`;
+	if (part.type === "date") return `${rt}.d${part.format}(${argName(part.arg)})`;
 	if (part.type === "select") {
 		const arms = part.arms.map((a) => `${inner}case ${lit(a.key)}: return ${expr(a.parts, inner, rt)}\n`).join("");
 		return `{ () -> String in\n${inner}switch ${argName(part.arg)} {\n${arms}${inner}default: return ${expr(part.other, inner, rt)}\n${inner}}\n${indent}}()`;
@@ -4601,7 +5644,7 @@ function member(m, name, rt, number) {
 	] : m.doc, "    ");
 	const body = `        switch self {\n${cases((parts) => expr(parts, "        ", rt))}        }\n`;
 	if (m.args.length === 0) return `${head}    public var ${name}: String {\n${body}    }\n`;
-	return `${head}    public func ${name}(${m.args.map((a) => `${argName(a.name)}: ${a.type === "number" ? `some ${number.type}` : "String"}`).join(", ")}) -> String {\n${m.args.filter((a) => a.type === "number").map((a) => `        let ${argName(a.name)} = ${argName(a.name)}.${number.value}\n`).join("")}${body}    }\n`;
+	return `${head}    public func ${name}(${m.args.map((a) => `${argName(a.name)}: ${a.type === "number" ? `some ${number.type}` : a.type === "date" ? "Date" : "String"}`).join(", ")}) -> String {\n${m.args.map((a) => a.type === "number" ? `        let ${argName(a.name)} = ${argName(a.name)}.${number.value}\n` : a.type === "date" ? `        let ${argName(a.name)} = ${rt}.clock(${argName(a.name)})\n` : "").join("")}${body}    }\n`;
 }
 function formatConst(spec, i) {
 	const affix = ([prefix, suffix]) => `(${lit(prefix)}, ${lit(suffix)})`;
@@ -4624,6 +5667,47 @@ function formatConst(spec, i) {
 		`negativeInfinity: ${lit(spec.negativeInfinity)}`
 	].map((f) => `        ${f}`).join(",\n")}\n    )\n`;
 }
+/** A date format as a function of the clock's fields. */
+function dateFn(spec, i) {
+	const digits = spec.digits === void 0 ? "nil" : `g${i}`;
+	const at = (field) => `t.${field}`;
+	const lines = spec.pieces.map((piece) => {
+		if (piece.type === "text") return `s += ${lit(piece.value)}`;
+		if (piece.type === "name") return `s += [${piece.names.map(lit).join(", ")}][${pieceExpr(piece, at)}]`;
+		return `s += pad(${pieceExpr(piece, at)}, ${piece.pad}, ${digits})`;
+	});
+	return `${spec.digits === void 0 ? "" : `    static let g${i} = [${spec.digits.map(lit).join(", ")}]\n`}    static func d${i}(_ t: Clock) -> String {\n        var s = ""\n${lines.map((l) => `        ${l}\n`).join("")}        return s\n    }\n`;
+}
+const DATE = `
+    /// A date as the clock shows it in the device's time zone; \`weekday\` is 0 for Sunday.
+    struct Clock {
+        let year: Int
+        let month: Int
+        let day: Int
+        let hour: Int
+        let minute: Int
+        let second: Int
+        let weekday: Int
+    }
+
+    static func clock(_ date: Date) -> Clock {
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = .current
+        let c = calendar.dateComponents([.year, .month, .day, .hour, .minute, .second, .weekday], from: date)
+        return Clock(
+            year: c.year ?? 0, month: c.month ?? 1, day: c.day ?? 1, hour: c.hour ?? 0, minute: c.minute ?? 0,
+            second: c.second ?? 0, weekday: (c.weekday ?? 1) - 1
+        )
+    }
+
+    /// \`value\` written with at least \`width\` digits, in \`digits\` where the locale has its own.
+    private static func pad(_ value: Int, _ width: Int, _ digits: [String]?) -> String {
+        var text = String(value)
+        while text.count < width { text = "0" + text }
+        guard let digits else { return text }
+        return text.map { c in c.wholeNumberValue.map { digits[$0] } ?? String(c) }.joined()
+    }
+`;
 const NUMBER = `
     /// A number format, taken apart when the file was generated.
     struct Format {
@@ -4795,7 +5879,10 @@ function swiftFile(model, target, banner) {
 		value: `${name.charAt(0).toLowerCase()}${name.slice(1)}Value`
 	};
 	const members = model.messages.map((m, i) => member(m, names[i][1], rt, number)).join("\n");
-	const numberProtocol = !model.messages.some((m) => m.args.some((a) => a.type === "number")) ? "" : `
+	const usesNumbers = model.messages.some((m) => m.args.some((a) => a.type === "number"));
+	const usesDates = model.dates.length > 0;
+	const usesFormats = model.formats.length + model.rules.length > 0;
+	const numberProtocol = !usesNumbers ? "" : `
 /// A number a message formats: any of Swift's integers or floats.
 public protocol ${number.type} {
     var ${number.value}: Double { get }
@@ -4810,10 +5897,10 @@ ${NUMBER_TYPES.map((t) => `extension ${t}: ${number.type} { public var ${number.
 			within: (v, from, to) => `within(${v}, ${from}, ${to})`
 		})} { return ${lit(category)} }\n`).join("")}        return "other"\n    }\n`;
 	}).join("\n");
-	const runtime = model.formats.length + model.rules.length === 0 ? "" : `
+	const runtime = !usesFormats && !usesDates ? "" : `
 /// What formats the messages, generated with them.
-private enum ${rt} {${NUMBER}${model.rules.length > 0 ? PLURAL : ""}
-${model.formats.map(formatConst).join("\n")}${rules === "" ? "" : `\n${rules}`}}
+private enum ${rt} {${usesFormats ? NUMBER : ""}${model.rules.length > 0 ? PLURAL : ""}${usesDates ? DATE : ""}
+${[...model.formats.map(formatConst), ...model.dates.map(dateFn)].join("\n")}${rules === "" ? "" : `\n${rules}`}}
 `;
 	return `${banner}
 import Foundation
@@ -4848,8 +5935,9 @@ ${runtime}`;
 }
 // src/tools/native/index.ts
 /**
-* The native files `generate` writes beside the TypeScript, one per target in the config's `native`.
-* A message a target can't render fails the build with the reason, as a translation that drifted does.
+* The native files `generate` writes beside the TypeScript, one per target in the config's `native`
+* (Android's and Apple's string resources, a file per locale). A message a target can't render
+* fails the build with the reason, as a translation that drifted does.
 */
 const WRITERS = {
 	rust: rustModule,
@@ -4859,18 +5947,22 @@ const WRITERS = {
 function nativeFiles(config, catalog, locales, entries, banner) {
 	const files = /* @__PURE__ */ new Map();
 	const problems = [];
-	for (const target of config.native) {
+	for (const target of config.native) try {
+		if (target.language === "android" || target.language === "apple") {
+			const { files: written, problems: found } = target.language === "android" ? androidResources(target, catalog, locales, entries, banner) : appleStrings(target, config.root, catalog, locales, entries, banner);
+			problems.push(...found);
+			for (const [path, content] of written) files.set(path, content);
+			continue;
+		}
 		const { model, problems: found } = nativeModel(target, catalog, locales, entries);
 		problems.push(...found);
 		if (found.length > 0) continue;
-		try {
-			files.set(target.out, WRITERS[target.language](model, target, banner));
-		} catch (e) {
-			problems.push({
-				severity: "error",
-				message: e.message
-			});
-		}
+		files.set(target.out, WRITERS[target.language](model, target, banner));
+	} catch (e) {
+		problems.push({
+			severity: "error",
+			message: e.message
+		});
 	}
 	if (problems.length > 0) throw new CatalogError(problems);
 	return files;
@@ -5140,6 +6232,11 @@ function render(config, accept) {
 	}
 	for (const [path, content] of nativeFiles(config, catalog, locales, entries, head)) files.set(path, content);
 	files.set(join(config.catalog, "catalog.schema.json"), `${JSON.stringify(catalogSchema(config), null, 2)}\n`);
+	for (const file of yamlFiles(config.catalog)) {
+		const path = join(config.catalog, file);
+		const text = readFileSync(path, "utf8");
+		if (withSchemaLine(text) !== text) files.set(path, withSchemaLine(text));
+	}
 	if (Object.keys(lock.translations).length > 0 || existsSync(config.lock)) files.set(config.lock, serializeLock(lock));
 	return {
 		catalog,
@@ -5168,6 +6265,6 @@ function generate(config, options = {}) {
 		changed: writeFiles(generated.files, options.check)
 	};
 }
-export { writeMessage as A, entryLocation as C, whereOf as D, previewOf as E, toMf1 as F, intlNumber as M, parseMf2 as N, SYNTAX_NAME as O, toMf2 as P, KEY_PATTERN as S, loadCatalog as T, applyFixes as _, render as a, readEntry as b, pseudoText as c, hash as d, readLock as f, wordDiff as g, formatDiff as h, localesOf as i, intlDate as j, readMessage as k, changeOf as l, serializeLock as m, generate as n, writeFiles as o, reconcile as p, localeEntries as r, pseudoAst as s, catalogSchema as t, emptyLock as u, editEntry as v, entryLocator as w, CatalogError as x, importTranslations as y };
+export { loadCatalog as A, toMf1 as B, formatDiff as C, SCHEMA_LINE as D, KEY_PATTERN as E, writeMessage as F, intlDate as I, intlNumber as L, whereOf as M, SYNTAX_NAME as N, entryLocation as O, readMessage as P, parseMf2 as R, serializeLock as S, CatalogError as T, changeOf as _, render as a, readLock as b, pseudoText as c, importTranslations as d, readEntry as f, todoOf as g, todoMessages as h, localesOf as i, previewOf as j, entryLocator as k, applyFixes as l, readReturned as m, generate as n, writeFiles as o, exportOf as p, localeEntries as r, pseudoAst as s, catalogSchema as t, editEntry as u, emptyLock as v, wordDiff as w, reconcile as x, hash as y, toMf2 as z };
 
-//# sourceMappingURL=generate-9pR3i5Bj.js.map
+//# sourceMappingURL=generate-CKv86Iki.js.map