@moku-labs/game 0.0.2 → 0.1.0

package/dist/assets.mjs

@@ -1,7 +1,323 @@
-import path from "node:path";
+import { createRequire } from "node:module";
 import { createBrandConsole } from "@moku-labs/common/cli";
-import { mkdir, open, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { mkdir, open, readFile, readdir, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { MaxRectsBin, MaxRectsPacker } from "maxrects-packer";
 import { pathToFileURL } from "node:url";
+/** Bytes per pixel of the decoded images: RGBA, 8 bits each. */
+const CHANNELS = 4;
+/**
+* Copies the rows of one decoded texture into the pixels of a page. A copy, not a blend: the
+* page is transparent everywhere else, so the frame holds exactly the source's pixels.
+*
+* @param page - The RGBA pixels of the page.
+* @param pageWidth - Width of the page.
+* @param part - The texture and its place.
+*/
+function blit(page, pageWidth, part) {
+	const { pixels, x, y } = part;
+	const rowBytes = pixels.width * CHANNELS;
+	for (let row = 0; row < pixels.height; row += 1) {
+		const from = row * rowBytes;
+		page.set(pixels.data.subarray(from, from + rowBytes), ((y + row) * pageWidth + x) * CHANNELS);
+	}
+}
+/**
+* Builds the encoder over the `sharp` factory.
+*
+* @param sharp - The default export of the `sharp` module.
+* @returns The encoder.
+*/
+function encoderOf(sharp) {
+	const webpOptions = {
+		quality: 80,
+		alphaQuality: 80
+	};
+	return {
+		version: sharp.versions.sharp ?? "unknown",
+		decode: async (bytes) => {
+			const { data, info } = await sharp(bytes).toColourspace("srgb").ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+			return {
+				width: info.width,
+				height: info.height,
+				data: new Uint8Array(data)
+			};
+		},
+		page: async (width, height, parts) => {
+			const pixels = new Uint8Array(width * height * CHANNELS);
+			for (const part of parts) blit(pixels, width, part);
+			const encoded = await sharp(pixels, { raw: {
+				width,
+				height,
+				channels: CHANNELS
+			} }).webp(webpOptions).toBuffer();
+			return new Uint8Array(encoded);
+		},
+		webp: async (bytes) => new Uint8Array(await sharp(bytes).webp(webpOptions).toBuffer())
+	};
+}
+/**
+* Loads `sharp` and builds the encoder. `sharp` is an optional peer dependency of the engine,
+* so a game installs it for its pack command only.
+*
+* @returns The encoder.
+* @throws {Error} When `sharp` is not installed, with the command that installs it.
+* @example
+* ```ts
+* const encoder = await loadEncoder();
+* encoder.version; // the installed sharp version, such as "0.34.5"
+* ```
+*/
+async function loadEncoder() {
+	try {
+		return encoderOf((await import("sharp")).default);
+	} catch (error) {
+		throw new Error("[game] assets: \"--pack\" needs sharp.\n  Run \"bun add -d sharp\".", { cause: error });
+	}
+}
+//#endregion
+//#region src/plugins/assets/scan/pack/layout.ts
+/**
+* @file assets packer, build time — where each texture of an atlas group lies on its pages. Pure
+* over sizes: `maxrects-packer` places rectangles, nothing here reads a pixel. This is the one
+* file that imports `maxrects-packer` (lint rule L11); its version decides the layout, so the
+* package is pinned and the cache key carries it.
+*/
+/** The largest page, in pixels per side. A page is only as large as its content. */
+const PAGE_SIZE = 2048;
+/**
+* Compares two members the way the packer likes them: the longest side first, a larger area
+* next, the key last, so the same members give the same layout in any input order.
+*
+* @param left - One member.
+* @param right - Another member.
+* @returns The sort order.
+*/
+function packingOrder(left, right) {
+	return Math.max(right.width, right.height) - Math.max(left.width, left.height) || right.width * right.height - left.width * left.height || left.key.localeCompare(right.key);
+}
+/**
+* Tells whether a texture fits a page at all, inside the border.
+*
+* @param member - The texture.
+* @returns True when both sides fit.
+* @example
+* ```ts
+* fitsPage({ key: "ui.fx-rays", width: 504, height: 512 }); // true
+* ```
+*/
+function fitsPage(member) {
+	const room = 2044;
+	return member.width <= room && member.height <= room;
+}
+/**
+* Reads the frames of one bin of the packer, sorted by key.
+*
+* @param rects - The rectangles the packer placed on the bin.
+* @returns The frames.
+*/
+function framesOf(rects) {
+	return rects.map((rect) => ({
+		key: rect.data.key,
+		x: rect.x,
+		y: rect.y,
+		width: rect.width,
+		height: rect.height
+	})).toSorted((left, right) => left.key.localeCompare(right.key));
+}
+/**
+* Names every texture that fits no page, one sentence each, sorted by key.
+*
+* @param members - The textures of a group.
+* @returns One problem per texture that is too large.
+* @example
+* ```ts
+* unfitProblems([{ key: "ui.sky", width: 4096, height: 64 }]); // ['the texture "ui.sky" (4096×64) fits no 2048×2048 page with a 2 px border.']
+* ```
+*/
+function unfitProblems(members) {
+	return members.filter((member) => !fitsPage(member)).toSorted((left, right) => left.key.localeCompare(right.key)).map((member) => `the texture "${member.key}" (${member.width}×${member.height}) fits no ${PAGE_SIZE}×${PAGE_SIZE} page with a 2 px border.`);
+}
+/**
+* Lays the members of one atlas group out on pages of at most 2048 × 2048 pixels: 2 px of
+* padding between frames and a 2 px border, never trimmed and never rotated, so every frame keeps
+* the size of its source and a nine-slice keeps its borders. A texture that fits no page is a
+* problem naming its key, never a silent drop; an `fx` group that needs more than one page is a
+* problem naming the bundle and the count, because a particle emitter binds one page.
+*
+* @param bundle - Name of the bundle, for the messages.
+* @param group - The atlas group.
+* @param members - Its textures, with their sizes.
+* @returns The pages and the problems.
+* @example
+* ```ts
+* layoutGroup("ui", "main", [{ key: "ui.dot", width: 8, height: 8 }]).pages; // [{ width: 12, height: 12, frames: [{ key: "ui.dot", x: 2, y: 2, width: 8, height: 8 }] }]
+* ```
+*/
+function layoutGroup(bundle, group, members) {
+	const problems = unfitProblems(members);
+	const packer = new MaxRectsPacker(PAGE_SIZE, PAGE_SIZE, 2, {
+		smart: true,
+		pot: false,
+		square: false,
+		allowRotation: false,
+		border: 2
+	});
+	for (const member of members.filter((entry) => fitsPage(entry)).toSorted(packingOrder)) packer.add(member.width, member.height, { key: member.key });
+	const pages = packer.bins.filter((bin) => bin instanceof MaxRectsBin && bin.rects.length > 0).map((bin) => ({
+		width: bin.width,
+		height: bin.height,
+		frames: framesOf(bin.rects)
+	}));
+	if (group === "fx" && pages.length > 1) problems.push(`the fx textures of bundle "${bundle}" need ${pages.length} pages; a particle emitter binds one. Make them smaller, or move some to another bundle.`);
+	return {
+		pages,
+		problems
+	};
+}
+//#endregion
+//#region src/plugins/assets/scan/pack/cache.ts
+/**
+* @file assets packer, build time — the content-hash cache. One entry per atlas group and per
+* encoded loose texture, keyed by everything that decides its bytes: the format of the entry, the
+* versions of `sharp` and `maxrects-packer`, the packing constants and the members (key, SHA-256
+* of the source, nine). A hit replays the frames and the encoded bytes: no decode, no encode.
+* Entries are content-addressed, so the cache is never pruned.
+*/
+/** The cache folder under the working directory. */
+const CACHE_FOLDER = path.join("node_modules", ".cache", "moku-game-pack");
+/** Changes when the shape of an entry changes, so an old entry is never read as a new one. */
+const FORMAT = "pack-1";
+/**
+* Hashes bytes into the hex SHA-256 the cache keys and members use.
+*
+* @param bytes - Anything.
+* @returns 64 lowercase hex characters.
+* @example
+* ```ts
+* sha256(new TextEncoder().encode("abc")).slice(0, 10); // "ba7816bf8f"
+* ```
+*/
+function sha256(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+/**
+* Reads the version of `maxrects-packer` that is installed: its layout decides the frames, so a
+* new version is a new cache.
+*
+* @returns The version from its `package.json`.
+*/
+function packerVersion() {
+	const manifest = createRequire(import.meta.url)("maxrects-packer/package.json");
+	return typeof manifest.version === "string" ? manifest.version : "unknown";
+}
+/**
+* Computes the cache key of one entry from everything that decides its bytes.
+*
+* @param input - The kind, the encoder version and the members.
+* @returns The key: 64 hex characters, also the file name of the entry.
+* @example
+* ```ts
+* cacheKey({ kind: "loose", sharp: "0.34.5", members: [] }).length; // 64, the same key on every run
+* ```
+*/
+function cacheKey(input) {
+	const members = input.members.toSorted((left, right) => left.key.localeCompare(right.key)).map((member) => [
+		member.key,
+		member.source,
+		member.nine === void 0 ? void 0 : [
+			member.nine.left,
+			member.nine.top,
+			member.nine.right,
+			member.nine.bottom
+		]
+	]);
+	return sha256(JSON.stringify({
+		format: FORMAT,
+		kind: input.kind,
+		sharp: input.sharp,
+		packer: packerVersion(),
+		page: PAGE_SIZE,
+		border: 2,
+		padding: 2,
+		quality: 80,
+		alphaQuality: 80,
+		members
+	}));
+}
+/**
+* Tells whether a value read from an entry file is one frame.
+*
+* @param value - Anything the JSON carried.
+* @returns True for a frame.
+*/
+function isFrame(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const frame = value;
+	return typeof frame.key === "string" && [
+		"x",
+		"y",
+		"width",
+		"height"
+	].every((field) => typeof frame[field] === "number");
+}
+/**
+* Reads the JSON file of an entry. A file that is missing, broken or of another shape is a miss.
+*
+* @param file - Path of the JSON file.
+* @returns The images without their bytes, or `undefined`.
+*/
+async function readEntryFile(file) {
+	try {
+		const parsed = JSON.parse(await readFile(file, "utf8"));
+		if (!Array.isArray(parsed.images)) return void 0;
+		const images = parsed.images;
+		return images.every((image) => typeof image.width === "number" && typeof image.height === "number" && Array.isArray(image.frames) && image.frames.every((frame) => isFrame(frame))) ? images : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Reads one entry of the cache.
+*
+* @param folder - The cache folder, or `false` when the cache is off.
+* @param key - The cache key of the entry.
+* @returns The images with their bytes, or `undefined` on a miss.
+*/
+async function readCache(folder, key) {
+	if (folder === false) return void 0;
+	const images = await readEntryFile(path.join(folder, `${key}.json`));
+	if (images === void 0) return void 0;
+	try {
+		return await Promise.all(images.map(async (image, index) => ({
+			...image,
+			bytes: new Uint8Array(await readFile(path.join(folder, `${key}-${index}.webp`)))
+		})));
+	} catch {
+		return;
+	}
+}
+/**
+* Writes one entry of the cache: the bytes of every image first, the JSON file last, so a run
+* that stops half way leaves a miss, never a broken hit.
+*
+* @param folder - The cache folder, or `false` when the cache is off.
+* @param key - The cache key of the entry.
+* @param images - The encoded images and their frames.
+*/
+async function writeCache(folder, key, images) {
+	if (folder === false) return;
+	await mkdir(folder, { recursive: true });
+	for (const [index, image] of images.entries()) await writeFile(path.join(folder, `${key}-${index}.webp`), image.bytes);
+	const entry = { images: images.map(({ width, height, frames }) => ({
+		width,
+		height,
+		frames
+	})) };
+	await writeFile(path.join(folder, `${key}.json`), JSON.stringify(entry));
+}
+//#endregion
 //#region src/plugins/assets/scan/emit.ts
 const HEADER$1 = "// generated by @moku-labs/game/assets, do not edit";
 /** How the generated table ends, so the keys stay literal types for the game. */
@@ -17,42 +333,63 @@ function byName$2(left, right) {
 	return left.localeCompare(right);
 }
 /**
-* Writes one file entry with a fixed field order. A texture says nothing about its kind, which
-* is what keeps a manifest written before fonts and audio readable. The reserved `atlas` field
-* is dropped: this version never packs an atlas.
+* Writes one file entry in the field order of the manifest: `key`, `path`, `kind`, `width`,
+* `height`, `mb`, `pages`, `nine`, `atlas`. A field the file does not carry is left out: a
+* texture says nothing about its kind, which keeps a manifest written before fonts and audio
+* readable, and a texture packed in an atlas has no `path`. A font and a sound carry no size.
 *
 * @param file - The file.
 * @returns The entry as JSON data.
 */
 function plainFile(file) {
 	const kind = file.kind ?? "texture";
+	const path = file.path === void 0 ? {} : { path: file.path };
 	if (kind !== "texture") return {
 		key: file.key,
-		path: file.path,
+		...path,
 		kind,
 		mb: file.mb,
 		...file.pages === void 0 ? {} : { pages: file.pages.map((page) => ({ ...page })) }
 	};
 	return {
 		key: file.key,
-		path: file.path,
+		...path,
 		width: file.width,
 		height: file.height,
 		mb: file.mb,
-		...file.nine === void 0 ? {} : { nine: file.nine }
+		...file.nine === void 0 ? {} : { nine: file.nine },
+		...file.atlas === void 0 ? {} : { atlas: { ...file.atlas } }
+	};
+}
+/**
+* Writes one atlas page with a fixed field order.
+*
+* @param page - The page.
+* @returns The page as JSON data.
+*/
+function plainPage(page) {
+	return {
+		id: page.id,
+		path: page.path,
+		width: page.width,
+		height: page.height,
+		mb: page.mb
 	};
 }
 /**
-* Writes one bundle with a fixed field order and its files sorted by key.
+* Writes one bundle with a fixed field order, its pages sorted by id when it has any and its
+* files sorted by key.
 *
 * @param bundle - The bundle.
 * @returns The bundle as JSON data.
 */
 function plainBundle(bundle) {
+	const pages = bundle.pages?.toSorted((left, right) => byName$2(left.id, right.id)).map((page) => plainPage(page));
 	return {
 		feature: bundle.feature,
 		tier: bundle.tier,
 		mb: bundle.mb,
+		...pages === void 0 ? {} : { pages },
 		files: bundle.files.toSorted((left, right) => byName$2(left.key, right.key)).map((file) => plainFile(file))
 	};
 }
@@ -124,271 +461,1238 @@ function nineTable(entries) {
 	return `export const nineSlice = {\n${entries.toSorted((left, right) => byName$2(left.key, right.key)).map(({ key, nine }) => `  "${key}": { left: ${nine.left}, top: ${nine.top}, right: ${nine.right}, bottom: ${nine.bottom} }`).join(",\n")}\n}${FROZEN}`;
 }
 /**
-* Writes `manifest.json`: two-space JSON with a trailing newline, bundles sorted by name and
-* files sorted by key.
+* Writes `manifest.json`: two-space JSON with a trailing newline, bundles sorted by name, pages
+* by id and files by key. The version is written as given: `1` from the scanner, `2` from the
+* packer.
+*
+* @param manifest - What the scan produced.
+* @returns The text of the file.
+* @example
+* ```ts
+* emitManifest({ version: 1, bundles: {} }); // '{\n  "version": 1,\n  "bundles": {}\n}\n'
+* ```
+*/
+function emitManifest(manifest) {
+	const bundles = {};
+	for (const [name, bundle] of sortedBundles(manifest)) bundles[name] = plainBundle(bundle);
+	const plain = {
+		version: manifest.version,
+		bundles
+	};
+	return `${JSON.stringify(plain, void 0, 2)}\n`;
+}
+/**
+* Writes `generated/assets.ts`: `AssetKey` over every kind, the narrower `FontKey` and `AudioKey`
+* next to it, `BundleKey`, and the nine-slice table. A game commits this file, so `defineGame` can
+* type `Sprite`, a text style, a sound, `defineBundles` and the `load` effect from it.
+*
+* @param manifest - What the scan produced.
+* @returns The text of the module.
+* @example
+* ```ts
+* emitKeys({ version: 1, bundles: {} });
+* // the header, four unions that are all "never" and an empty nine-slice table
+* ```
+*/
+function emitKeys(manifest) {
+	const files = allFiles(manifest);
+	const nine = [];
+	for (const file of files) if (file.nine !== void 0) nine.push({
+		key: file.key,
+		nine: file.nine
+	});
+	return `${[
+		HEADER$1,
+		union("AssetKey", files.map((file) => file.key)),
+		union("FontKey", keysOfKind(files, "font")),
+		union("AudioKey", keysOfKind(files, "audio")),
+		union("BundleKey", bundleNames(manifest)),
+		nineTable(nine)
+	].join("\n\n")}\n`;
+}
+const PNG_SIGNATURE = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+const VP8_SYNC = [
+	157,
+	1,
+	42
+];
+const VP8L_SIGNATURE = 47;
+/** Both WebP frame headers carry the width and the height in 14 bits each. */
+const SIZE_MASK = 16383;
+const BYTES_PER_PIXEL = 4;
+const BYTES_PER_MB = 1048576;
+/**
+* Wraps a scanner problem in the message shape of the framework.
+*
+* @param message - One sentence naming the file.
+* @returns The error to throw.
+*/
+function problem$5(message) {
+	return /* @__PURE__ */ new Error(`[game] assets: ${message}`);
+}
+/**
+* Reads the bytes as a data view.
+*
+* @param head - The first bytes of the file.
+* @returns A view over exactly those bytes.
+*/
+function viewOf(head) {
+	return new DataView(head.buffer, head.byteOffset, head.byteLength);
+}
+/**
+* Tells whether a run of bytes stands at an offset.
+*
+* @param head - The first bytes of the file.
+* @param offset - Where to look.
+* @param bytes - What to find.
+* @returns True when every byte matches.
+*/
+function hasBytes(head, offset, bytes) {
+	return bytes.every((byte, index) => head[offset + index] === byte);
+}
+/**
+* Reads a run of bytes as ASCII, which is what the chunk names of these formats are.
+*
+* @param head - The first bytes of the file.
+* @param offset - Where to start.
+* @param length - How many bytes to read.
+* @returns The text.
+*/
+function ascii(head, offset, length) {
+	return String.fromCodePoint(...head.subarray(offset, offset + length));
+}
+/**
+* Reads a 24-bit little-endian number, the shape the `VP8X` canvas size uses.
+*
+* @param view - A view over the header bytes.
+* @param offset - Where the number starts.
+* @returns The number.
+*/
+function uint24Le(view, offset) {
+	return view.getUint16(offset, true) | view.getUint8(offset + 2) << 16;
+}
+/**
+* Reads the size out of the IHDR chunk of a PNG.
+*
+* @param head - The first bytes of the file.
+* @returns The size.
+*/
+function readPng(head) {
+	const view = viewOf(head);
+	return {
+		width: view.getUint32(16),
+		height: view.getUint32(20)
+	};
+}
+/**
+* Reads the size out of the frame header of a WebP, whichever of the three chunks it carries.
+*
+* @param head - The first bytes of the file.
+* @param file - Path of the file, for the messages.
+* @returns The size.
+* @throws {Error} When the chunk is unknown or its frame header is damaged.
+*/
+function readWebp(head, file) {
+	const view = viewOf(head);
+	const chunk = ascii(head, 12, 4);
+	if (chunk === "VP8 ") {
+		if (!hasBytes(head, 23, VP8_SYNC)) throw problem$5(`the VP8 frame of "${file}" is damaged.`);
+		return {
+			width: view.getUint16(26, true) & SIZE_MASK,
+			height: view.getUint16(28, true) & SIZE_MASK
+		};
+	}
+	if (chunk === "VP8L") {
+		if (head[20] !== VP8L_SIGNATURE) throw problem$5(`the VP8L frame of "${file}" is damaged.`);
+		const bits = view.getUint32(21, true);
+		return {
+			width: (bits & SIZE_MASK) + 1,
+			height: (bits >>> 14 & SIZE_MASK) + 1
+		};
+	}
+	if (chunk === "VP8X") return {
+		width: uint24Le(view, 24) + 1,
+		height: uint24Le(view, 27) + 1
+	};
+	throw problem$5(`"${file}" carries the WebP chunk "${chunk}", which this version cannot read.`);
+}
+/**
+* Reads the pixel size of an image out of its header bytes.
+*
+* @param head - The first `HEADER_BYTES` bytes of the file.
+* @param file - Path of the file, for the messages.
+* @returns The size.
+* @throws {Error} When the bytes are neither a PNG nor a WebP the scanner reads.
+* @example
+* ```ts
+* readImageSize(await readHead("panel.png"), "features/ui/assets/panel.png");
+* // { width: 256, height: 128 }
+* ```
+*/
+function readImageSize(head, file) {
+	if (head.length >= 30) {
+		if (hasBytes(head, 0, PNG_SIGNATURE) && ascii(head, 12, 4) === "IHDR") return readPng(head);
+		if (ascii(head, 0, 4) === "RIFF" && ascii(head, 8, 4) === "WEBP") return readWebp(head, file);
+	}
+	throw problem$5(`"${file}" is not a PNG or a WebP file.`);
+}
+/**
+* Estimates what one image costs on the GPU: four bytes per pixel, no mipmaps, rounded to three
+* decimals so two scans of the same tree write the same bytes.
+*
+* @param width - Width in pixels.
+* @param height - Height in pixels.
+* @returns The estimated texture memory in MB.
+* @example
+* ```ts
+* textureMb(256, 128); // 0.125
+* ```
+*/
+function textureMb(width, height) {
+	return Math.round(width * height * BYTES_PER_PIXEL / BYTES_PER_MB * 1e3) / 1e3;
+}
+/**
+* What a file costs in memory when it is kept as it is: an audio file is held undecoded, so its
+* bytes are the estimate. Rounded to three decimals, like every other number of the manifest.
+*
+* @param bytes - Size of the file in bytes.
+* @returns The size in MB.
+* @example
+* ```ts
+* bytesMb(8192); // 0.008
+* ```
+*/
+function bytesMb(bytes) {
+	return Math.round(bytes / BYTES_PER_MB * 1e3) / 1e3;
+}
+//#endregion
+//#region src/plugins/assets/scan/fonts.ts
+/**
+* @file assets plugin, build time — the page images a BMFont file names. A `.fnt` and its pages
+* are one asset, so the scanner has to read the file to know which images belong to it. Pure and
+* free of the file system: the three formats a font exporter writes are all text.
+*/
+/** `page id=0 file="body_0.png"` in the text format, `<page id="0" file="body_0.png"/>` in XML. */
+const PAGE_FILE = /\bpage\b[^\n>]*?\bfile\s*=\s*"([^"]+)"/g;
+/**
+* Wraps a scanner problem in the message shape of the framework.
+*
+* @param message - One sentence naming the file.
+* @returns The error to throw.
+*/
+function problem$4(message) {
+	return /* @__PURE__ */ new Error(`[game] assets: ${message}`);
+}
+/**
+* Tells whether a parsed JSON value is an object, so its fields can be read.
+*
+* @param value - A value of the parsed font.
+* @returns `true` for an object or an array, `false` for `null` and every primitive.
+*/
+function isObject(value) {
+	return typeof value === "object" && value !== null;
+}
+/**
+* Tells whether a parsed BMFont JSON value carries a list of pages.
+*
+* @param font - The parsed file.
+* @returns `true` when `font.pages` is an array.
+*/
+function hasPageList(font) {
+	return isObject(font) && "pages" in font && Array.isArray(font.pages);
+}
+/**
+* Reads the file name of one BMFont JSON page: the page itself when it is a name, its `file`
+* field when it is an object with a name there.
+*
+* @param page - One entry of the `pages` list.
+* @returns The file name, or `undefined` when the page names none.
+*/
+function pageFile(page) {
+	if (typeof page === "string") return page;
+	if (isObject(page) && "file" in page && typeof page.file === "string") return page.file;
+}
+/**
+* Parses a BMFont JSON file.
+*
+* @param source - The file contents.
+* @param message - The problem to throw when the JSON cannot be read.
+* @returns The parsed file, still to be narrowed.
+* @throws {Error} When the JSON cannot be read.
+*/
+function parseFont(source, message) {
+	try {
+		return JSON.parse(source);
+	} catch {
+		throw problem$4(message);
+	}
+}
+/**
+* Reads the page names of a BMFont JSON file. A page is a file name, or an object with one.
+*
+* @param source - The file contents.
+* @param file - Path of the file, for the message.
+* @returns The page file names, in the order the font declares them.
+* @throws {Error} When the JSON cannot be read.
+*/
+function jsonPages(source, file) {
+	const font = parseFont(source, `the font "${file}" is not readable BMFont JSON.`);
+	if (!hasPageList(font)) return [];
+	return font.pages.map((page) => pageFile(page)).filter((page) => page !== void 0);
+}
+/**
+* Reads the page images one `.fnt` file names, whichever of the three BMFont formats it is in.
+*
+* @param source - The file contents.
+* @param file - Path of the file from the scan root, for the messages.
+* @returns The page file names, relative to the folder of the font, in declaration order.
+* @throws {Error} When the file names no page, or its JSON cannot be read.
+* @example
+* ```ts
+* pagesOfFont('page id=0 file="body_0.png"', "features/ui/assets/body.fnt"); // ["body_0.png"]
+* ```
+*/
+function pagesOfFont(source, file) {
+	const text = source.trimStart();
+	const pages = text.startsWith("{") ? jsonPages(text, file) : [...source.matchAll(PAGE_FILE)].map((match) => match[1] ?? "");
+	if (pages.length === 0) throw problem$4(`the font "${file}" declares no page.`);
+	return pages;
+}
+/**
+* Renames the pages of a BMFont JSON file, in declaration order. A page is a file name, or an
+* object with one; the object keeps its other fields.
+*
+* @param source - The file contents, starting with `{`.
+* @param names - The new page names, one per declared page.
+* @returns The file as compact JSON.
+* @throws {Error} When the JSON cannot be read.
+*/
+function renameJsonPages(source, names) {
+	const font = parseFont(source, "a font to rename is not readable BMFont JSON.");
+	if (!hasPageList(font)) return JSON.stringify(font);
+	const pages = font.pages.map((page, index) => {
+		const name = names[index];
+		if (name === void 0) return page;
+		if (typeof page === "string") return name;
+		return isObject(page) ? {
+			...page,
+			file: name
+		} : { file: name };
+	});
+	return JSON.stringify({
+		...font,
+		pages
+	});
+}
+/**
+* Points a `.fnt` file at new page images, in the order it declares them: the packer renames
+* every page to its hashed name and rewrites the font, so nothing renames a page behind it. In
+* the text and XML formats only the `file="…"` of each page line changes; a JSON font is written
+* back compact.
+*
+* @param source - The file contents.
+* @param names - The new page names, relative to the folder of the font, one per declared page.
+* @returns The rewritten file contents.
+* @throws {Error} When a JSON font cannot be read.
+* @example
+* ```ts
+* renamePages('page id=0 file="body_0.png"', ["ui.body-0-c81f3e2d55.png"]);
+* // 'page id=0 file="ui.body-0-c81f3e2d55.png"'
+* ```
+*/
+function renamePages(source, names) {
+	const text = source.trimStart();
+	if (text.startsWith("{")) return renameJsonPages(text, names);
+	let index = 0;
+	return source.replaceAll(PAGE_FILE, (line, file) => {
+		const name = names[index] ?? file;
+		index += 1;
+		return `${line.slice(0, line.length - file.length - 1)}${name}"`;
+	});
+}
+//#endregion
+//#region src/plugins/assets/scan/pack/names.ts
+/**
+* @file assets packer, build time — the content hash and the file name rules of the pack folder.
+* Pure: a name is built from a bundle, a key and the hash of the bytes it holds, and is never
+* parsed back. The manifest is the only reader of the folder.
+*/
+/** How many hex characters of the SHA-256 a file name carries. */
+const HASH_LENGTH = 10;
+/**
+* Hashes the bytes of one output file: the first 10 hex characters of their SHA-256. A file that
+* changes gets a new name, so a CDN may cache every name forever.
+*
+* @param bytes - The bytes as they are written.
+* @returns Ten lowercase hex characters.
+* @example
+* ```ts
+* contentHash(new TextEncoder().encode("abc")); // "ba7816bf8f"
+* ```
+*/
+function contentHash(bytes) {
+	return createHash("sha256").update(bytes).digest("hex").slice(0, HASH_LENGTH);
+}
+/**
+* Names an atlas page in the manifest: the id an `atlas` frame points at.
+*
+* @param bundle - Name of the bundle.
+* @param group - The atlas group of the page.
+* @param index - Its index inside the group, from 0.
+* @returns The page id.
+* @example
+* ```ts
+* pageId("ui", "main", 0); // "ui/main-0"
+* ```
+*/
+function pageId(bundle, group, index) {
+	return `${bundle}/${group}-${index}`;
+}
+/**
+* Names the file of an atlas page.
+*
+* @param bundle - Name of the bundle.
+* @param group - The atlas group of the page.
+* @param index - Its index inside the group, from 0.
+* @param hash - The content hash of the WebP bytes.
+* @returns The path inside the pack folder.
+* @example
+* ```ts
+* pageName("ui", "fx", 0, "2a7f9c04e1"); // "ui/fx-0-2a7f9c04e1.webp"
+* ```
+*/
+function pageName(bundle, group, index, hash) {
+	return `${pageId(bundle, group, index)}-${hash}.webp`;
+}
+/**
+* Names the file of a loose texture.
+*
+* @param bundle - Name of the bundle.
+* @param key - Asset key of the texture.
+* @param hash - The content hash of the bytes.
+* @param extension - The extension of the written format, without the dot.
+* @returns The path inside the pack folder.
+* @example
+* ```ts
+* looseName("ui", "ui.bg-splash", "5e0a71bd42", "webp"); // "ui/ui.bg-splash-5e0a71bd42.webp"
+* ```
+*/
+function looseName(bundle, key, hash, extension) {
+	return `${bundle}/${key}-${hash}.${extension}`;
+}
+/**
+* Names the `.fnt` file of a font.
+*
+* @param bundle - Name of the bundle.
+* @param key - Asset key of the font.
+* @param hash - The content hash of the rewritten `.fnt` bytes.
+* @returns The path inside the pack folder.
+* @example
+* ```ts
+* fontName("ui", "ui.font-body", "7d2c90f1ab"); // "ui/ui.font-body-7d2c90f1ab.fnt"
+* ```
+*/
+function fontName(bundle, key, hash) {
+	return `${bundle}/${key}-${hash}.fnt`;
+}
+/**
+* Names one page image of a font. The page keeps its format: MSDF needs lossless pixels.
+*
+* @param bundle - Name of the bundle.
+* @param key - Asset key of the font.
+* @param index - The index of the page, in the order the font declares them.
+* @param hash - The content hash of the page bytes.
+* @param extension - The extension of the source page, without the dot.
+* @returns The path inside the pack folder.
+* @example
+* ```ts
+* fontPageName("ui", "ui.font-body", 0, "c81f3e2d55", "png"); // "ui/ui.font-body-0-c81f3e2d55.png"
+* ```
+*/
+function fontPageName(bundle, key, index, hash, extension) {
+	return `${bundle}/${key}-${index}-${hash}.${extension}`;
+}
+/**
+* Names the file of a sound.
+*
+* @param bundle - Name of the bundle.
+* @param key - Asset key of the sound.
+* @param hash - The content hash of the bytes.
+* @returns The path inside the pack folder.
+* @example
+* ```ts
+* audioName("ui", "ui.click", "9c4e2b7a10"); // "ui/ui.click-9c4e2b7a10.mp3"
+* ```
+*/
+function audioName(bundle, key, hash) {
+	return `${bundle}/${key}-${hash}.mp3`;
+}
+//#endregion
+//#region src/plugins/assets/scan/pack/copy.ts
+/**
+* @file assets packer, build time — the files that are copied, not encoded: a font (its `.fnt`
+* rewritten to name its hashed pages, the pages byte for byte, so MSDF stays lossless), a sound
+* and a loose WebP texture (no second generation of loss). Copies are cheap and are not cached.
+*/
+/**
+* Reads one source file of the scan.
+*
+* @param root - The game source root.
+* @param posixPath - The path of the manifest, relative to the root.
+* @returns The bytes.
+*/
+async function readSource(root, posixPath) {
+	return new Uint8Array(await readFile(path.join(root, ...posixPath.split("/"))));
+}
+/**
+* Reads the extension of a POSIX path, without the dot.
+*
+* @param posixPath - A path of the manifest.
+* @returns The extension, in lower case.
+* @example
+* ```ts
+* extensionOf("features/ui/assets/body_0.png"); // "png"
+* ```
+*/
+function extensionOf(posixPath) {
+	return path.posix.extname(posixPath).slice(1).toLowerCase();
+}
+/**
+* Copies one font: every page byte for byte under its hashed name, then the `.fnt` rewritten to
+* name those pages, hashed by its new bytes.
+*
+* @param root - The game source root.
+* @param bundle - Name of the bundle.
+* @param file - The font of the scanned manifest, with its `path` and `pages`.
+* @param fontPath - The path of its `.fnt` file.
+* @returns The packed entry and the files to write.
+*/
+async function copyFont(root, bundle, file, fontPath) {
+	const outputs = [];
+	const pages = [];
+	for (const [index, page] of (file.pages ?? []).entries()) {
+		const bytes = await readSource(root, page.path);
+		const name = fontPageName(bundle, file.key, index, contentHash(bytes), extensionOf(page.path));
+		outputs.push({
+			path: name,
+			bytes
+		});
+		pages.push({
+			...page,
+			path: name
+		});
+	}
+	const text = renamePages(new TextDecoder().decode(await readSource(root, fontPath)), pages.map((page) => path.posix.basename(page.path)));
+	const bytes = new TextEncoder().encode(text);
+	const name = fontName(bundle, file.key, contentHash(bytes));
+	outputs.push({
+		path: name,
+		bytes
+	});
+	return {
+		file: {
+			...file,
+			path: name,
+			pages
+		},
+		outputs
+	};
+}
+/**
+* Copies one sound byte for byte under its hashed name.
+*
+* @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.
+* @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));
+	return {
+		file: {
+			...file,
+			path: name
+		},
+		outputs: [{
+			path: name,
+			bytes
+		}]
+	};
+}
+/**
+* Copies one loose texture that already is a WebP, byte for byte under its hashed name.
+*
+* @param bundle - Name of the bundle.
+* @param file - The texture of the scanned manifest.
+* @param bytes - Its WebP bytes, as read from the source.
+* @returns The packed entry and the file to write.
+*/
+function copyLoose(bundle, file, bytes) {
+	const name = looseName(bundle, file.key, contentHash(bytes), "webp");
+	return {
+		file: {
+			...file,
+			path: name
+		},
+		outputs: [{
+			path: name,
+			bytes
+		}]
+	};
+}
+//#endregion
+//#region src/plugins/assets/scan/pack/groups.ts
+/** A texture with a side above this stays loose: packing it would cost more memory than it saves. */
+const LOOSE_SIDE = 512;
+/** The last segment of a key that names a particle texture starts with this. */
+const FX_PREFIX = "fx-";
+/** The groups in the order a bundle packs them. */
+const GROUP_ORDER = ["fx", "main"];
+/**
+* Picks the atlas group of one texture. A key whose last segment starts with `fx-` goes to `fx`
+* whatever its size; any other texture goes to `main` when no side is above 512 px.
+*
+* @param texture - The key and the size of the texture.
+* @returns The group, or `undefined` when the texture stays loose by its size.
+* @example
+* ```ts
+* groupOf({ key: "ui.fx-rays", width: 504, height: 512 }); // "fx"
+* ```
+*/
+function groupOf(texture) {
+	if (texture.key.slice(texture.key.lastIndexOf(".") + 1).startsWith(FX_PREFIX)) return "fx";
+	return texture.width <= LOOSE_SIDE && texture.height <= LOOSE_SIDE ? "main" : void 0;
+}
+/**
+* Compares two textures by key, so every list of the plan has one order.
+*
+* @param left - One texture.
+* @param right - Another texture.
+* @returns The sort order.
+*/
+function byKey(left, right) {
+	return left.key.localeCompare(right.key);
+}
+/**
+* Collects the atlas groups of sorted textures. A group of one is no group: its texture joins the
+* loose ones.
+*
+* @param sorted - The textures of a bundle, sorted by key.
+* @param loose - Where a texture of a group of one goes.
+* @returns Group name to its members, in the order a bundle packs them.
+*/
+function collectGroups(sorted, loose) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const group of GROUP_ORDER) {
+		const members = sorted.filter((texture) => groupOf(texture) === group);
+		if (members.length > 1) groups.set(group, members);
+		else loose.push(...members);
+	}
+	return groups;
+}
+/**
+* Splits the textures of one bundle into atlas groups and loose files. A group of one stays
+* loose as well: an atlas of one file is one request either way, and costs its padding.
+*
+* @param textures - The textures of the bundle, in any order.
+* @returns The groups and the loose textures, each sorted by key.
+* @example
+* ```ts
+* planGroups([{ key: "orders.card", width: 218, height: 304 }]);
+* // { groups: Map {}, loose: [{ key: "orders.card", width: 218, height: 304 }] }
+* ```
+*/
+function planGroups(textures) {
+	const sorted = textures.toSorted(byKey);
+	const loose = sorted.filter((texture) => groupOf(texture) === void 0);
+	return {
+		groups: collectGroups(sorted, loose),
+		loose: loose.toSorted(byKey)
+	};
+}
+//#endregion
+//#region src/plugins/assets/scan/pack/pack.ts
+/** The pack folder keeps a file of this name even when the manifest goes elsewhere. */
+const MANIFEST_NAME = "manifest.json";
+/** What the problems of a file call its kind. */
+const KIND_WORD = {
+	texture: "texture",
+	font: "font",
+	audio: "sound"
+};
+/**
+* Creates an empty map. It lives in its own non-exported function because lint rule L5 refuses a
+* collection built inside an exported declaration.
+*
+* @returns An empty map.
+*/
+function emptyMap() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Lists the keys of two maps once each, for the same reason as `emptyMap`.
+*
+* @param left - One map.
+* @param right - Another map.
+* @returns Every key of either, without repeats.
+*/
+function keysOfBoth(left, right) {
+	return [.../* @__PURE__ */ new Set([...left.keys(), ...right.keys()])];
+}
+/**
+* Reads the message of anything that was thrown.
+*
+* @param failure - What the `catch` caught.
+* @returns The message.
+*/
+function messageOf$1(failure) {
+	return failure instanceof Error ? failure.message : String(failure);
+}
+/**
+* Collects every problem of a pack into one error, so a game fixes its art in one round.
+*
+* @param problems - The problems, in pack order.
+* @returns The error to reject with.
+*/
+function collected$2(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.`);
+}
+/**
+* Adds up what a list of entries costs.
+*
+* @param entries - Pages and files, each with an `mb`.
+* @returns The sum in MB, rounded to three decimals.
+*/
+function sumMb$1(entries) {
+	let total = 0;
+	for (const entry of entries) total += entry.mb;
+	return Math.round(total * 1e3) / 1e3;
+}
+/**
+* Reads the path of a file of the scan. A file without one comes from a packed manifest, which
+* the packer cannot read its sources from.
+*
+* @param run - The pack run, which collects the problem.
+* @param file - A file of the scanned manifest.
+* @returns The path, or `undefined` after a problem.
+*/
+function sourcePathOf(run, file) {
+	if (file.path !== void 0) return file.path;
+	run.problems.push(`the ${KIND_WORD[file.kind ?? "texture"]} "${file.key}" has no path: pack the manifest of the scan.`);
+}
+/**
+* Reads the source of every texture of a bundle and hashes it.
+*
+* @param run - The pack run.
+* @param bundle - The bundle of the scan.
+* @returns The textures with their bytes, in manifest order.
+*/
+async function readTextures(run, bundle) {
+	const sources = [];
+	for (const file of bundle.files.filter((entry) => (entry.kind ?? "texture") === "texture")) {
+		const at = sourcePathOf(run, file);
+		if (at === void 0) continue;
+		try {
+			const bytes = await readSource(run.root, at);
+			sources.push({
+				key: file.key,
+				width: file.width,
+				height: file.height,
+				file,
+				bytes,
+				sha: sha256(bytes)
+			});
+		} catch (error) {
+			run.problems.push(`the file "${at}" could not be read: ${messageOf$1(error)}`);
+		}
+	}
+	return sources;
+}
+/**
+* Decodes the textures of one layout page and composes the page.
+*
+* @param run - The pack run.
+* @param page - The size and the frames of the page.
+* @param page.width - Width of the page.
+* @param page.height - Height of the page.
+* @param page.frames - Where each texture lies.
+* @param sources - The members of the group, by key.
+* @returns The page, encoded.
+*/
+async function encodePage(run, page, sources) {
+	const parts = [];
+	for (const frame of page.frames) {
+		const source = sources.get(frame.key);
+		if (source === void 0) continue;
+		const pixels = await run.encoder.decode(source.bytes);
+		if (pixels.width !== frame.width || pixels.height !== frame.height) {
+			run.problems.push(`the texture "${frame.key}" decodes to ${pixels.width}×${pixels.height}, not the ${frame.width}×${frame.height} its header says.`);
+			continue;
+		}
+		parts.push({
+			pixels,
+			x: frame.x,
+			y: frame.y
+		});
+	}
+	const bytes = await run.encoder.page(page.width, page.height, parts);
+	return {
+		width: page.width,
+		height: page.height,
+		frames: page.frames,
+		bytes
+	};
+}
+/**
+* Packs one atlas group into pages: from the cache when every member is unchanged, otherwise laid
+* out, composed and encoded, and stored in the cache when nothing went wrong.
+*
+* @param run - The pack run.
+* @param bundle - Name of the bundle.
+* @param group - The atlas group.
+* @param members - Its textures, sorted by key.
+* @returns The encoded pages with their frames.
+*/
+async function packGroup(run, bundle, group, members) {
+	const key = cacheKey({
+		kind: "atlas",
+		sharp: run.encoder.version,
+		members: members.map((member) => ({
+			key: member.key,
+			source: member.sha,
+			nine: member.file.nine
+		}))
+	});
+	const cached = await readCache(run.cache, key);
+	if (cached !== void 0) {
+		run.cacheHits += cached.length;
+		return cached;
+	}
+	const open = run.problems.length;
+	const layout = layoutGroup(bundle, group, members);
+	const sources = new Map(members.map((member) => [member.key, member]));
+	const images = [];
+	run.problems.push(...layout.problems);
+	for (const page of layout.pages) images.push(await encodePage(run, page, sources));
+	if (run.problems.length === open) await writeCache(run.cache, key, images);
+	return images;
+}
+/**
+* Writes the entry of a texture cut out of a page: no `path`, no cost of its own, the frame.
+*
+* @param file - The texture of the scan.
+* @param page - The id of its page.
+* @param frame - Where it lies on the page.
+* @returns The packed entry.
+*/
+function packedFile(file, page, frame) {
+	return {
+		key: file.key,
+		width: file.width,
+		height: file.height,
+		mb: 0,
+		...file.nine === void 0 ? {} : { nine: file.nine },
+		atlas: {
+			page,
+			x: frame.x,
+			y: frame.y,
+			width: frame.width,
+			height: frame.height
+		}
+	};
+}
+/**
+* Writes one loose texture: a WebP source is copied byte for byte, a PNG source is encoded to
+* WebP, through the cache.
+*
+* @param run - The pack run.
+* @param bundle - Name of the bundle.
+* @param source - The texture and its bytes.
+* @returns The packed entry and the file it writes.
+*/
+async function looseTexture(run, bundle, source) {
+	if (extensionOf(source.file.path ?? "") === "webp") return copyLoose(bundle, source.file, source.bytes);
+	const key = cacheKey({
+		kind: "loose",
+		sharp: run.encoder.version,
+		members: [{
+			key: source.key,
+			source: source.sha,
+			nine: source.file.nine
+		}]
+	});
+	const cached = await readCache(run.cache, key);
+	const bytes = cached?.[0]?.bytes ?? await run.encoder.webp(source.bytes);
+	if (cached === void 0) await writeCache(run.cache, key, [{
+		width: source.width,
+		height: source.height,
+		frames: [],
+		bytes
+	}]);
+	const name = looseName(bundle, source.key, contentHash(bytes), "webp");
+	return {
+		file: {
+			...source.file,
+			path: name
+		},
+		outputs: [{
+			path: name,
+			bytes
+		}]
+	};
+}
+/**
+* Copies the fonts and the sounds of a bundle.
+*
+* @param run - The pack run.
+* @param bundle - Name of the bundle.
+* @param files - The files of the bundle.
+* @returns What each copy wrote.
+*/
+async function copyOthers(run, bundle, files) {
+	const copies = [];
+	for (const file of files.filter((entry) => entry.kind === "font" || entry.kind === "audio")) {
+		const at = sourcePathOf(run, file);
+		if (at === void 0) continue;
+		try {
+			copies.push(file.kind === "font" ? await copyFont(run.root, bundle, file, at) : await copyAudio(run.root, bundle, file, at));
+		} catch (error) {
+			run.problems.push(`the ${KIND_WORD[file.kind ?? "texture"]} "${file.key}" could not be copied: ${messageOf$1(error)}`);
+		}
+	}
+	return copies;
+}
+/**
+* Hands one encoded page to the pack folder under its hashed name.
 *
-* @param manifest - What the scan produced.
-* @returns The text of the file.
-* @example
-* ```ts
-* emitManifest({ version: 1, bundles: {} }); // '{\n  "version": 1,\n  "bundles": {}\n}\n'
-* ```
-*/
-function emitManifest(manifest) {
-	const bundles = {};
-	for (const [name, bundle] of sortedBundles(manifest)) bundles[name] = plainBundle(bundle);
-	return `${JSON.stringify({
-		version: manifest.version,
-		bundles
-	}, void 0, 2)}\n`;
+* @param run - The pack run, which collects the files to write.
+* @param id - The id of the page.
+* @param file - Its hashed file name.
+* @param image - The encoded page.
+* @returns The page entry of the manifest.
+*/
+function writePage(run, id, file, image) {
+	run.outputs.set(file, image.bytes);
+	return {
+		id,
+		path: file,
+		width: image.width,
+		height: image.height,
+		mb: textureMb(image.width, image.height)
+	};
 }
 /**
-* Writes `generated/assets.ts`: `AssetKey` over every kind, the narrower `FontKey` and `AudioKey`
-* next to it, `BundleKey`, and the nine-slice table. A game commits this file, so `defineGame` can
-* type `Sprite`, a text style, a sound, `defineBundles` and the `load` effect from it.
+* Writes the entries of the textures cut out of one page.
 *
-* @param manifest - What the scan produced.
-* @returns The text of the module.
-* @example
-* ```ts
-* emitKeys({ version: 1, bundles: {} });
-* // the header, four unions that are all "never" and an empty nine-slice table
-* ```
-*/
-function emitKeys(manifest) {
-	const files = allFiles(manifest);
-	const nine = [];
-	for (const file of files) if (file.nine !== void 0) nine.push({
-		key: file.key,
-		nine: file.nine
+* @param image - The encoded page with its frames.
+* @param page - The id of the page.
+* @param byKey - The textures of the scan in its group, by key.
+* @returns One packed entry per frame of a known texture.
+*/
+function framedFiles(image, page, byKey) {
+	return image.frames.flatMap((frame) => {
+		const source = byKey.get(frame.key);
+		return source === void 0 ? [] : [packedFile(source, page, frame)];
 	});
-	return `${[
-		HEADER$1,
-		union("AssetKey", files.map((file) => file.key)),
-		union("FontKey", keysOfKind(files, "font")),
-		union("AudioKey", keysOfKind(files, "audio")),
-		union("BundleKey", bundleNames(manifest)),
-		nineTable(nine)
-	].join("\n\n")}\n`;
 }
-//#endregion
-//#region src/plugins/assets/scan/fonts.ts
 /**
-* @file assets plugin, build time — the page images a BMFont file names. A `.fnt` and its pages
-* are one asset, so the scanner has to read the file to know which images belong to it. Pure and
-* free of the file system: the three formats a font exporter writes are all text.
-*/
-/** `page id=0 file="body_0.png"` in the text format, `<page id="0" file="body_0.png"/>` in XML. */
-const PAGE_FILE = /\bpage\b[^\n>]*?\bfile\s*=\s*"([^"]+)"/g;
+* Packs the atlas groups of one bundle into pages, and writes the entry of every texture on them.
+*
+* @param run - The pack run, which collects the files to write.
+* @param bundle - Name of the bundle.
+* @param groups - The atlas groups of the bundle with their textures.
+* @returns The pages and the packed textures.
+*/
+async function packGroups(run, bundle, groups) {
+	const packed = {
+		pages: [],
+		files: []
+	};
+	for (const [group, members] of groups) {
+		const images = await packGroup(run, bundle, group, members);
+		const byKey = new Map(members.map((member) => [member.key, member.file]));
+		for (const [index, image] of images.entries()) {
+			const name = pageName(bundle, group, index, contentHash(image.bytes));
+			const page = writePage(run, pageId(bundle, group, index), name, image);
+			packed.pages.push(page);
+			packed.files.push(...framedFiles(image, page.id, byKey));
+		}
+	}
+	return packed;
+}
 /**
-* Wraps a scanner problem in the message shape of the framework.
+* Writes what stays a file of its own: the loose textures as WebP, the fonts and the sounds as
+* copies.
 *
-* @param message - One sentence naming the file.
-* @returns The error to throw.
+* @param run - The pack run, which collects the files to write.
+* @param bundle - Name of the bundle.
+* @param loose - The textures no atlas group took.
+* @param files - Every file of the bundle in the scan.
+* @returns The entries of the written files.
 */
-function problem$5(message) {
-	return /* @__PURE__ */ new Error(`[game] assets: ${message}`);
+async function packLoose(run, bundle, loose, files) {
+	const copies = [...await Promise.all(loose.map((source) => looseTexture(run, bundle, source))), ...await copyOthers(run, bundle, files)];
+	for (const copy of copies) for (const output of copy.outputs) run.outputs.set(output.path, output.bytes);
+	return copies.map((copy) => copy.file);
 }
 /**
-* Reads the page names of a BMFont JSON file. A page is a file name, or an object with one.
+* Packs one bundle: its atlas groups become pages, the rest is written loose or copied.
 *
-* @param source - The file contents.
-* @param file - Path of the file, for the message.
-* @returns The page file names, in the order the font declares them.
-* @throws {Error} When the JSON cannot be read.
-*/
-function jsonPages(source, file) {
-	let parsed;
-	try {
-		parsed = JSON.parse(source);
-	} catch {
-		throw problem$5(`the font "${file}" is not readable BMFont JSON.`);
-	}
-	const pages = parsed.pages;
-	if (!Array.isArray(pages)) return [];
-	return pages.map((page) => typeof page === "string" ? page : page.file).filter((page) => typeof page === "string");
+* @param run - The pack run, which collects the files to write.
+* @param name - Name of the bundle.
+* @param bundle - The bundle of the scan.
+* @returns The packed bundle.
+*/
+async function packBundle(run, name, bundle) {
+	const plan = planGroups(await readTextures(run, bundle));
+	const packed = await packGroups(run, name, plan.groups);
+	const files = [...packed.files, ...await packLoose(run, name, plan.loose, bundle.files)];
+	const mb = sumMb$1([...packed.pages, ...files.filter((file) => file.atlas === void 0)]);
+	return {
+		feature: bundle.feature,
+		tier: bundle.tier,
+		mb,
+		...packed.pages.length === 0 ? {} : { pages: packed.pages.toSorted((left, right) => left.id.localeCompare(right.id)) },
+		files: files.toSorted((left, right) => left.key.localeCompare(right.key))
+	};
 }
 /**
-* Reads the page images one `.fnt` file names, whichever of the three BMFont formats it is in.
+* Checks one packed texture against its page and its source.
 *
-* @param source - The file contents.
-* @param file - Path of the file from the scan root, for the messages.
-* @returns The page file names, relative to the folder of the font, in declaration order.
-* @throws {Error} When the file names no page, or its JSON cannot be read.
+* @param bundle - Name of the bundle.
+* @param entry - The packed bundle.
+* @param file - One of its textures.
+* @param source - The same texture in the scan.
+* @returns The problems, empty when the file is right.
+*/
+function checkTexture(bundle, entry, file, source) {
+	const atlas = file.atlas;
+	if (atlas === void 0 === (file.path === void 0)) return [`the texture "${file.key}" must have either a path or an atlas frame.`];
+	if (atlas === void 0) return [];
+	const page = entry.pages?.find((candidate) => candidate.id === atlas.page);
+	if (page === void 0) return [`the texture "${file.key}" names page "${atlas.page}", which bundle "${bundle}" does not list.`];
+	const problems = [];
+	if (!(atlas.x >= 0 && atlas.y >= 0 && atlas.x + atlas.width <= page.width && atlas.y + atlas.height <= page.height)) problems.push(`the frame of "${file.key}" lies outside page "${page.id}" (${page.width}×${page.height}).`);
+	if (atlas.width !== source?.width || atlas.height !== source.height) problems.push(`the frame of "${file.key}" is ${atlas.width}×${atlas.height}, its source ${source?.width ?? 0}×${source?.height ?? 0}.`);
+	return problems;
+}
+/**
+* Checks a packed manifest against the scan it came from: every key landed exactly once, as a
+* page frame or a file; every frame names a page of its own bundle, lies inside it and has the
+* size of its source, so `nine` stays valid as it is.
+*
+* @param source - The manifest of the scan.
+* @param packed - The packed manifest.
+* @returns One sentence per problem, empty when the pack is right.
 * @example
 * ```ts
-* pagesOfFont('page id=0 file="body_0.png"', "features/ui/assets/body.fnt"); // ["body_0.png"]
+* checkPacked(emptyManifest(), { version: 2, bundles: {} }); // []
 * ```
 */
-function pagesOfFont(source, file) {
-	const text = source.trimStart();
-	const pages = text.startsWith("{") ? jsonPages(text, file) : [...source.matchAll(PAGE_FILE)].map((match) => match[1] ?? "");
-	if (pages.length === 0) throw problem$5(`the font "${file}" declares no page.`);
-	return pages;
+function checkPacked(source, packed) {
+	const problems = [];
+	const scanned = emptyMap();
+	const landed = emptyMap();
+	for (const bundle of Object.values(source.bundles)) for (const file of bundle.files) scanned.set(file.key, file);
+	for (const [name, entry] of Object.entries(packed.bundles)) for (const file of entry.files) {
+		landed.set(file.key, (landed.get(file.key) ?? 0) + 1);
+		if ((file.kind ?? "texture") === "texture") problems.push(...checkTexture(name, entry, file, scanned.get(file.key)));
+	}
+	for (const key of keysOfBoth(scanned, landed)) {
+		const count = landed.get(key) ?? 0;
+		if (!scanned.has(key)) problems.push(`the key "${key}" is in the pack but not in the scan.`);
+		else if (count !== 1) problems.push(`the key "${key}" landed ${count} times, not once.`);
+	}
+	return problems;
 }
-const PNG_SIGNATURE = [
-	137,
-	80,
-	78,
-	71,
-	13,
-	10,
-	26,
-	10
-];
-const VP8_SYNC = [
-	157,
-	1,
-	42
-];
-const VP8L_SIGNATURE = 47;
-/** Both WebP frame headers carry the width and the height in 14 bits each. */
-const SIZE_MASK = 16383;
-const BYTES_PER_PIXEL = 4;
-const BYTES_PER_MB = 1048576;
 /**
-* Wraps a scanner problem in the message shape of the framework.
+* Tells whether a file already holds these bytes, so an unchanged file is not written again.
 *
-* @param message - One sentence naming the file.
-* @returns The error to throw.
+* @param file - Path of the file.
+* @param bytes - What it should hold.
+* @returns True when it does.
 */
-function problem$4(message) {
-	return /* @__PURE__ */ new Error(`[game] assets: ${message}`);
+async function holds(file, bytes) {
+	try {
+		return Buffer.from(await readFile(file)).equals(bytes);
+	} catch {
+		return false;
+	}
 }
 /**
-* Reads the bytes as a data view.
+* Writes one file when its bytes changed.
 *
-* @param head - The first bytes of the file.
-* @returns A view over exactly those bytes.
+* @param file - Path of the file.
+* @param bytes - What it should hold.
 */
-function viewOf(head) {
-	return new DataView(head.buffer, head.byteOffset, head.byteLength);
+async function writeChanged(file, bytes) {
+	if (await holds(file, bytes)) return;
+	await mkdir(path.dirname(file), { recursive: true });
+	await writeFile(file, bytes);
 }
 /**
-* Tells whether a run of bytes stands at an offset.
+* Prunes one entry of a folder: a sub-folder is pruned and removed once empty, a kept file stays,
+* any other file is deleted.
 *
-* @param head - The first bytes of the file.
-* @param offset - Where to look.
-* @param bytes - What to find.
-* @returns True when every byte matches.
-*/
-function hasBytes(head, offset, bytes) {
-	return bytes.every((byte, index) => head[offset + index] === byte);
+* @param folder - The folder that holds the entry.
+* @param entry - The entry as `readdir` listed it.
+* @param keep - Absolute paths of the files to keep.
+* @returns True when the entry is gone afterwards.
+*/
+async function pruneEntry(folder, entry, keep) {
+	const target = path.join(folder, entry.name);
+	if (entry.isDirectory()) {
+		if (!await prune(target, keep)) return false;
+		await rmdir(target);
+		return true;
+	}
+	if (keep.has(target)) return false;
+	await rm(target, { force: true });
+	return true;
 }
 /**
-* Reads a run of bytes as ASCII, which is what the chunk names of these formats are.
+* Deletes every file under a folder that is not kept, and every folder that ends up empty.
 *
-* @param head - The first bytes of the file.
-* @param offset - Where to start.
-* @param length - How many bytes to read.
-* @returns The text.
+* @param folder - The folder to prune.
+* @param keep - Absolute paths of the files to keep.
+* @returns True when the folder is empty afterwards.
 */
-function ascii(head, offset, length) {
-	return String.fromCodePoint(...head.subarray(offset, offset + length));
+async function prune(folder, keep) {
+	let empty = true;
+	for (const entry of await readdir(folder, { withFileTypes: true })) if (!await pruneEntry(folder, entry, keep)) empty = false;
+	return empty;
 }
 /**
-* Reads a 24-bit little-endian number, the shape the `VP8X` canvas size uses.
+* Writes the pack folder: every output whose bytes changed, then the manifest, then the prune
+* that leaves exactly what the manifest references, plus `manifest.json`.
 *
-* @param view - A view over the header bytes.
-* @param offset - Where the number starts.
-* @returns The number.
-*/
-function uint24Le(view, offset) {
-	return view.getUint16(offset, true) | view.getUint8(offset + 2) << 16;
+* @param options - The pack folder and the manifest file.
+* @param options.out - The pack folder.
+* @param options.manifestFile - Where the packed manifest goes.
+* @param outputs - POSIX path inside the pack folder to the bytes it gets.
+* @param manifestText - The packed manifest as `emitManifest` wrote it.
+* @returns The bytes of every output.
+*/
+async function writePack(options, outputs, manifestText) {
+	const out = path.resolve(options.out);
+	const manifestFile = path.resolve(options.manifestFile);
+	const keep = /* @__PURE__ */ new Set([manifestFile, path.join(out, MANIFEST_NAME)]);
+	let bytes = 0;
+	for (const [relative, content] of outputs) {
+		const file = path.join(out, ...relative.split("/"));
+		keep.add(file);
+		bytes += content.byteLength;
+		await writeChanged(file, content);
+	}
+	await writeChanged(manifestFile, new TextEncoder().encode(manifestText));
+	await mkdir(out, { recursive: true });
+	await prune(out, keep);
+	return bytes;
 }
 /**
-* Reads the size out of the IHDR chunk of a PNG.
+* Tells whether the pack folder holds the game sources: pruning it would delete them.
 *
-* @param head - The first bytes of the file.
-* @returns The size.
+* @param out - The pack folder.
+* @param root - The game source root.
+* @returns True when the root is the pack folder or inside it.
 */
-function readPng(head) {
-	const view = viewOf(head);
-	return {
-		width: view.getUint32(16),
-		height: view.getUint32(20)
-	};
+function holdsSources(out, root) {
+	const relative = path.relative(path.resolve(out), path.resolve(root));
+	return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
 }
 /**
-* Reads the size out of the frame header of a WebP, whichever of the three chunks it carries.
+* Tells whether a packed file is a texture written as a file of its own, not cut out of a page.
 *
-* @param head - The first bytes of the file.
-* @param file - Path of the file, for the messages.
-* @returns The size.
-* @throws {Error} When the chunk is unknown or its frame header is damaged.
+* @param file - A file of the packed manifest.
+* @returns `true` for a loose texture.
 */
-function readWebp(head, file) {
-	const view = viewOf(head);
-	const chunk = ascii(head, 12, 4);
-	if (chunk === "VP8 ") {
-		if (!hasBytes(head, 23, VP8_SYNC)) throw problem$4(`the VP8 frame of "${file}" is damaged.`);
-		return {
-			width: view.getUint16(26, true) & SIZE_MASK,
-			height: view.getUint16(28, true) & SIZE_MASK
-		};
-	}
-	if (chunk === "VP8L") {
-		if (head[20] !== VP8L_SIGNATURE) throw problem$4(`the VP8L frame of "${file}" is damaged.`);
-		const bits = view.getUint32(21, true);
-		return {
-			width: (bits & SIZE_MASK) + 1,
-			height: (bits >>> 14 & SIZE_MASK) + 1
-		};
-	}
-	if (chunk === "VP8X") return {
-		width: uint24Le(view, 24) + 1,
-		height: uint24Le(view, 27) + 1
-	};
-	throw problem$4(`"${file}" carries the WebP chunk "${chunk}", which this version cannot read.`);
+function isLooseFile(file) {
+	return file.kind === void 0 && file.path !== void 0;
 }
 /**
-* Reads the pixel size of an image out of its header bytes.
+* Counts the atlas pages of the packed bundles.
 *
-* @param head - The first `HEADER_BYTES` bytes of the file.
-* @param file - Path of the file, for the messages.
-* @returns The size.
-* @throws {Error} When the bytes are neither a PNG nor a WebP the scanner reads.
-* @example
-* ```ts
-* readImageSize(await readHead("panel.png"), "features/ui/assets/panel.png");
-* // { width: 256, height: 128 }
-* ```
+* @param bundles - The packed bundles.
+* @returns How many pages they hold together.
 */
-function readImageSize(head, file) {
-	if (head.length >= 30) {
-		if (hasBytes(head, 0, PNG_SIGNATURE) && ascii(head, 12, 4) === "IHDR") return readPng(head);
-		if (ascii(head, 0, 4) === "RIFF" && ascii(head, 8, 4) === "WEBP") return readWebp(head, file);
-	}
-	throw problem$4(`"${file}" is not a PNG or a WebP file.`);
+function countPages(bundles) {
+	return bundles.reduce((count, bundle) => count + (bundle.pages?.length ?? 0), 0);
 }
 /**
-* Estimates what one image costs on the GPU: four bytes per pixel, no mipmaps, rounded to three
-* decimals so two scans of the same tree write the same bytes.
+* Counts the loose textures of the packed bundles.
 *
-* @param width - Width in pixels.
-* @param height - Height in pixels.
-* @returns The estimated texture memory in MB.
-* @example
-* ```ts
-* textureMb(256, 128); // 0.125
-* ```
+* @param bundles - The packed bundles.
+* @returns How many textures stayed files of their own.
 */
-function textureMb(width, height) {
-	return Math.round(width * height * BYTES_PER_PIXEL / BYTES_PER_MB * 1e3) / 1e3;
+function countLoose(bundles) {
+	return bundles.reduce((count, bundle) => count + bundle.files.filter((file) => isLooseFile(file)).length, 0);
 }
 /**
-* What a file costs in memory when it is kept as it is: an audio file is held undecoded, so its
-* bytes are the estimate. Rounded to three decimals, like every other number of the manifest.
+* Packs the art of a game for production: per bundle, the textures of the `fx` group and of the
+* `main` group go onto WebP atlas pages (2048 px at most, 2 px padding and border, never trimmed
+* or rotated), a texture with a side above 512 px and a group of one stay loose files, fonts and
+* sounds are copied, every file name carries the hash of its bytes, and the packed manifest
+* (version 2) names it all. Nothing is written while a problem is open; afterwards the pack folder
+* holds exactly what the manifest references, plus `manifest.json`. Two runs on the same tree and
+* the same `sharp` write the same bytes.
 *
-* @param bytes - Size of the file in bytes.
-* @returns The size in MB.
+* @param options - The sources, the scanned manifest, the pack folder, the manifest file, the cache.
+* @returns The packed manifest and what was written.
+* @throws {Error} One error that lists every problem, when `sharp` is missing, or when the pack
+*   folder holds the sources.
 * @example
 * ```ts
-* bytesMb(8192); // 0.008
+* // After `scanAssets` read the features of the game. `cache: false` skips the cache.
+* const { manifest, pages, cacheHits } = await packAssets({
+*   root: "src", manifest: scanned, cache: "node_modules/.cache/moku-game-pack",
+*   out: "dist/assets", manifestFile: "dist/assets/manifest.json"
+* });
+* // manifest.version: 2; on a second run with the same art, cacheHits equals pages
 * ```
 */
-function bytesMb(bytes) {
-	return Math.round(bytes / BYTES_PER_MB * 1e3) / 1e3;
+async function packAssets(options) {
+	if (holdsSources(options.out, options.root)) throw new Error(`[game] assets: the pack folder "${options.out}" holds the game sources.\n  Give the pack a folder of its own, like "dist/assets".`);
+	const run = {
+		root: options.root,
+		cache: options.cache,
+		encoder: await loadEncoder(),
+		outputs: emptyMap(),
+		problems: [],
+		cacheHits: 0
+	};
+	const bundles = {};
+	for (const name of Object.keys(options.manifest.bundles).toSorted((left, right) => left.localeCompare(right))) {
+		const bundle = options.manifest.bundles[name];
+		if (bundle !== void 0) bundles[name] = await packBundle(run, name, bundle);
+	}
+	const manifest = {
+		version: 2,
+		bundles
+	};
+	if (run.problems.length === 0) run.problems.push(...checkPacked(options.manifest, manifest));
+	if (run.problems.length > 0) throw collected$2(run.problems);
+	const bytes = await writePack(options, run.outputs, emitManifest(manifest));
+	const all = Object.values(bundles);
+	return {
+		manifest,
+		pages: countPages(all),
+		loose: countLoose(all),
+		bytes,
+		cacheHits: run.cacheHits
+	};
 }
 //#endregion
 //#region src/plugins/assets/scan/keys.ts
@@ -1122,11 +2426,17 @@ async function readCurrent$1(file) {
 	}
 }
 /**
-* Writes the outputs whose text changed, and tells whether any of them differed.
+* Writes the outputs whose text changed, and tells whether any of them differed. The pack run of
+* the CLI writes the key module through it, so the keys get the same bytes in both modes.
 *
 * @param outputs - Where each output goes and what it should contain.
 * @param write - False for a check run: nothing is written.
 * @returns True when an output on disk differs from what the scan produced.
+* @example
+* ```ts
+* await applyOutputs([{ file: "src/generated/assets.ts", text: keysSource }], true);
+* // true when the file was missing or held other text, and it holds keysSource now
+* ```
 */
 async function applyOutputs(outputs, write) {
 	let changed = false;
@@ -1180,11 +2490,12 @@ async function scanAssets(options) {
 //#endregion
 //#region src/plugins/assets/scan/cli.ts
 /**
-* @file assets plugin, build time — the command line of the scanner. It is the only file here
-* that touches the terminal: the scan, the emitters and the key rule are pure. 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 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.
 */
 const MANIFEST_FILE = "manifest.json";
 const KEYS_FILE = path.join("generated", "assets.ts");
@@ -1210,31 +2521,34 @@ function messageOf(failure) {
 * Tells whether an argument is one of the flags that take a path.
 *
 * @param flag - The argument.
-* @returns True for `--root`, `--manifest` and `--keys`.
+* @returns True for `--root`, `--manifest`, `--keys` and `--pack`.
 */
 function isPathFlag(flag) {
-	return flag === "--root" || flag === "--manifest" || flag === "--keys";
+	return flag === "--root" || flag === "--manifest" || flag === "--keys" || flag === "--pack";
 }
 /**
-* Reads the flags. `--manifest` and `--keys` default to `manifest.json` and `generated/assets.ts`
-* inside the root.
+* 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`.
 *
 * @param argv - The arguments after the script name.
-* @returns The resolved paths and whether this is a check run.
+* @returns The resolved paths, the pack folder and the two 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
+		"--keys": void 0,
+		"--pack": void 0
 	};
 	let check = false;
+	let cache = true;
 	let index = 0;
 	while (index < argv.length) {
 		const flag = argv[index];
-		if (flag === "--check") {
-			check = true;
+		if (flag === "--check" || flag === "--no-cache") {
+			if (flag === "--check") check = true;
+			else cache = false;
 			index += 1;
 			continue;
 		}
@@ -1245,11 +2559,14 @@ function parseArgv(argv) {
 		index += 2;
 	}
 	const root = path.resolve(given["--root"] ?? ".");
+	const pack = given["--pack"] === void 0 ? void 0 : path.resolve(given["--pack"]);
 	return {
 		root,
-		manifest: path.resolve(given["--manifest"] ?? path.join(root, MANIFEST_FILE)),
+		manifest: path.resolve(given["--manifest"] ?? path.join(pack ?? root, MANIFEST_FILE)),
 		keys: path.resolve(given["--keys"] ?? path.join(root, KEYS_FILE)),
-		check
+		check,
+		pack,
+		cache
 	};
 }
 /**
@@ -1301,23 +2618,101 @@ function stringsSummary(report) {
 	return `${report.keys.length} strings in ${report.locales.length} locales (${report.locales.join(", ")}).`;
 }
 /**
+* One line about a packed bundle.
+*
+* @param name - Name of the bundle.
+* @param bundle - The packed bundle.
+* @returns The line for the console.
+* @example
+* ```ts
+* bundleLine("orders", { feature: "orders", tier: "scene", mb: 0.253, files: [] });
+* // "packed orders: 0 pages, 0 loose, 0 fonts, 0 sounds, 0.253 MB"
+* ```
+*/
+function bundleLine(name, bundle) {
+	const pages = bundle.pages?.length ?? 0;
+	const loose = bundle.files.filter((file) => file.kind === void 0 && file.path !== void 0);
+	const fonts = bundle.files.filter((file) => file.kind === "font").length;
+	const sounds = bundle.files.filter((file) => file.kind === "audio").length;
+	return `packed ${name}: ${plural(pages, "page")}, ${loose.length} loose, ${plural(fonts, "font")}, ${plural(sounds, "sound")}, ${bundle.mb} MB`;
+}
+/**
+* The closing line of a pack: where the manifest went, what the folder holds and what the cache
+* gave.
+*
+* @param file - Path of the packed manifest.
+* @param result - What the pack wrote.
+* @param cache - False after `--no-cache`.
+* @returns The line for the console.
+*/
+function packSummary(file, result, cache) {
+	const files = Object.values(result.manifest.bundles).flatMap((bundle) => bundle.files);
+	const fonts = files.filter((entry) => entry.kind === "font").length;
+	const sounds = files.filter((entry) => entry.kind === "audio").length;
+	const hits = cache ? `${result.cacheHits} of ${plural(result.pages, "page")}` : "off";
+	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 `--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`.
+*
+* @param options - The parsed flags, with a pack folder.
+* @param pack - The pack folder.
+* @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.
+*/
+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,
+		keys: options.keys,
+		write: false
+	});
+	await applyOutputs([{
+		file: options.keys,
+		text: scan.keysSource
+	}], true);
+	const strings = await compile(options.root, path.dirname(options.keys), { check: false });
+	for (const note of [...scan.notes, ...strings.notes]) ui.warn(note);
+	const result = await packAssets({
+		root: options.root,
+		manifest: scan.manifest,
+		out: pack,
+		manifestFile: options.manifest,
+		cache: options.cache ? path.join(process.cwd(), CACHE_FOLDER) : false
+	});
+	for (const [name, bundle] of Object.entries(result.manifest.bundles)) ui.info(bundleLine(name, bundle));
+	ui.info(packSummary(options.manifest, result, options.cache));
+	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.
+* 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.
 *
 * @param argv - The arguments after the script name.
 * @param compile - The strings compiler, `compileStrings` of i18n.
 * @param ui - Where the lines go. The branded console by default.
-* @returns The exit code: `1` when the scan or the compile failed or `--check` found a difference, else `0`.
+* @returns The exit code: `1` when the scan, the compile or the pack 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);
+* // 0, and dist/assets holds the pages, the loose files and the packed manifest.json
 * ```
 */
 async function runCli(argv, compile, 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,
@@ -4719,11 +6114,12 @@ async function checkStrings(root, out) {
 //#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 and the string
-* compiler; a game runs both as `bun run assets:keys`, the editor imports the same functions later.
+* 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);
 //#endregion
-export { checkStrings, compileStrings, emitKeys, emitManifest, runCli, scanAssets };
+export { checkStrings, compileStrings, emitKeys, emitManifest, packAssets, runCli, scanAssets };