@moku-labs/game 0.2.0 → 0.3.0

package/dist/assets.mjs

@@ -922,19 +922,21 @@ function fontPageName(bundle, key, index, hash, extension) {
 	return `${bundle}/${key}-${index}-${hash}.${extension}`;
 }
 /**
-* Names the file of a sound.
+* Names the file of a sound. The sound keeps its format, and so its extension: the loader reads
+* the MIME type of a sound from it.
 *
 * @param bundle - Name of the bundle.
 * @param key - Asset key of the sound.
 * @param hash - The content hash of the bytes.
+* @param extension - The extension of the source, without the dot: `mp3` or `m4a`.
 * @returns The path inside the pack folder.
 * @example
 * ```ts
-* audioName("ui", "ui.click", "9c4e2b7a10"); // "ui/ui.click-9c4e2b7a10.mp3"
+* audioName("ui", "ui.theme", "9c4e2b7a10", "m4a"); // "ui/ui.theme-9c4e2b7a10.m4a"
 * ```
 */
-function audioName(bundle, key, hash) {
-	return `${bundle}/${key}-${hash}.mp3`;
+function audioName(bundle, key, hash, extension) {
+	return `${bundle}/${key}-${hash}.${extension}`;
 }
 //#endregion
 //#region src/plugins/assets/scan/pack/copy.ts
@@ -1008,17 +1010,17 @@ async function copyFont(root, bundle, file, fontPath) {
 	};
 }
 /**
-* Copies one sound byte for byte under its hashed name.
+* Copies one sound byte for byte under its hashed name, with the extension of its source.
 *
 * @param root - The game source root.
 * @param bundle - Name of the bundle.
 * @param file - The sound of the scanned manifest.
-* @param soundPath - The path of its `.mp3` file.
+* @param soundPath - The path of its `.mp3` or `.m4a` file.
 * @returns The packed entry and the file to write.
 */
 async function copyAudio(root, bundle, file, soundPath) {
 	const bytes = await readSource(root, soundPath);
-	const name = audioName(bundle, file.key, contentHash(bytes));
+	const name = audioName(bundle, file.key, contentHash(bytes), extensionOf(soundPath));
 	return {
 		file: {
 			...file,
@@ -1165,7 +1167,7 @@ function messageOf$1(failure) {
 * @param problems - The problems, in pack order.
 * @returns The error to reject with.
 */
-function collected$2(problems) {
+function collected$1(problems) {
 	const count = problems.length;
 	const lines = problems.map((text) => `  ${text}`).join("\n");
 	return /* @__PURE__ */ new Error(`[game] assets: the pack found ${count} problem${count === 1 ? "" : "s"}.\n${lines}\n  Fix them and run "bun run assets:pack" again.`);
@@ -1683,7 +1685,7 @@ async function packAssets(options) {
 		bundles
 	};
 	if (run.problems.length === 0) run.problems.push(...checkPacked(options.manifest, manifest));
-	if (run.problems.length > 0) throw collected$2(run.problems);
+	if (run.problems.length > 0) throw collected$1(run.problems);
 	const bytes = await writePack(options, run.outputs, emitManifest(manifest));
 	const all = Object.values(bundles);
 	return {
@@ -1698,7 +1700,7 @@ async function packAssets(options) {
 //#region src/plugins/assets/scan/keys.ts
 const TEXTURE = /\.(?:png|webp)$/i;
 const FONT = /\.fnt$/i;
-const AUDIO = /\.mp3$/i;
+const AUDIO = /\.(?:mp3|m4a)$/i;
 const TAG_GROUPS = /^(?:\{[^{}]*\})*$/;
 const WHOLE_NUMBER = /^\d+$/;
 /**
@@ -1736,13 +1738,15 @@ function problem$3(message) {
 }
 /**
 * Tells what the scanner makes of a file: one texture per PNG or WebP, one font per `.fnt` with
-* the pages it names, one sound per MP3. Everything else is left out with a note.
+* the pages it names, one sound per MP3 or M4A (AAC in an MP4 container). Everything else is left
+* out with a note.
 *
 * @param fileName - Name of the file, with its extension.
 * @returns The kind of the asset, or `undefined` when the scanner reads no such file.
 * @example
 * ```ts
 * assetKindOf("body.fnt"); // "font"
+* assetKindOf("theme.m4a"); // "audio"
 * assetKindOf("theme.ogg"); // undefined
 * ```
 */
@@ -1755,7 +1759,7 @@ function assetKindOf(fileName) {
 * Tells whether the scanner reads this file.
 *
 * @param fileName - Name of the file, with its extension.
-* @returns True for a PNG, a WebP, a `.fnt` or an MP3.
+* @returns True for a PNG, a WebP, a `.fnt`, an MP3 or an M4A.
 * @example
 * ```ts
 * isAssetFile("star-on.webp"); // true
@@ -1903,8 +1907,11 @@ const TIERS = [
 ];
 const PREFIX$1 = "[game] assets: ";
 const ESCAPE = /[.+^${}()|[\]\\]/g;
-/** The formats a game brings instead of an MP3. One format decodes everywhere, so MP3 it is. */
-const OTHER_AUDIO = /\.(?:ogg|wav|m4a|aac|opus|flac)$/i;
+/**
+* The formats a game brings instead of an MP3 or an M4A. Only those two decode in every browser
+* and WebView; a raw ADTS `.aac` is AAC without its MP4 container, so it stays out too.
+*/
+const OTHER_AUDIO = /\.(?:ogg|wav|aac|opus|flac)$/i;
 /** A vector font. The engine draws bitmap text, so a font arrives as a `.fnt` with its pages. */
 const OTHER_FONT = /\.(?:ttf|otf|woff2?)$/i;
 /** A page name that says "this folder". */
@@ -2186,13 +2193,13 @@ function draftOf(scan, name, feature, tier) {
 * @example
 * ```ts
 * ignoredNote("features/ui/assets/click.wav");
-* // 'ignored "features/ui/assets/click.wav": audio is .mp3 only.'
+* // 'ignored "features/ui/assets/click.wav": audio is .mp3 or .m4a only.'
 * ```
 */
 function ignoredNote(file) {
-	if (OTHER_AUDIO.test(file)) return `ignored "${file}": audio is .mp3 only.`;
+	if (OTHER_AUDIO.test(file)) return `ignored "${file}": audio is .mp3 or .m4a only.`;
 	if (OTHER_FONT.test(file)) return `ignored "${file}": a font is a .fnt file with its .png pages.`;
-	return `ignored "${file}": the scanner reads .png, .webp, .fnt and .mp3 only.`;
+	return `ignored "${file}": the scanner reads .png, .webp, .fnt, .mp3 and .m4a only.`;
 }
 /**
 * Works out where a page of a font lives: page names are relative to the `.fnt` file.
@@ -2407,7 +2414,7 @@ function toManifest(scan) {
 * @param problems - The problems, in scan order.
 * @returns The error to reject with.
 */
-function collected$1(problems) {
+function collected(problems) {
 	const count = problems.length;
 	const lines = problems.map((text) => `  ${text}`).join("\n");
 	return /* @__PURE__ */ new Error(`${PREFIX$1}the scan found ${count} problem${count === 1 ? "" : "s"}.\n${lines}\n  Fix them and run "bun run assets:keys" again.`);
@@ -2470,7 +2477,7 @@ async function applyOutputs(outputs, write) {
 async function scanAssets(options) {
 	const scan = createState(options.root, options.features ?? "features");
 	for (const feature of await listFeatures(scan.featuresFolder)) await scanFeature(scan, feature);
-	if (scan.problems.length > 0) throw collected$1(scan.problems);
+	if (scan.problems.length > 0) throw collected(scan.problems);
 	const manifest = toManifest(scan);
 	const manifestSource = emitManifest(manifest);
 	const keysSource = emitKeys(manifest);
@@ -2490,15 +2497,19 @@ async function scanAssets(options) {
 //#endregion
 //#region src/plugins/assets/scan/cli.ts
 /**
-* @file assets plugin, build time — the command line of the scanner and the packer. It is the
-* only file here that touches the terminal: the scan, the emitters, the key rule and the packer
-* report back instead of printing. Output goes through the branded console of
-* `@moku-labs/common`, and `runCli` returns the exit code instead of taking it. The string
-* compiler of i18n comes in as a parameter: i18n sits above assets, so the door `src/assets.ts`
-* hands it over instead of this file importing it.
+* @file assets plugin, build time — the command line of the scanner, the packer and the string
+* tools. It is the only file here that touches the terminal: the scan, the emitters, the key rule
+* and the packer report back instead of printing. Output goes through the branded console of
+* `@moku-labs/common`, and `runCli` returns the exit code instead of taking it. The string tools
+* of i18n (compile, export, import) come in as a parameter: i18n sits above assets, so the door
+* `src/assets.ts` hands them over instead of this file importing them.
 */
 const MANIFEST_FILE = "manifest.json";
 const KEYS_FILE = path.join("generated", "assets.ts");
+/** The locale translators read from when `--source` names none. */
+const DEFAULT_SOURCE$1 = "en";
+/** The extension of an exchange file: the export writes `<dir>/<locale>.json`. */
+const EXCHANGE_EXTENSION = ".json";
 /**
 * Wraps a command line problem in the message shape of the framework.
 *
@@ -2518,55 +2529,107 @@ function messageOf(failure) {
 	return failure instanceof Error ? failure.message : String(failure);
 }
 /**
-* Tells whether an argument is one of the flags that take a path.
+* Tells whether an argument is one of the flags that take a value.
 *
 * @param flag - The argument.
-* @returns True for `--root`, `--manifest`, `--keys` and `--pack`.
+* @returns True for the path flags and `--source`.
 */
-function isPathFlag(flag) {
-	return flag === "--root" || flag === "--manifest" || flag === "--keys" || flag === "--pack";
+function isValueFlag(flag) {
+	return flag === "--root" || flag === "--manifest" || flag === "--keys" || flag === "--pack" || flag === "--export" || flag === "--import" || flag === "--source";
 }
 /**
-* Reads the flags. `--keys` defaults to `generated/assets.ts` inside the root; `--manifest` to
-* `manifest.json` inside the root, or inside the pack folder with `--pack`.
+* Tells whether an argument is one of the flags that stand alone.
+*
+* @param flag - The argument.
+* @returns True for `--check`, `--no-cache` and `--pseudo`.
+*/
+function isSwitch(flag) {
+	return flag === "--check" || flag === "--no-cache" || flag === "--pseudo";
+}
+/**
+* Reads the flags as they were given.
 *
 * @param argv - The arguments after the script name.
-* @returns The resolved paths, the pack folder and the two switches.
+* @returns The value of each flag that takes one, and the switches.
 * @throws {Error} When an option is unknown or misses its value.
 */
-function parseArgv(argv) {
-	const given = {
-		"--root": void 0,
-		"--manifest": void 0,
-		"--keys": void 0,
-		"--pack": void 0
-	};
-	let check = false;
-	let cache = true;
+function readFlags(argv) {
+	const values = {};
+	const switches = /* @__PURE__ */ new Set();
 	let index = 0;
 	while (index < argv.length) {
 		const flag = argv[index];
-		if (flag === "--check" || flag === "--no-cache") {
-			if (flag === "--check") check = true;
-			else cache = false;
+		if (isSwitch(flag)) {
+			switches.add(flag);
 			index += 1;
 			continue;
 		}
-		if (!isPathFlag(flag)) throw problem$1(`unknown option "${String(flag)}".`);
+		if (!isValueFlag(flag)) throw problem$1(`unknown option "${String(flag)}".`);
 		const value = argv[index + 1];
-		if (value === void 0 || value.startsWith("--")) throw problem$1(`"${flag}" needs a path.`);
-		given[flag] = value;
+		if (value === void 0 || value.startsWith("--")) throw problem$1(`"${flag}" needs ${flag === "--source" ? "a locale" : "a path"}.`);
+		values[flag] = value;
 		index += 2;
 	}
-	const root = path.resolve(given["--root"] ?? ".");
-	const pack = given["--pack"] === void 0 ? void 0 : path.resolve(given["--pack"]);
+	return {
+		values,
+		switches
+	};
+}
+/**
+* Refuses the flags that do not go together, before anything is read or written. An exchange
+* with the translators runs alone; only `--pseudo` may join an import, because the compile after
+* it writes the pseudo-locale too.
+*
+* @param flags - The flags as they were given.
+* @throws {Error} When two flags do not go together.
+*/
+function refuseConflicts(flags) {
+	const { values, switches } = flags;
+	const exporting = values["--export"] !== void 0;
+	const importing = values["--import"] !== void 0;
+	const packing = values["--pack"] !== void 0;
+	if (exporting || importing) {
+		if (exporting && importing || packing || switches.has("--check") || exporting && switches.has("--pseudo")) throw problem$1("\"--export\" and \"--import\" run alone; drop the other flags.");
+		return;
+	}
+	if (values["--source"] !== void 0) throw problem$1("\"--source\" goes with \"--export\" or \"--import\".");
+	if (packing && switches.has("--pseudo")) throw problem$1("\"--pseudo\" is for a dev run; drop it from \"--pack\".");
+	if (packing && switches.has("--check")) throw problem$1("\"--pack\" writes files; drop \"--check\".");
+}
+/**
+* Resolves a folder flag against the working directory.
+*
+* @param given - The value of the flag, or `undefined` when it was not given.
+* @returns The absolute path, or `undefined`.
+*/
+function resolveGiven(given) {
+	return given === void 0 ? void 0 : path.resolve(given);
+}
+/**
+* Reads the flags. `--keys` defaults to `generated/assets.ts` inside the root; `--manifest` to
+* `manifest.json` inside the root, or inside the pack folder with `--pack`; `--source` to `"en"`.
+*
+* @param argv - The arguments after the script name.
+* @returns The resolved paths, the folders of the three modes and the switches.
+* @throws {Error} When an option is unknown, misses its value or does not go with another.
+*/
+function parseArgv(argv) {
+	const flags = readFlags(argv);
+	refuseConflicts(flags);
+	const { values, switches } = flags;
+	const root = path.resolve(values["--root"] ?? ".");
+	const pack = resolveGiven(values["--pack"]);
 	return {
 		root,
-		manifest: path.resolve(given["--manifest"] ?? path.join(pack ?? root, MANIFEST_FILE)),
-		keys: path.resolve(given["--keys"] ?? path.join(root, KEYS_FILE)),
-		check,
+		manifest: path.resolve(values["--manifest"] ?? path.join(pack ?? root, MANIFEST_FILE)),
+		keys: path.resolve(values["--keys"] ?? path.join(root, KEYS_FILE)),
+		check: switches.has("--check"),
 		pack,
-		cache
+		cache: !switches.has("--no-cache"),
+		pseudo: switches.has("--pseudo"),
+		source: values["--source"] ?? DEFAULT_SOURCE$1,
+		exportDir: resolveGiven(values["--export"]),
+		importDir: resolveGiven(values["--import"])
 	};
 }
 /**
@@ -2618,6 +2681,37 @@ function stringsSummary(report) {
 	return `${report.keys.length} strings in ${report.locales.length} locales (${report.locales.join(", ")}).`;
 }
 /**
+* One line about one exported locale: its file and how many keys it lacks.
+*
+* @param dir - The export folder, resolved.
+* @param locale - The locale of the file.
+* @param missing - How many keys have no text in that locale.
+* @returns The line for the console.
+* @example
+* ```ts
+* exportLine("/game/translations", "ru", 3); // 'exported "/game/translations/ru.json": 3 missing.'
+* ```
+*/
+function exportLine(dir, locale, missing) {
+	return `exported "${path.join(dir, locale + EXCHANGE_EXTENSION)}": ${missing} missing.`;
+}
+/**
+* One line about an import. The importer reports the totals of the run, so one line sums up
+* every locale: the folder, the locales read, the keys written and the feature files rewritten.
+*
+* @param dir - The import folder, resolved.
+* @param report - What the import wrote.
+* @returns The line for the console.
+* @example
+* ```ts
+* importLine("/game/translations", { locales: ["ru"], keys: 3, files: ["a.json", "b.json"] });
+* // 'imported "/game/translations" (ru): 3 keys into 2 files.'
+* ```
+*/
+function importLine(dir, report) {
+	return `imported "${dir}"${report.locales.length === 0 ? "" : ` (${report.locales.join(", ")})`}: ${plural(report.keys, "key")} into ${plural(report.files.length, "file")}.`;
+}
+/**
 * One line about a packed bundle.
 *
 * @param name - Name of the bundle.
@@ -2653,6 +2747,38 @@ function packSummary(file, result, cache) {
 	return `wrote "${file}": ${plural(result.pages, "page")}, ${plural(result.loose, "loose file")}, ${plural(fonts, "font")}, ${plural(sounds, "sound")}, ${Math.round(result.bytes / 1024)} KB. cache: ${hits}.`;
 }
 /**
+* The dev run of `bun run assets:keys`: walk the features, write the manifest and the key module, then compile the
+* feature strings next to the key module (the pseudo-locale too with `--pseudo`). With `--check`
+* nothing is written and a difference fails the run.
+*
+* @param options - The parsed flags.
+* @param compile - The strings compiler.
+* @param ui - Where the lines go.
+* @returns The exit code: `1` when `--check` found a difference, else `0`.
+* @throws {Error} When the scan or the compile fails.
+*/
+async function runKeys(options, compile, ui) {
+	const { manifest, changed, notes } = await scanAssets({
+		root: options.root,
+		manifest: options.manifest,
+		keys: options.keys,
+		write: !options.check
+	});
+	const strings = await compile(options.root, path.dirname(options.keys), {
+		check: options.check,
+		pseudo: options.pseudo
+	});
+	for (const note of [...notes, ...strings.notes]) ui.warn(note);
+	if ((changed || strings.changed) && options.check) {
+		ui.error(`${changed ? outputNames(options) : "the generated strings"} are out of date.\n  Run "bun run assets:keys" and commit the result.`);
+		return 1;
+	}
+	ui.info(changed ? `wrote ${outputNames(options)}.` : `${outputNames(options)} are up to date.`);
+	ui.info(summary(manifest));
+	if (strings.keys.length > 0) ui.info(stringsSummary(strings));
+	return 0;
+}
+/**
 * The `--pack` run: the same scan and key list as a dev run, the strings compile, then the packer.
 * The keys are written as a dev run writes them; the dev manifest is not touched, the packed one
 * goes to `--manifest`.
@@ -2662,10 +2788,9 @@ function packSummary(file, result, cache) {
 * @param compile - The strings compiler.
 * @param ui - Where the lines go.
 * @returns The exit code.
-* @throws {Error} With `--check`, and when the scan, the compile or the pack fails.
+* @throws {Error} When the scan, the compile or the pack fails.
 */
 async function runPack(options, pack, compile, ui) {
-	if (options.check) throw problem$1("\"--pack\" writes files; drop \"--check\".");
 	const scan = await scanAssets({
 		root: options.root,
 		manifest: options.manifest,
@@ -2676,7 +2801,10 @@ async function runPack(options, pack, compile, ui) {
 		file: options.keys,
 		text: scan.keysSource
 	}], true);
-	const strings = await compile(options.root, path.dirname(options.keys), { check: false });
+	const strings = await compile(options.root, path.dirname(options.keys), {
+		check: false,
+		pseudo: false
+	});
 	for (const note of [...scan.notes, ...strings.notes]) ui.warn(note);
 	const result = await packAssets({
 		root: options.root,
@@ -2690,45 +2818,70 @@ async function runPack(options, pack, compile, ui) {
 	return 0;
 }
 /**
+* The `--export <dir>` run: the exchange files for the translators and nothing else. No asset
+* scan, no generated module.
+*
+* @param options - The parsed flags.
+* @param dir - The export folder, resolved.
+* @param exportStrings - The strings exporter.
+* @param ui - Where the lines go.
+* @returns The exit code.
+* @throws {Error} When the export fails.
+*/
+async function runExport(options, dir, exportStrings, ui) {
+	const report = await exportStrings(options.root, dir, { source: options.source });
+	for (const locale of report.locales) ui.info(exportLine(dir, locale, report.missing[locale] ?? 0));
+	return 0;
+}
+/**
+* The `--import <dir>` run: the translated files go into the feature string files, and the
+* importer compiles into the folder of the key module. No asset scan.
+*
+* @param options - The parsed flags.
+* @param dir - The import folder, resolved.
+* @param importStrings - The strings importer.
+* @param ui - Where the lines go.
+* @returns The exit code.
+* @throws {Error} When the import or its compile fails.
+*/
+async function runImport(options, dir, importStrings, ui) {
+	const report = await importStrings(options.root, dir, {
+		source: options.source,
+		pseudo: options.pseudo,
+		out: path.dirname(options.keys)
+	});
+	ui.info(importLine(dir, report));
+	return 0;
+}
+/**
 * Runs the asset key scanner: walk the features, write the manifest and the key module, then
 * compile the feature strings next to the key module, or check that all of it is current. With
-* `--pack <dir>` it packs the art for production on the same scan (`--no-cache` for a cold run).
-* Nothing here calls `process.exit`; the caller does.
+* `--pack <dir>` it packs the art for production on the same scan (`--no-cache` for a cold run);
+* `--pseudo` adds the pseudo-locale to a dev run. `--export <dir>` and `--import <dir>` exchange
+* the strings with translators and run alone, from the locale of `--source`. Nothing here calls
+* `process.exit`; the caller does.
 *
 * @param argv - The arguments after the script name.
-* @param compile - The strings compiler, `compileStrings` of i18n.
+* @param strings - The string tools of i18n: compile, export and import.
 * @param ui - Where the lines go. The branded console by default.
-* @returns The exit code: `1` when the scan, the compile or the pack failed or `--check` found a
-*   difference, else `0`.
+* @returns The exit code: `1` when the flags, the scan, the compile, the pack, the export or the
+*   import failed or `--check` found a difference, else `0`.
 * @example
 * ```ts
-* await runCli(["--root", "src", "--manifest", "public/assets/manifest.json", "--check"], compileStrings);
-* // 1 when public/assets/manifest.json is older than the files in src/features
-*
-* await runCli(["--root", "src", "--keys", "src/generated/assets.ts", "--pack", "dist/assets"], compileStrings);
+* const strings = { compile: compileStrings, exportStrings, importStrings };
+* await runCli(["--root", "src", "--keys", "src/generated/assets.ts", "--pack", "dist/assets"], strings);
 * // 0, and dist/assets holds the pages, the loose files and the packed manifest.json
+* await runCli(["--root", "src", "--export", "translations"], strings);
+* // 0, and translations/ holds one <locale>.json per locale for the translators
 * ```
 */
-async function runCli(argv, compile, ui = createBrandConsole()) {
+async function runCli(argv, strings, ui = createBrandConsole()) {
 	try {
 		const options = parseArgv(argv);
-		if (options.pack !== void 0) return await runPack(options, options.pack, compile, ui);
-		const { manifest, changed, notes } = await scanAssets({
-			root: options.root,
-			manifest: options.manifest,
-			keys: options.keys,
-			write: !options.check
-		});
-		const strings = await compile(options.root, path.dirname(options.keys), { check: options.check });
-		for (const note of [...notes, ...strings.notes]) ui.warn(note);
-		if ((changed || strings.changed) && options.check) {
-			ui.error(`${changed ? outputNames(options) : "the generated strings"} are out of date.\n  Run "bun run assets:keys" and commit the result.`);
-			return 1;
-		}
-		ui.info(changed ? `wrote ${outputNames(options)}.` : `${outputNames(options)} are up to date.`);
-		ui.info(summary(manifest));
-		if (strings.keys.length > 0) ui.info(stringsSummary(strings));
-		return 0;
+		if (options.exportDir !== void 0) return await runExport(options, options.exportDir, strings.exportStrings, ui);
+		if (options.importDir !== void 0) return await runImport(options, options.importDir, strings.importStrings, ui);
+		if (options.pack !== void 0) return await runPack(options, options.pack, strings.compile, ui);
+		return await runKeys(options, strings.compile, ui);
 	} catch (error) {
 		ui.error(messageOf(error));
 		return 1;
@@ -2780,6 +2933,30 @@ function argumentHelper() {
 	].join("\n");
 }
 /**
+* The helper a compiled `duration` calls: milliseconds into the record `Intl.DurationFormat`
+* reads. The same split as `durationInput` of the plugin: whole seconds rounded up, a negative or
+* non-finite value as zero, hours and minutes when above zero, seconds always.
+*
+* @returns The helper as source.
+*/
+function durationHelper() {
+	return [
+		"/** Milliseconds as Intl.DurationFormat reads them: whole seconds rounded up, seconds always. */",
+		"function duration(ms: number): Partial<Record<Intl.DurationFormatUnit, number>> {",
+		"  const total = Number.isFinite(ms) ? Math.max(0, Math.ceil(ms / 1000)) : 0;",
+		"  const hours = Math.floor(total / 3600);",
+		"  const minutes = Math.floor((total % 3600) / 60);",
+		"  const input: Partial<Record<Intl.DurationFormatUnit, number>> = {};",
+		"",
+		"  if (hours > 0) input.hours = hours;",
+		"  if (minutes > 0) input.minutes = minutes;",
+		"  input.seconds = total % 60;",
+		"",
+		"  return input;",
+		"}"
+	].join("\n");
+}
+/**
 * Compares two keys, so every list the compiler writes has one order.
 *
 * @param left - First key.
@@ -2791,7 +2968,7 @@ function byName(left, right) {
 	return left < right ? -1 : 1;
 }
 /**
-* Writes `generated/strings.<locale>.ts`: one arrow per key, keys sorted, the helper only when a
+* Writes `generated/strings.<locale>.ts`: one arrow per key, keys sorted, each helper only when a
 * message needs it.
 *
 * @param entries - The keys of the locale, in any order.
@@ -2807,6 +2984,7 @@ function emitLocale(entries) {
 	const rows = sorted.map((entry) => `  ${JSON.stringify(entry.key)}: ${entry.compiled.source}`);
 	const blocks = [`${HEADER}\nimport type { I18n } from "@moku-labs/game";`];
 	if (sorted.some((entry) => entry.compiled.usesArgument)) blocks.push(argumentHelper());
+	if (sorted.some((entry) => entry.compiled.usesDuration)) blocks.push(durationHelper());
 	blocks.push(`export default {\n${rows.join(",\n")}\n} satisfies I18n.CompiledMessages;`);
 	return `${blocks.join("\n\n")}\n`;
 }
@@ -2822,7 +3000,7 @@ function emitLocale(entries) {
 */
 function typeOf(type) {
 	if (type.kind === "argument") return ARGUMENT;
-	if (type.kind === "number") return "number";
+	if (type.kind === "number" || type.kind === "duration") return "number";
 	if (type.kind === "date") return "Date | number";
 	return type.options.map((option) => JSON.stringify(option)).join(" | ");
 }
@@ -5369,6 +5547,20 @@ function parse(message, opts = {}) {
 */
 /** The style a `{d, date}` with no style means. */
 const DEFAULT_DATE_STYLE = "medium";
+/** The style a `{left, duration}` with no style means, the `Intl.DurationFormat` default. */
+const DEFAULT_DURATION_STYLE = "short";
+/**
+* The number style a `{left, duration, short}` is rewritten to before the parser reads it: the
+* parser knows no `duration` type, and refuses it.
+*/
+const DURATION_PREFIX = "duration-";
+/**
+* One `duration` argument at the start of a string: `{name, duration}` or
+* `{name, duration, style}`. It has no sub-messages, so it never crosses a brace.
+*/
+const DURATION_ARGUMENT = /^\{\s*([^\s{},]+)\s*,\s*duration\s*(?:,\s*([^\s{},]+)\s*)?\}/;
+/** The characters an apostrophe quotes when it stands right before one of them. */
+const QUOTABLE = "{}<>#";
 /** A parameter name that can be read with a dot. */
 const PLAIN_NAME = /^[A-Za-z_$][\w$]*$/;
 /** The TypeScript cast keyword, kept apart so this file writes one and holds none. */
@@ -5402,15 +5594,97 @@ function detailOf$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 /**
-* Parses one message, turning a parser failure into a compile problem.
+* Measures the run at one position that the pre-pass copies untouched: `''`, one literal
+* apostrophe, or a run an apostrophe quotes because a syntax character follows it, up to the
+* closing apostrophe or the end of the message.
+*
+* @param text - The message as the game wrote it.
+* @param index - Where the run may start.
+* @returns Where the run ends, or the same index when none starts there.
+* @example
+* ```ts
+* quotedRunEnd("'{x}' left", 0); // 5
+* ```
+*/
+function quotedRunEnd(text, index) {
+	const next = text[index + 1];
+	if (text[index] !== "'" || next === void 0) return index;
+	if (next === "'") return index + 2;
+	if (!QUOTABLE.includes(next)) return index;
+	let cursor = index + 2;
+	while (cursor < text.length) if (text[cursor] !== "'") cursor += 1;
+	else if (text[cursor + 1] === "'") cursor += 2;
+	else return cursor + 1;
+	return text.length;
+}
+/**
+* Reads a `duration` argument at one position and writes, in its place, the number style the
+* parser accepts.
+*
+* @param text - The message as the game wrote it.
+* @param index - Where the argument may start.
+* @returns The rewritten argument and the length it replaces, or `undefined` when none starts there.
+* @example
+* ```ts
+* durationAt("{left, duration}", 0); // { text: "{left, number, duration-short}", length: 16 }
+* ```
+*/
+function durationAt(text, index) {
+	const match = DURATION_ARGUMENT.exec(text.slice(index));
+	if (match === null) return void 0;
+	const [whole, name, style = DEFAULT_DURATION_STYLE] = match;
+	return {
+		text: `{${name}, number, ${DURATION_PREFIX}${style}}`,
+		length: whole.length
+	};
+}
+/**
+* The pre-pass the parser needs: every `duration` argument outside a quoted run becomes a number
+* with a `duration-<style>` style, which `numberPiece` turns back into a duration.
+*
+* @param text - The message as the game wrote it.
+* @returns The message the parser reads.
+* @example
+* ```ts
+* rewriteDurations("Opens in {left, duration, long}"); // "Opens in {left, number, duration-long}"
+* ```
+*/
+function rewriteDurations(text) {
+	let rewritten = "";
+	let index = 0;
+	while (index < text.length) {
+		const quoted = quotedRunEnd(text, index);
+		if (quoted > index) {
+			rewritten += text.slice(index, quoted);
+			index = quoted;
+			continue;
+		}
+		const argument = text[index] === "{" ? durationAt(text, index) : void 0;
+		if (argument !== void 0) {
+			rewritten += argument.text;
+			index += argument.length;
+			continue;
+		}
+		rewritten += text.charAt(index);
+		index += 1;
+	}
+	return rewritten;
+}
+/**
+* Parses one message, turning a parser failure into a compile problem. The `duration` pre-pass
+* runs first, so the elements carry a duration as a number with a `duration-<style>` style.
 *
 * @param text - The message as the game wrote it.
 * @returns The elements of the message.
 * @throws {Error} When the message does not parse.
+* @example
+* ```ts
+* parseMessage("{left, duration}"); // [{ type: TYPE.number, value: "left", style: "duration-short" }]
+* ```
 */
 function parseMessage(text) {
 	try {
-		return parse(text, { ignoreTag: true });
+		return parse(rewriteDurations(text), { ignoreTag: true });
 	} catch (error) {
 		throw problem(detailOf$1(error));
 	}
@@ -5425,6 +5699,19 @@ function isDateStyle(style) {
 	return style === "short" || style === "medium" || style === "long" || style === "full";
 }
 /**
+* Tells whether a style is one of the four `Intl.DurationFormat` names.
+*
+* @param style - The style the message asked for, without the `duration-` prefix.
+* @returns True for "long", "short", "narrow" and "digital".
+* @example
+* ```ts
+* isDurationStyle("tiny"); // false
+* ```
+*/
+function isDurationStyle(style) {
+	return style === "long" || style === "short" || style === "narrow" || style === "digital";
+}
+/**
 * Names one style for a problem message, whether it arrived as text or as a parsed skeleton.
 *
 * @param style - What the parser read after the argument type.
@@ -5671,7 +5958,29 @@ function numberOptions(style) {
 	return "";
 }
 /**
-* Compiles a `number` argument.
+* Compiles a `duration` argument, which the pre-pass handed over as a number with a `duration-`
+* style. The kit's formatter reads the record of the module's `duration` helper, with the seconds
+* always shown: `format({ seconds: 0 })` is empty by default, and a countdown at zero must read
+* "0 sec".
+*
+* @param element - The argument the parser read.
+* @param scan - What the walk collects.
+* @param style - The style the message named, without the `duration-` prefix.
+* @returns The piece it becomes.
+* @throws {Error} When the style is not one of the four `Intl.DurationFormat` styles.
+*/
+function durationPiece(element, scan, style) {
+	if (!isDurationStyle(style)) throw problem(`the duration style "${style}" is not supported`);
+	addParameter(scan, element.value, { kind: "duration" });
+	scan.usesIntl = true;
+	scan.usesDuration = true;
+	return {
+		kind: "expr",
+		code: `intl.duration(${`{ style: ${JSON.stringify(style)}, secondsDisplay: "always" }`}).format(duration(${cast(access(element.value), "number")}))`
+	};
+}
+/**
+* Compiles a `number` argument, or a `duration` the pre-pass rewrote into one.
 *
 * @param element - The argument the parser read.
 * @param scan - What the walk collects.
@@ -5680,6 +5989,7 @@ function numberOptions(style) {
 */
 function numberPiece(element, scan) {
 	const style = styleName(element.style);
+	if (style.startsWith(DURATION_PREFIX)) return durationPiece(element, scan, style.slice(9));
 	if (style !== "" && style !== "integer" && style !== "percent") throw problem(`the number style "${style}" is not supported`);
 	addParameter(scan, element.value, { kind: "number" });
 	scan.usesIntl = true;
@@ -5772,39 +6082,239 @@ function headOf(scan) {
 	return scan.usesParams ? "p" : "()";
 }
 /**
-* Compiles one ICU message into the arrow the build writes into `generated/strings.<locale>.ts`.
+* Compiles the parsed elements of one message into the arrow the build writes. The pseudo-locale
+* hands its rewritten elements here directly.
 *
-* @param text - The message as the game wrote it.
-* @returns The arrow source, the parameter types and whether the module needs the helper.
-* @throws {Error} When the message does not parse or uses an unsupported ICU feature.
+* @param elements - What `parseMessage` read, or a rewrite of it.
+* @returns The arrow source, the parameter types and the helpers the module needs.
+* @throws {Error} When the elements use an unsupported ICU feature.
 * @example
 * ```ts
-* compileMessage("Заказы").source; // '() => [{ kind: "text", text: "Заказы" }]'
+* compileElements([{ type: TYPE.literal, value: "Play" }]).source; // '() => [{ kind: "text", text: "Play" }]'
 * ```
 */
-function compileMessage(text) {
+function compileElements(elements) {
 	const scan = {
 		params: {},
 		usesArgument: false,
+		usesDuration: false,
 		usesParams: false,
 		usesIntl: false
 	};
-	const pieces = piecesOf(parseMessage(text), scan);
+	const pieces = piecesOf(elements, scan);
 	return {
 		source: `${headOf(scan)} => ${toParts(pieces)}`,
 		params: scan.params,
-		usesArgument: scan.usesArgument
+		usesArgument: scan.usesArgument,
+		usesDuration: scan.usesDuration
 	};
 }
+/**
+* Compiles one ICU message into the arrow the build writes into `generated/strings.<locale>.ts`.
+*
+* @param text - The message as the game wrote it.
+* @returns The arrow source, the parameter types and the helpers the module needs.
+* @throws {Error} When the message does not parse or uses an unsupported ICU feature.
+* @example
+* ```ts
+* compileMessage("Заказы").source; // '() => [{ kind: "text", text: "Заказы" }]'
+* ```
+*/
+function compileMessage(text) {
+	return compileElements(parseMessage(text));
+}
 //#endregion
-//#region src/plugins/i18n/compile/compile.ts
+//#region src/plugins/i18n/compile/pseudo.ts
+/**
+* @file i18n plugin, build time — the pseudo-locale `en-XA`: every English message with accented
+* letters, 40 % more length in whole words, and brackets around it. On screen it shows a label
+* that is not translated, a box too small for a longer language and a sentence cut short. It works
+* on the parsed message: only literal text changes; arguments, plural keywords, exact matches, `#`
+* and tags stay as they are. Node and Bun only, like the rest of `compile/`.
+*/
+/** The ASCII letters, in the order of `ACCENTED`. */
+const PLAIN = "abcdefghijklmnopqrstuvwxyz";
+/** The accent table: the accented form of each letter of `PLAIN`; a capital takes its upper case. */
+const ACCENTED = "áɓçðéƒĝĥíĵķļɱñóþǫŕšţúṿŵẋýž";
+/** One ASCII letter of either case. */
+const LETTER = /[a-z]/gi;
+/** One tag run inside a literal, captured so a split keeps it: `<b>`, `</b>`, `<icon=hud.coin>`. */
+const TAG_RUN = /(<\/?[a-z][^<>]*>)/;
+/** The words the padding is made of, cycled. */
+const PADDING_WORDS = [
+	"one",
+	"two",
+	"three",
+	"four",
+	"five",
+	"six",
+	"seven",
+	"eight",
+	"nine",
+	"ten"
+];
+/** The literal length of a pseudo message against its original, in percent. */
+const GROWTH_PERCENT = 140;
 /**
-* @file i18n plugin, build time — the walk over `features/*​/strings/<locale>.json` and the two
-* generated modules it writes. Every problem of a run is collected and reported in one error, so
-* a game fixes its messages in one round. Node and Bun only: nothing under `src/` outside this
-* folder and `src/assets.ts` imports it, so no game bundles the ICU parser.
+* Accents one ASCII letter, keeping its case.
+*
+* @param letter - One letter from `a` to `z` or `A` to `Z`.
+* @returns The accented letter.
+* @example
+* ```ts
+* accentLetter("P"); // "Þ"
+* ```
 */
-/** How every problem of this compiler is prefixed. */
+function accentLetter(letter) {
+	const lower = letter.toLowerCase();
+	const accented = ACCENTED.charAt(PLAIN.indexOf(lower));
+	return letter === lower ? accented : accented.toUpperCase();
+}
+/**
+* Splits a literal into its runs: text at even positions, tag runs at odd ones.
+*
+* @param text - One literal of a message.
+* @returns The runs, in order.
+* @example
+* ```ts
+* runsOf("<b>Gold</b>"); // ["", "<b>", "Gold", "</b>", ""]
+* ```
+*/
+function runsOf(text) {
+	return text.split(TAG_RUN);
+}
+/**
+* Tells whether a run of `runsOf` is a tag run.
+*
+* @param index - The position of the run.
+* @returns True for a tag run.
+*/
+function isTagRun(index) {
+	return index % 2 === 1;
+}
+/**
+* Accents every ASCII letter of a literal and copies its tag runs as they are, so the tag pass
+* of `text` still finds them. Every other character stays, and the length does not change.
+*
+* @param text - One literal of a message.
+* @returns The accented literal.
+* @example
+* ```ts
+* accent("<b>Gold</b> 25"); // "<b>Ĝóļð</b> 25"
+* ```
+*/
+function accent(text) {
+	return runsOf(text).map((run, index) => isTagRun(index) ? run : run.replaceAll(LETTER, accentLetter)).join("");
+}
+/**
+* The padding a message of one literal length gets: whole words, each after a space, until the
+* length reaches 140 % of the original. A message with no literal text gets none.
+*
+* @param original - The literal characters of the message outside tags, every branch counted.
+* @returns The padding text.
+* @example
+* ```ts
+* pad(13); // " one two"
+* ```
+*/
+function pad(original) {
+	const target = Math.ceil(original * GROWTH_PERCENT / 100);
+	const words = [];
+	let length = original;
+	while (length < target) {
+		const word = PADDING_WORDS[words.length % PADDING_WORDS.length] ?? "";
+		words.push(word);
+		length += word.length + 1;
+	}
+	return words.map((word) => ` ${word}`).join("");
+}
+/**
+* Counts the literal characters of a message outside tags, every branch of every plural and
+* select counted.
+*
+* @param elements - The parsed message.
+* @returns The count.
+*/
+function literalLength(elements) {
+	let length = 0;
+	for (const element of elements) {
+		if (element.type === TYPE.literal) length += runsOf(element.value).filter((_run, index) => !isTagRun(index)).join("").length;
+		if (element.type === TYPE.plural || element.type === TYPE.select) for (const option of Object.values(element.options)) length += literalLength(option.value);
+	}
+	return length;
+}
+/**
+* Accents the branches of a plural or a select, keeping their names.
+*
+* @param options - The branches the parser read.
+* @returns The same branches with accented literals.
+*/
+function accentOptions(options) {
+	const accented = {};
+	for (const [name, option] of Object.entries(options)) accented[name] = {
+		...option,
+		value: option.value.map((element) => accentElement(element))
+	};
+	return accented;
+}
+/**
+* Accents the literals of one element, at any depth. Arguments, `#` and every name stay.
+*
+* @param element - One parsed element.
+* @returns The element with accented literals.
+*/
+function accentElement(element) {
+	if (element.type === TYPE.literal) return {
+		...element,
+		value: accent(element.value)
+	};
+	if (element.type === TYPE.plural) return {
+		...element,
+		options: accentOptions(element.options)
+	};
+	if (element.type === TYPE.select) return {
+		...element,
+		options: accentOptions(element.options)
+	};
+	return element;
+}
+/**
+* Builds one literal element.
+*
+* @param value - The text.
+* @returns The element.
+*/
+function literal(value) {
+	return {
+		type: TYPE.literal,
+		value
+	};
+}
+/**
+* Derives the `en-XA` message of one English message: accented literals, the padding after the
+* last top-level piece, and brackets around everything. `"Opens in {left, duration, short}"`
+* reads `"[Óþéñš íñ {left, duration, short} one]"`.
+*
+* @param elements - The parsed English message.
+* @returns The parsed pseudo message, ready for `compileElements`.
+*/
+function pseudoMessage(elements) {
+	const padding = pad(literalLength(elements));
+	return [
+		literal("["),
+		...elements.map((element) => accentElement(element)),
+		literal(`${padding}]`)
+	];
+}
+//#endregion
+//#region src/plugins/i18n/compile/walk.ts
+/**
+* @file i18n plugin, build time — the walk over `features/*​/strings/<locale>.json`: every file
+* read, every key claimed by one feature, every message compiled once and every problem collected,
+* with the text and the translator note of each key kept aside. `compileStrings`, `exportStrings`
+* and `importStrings` all start from it. Node and Bun only.
+*/
+/** How every problem of the string compiler is prefixed. */
 const PREFIX = "[game] i18n: ";
 /**
 * Creates the table of compiled messages per locale. Its own function because lint rule L5
@@ -5832,6 +6342,30 @@ function emptyParameters() {
 	return /* @__PURE__ */ new Map();
 }
 /**
+* Creates a table of key to locale to text, for the messages or the notes.
+*
+* @returns An empty table.
+*/
+function emptyTexts() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Creates the parameter table of one key.
+*
+* @returns An empty table.
+*/
+function emptyOrigins() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Creates the per-locale table of one key.
+*
+* @returns An empty table.
+*/
+function emptyByLocale() {
+	return /* @__PURE__ */ new Map();
+}
+/**
 * Reads the message of anything that was thrown.
 *
 * @param error - What the `catch` caught.
@@ -5846,13 +6380,59 @@ function detailOf(error) {
 * @param problems - The problems, in walk order.
 * @returns The error to reject with.
 */
-function collected(problems) {
+function compileFailure(problems) {
 	const only = problems[0];
 	if (problems.length === 1 && only !== void 0) return /* @__PURE__ */ new Error(`${PREFIX}${only}\n  Fix the message or use a supported ICU feature.`);
 	const lines = problems.map((text) => `  ${text}`).join("\n");
 	return /* @__PURE__ */ new Error(`${PREFIX}the compile found ${problems.length} problems.\n${lines}\n  Fix them and run "bun run assets:keys" again.`);
 }
 /**
+* Tells whether an object is the `{ text, note }` form of a message: a string `text`, an optional
+* string `note`, and nothing else.
+*
+* @param value - One value of a string file that is an object.
+* @returns True for the noted form.
+* @example
+* ```ts
+* isNoted({ text: "Deliver", note: "Button, max 10 chars" }); // true
+* ```
+*/
+function isNoted(value) {
+	const hasText = "text" in value && typeof value.text === "string";
+	const noteIsText = !("note" in value) || typeof value.note === "string";
+	const onlyKnown = Object.keys(value).every((name) => name === "text" || name === "note");
+	return hasText && noteIsText && onlyKnown;
+}
+/**
+* Tells whether a parsed JSON value is a table of key to value: an object, not `null`, not an
+* array.
+*
+* @param value - A parsed JSON value.
+* @returns True when the value is a table.
+* @example
+* ```ts
+* isTable(["hud.title"]); // false
+* ```
+*/
+function isTable(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Tells whether one value of a string file is a message: a string, or `{ text, note }`.
+*
+* @param value - One value of a string file.
+* @returns True when the value is a message.
+* @example
+* ```ts
+* isMessageEntry({ text: "Deliver", max: 10 }); // false: an extra member
+* ```
+*/
+function isMessageEntry(value) {
+	if (typeof value === "string") return true;
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	return isNoted(value);
+}
+/**
 * Lists the sub-folders of a folder that may not exist.
 *
 * @param folder - Path of the folder.
@@ -5879,17 +6459,38 @@ async function listLocales(folder) {
 	}
 }
 /**
+* Lists every string file of a game: features sorted, then locales sorted.
+*
+* @param root - Game source root, the folder that holds the features.
+* @param features - Name of the folder that holds the features.
+* @returns The files, in walk order.
+*/
+async function listStringFiles(root, features) {
+	const files = [];
+	const featuresFolder = path.join(root, features);
+	for (const feature of await listFolders(featuresFolder)) {
+		const stringsFolder = path.join(featuresFolder, feature, "strings");
+		for (const locale of await listLocales(stringsFolder)) files.push({
+			feature,
+			locale,
+			file: path.join(stringsFolder, `${locale}.json`),
+			relative: `features/${feature}/strings/${locale}.json`
+		});
+	}
+	return files;
+}
+/**
 * Reads one string file as a flat table of key to message.
 *
 * @param file - Path of the file.
 * @param relative - The path a problem names it by.
-* @param walk - What the compile collects.
+* @param walk - What the walk collects.
 * @returns The table, or `undefined` when the file is a problem.
 */
 async function readTable(file, relative, walk) {
 	try {
 		const parsed = JSON.parse(await readFile(file, "utf8"));
-		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+		if (!isTable(parsed)) {
 			walk.problems.push(`${relative}: a string file is an object of key to message.`);
 			return;
 		}
@@ -5902,7 +6503,7 @@ async function readTable(file, relative, walk) {
 /**
 * Records which feature owns a key, refusing the same key in two features.
 *
-* @param walk - What the compile collects.
+* @param walk - What the walk collects.
 * @param key - The message key.
 * @param source - Where this message came from.
 * @returns True when the key belongs to this feature.
@@ -5931,17 +6532,9 @@ function unique(options) {
 	return [...new Set(options)].toSorted();
 }
 /**
-* Creates the parameter table of one key.
-*
-* @returns An empty table.
-*/
-function emptyOrigins() {
-	return /* @__PURE__ */ new Map();
-}
-/**
 * Merges the parameters one locale read for a key into what the other locales read.
 *
-* @param walk - What the compile collects.
+* @param walk - What the walk collects.
 * @param key - The message key.
 * @param params - What this locale read.
 * @param relative - The file this locale came from.
@@ -5972,19 +6565,35 @@ function mergeParameters(walk, key, params, relative) {
 	}
 }
 /**
-* Compiles one message into the locale it belongs to.
+* Keeps one text of one key in one locale: the message, or its note.
 *
-* @param walk - What the compile collects.
+* @param table - The messages or the notes of the walk.
 * @param key - The message key.
-* @param text - The message.
+* @param locale - The locale of the file.
+* @param text - What the file wrote.
+*/
+function remember(table, key, locale, text) {
+	const byLocale = table.get(key) ?? emptyByLocale();
+	byLocale.set(locale, text);
+	table.set(key, byLocale);
+}
+/**
+* Reads one value of a string file and compiles its message into the locale it belongs to.
+*
+* @param walk - What the walk collects.
+* @param key - The message key.
+* @param value - The value the file wrote for the key.
 * @param source - Where this message came from.
 */
-function compileOne(walk, key, text, source) {
-	if (typeof text !== "string") {
-		walk.problems.push(`"${key}" in ${source.relative}: a message must be a string.`);
+function compileOne(walk, key, value, source) {
+	if (!isMessageEntry(value)) {
+		walk.problems.push(`"${key}" in ${source.relative}: a message is a string or { "text": string, "note": string }.`);
 		return;
 	}
 	if (!claim(walk, key, source)) return;
+	const text = typeof value === "string" ? value : value.text;
+	remember(walk.texts, key, source.locale, text);
+	if (typeof value !== "string" && value.note !== void 0) remember(walk.notes, key, source.locale, value.note);
 	try {
 		const compiled = compileMessage(text);
 		const entries = walk.byLocale.get(source.locale) ?? [];
@@ -5999,6 +6608,100 @@ function compileOne(walk, key, text, source) {
 	}
 }
 /**
+* Walks every string file of a game and compiles every message once. Problems are collected, not
+* thrown, so the caller reports them all in one error.
+*
+* @param root - Game source root, the folder that holds the features.
+* @param features - Name of the folder that holds the features.
+* @returns The compiled messages per locale, the owner and parameters of each key, the texts and
+*   notes of each key per locale, and every problem.
+*/
+async function walkStrings(root, features) {
+	const walk = {
+		byLocale: emptyLocales(),
+		owner: emptyOwners(),
+		params: emptyParameters(),
+		problems: [],
+		texts: emptyTexts(),
+		notes: emptyTexts()
+	};
+	for (const file of await listStringFiles(root, features)) {
+		const table = await readTable(file.file, file.relative, walk);
+		if (table === void 0) continue;
+		const source = {
+			feature: file.feature,
+			locale: file.locale,
+			relative: file.relative
+		};
+		for (const [key, value] of Object.entries(table)) compileOne(walk, key, value, source);
+	}
+	return walk;
+}
+//#endregion
+//#region src/plugins/i18n/compile/compile.ts
+/**
+* @file i18n plugin, build time — `compileStrings`: the walk over `features/*​/strings/<locale>.json`
+* turned into the generated modules, and on request the pseudo-locale `en-XA` derived from English.
+* Every problem of a run is collected and reported in one error, so a game fixes its messages in
+* one round. Node and Bun only: nothing under `src/` outside this folder and `src/assets.ts`
+* imports it, so no game bundles the ICU parser.
+*/
+/** The locale the pseudo-locale is derived from. */
+const PSEUDO_SOURCE = "en";
+/** The pseudo-locale `--pseudo` writes. */
+const PSEUDO_LOCALE = "en-XA";
+/**
+* Wraps a pseudo run without English in the message shape of the framework.
+*
+* @returns The error to reject with.
+*/
+function pseudoNeedsEnglish() {
+	return /* @__PURE__ */ new Error(`${PREFIX}"--pseudo" needs an "en" string file in at least one feature.\n  Add features/<feature>/strings/en.json or drop "--pseudo".`);
+}
+/**
+* Tells whether at least one feature brings a string file for a locale.
+*
+* @param root - Game source root, the folder that holds the features.
+* @param features - Name of the folder that holds the features.
+* @param locale - The locale to look for.
+* @returns True when a feature has `strings/<locale>.json`.
+*/
+async function bringsLocale(root, features, locale) {
+	return (await listStringFiles(root, features)).some((file) => file.locale === locale);
+}
+/**
+* Derives the pseudo message of every English message. Each one compiled already in the walk, so
+* nothing here can fail.
+*
+* @param walk - What the walk collected.
+* @returns One entry per English key.
+*/
+function pseudoEntries(walk) {
+	const entries = [];
+	for (const [key, texts] of walk.texts) {
+		const english = texts.get(PSEUDO_SOURCE);
+		if (english === void 0) continue;
+		entries.push({
+			key,
+			compiled: compileElements(pseudoMessage(parseMessage(english)))
+		});
+	}
+	return entries;
+}
+/**
+* The locale modules one compile writes: what the features brought, and the pseudo-locale derived
+* from English on request.
+*
+* @param walk - What the walk collected.
+* @param pseudo - Whether the pseudo-locale is written too.
+* @returns The compiled messages per locale.
+*/
+function localeModules(walk, pseudo) {
+	const modules = new Map(walk.byLocale);
+	if (pseudo) modules.set(PSEUDO_LOCALE, pseudoEntries(walk));
+	return modules;
+}
+/**
 * Lists the keys a locale is missing, so a translator sees the gap without the build stopping.
 *
 * @param walk - What the compile collects.
@@ -6033,57 +6736,47 @@ function typeEntries(walk) {
 }
 /**
 * Walks `features/*​/strings/<locale>.json` of a game, compiles every message and writes the
-* generated modules: the types module `strings.ts` and one `strings.<locale>.ts` per locale. A
-* check run writes nothing and only reports whether something would change.
+* generated modules: the types module `strings.ts` and one `strings.<locale>.ts` per locale, plus
+* `strings.en-XA.ts` with `pseudo`. A check run writes nothing and only reports whether something
+* would change; it checks `strings.en-XA.ts` only with `pseudo`.
 *
 * @param root - Game source root, the folder that holds the features.
 * @param out - The generated directory the modules are written into.
-* @param options - Whether this is a check run, and what the features folder is called.
+* @param options - Whether this is a check run, what the features folder is called, and whether
+*   the pseudo-locale is written.
 * @returns Whether an output differed, the locales, the keys and the notes.
-* @throws {Error} One error that lists every problem the compile found.
+* @throws {Error} One error that lists every problem the compile found, or the pseudo error when
+*   no feature brings an `en` string file.
 * @example
 * ```ts
-* const report = await compileStrings("src", "src/generated");
-* // report.locales: ["en", "ru"], report.changed: true on the first run
+* // A dev build also writes the pseudo-locale, derived from the English messages.
+* const report = await compileStrings("src", "src/generated", { pseudo: true });
+* // report.locales: ["en", "en-XA", "ru"], report.changed: true on the first run
 * ```
 */
 async function compileStrings(root, out, options = {}) {
-	const walk = {
-		byLocale: emptyLocales(),
-		owner: emptyOwners(),
-		params: emptyParameters(),
-		problems: []
-	};
-	const featuresFolder = path.join(root, options.features ?? "features");
-	for (const feature of await listFolders(featuresFolder)) {
-		const stringsFolder = path.join(featuresFolder, feature, "strings");
-		for (const locale of await listLocales(stringsFolder)) {
-			const relative = `features/${feature}/strings/${locale}.json`;
-			const table = await readTable(path.join(stringsFolder, `${locale}.json`), relative, walk);
-			if (table === void 0) continue;
-			for (const [key, text] of Object.entries(table)) compileOne(walk, key, text, {
-				feature,
-				locale,
-				relative
-			});
-		}
-	}
-	if (walk.problems.length > 0) throw collected(walk.problems);
-	const locales = [...walk.byLocale.keys()].toSorted();
+	const features = options.features ?? "features";
+	const pseudo = options.pseudo === true;
+	if (pseudo && !await bringsLocale(root, features, PSEUDO_SOURCE)) throw pseudoNeedsEnglish();
+	const walk = await walkStrings(root, features);
+	if (walk.problems.length > 0) throw compileFailure(walk.problems);
+	const brought = [...walk.byLocale.keys()].toSorted();
 	const keys = [...walk.owner.keys()].toSorted();
-	if (locales.length === 0) return {
+	if (brought.length === 0) return {
 		changed: false,
-		locales,
+		locales: brought,
 		keys,
 		notes: []
 	};
+	const modules = localeModules(walk, pseudo);
+	const locales = [...modules.keys()].toSorted();
 	const write = options.check !== true;
 	const outputs = [{
 		file: path.join(out, "strings.ts"),
 		text: emitTypes(typeEntries(walk))
 	}, ...locales.map((locale) => ({
 		file: path.join(out, `strings.${locale}.ts`),
-		text: emitLocale(walk.byLocale.get(locale) ?? [])
+		text: emitLocale(modules.get(locale) ?? [])
 	}))];
 	let changed = false;
 	for (const output of outputs) changed = await writeIfChanged(output.file, output.text, write) || changed;
@@ -6091,7 +6784,7 @@ async function compileStrings(root, out, options = {}) {
 		changed,
 		locales,
 		keys,
-		notes: missingNotes(walk, locales)
+		notes: missingNotes(walk, brought)
 	};
 }
 /**
@@ -6111,15 +6804,348 @@ async function checkStrings(root, out) {
 	return !(await compileStrings(root, out, { check: true })).changed;
 }
 //#endregion
+//#region src/plugins/i18n/compile/exchange.ts
+/**
+* @file i18n plugin, build time — the exchange with translators. `exportStrings` writes one JSON
+* file per locale with every key, the source text and the note beside it; `importStrings` checks
+* the translated files against the game, writes them into the string files of the features that
+* own the keys, and compiles. Node and Bun only, reached through `src/assets.ts`.
+*/
+/** The locale translators read from when none is named. */
+const DEFAULT_SOURCE = "en";
+/** The folder that holds the features when none is named. */
+const DEFAULT_FEATURES = "features";
+/** The extension of every string file and every exchange file. */
+const JSON_EXTENSION = ".json";
+/**
+* Writes a table the way every exchange and string file is written: 2-space indent, trailing
+* newline.
+*
+* @param table - The content.
+* @returns The text of the file.
+* @example
+* ```ts
+* jsonText({ "hud.title": "Orders" }); // '{\n  "hud.title": "Orders"\n}\n'
+* ```
+*/
+function jsonText(table) {
+	return `${JSON.stringify(table, void 0, 2)}\n`;
+}
+/**
+* Builds the error of a source locale that no feature has a string file for.
+*
+* @param source - The locale the export was told to read from.
+* @returns The error to reject with.
+*/
+function sourceMissing(source) {
+	return /* @__PURE__ */ new Error(`${PREFIX}the source locale "${source}" has no string file.\n  Pass "--source <locale>".`);
+}
+/**
+* Collects every problem of an import into one error.
+*
+* @param problems - The problems, in file order.
+* @returns The error to reject with.
+*/
+function importFailure(problems) {
+	const only = problems[0];
+	if (problems.length === 1 && only !== void 0) return /* @__PURE__ */ new Error(`${PREFIX}${only}\n  Fix the file and import again.`);
+	const lines = problems.map((text) => `  ${text}`).join("\n");
+	return /* @__PURE__ */ new Error(`${PREFIX}the import found ${problems.length} problems.\n${lines}\n  Fix the files and import again.`);
+}
+/**
+* Reads the strings of a game, refusing one that does not compile: an export of it would hand the
+* translators broken text, and an import could not tell where a key belongs.
+*
+* @param root - Game source root, the folder that holds the features.
+* @param features - Name of the folder that holds the features.
+* @returns What the walk collected.
+* @throws {Error} One error that lists every problem the compile found.
+*/
+async function readGame(root, features) {
+	const walk = await walkStrings(root, features);
+	if (walk.problems.length > 0) throw compileFailure(walk.problems);
+	return walk;
+}
+/**
+* Builds the exchange entry of one key in one locale. The note of the source wins over the
+* locale's own, because a translator reads the source.
+*
+* @param walk - What the walk collected.
+* @param key - The message key.
+* @param locale - The locale of the exchange file.
+* @param source - The locale translators read from.
+* @returns The entry: the locale's text or `""`, the source text or `""`, and a note if any.
+*/
+function exchangeEntry(walk, key, locale, source) {
+	const texts = walk.texts.get(key);
+	const notes = walk.notes.get(key);
+	const note = notes?.get(source) ?? notes?.get(locale);
+	const entry = {
+		text: texts?.get(locale) ?? "",
+		source: texts?.get(source) ?? ""
+	};
+	return note === void 0 ? entry : {
+		...entry,
+		note
+	};
+}
+/**
+* Writes the files translators work in: one `<dir>/<locale>.json` per locale the features bring,
+* the source locale included, so a new language starts as a copy of `en.json`. Every key of the
+* game is in every file, sorted: `{ text, source, note? }`, with `text: ""` where the locale has no
+* message yet. The game tree is not touched, and a second run writes the same bytes.
+*
+* @param root - Game source root, the folder that holds the features.
+* @param dir - The folder the exchange files are written into; created when missing.
+* @param options - The source locale and the name of the features folder.
+* @returns The exported locales and how many keys each one lacks.
+* @throws {Error} When the game's strings do not compile, or no feature brings the source locale.
+* @example
+* ```ts
+* // Before a release, the game hands its strings to the translators.
+* await exportStrings("src", "translations"); // { locales: ["en", "ru"], missing: { en: 0, ru: 3 } }
+* // translations/ru.json: { "hud.bonus": { "text": "", "source": "Bonus" }, … }
+* ```
+*/
+async function exportStrings(root, dir, options = {}) {
+	const source = options.source ?? DEFAULT_SOURCE;
+	const walk = await readGame(root, options.features ?? DEFAULT_FEATURES);
+	const locales = [...walk.byLocale.keys()].toSorted();
+	if (!locales.includes(source)) throw sourceMissing(source);
+	const keys = [...walk.owner.keys()].toSorted();
+	const missing = {};
+	for (const locale of locales) {
+		const table = {};
+		for (const key of keys) table[key] = exchangeEntry(walk, key, locale, source);
+		missing[locale] = keys.filter((key) => walk.texts.get(key)?.has(locale) !== true).length;
+		await writeIfChanged(path.join(dir, `${locale}${JSON_EXTENSION}`), jsonText(table), true);
+	}
+	return {
+		locales,
+		missing
+	};
+}
+/**
+* Lists the exchange files of a folder.
+*
+* @param dir - The folder the translators handed back.
+* @param review - Where a folder that cannot be read is reported.
+* @returns The file names, sorted.
+*/
+async function listExchangeFiles(dir, review) {
+	try {
+		return (await readdir(dir, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(JSON_EXTENSION)).map((entry) => entry.name).toSorted();
+	} catch (error) {
+		review.problems.push(`the folder ${dir} could not be read: ${detailOf(error)}.`);
+		return [];
+	}
+}
+/**
+* Reads one exchange file as a table of key to entry.
+*
+* @param dir - The folder the translators handed back.
+* @param name - The file name; minus `.json` it is the locale.
+* @param review - Where a file that is a problem is reported.
+* @returns The file, or `undefined` when it is a problem.
+*/
+async function readExchangeFile(dir, name, review) {
+	const file = path.join(dir, name);
+	const locale = name.slice(0, -5);
+	review.locales.push(locale);
+	try {
+		const parsed = JSON.parse(await readFile(file, "utf8"));
+		if (!isTable(parsed)) {
+			review.problems.push(`${file}: an import file is an object of key to entry.`);
+			return;
+		}
+		return {
+			locale,
+			file,
+			table: parsed
+		};
+	} catch (error) {
+		review.problems.push(`${file} could not be read: ${detailOf(error)}.`);
+		return;
+	}
+}
+/**
+* Reads the text of one exchange entry. `source` and `note` are ignored: notes are written in the
+* game tree.
+*
+* @param entry - One value of an exchange file.
+* @returns The text, or `undefined` when the entry has no string `text`.
+* @example
+* ```ts
+* textOf({ text: "Заказы", source: "Orders" }); // "Заказы"
+* ```
+*/
+function textOf(entry) {
+	if (typeof entry !== "object" || entry === null || !("text" in entry)) return void 0;
+	return typeof entry.text === "string" ? entry.text : void 0;
+}
+/**
+* Checks one entry of an exchange file against the game, and keeps it as a change when it brings
+* a new text that compiles.
+*
+* @param walk - What the walk of the game collected.
+* @param review - What the review found so far.
+* @param exchange - The exchange file the entry belongs to.
+* @param key - The key of the entry.
+*/
+function reviewEntry(walk, review, exchange, key) {
+	const text = textOf(exchange.table[key]);
+	const owner = walk.owner.get(key);
+	if (text === void 0) {
+		review.problems.push(`"${key}" in ${exchange.file}: an entry is { "text": string }.`);
+		return;
+	}
+	if (owner === void 0) {
+		review.problems.push(`"${key}" in ${exchange.file} is not a key of this game.`);
+		return;
+	}
+	if (text === "" || text === walk.texts.get(key)?.get(exchange.locale)) return;
+	try {
+		compileMessage(text);
+		review.changes.push({
+			feature: owner.feature,
+			locale: exchange.locale,
+			key,
+			text
+		});
+	} catch (error) {
+		review.problems.push(`"${key}" in ${exchange.file}: ${detailOf(error)}.`);
+	}
+}
+/**
+* Reads every exchange file of a folder and checks every entry against the game. Nothing is
+* written here.
+*
+* @param walk - What the walk of the game collected.
+* @param dir - The folder the translators handed back.
+* @returns The locales read, the texts to write and every problem.
+*/
+async function reviewImport(walk, dir) {
+	const review = {
+		locales: [],
+		changes: [],
+		problems: []
+	};
+	for (const name of await listExchangeFiles(dir, review)) {
+		const exchange = await readExchangeFile(dir, name, review);
+		if (exchange === void 0) continue;
+		for (const key of Object.keys(exchange.table)) reviewEntry(walk, review, exchange, key);
+	}
+	return review;
+}
+/**
+* Reads a string file of a feature, or an empty table when the feature has none for the locale
+* yet. The walk checked every file that exists, so each value is a message.
+*
+* @param file - Path of the string file.
+* @returns The messages by key, in file order.
+*/
+async function readStrings(file) {
+	const text = await readFile(file, "utf8").catch(() => "{}");
+	const parsed = JSON.parse(text);
+	const table = {};
+	if (typeof parsed !== "object" || parsed === null) return table;
+	for (const [key, value] of Object.entries(parsed)) if (isMessageEntry(value)) table[key] = value;
+	return table;
+}
+/**
+* Rewrites one string file of a feature with its new texts. A key the file has keeps its place
+* and its form (`{ text, note }` keeps the note); a key it lacks is appended, the new ones sorted
+* among themselves. No other key is touched.
+*
+* @param file - Path of the string file; created when missing.
+* @param texts - The new text of each key.
+*/
+async function rewriteStrings(file, texts) {
+	const table = await readStrings(file);
+	const added = [];
+	for (const [key, text] of texts) {
+		const current = table[key];
+		if (current === void 0) added.push(key);
+		else table[key] = typeof current === "string" ? text : {
+			...current,
+			text
+		};
+	}
+	for (const key of added.toSorted()) table[key] = texts.get(key) ?? "";
+	await mkdir(path.dirname(file), { recursive: true });
+	await writeFile(file, jsonText(table));
+}
+/**
+* Groups the changes of an import by the string file they land in.
+*
+* @param changes - Every text the import writes.
+* @param folder - Path of the folder that holds the features.
+* @returns The path and the new texts of each file, by its path relative to the root.
+*/
+function groupByFile(changes, folder) {
+	const files = /* @__PURE__ */ new Map();
+	for (const change of changes) {
+		const name = `${change.locale}${JSON_EXTENSION}`;
+		const relative = `features/${change.feature}/strings/${name}`;
+		const group = files.get(relative) ?? {
+			file: path.join(folder, change.feature, "strings", name),
+			texts: /* @__PURE__ */ new Map()
+		};
+		group.texts.set(change.key, change.text);
+		files.set(relative, group);
+	}
+	return files;
+}
+/**
+* Takes translated exchange files back into the game: every `<dir>/<locale>.json` is checked
+* against the game first, then each new text is written into the string file of the feature that
+* owns its key, and the strings are compiled into `out` as a dev run does. An empty text and a
+* text equal to the current message are skipped. With any problem nothing is written.
+*
+* @param root - Game source root, the folder that holds the features.
+* @param dir - The folder the translators handed back.
+* @param options - The features folder, where the compile writes, and whether it writes `en-XA`.
+* @returns The locales read, how many keys were written and the files rewritten.
+* @throws {Error} One error that lists every problem of the exchange files, or the compile's own
+*   error after the files are written (a parameter kind that differs across locales).
+* @example
+* ```ts
+* // The translators handed back translations/ru.json with two hud texts filled in.
+* await importStrings("src", "translations", { out: "src/generated" });
+* // { locales: ["ru"], keys: 2, files: ["features/hud/strings/ru.json"] }
+* ```
+*/
+async function importStrings(root, dir, options = {}) {
+	const features = options.features ?? DEFAULT_FEATURES;
+	const review = await reviewImport(await readGame(root, features), dir);
+	if (review.problems.length > 0) throw importFailure(review.problems);
+	const byFile = groupByFile(review.changes, path.join(root, features));
+	for (const group of byFile.values()) await rewriteStrings(group.file, group.texts);
+	await compileStrings(root, options.out ?? path.join(root, "generated"), {
+		features,
+		pseudo: options.pseudo === true
+	});
+	return {
+		locales: review.locales.toSorted(),
+		keys: review.changes.length,
+		files: [...byFile.keys()].toSorted()
+	};
+}
+//#endregion
 //#region src/assets.ts
 /**
 * @file The node-side door of the engine (subpath `./assets`, node and bun only): asset and file
 * work that has no place in a browser bundle. It holds the asset key scanner, the production
-* packer and the string compiler; a game runs them as `bun run assets:keys` and
-* `bun run assets:pack` (`--pack <dir>`), the editor imports the same functions later.
-* Re-exports only: the code lives in `plugins/assets/scan/` and `plugins/i18n/compile/`, and this is
-* the one door to them in `src/`.
-*/
-if (import.meta.main) process.exitCode = await runCli(process.argv.slice(2), compileStrings);
+* packer, the string compiler and the exchange with translators; a game runs them as
+* `bun run assets:keys` (`--pseudo` for the pseudo-locale), `bun run assets:pack` (`--pack <dir>`),
+* `bun run assets:export` (`--export <dir>`) and `bun run assets:import` (`--import <dir>`), the
+* editor imports the same functions later. Re-exports only: the code lives in
+* `plugins/assets/scan/` and `plugins/i18n/compile/`, and this is the one door to them in `src/`.
+*/
+if (import.meta.main) process.exitCode = await runCli(process.argv.slice(2), {
+	compile: compileStrings,
+	exportStrings,
+	importStrings
+});
 //#endregion
-export { checkStrings, compileStrings, emitKeys, emitManifest, packAssets, runCli, scanAssets };
+export { checkStrings, compileStrings, emitKeys, emitManifest, exportStrings, importStrings, packAssets, runCli, scanAssets };