prosebook 0.4.0 → 0.5.0

package/dist/{generate-BW3N8EGb.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-nWZf9QmF.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$2(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$2(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,6 +1817,505 @@ function entryLocator(root) {
 function previewOf(message) {
 	return staticLiteral(message.ast) ?? message.text;
 }
+// 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/todo.ts
+/**
+* `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 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
@@ -1928,10 +2434,10 @@ function applyFixes(config, catalog, findings) {
 	};
 }
 /**
-* 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.
+* 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) => ({
@@ -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();
@@ -2059,263 +2570,99 @@ function viewOf(config, catalog, key, unsaved) {
 /** Where an entry is written: from the start of its key's line to the end of its value. */
 function snippetOf(file, key) {
 	const doc = parseDocument(file);
-	if (!isMap(doc.contents)) return void 0;
-	const pair = doc.contents.items.find((p) => isScalar(p.key) && p.key.value === key);
-	const keyStart = isScalar(pair?.key) ? pair.key.range?.[0] : void 0;
-	const valueEnd = (pair?.value)?.range?.[1];
-	if (keyStart === void 0 || valueEnd === void 0) return void 0;
-	const start = file.lastIndexOf("\n", keyStart - 1) + 1;
-	const end = start + file.slice(start, valueEnd).trimEnd().length;
-	return {
-		start,
-		end,
-		text: file.slice(start, end)
-	};
-}
-/** The file with the entry's text replaced, removed when `yaml` is empty, or added at the end. */
-function withSnippet(file, key, yaml) {
-	const text = yaml.replace(/\n+$/, "");
-	const at = snippetOf(file, key);
-	if (at !== void 0) {
-		if (text.trim() === "") return file.slice(0, at.start) + file.slice(at.end).replace(/^\n/, "");
-		return file.slice(0, at.start) + text + file.slice(at.end);
-	}
-	if (text.trim() === "") return file;
-	return file.trim() === "" ? `${text}\n` : `${file.replace(/\n*$/, "\n")}${text}\n`;
-}
-function parse$2(file) {
-	const doc = parseDocument(file, { version: "1.1" });
-	if (doc.contents === null) doc.contents = doc.createNode({});
-	return doc;
-}
-const print = (doc) => doc.toString({
-	lineWidth: 0,
-	singleQuote: true
-});
-/** A value written where one was, keeping how it was quoted; text over several lines as a block. */
-function setValue(doc, map, name, value) {
-	const node = map.get(name, true);
-	if (isScalar(node) && typeof value === "string") {
-		node.value = value;
-		if (value.includes("\n")) node.type = Scalar.BLOCK_LITERAL;
-		return;
-	}
-	map.set(name, doc.createNode(value));
-}
-function withFields(file, key, fields, source) {
-	const doc = parse$2(file);
-	let entry = doc.get(key, true);
-	if (!isMap(entry)) {
-		entry = doc.createNode({ [source]: fields.message });
-		doc.set(key, entry);
-	}
-	const map = entry;
-	const args = Object.fromEntries(Object.entries(fields.args).filter(([, v]) => v.trim() !== ""));
-	const wanted = [
-		["kind", fields.kind.trim() || void 0],
-		["surface", fields.surface.trim() || void 0],
-		["context", fields.context.trim() || void 0],
-		["args", Object.keys(args).length > 0 ? args : void 0],
-		["fragment", fields.fragment || void 0],
-		["comment", fields.comment.trim() || void 0],
-		["remove", fields.remove || void 0]
-	];
-	for (const [name, value] of wanted) {
-		if (value === void 0) {
-			map.delete(name);
-			continue;
-		}
-		if (map.has(name)) {
-			setValue(doc, map, name, value);
-			continue;
-		}
-		const at = map.items.findIndex((p) => isScalar(p.key) && p.key.value === source);
-		map.items.splice(at === -1 ? map.items.length : at, 0, doc.createPair(name, value));
-	}
-	setValue(doc, map, source, fields.message);
-	return print(doc);
-}
-/** The source message replaced, and nothing else: a `key: message` entry stays one. */
-function withMessage(file, key, message, source) {
-	const doc = parse$2(file);
-	const entry = doc.get(key, true);
-	if (!isMap(entry)) return withTranslation(file, key, message);
-	setValue(doc, entry, source, message);
-	return print(doc);
-}
-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
-	};
+	if (!isMap(doc.contents)) return void 0;
+	const pair = doc.contents.items.find((p) => isScalar(p.key) && p.key.value === key);
+	const keyStart = isScalar(pair?.key) ? pair.key.range?.[0] : void 0;
+	const valueEnd = (pair?.value)?.range?.[1];
+	if (keyStart === void 0 || valueEnd === void 0) return void 0;
+	const start = file.lastIndexOf("\n", keyStart - 1) + 1;
+	const end = start + file.slice(start, valueEnd).trimEnd().length;
 	return {
-		version: 2,
-		sources: {},
-		translations: raw
+		start,
+		end,
+		text: file.slice(start, end)
 	};
 }
-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`;
+/** The file with the entry's text replaced, removed when `yaml` is empty, or added at the end. */
+function withSnippet(file, key, yaml) {
+	const text = yaml.replace(/\n+$/, "");
+	const at = snippetOf(file, key);
+	if (at !== void 0) {
+		if (text.trim() === "") return file.slice(0, at.start) + file.slice(at.end).replace(/^\n/, "");
+		return file.slice(0, at.start) + text + file.slice(at.end);
+	}
+	if (text.trim() === "") return file;
+	return file.trim() === "" ? `${text}\n` : `${file.replace(/\n*$/, "\n")}${text}\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", " ");
+function parse$2(file) {
+	const doc = parseDocument(file, { version: "1.1" });
+	if (doc.contents === null) doc.contents = doc.createNode({});
+	return doc;
 }
-/**
-* 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
-				});
-			}
+const print = (doc) => doc.toString({
+	lineWidth: 0,
+	singleQuote: true
+});
+/** A value written where one was, keeping how it was quoted; text over several lines as a block. */
+function setValue(doc, map, name, value) {
+	const node = map.get(name, true);
+	if (isScalar(node) && typeof value === "string") {
+		node.value = value;
+		if (value.includes("\n")) node.type = Scalar.BLOCK_LITERAL;
+		return;
+	}
+	map.set(name, doc.createNode(value));
+}
+function withFields(file, key, fields, source) {
+	const doc = parse$2(file);
+	let entry = doc.get(key, true);
+	if (!isMap(entry)) {
+		entry = doc.createNode({ [source]: fields.message });
+		doc.set(key, entry);
+	}
+	const map = entry;
+	const args = Object.fromEntries(Object.entries(fields.args).filter(([, v]) => v.trim() !== ""));
+	const wanted = [
+		["kind", fields.kind.trim() || void 0],
+		["surface", fields.surface.trim() || void 0],
+		["context", fields.context.trim() || void 0],
+		["args", Object.keys(args).length > 0 ? args : void 0],
+		["fragment", fields.fragment || void 0],
+		["comment", fields.comment.trim() || void 0],
+		["remove", fields.remove || void 0]
+	];
+	for (const [name, value] of wanted) {
+		if (value === void 0) {
+			map.delete(name);
+			continue;
+		}
+		if (map.has(name)) {
+			setValue(doc, map, name, value);
+			continue;
 		}
+		const at = map.items.findIndex((p) => isScalar(p.key) && p.key.value === source);
+		map.items.splice(at === -1 ? map.items.length : at, 0, doc.createPair(name, value));
 	}
-	return {
-		lock,
-		stale
-	};
+	setValue(doc, map, source, fields.message);
+	return print(doc);
+}
+/** The source message replaced, and nothing else: a `key: message` entry stays one. */
+function withMessage(file, key, message, source) {
+	const doc = parse$2(file);
+	const entry = doc.get(key, true);
+	if (!isMap(entry)) return withTranslation(file, key, message);
+	setValue(doc, entry, source, message);
+	return print(doc);
+}
+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/native/emit.ts
 /** Words from an identifier written any way: `userName`, `user-name` and `user_name` are user, name. */
@@ -2371,6 +2718,195 @@ function checkNames(language, named, taken) {
 		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([
 	"integer",
@@ -3810,6 +4346,7 @@ 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 = [];
@@ -3829,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;
@@ -3848,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()]
@@ -3860,6 +4401,7 @@ function nativeModel(target, catalog, locales, entries) {
 			source,
 			messages,
 			formats: formats.list,
+			dates: dates.list,
 			rules: rules.list
 		},
 		problems
@@ -3878,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);
@@ -3892,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);
@@ -3910,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, {
@@ -4004,7 +4570,7 @@ function parts(elements, locale, formats, rules, pound) {
 // 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` files. Text and plain `{name}` placeholders, as `%N$s`
+* 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.
 */
@@ -4019,7 +4585,20 @@ function isCount(el, count) {
 	const options = Object.entries(numberOptions(el) ?? {});
 	return options.length === 0 || options.length === 1 && options[0][0] === "maximumFractionDigits" && options[0][1] === 0;
 }
-/** `elements` as a format string over `args`; inside a plural, its `count` is `%N$d`. */
+/**
+* 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) => {
@@ -4032,7 +4611,7 @@ function formatString(elements, args, printf, count) {
 	let out = "";
 	for (const el of elements) {
 		if (count !== void 0 && isCount(el, count)) {
-			out += place(el, count, "d");
+			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}`);
@@ -4100,9 +4679,15 @@ const PRINTF$1 = {
 	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
@@ -4116,13 +4701,7 @@ function resource(name, ast, args) {
 		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)];
-	const named = `{${plural.value}}`;
-	if (plural.pluralType === "ordinal") throw new Error(`${named} is an ordinal, and Android's <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 Android's <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 Android 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 Android's <plurals> have none for one number (its zero is a category, which most languages never pick): say it in a category's arm, or write a key for it and pick that in code, ${LEAVE_OUT}`);
+	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,
@@ -4211,9 +4790,46 @@ const PRINTF = {
 	formatter: "String(format:)",
 	holder: ".strings files",
 	string: "@",
+	count: "lld",
 	escape,
-	plural: (name) => `{${name}} is a plural, which a .strings file can't hold (it takes a .stringsdict, which this target doesn't write): show it from the Swift target, ${LEAVE_OUT}`
+	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: "<",
@@ -4271,32 +4887,47 @@ function appleStrings(target, root, catalog, locales, entries, banner) {
 		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 = `${head}"${escape(name, false)}" = "${formatString(asts.get(found).get(m.key), args, PRINTF)}";\n`;
+					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);
 			}
-			lines.get(locale).push(entry);
+			(entry.dict ? dicts : lines).get(locale).push(entry.entry);
 		}
 	}
-	const top = `/* ${banner.replace(/^\/\/ /, "")} */\n`;
+	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: new Map(locales.map((locale) => [join(target.out, `${locale}.lproj`, `${target.name}.strings`), [top, ...lines.get(locale)].join("\n")])),
+		files,
 		problems
 	};
 }
@@ -4318,6 +4949,7 @@ 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}}`;
@@ -4343,7 +4975,7 @@ function member$1(m, name, rt) {
 	] : 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`;
+	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)}`;
@@ -4366,6 +4998,33 @@ function formatConst$2(spec, i) {
 		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(
@@ -4501,10 +5160,10 @@ function kotlinFile(model, target, banner) {
 			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 ? "" : `
+	const runtime = model.formats.length + model.rules.length + model.dates.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}`}}
+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")
@@ -4573,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}}`;
@@ -4592,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`;
 }
@@ -4617,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 {
@@ -4807,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}`,
@@ -4815,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} {
@@ -4886,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}}()`;
@@ -4911,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)})`;
@@ -4934,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 {
@@ -5105,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 }
@@ -5120,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
@@ -5455,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,
@@ -5483,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-BW3N8EGb.js.map
+//# sourceMappingURL=generate-CKv86Iki.js.map