@moku-labs/game 0.13.1 → 0.13.2

package/dist/{src-SmT-XxVf.mjs → src-CltFFKtc.mjs}

@@ -3722,7 +3722,7 @@ function restorePosition(ctx, _modules, bookmark) {
 * @param view - The last view.
 * @returns True while nothing the state shows moved.
 */
-function isCurrent(ctx, view) {
+function isCurrent$1(ctx, view) {
 	const runner = ctx.state.runner;
 	return view.running === (runner.running !== void 0) && view.depth === runner.stack.length && view.top === runner.stack.at(-1) && view.open === ctx.state.gate.open && view.mode === ctx.state.fx.mode && view.journalIndex === runner.journalIndex;
 }
@@ -3763,7 +3763,7 @@ function viewOf(ctx) {
 function readState(ctx) {
 	const runner = ctx.state.runner;
 	const view = runner.view;
-	if (view !== void 0 && isCurrent(ctx, view)) return view.state;
+	if (view !== void 0 && isCurrent$1(ctx, view)) return view.state;
 	const next = viewOf(ctx);
 	runner.view = next;
 	return next.state;
@@ -8269,7 +8269,7 @@ function stopHost(state) {
 //#endregion
 //#region src/plugins/renderer/host/readback.ts
 /** Bytes of one pixel: the engine loads PNG and WebP only, so every source is 8-bit RGBA. */
-const BYTES_PER_PIXEL = 4;
+const BYTES_PER_PIXEL$1 = 4;
 /**
 * Estimates the GPU bytes of one texture source: 4 bytes per pixel, every mip level, a level never
 * smaller than one pixel.
@@ -8293,7 +8293,7 @@ function sourceBytes(source) {
 		width = Math.max(1, Math.floor(width / 2));
 		height = Math.max(1, Math.floor(height / 2));
 	}
-	return pixels * BYTES_PER_PIXEL;
+	return pixels * BYTES_PER_PIXEL$1;
 }
 /**
 * Counts the texture sources the GPU holds and sums their estimated bytes. Pixi's
@@ -8561,7 +8561,7 @@ function resetWindow(state) {
 //#endregion
 //#region src/plugins/renderer/monitor/api.ts
 /** Bytes of one MiB. */
-const BYTES_PER_MB = 1048576;
+const BYTES_PER_MB$1 = 1048576;
 /**
 * Rounds a number to a fixed count of decimals, so a counter reads well in a panel.
 *
@@ -8599,7 +8599,7 @@ function createMonitorApi(ctx, deps) {
 				fps: state.lastStart !== void 0 && clock.now() - state.lastStart <= 1e3 ? roundTo(state.fps, 1) : 0,
 				frameMs: roundTo(state.frameMs, 2),
 				textures: usage.count,
-				textureMb: roundTo(usage.bytes / BYTES_PER_MB, 2),
+				textureMb: roundTo(usage.bytes / BYTES_PER_MB$1, 2),
 				views: counts.views,
 				pooled: counts.pooled,
 				renderPasses: deps.sync.renderPasses()
@@ -8937,7 +8937,7 @@ function parseFont(pixi, key, fnt) {
 * @param texture - The page texture `assets` uploaded.
 * @throws {Error} When the renderer does not draw.
 */
-function installFont(sctx, key, fnt, texture) {
+function installFont$1(sctx, key, fnt, texture) {
 	const pixi = sctx.deps.host.pixi();
 	if (pixi === void 0) throw new Error("[game] Fonts need a renderer.\n  Call fonts.install after renderer.host.ready().");
 	const state = sctx.ctx.state.sync;
@@ -10207,7 +10207,9 @@ function clearFrames(state) {
 }
 /**
 * Frees a texture, its source and the crops cut from it. A slice keeps the source: it belongs to
-* the page, which frees it. A texture destroyed twice is a no-op.
+* the page, which frees it. A source that goes lets go of its `change` listeners first, the ones
+* of its style too, so no bind group Pixi still keeps is told. A texture destroyed twice is a
+* no-op.
 *
 * @param state - The sync branch of the plugin state.
 * @param texture - The texture to free.
@@ -10215,7 +10217,13 @@ function clearFrames(state) {
 function destroyTexture(state, texture) {
 	releaseFrames$1(state, texture);
 	if (texture.destroyed) return;
-	texture.destroy(!state.slices.has(texture));
+	if (state.slices.has(texture)) {
+		texture.destroy(false);
+		return;
+	}
+	texture.source.style.removeAllListeners("change");
+	texture.source.removeAllListeners("change");
+	texture.destroy(true);
 }
 //#endregion
 //#region src/plugins/renderer/sync/views.ts
@@ -11839,7 +11847,7 @@ function createSyncApi(ctx, deps) {
 			removed: markRemoved
 		}) },
 		fonts: {
-			install: (key, fnt, texture) => installFont(sctx, key, fnt, texture),
+			install: (key, fnt, texture) => installFont$1(sctx, key, fnt, texture),
 			installed: (key) => isFontInstalled(state, key)
 		},
 		debug: {
@@ -14629,6 +14637,12 @@ const TIERS = [
 	"feature",
 	"lazy"
 ];
+/** The bytes of one megabyte. */
+const BYTES_PER_MB = 1048576;
+/** The bytes one pixel takes in GPU memory: RGBA, no mipmaps. */
+const BYTES_PER_PIXEL = 4;
+/** Megabytes are kept to three decimals: a value is rounded to a whole number of these parts. */
+const PARTS_PER_MB = 1e3;
 /**
 * Creates an empty map. It lives in its own non-exported function because lint rule L5 refuses a
 * collection built inside an exported declaration.
@@ -14923,6 +14937,38 @@ function fileUrl(base, path) {
 	return `${base}${path.startsWith("/") ? path.slice(1) : path}`;
 }
 /**
+* Works out what an image costs in texture memory: `width × height × 4` bytes as megabytes,
+* rounded to 3 decimals. It is the number the scanner writes for a texture and for a font page;
+* the dev hot swap writes it again for a file that came back with another size.
+*
+* @param width - Width of the image in pixels.
+* @param height - Height of the image in pixels.
+* @returns The megabytes.
+* @example
+* ```ts
+* textureMb(256, 128); // 0.125
+* ```
+*/
+function textureMb(width, height) {
+	return Math.round(width * height * BYTES_PER_PIXEL / BYTES_PER_MB * PARTS_PER_MB) / PARTS_PER_MB;
+}
+/**
+* Adds up megabytes, rounded to 3 decimals: the pages of a font give the font, the files and the
+* atlas pages of a bundle give the bundle.
+*
+* @param parts - The records to add up.
+* @returns The sum.
+* @example
+* ```ts
+* sumMb([{ mb: 0.125 }, { mb: 0.063 }, { mb: 0.021 }]); // 0.209
+* ```
+*/
+function sumMb(parts) {
+	let total = 0;
+	for (const part of parts) total += part.mb;
+	return Math.round(total * PARTS_PER_MB) / PARTS_PER_MB;
+}
+/**
 * Turns the nine-slice metadata of a file into the options `renderer.sync.textures.create` takes.
 *
 * @param file - One file of a bundle.
@@ -14947,7 +14993,8 @@ function nineOf(file) {
 //#region src/plugins/assets/tiers.ts
 /**
 * @file assets plugin — loading one bundle and the boot sequence. One running load per bundle,
-* every caller a waiter: the last one to leave aborts the fetches.
+* every caller a waiter: the last one to leave aborts the fetches. The loaders of one image, one
+* font and one sound are exported: the dev hot swap of `swap.ts` reads a changed file through them.
 */
 /** The extension of an AAC sound in an MP4 container; every other sound is an MP3. */
 const M4A = /\.m4a$/i;
@@ -15102,10 +15149,13 @@ function touch(state, record) {
 	record.lastUsed = state.useCounter;
 }
 /**
-* Creates the four empty maps a bundle's assets live in. It is its own function because lint
-* rule L5 refuses a collection built inside an exported declaration.
+* Creates the four empty maps a bundle's assets live in: the home of a running load.
 *
 * @returns Empty maps for textures, fonts, audio and atlas pages.
+* @example
+* ```ts
+* emptyAssets().textures.size; // 0
+* ```
 */
 function emptyAssets() {
 	return {
@@ -15202,6 +15252,22 @@ async function loadFont(run, file) {
 	};
 }
 /**
+* Loads one sound: the bytes exactly as they were fetched, never decoded here, and the type of
+* their container.
+*
+* @param run - The running load.
+* @param file - The audio file of the manifest.
+* @returns The bytes and their MIME type.
+* @throws {Error} When the response is not ok.
+*/
+async function loadSound(run, file) {
+	const soundPath = pathOf(run.bundle, file);
+	return {
+		bytes: await (await fetchFile(run, soundPath)).arrayBuffer(),
+		mime: mimeOf(soundPath)
+	};
+}
+/**
 * Starts the one load of every atlas page of a bundle. A page lands in the `pages` map of the
 * running load, so a failure later frees it with the rest. Nobody may wait for a page, so its
 * failure is marked as handled here; the files on it still reject with it.
@@ -15269,12 +15335,7 @@ async function loadFile(run, file) {
 		return;
 	}
 	if (kind === "audio") {
-		const soundPath = pathOf(run.bundle, file);
-		const response = await fetchFile(run, soundPath);
-		assets.audio.set(file.key, {
-			bytes: await response.arrayBuffer(),
-			mime: mimeOf(soundPath)
-		});
+		assets.audio.set(file.key, await loadSound(run, file));
 		return;
 	}
 	const texture = file.atlas === void 0 ? await loadImage(run, pathOf(run.bundle, file), nineOf(file)) : await sliceFile(run, file, file.atlas);
@@ -16326,6 +16387,8 @@ function releaseAll(state) {
 	state.warned.clear();
 	state.current = void 0;
 	state.sceneBundle = void 0;
+	state.stamps = void 0;
+	state.swapping = void 0;
 	state.io = void 0;
 }
 //#endregion
@@ -16472,36 +16535,551 @@ function createAssetsApi(ctx) {
 	};
 }
 //#endregion
+//#region src/plugins/assets/paths.ts
+/** The name of the folder of a feature or of a layer the scanner reads. */
+const ASSETS = "assets";
+/** That folder inside a path. */
+const ASSETS_FOLDER = `/${ASSETS}/`;
+/**
+* Reads the folder the scanner found a manifest path in. The scanner reads the `assets/` folder
+* of a feature or of a layer, so the path is cut after it; a path with no such folder, as in a
+* manifest written by hand, gives the folder of the file.
+*
+* @param path - A path of the manifest.
+* @returns The folder, ending in a slash, or `""` for a file at the root.
+* @example
+* ```ts
+* folderOf("features/ui/assets/fx/leaf.webp"); // "features/ui/assets/"
+* ```
+*/
+function folderOf(path) {
+	const scanned = path.indexOf(ASSETS_FOLDER);
+	if (scanned !== -1) return path.slice(0, scanned + ASSETS_FOLDER.length);
+	return path.slice(0, path.lastIndexOf("/") + 1);
+}
+/**
+* Tells whether the scanner would read a path, by its shape alone. It mirrors `scanOwner` of
+* `scan/scan.ts`, which runtime code does not import: the scanner reads `<layer>/assets/` and
+* `<features>/<feature>/assets/` under the game root, so `assets` is the second or the third
+* segment and a file follows it. The page knows neither the layers nor the name of the features
+* folder, so any folder counts as one. This is what finds the first file of an `assets/` folder
+* the booted manifest names nowhere.
+*
+* @param path - A path of the game, root-relative with `/`.
+* @returns True for a path under the `assets/` of a layer or of a feature.
+* @example
+* ```ts
+* isScannerPath("features/shop/assets/coin.png"); // true
+* ```
+*/
+function isScannerPath(path) {
+	const segments = path.split("/");
+	const inLayer = segments[1] === ASSETS && segments.length > 2;
+	const inFeature = segments[2] === ASSETS && segments.length > 3;
+	return inLayer || inFeature;
+}
+/**
+* Builds the path index of a manifest: which file and bundle every path leads to, and the folders
+* the scanner read. A path under one of those folders that leads nowhere is a new asset.
+*
+* @param manifest - The manifest the page booted with.
+* @returns The index.
+*/
+function indexPaths(manifest) {
+	const owners = /* @__PURE__ */ new Map();
+	const folders = /* @__PURE__ */ new Set();
+	for (const [bundle, entry] of Object.entries(manifest.bundles)) for (const file of entry.files) {
+		if (file.path === void 0) continue;
+		const owner = {
+			bundle,
+			entry,
+			file,
+			path: file.path
+		};
+		for (const path of [file.path, ...(file.pages ?? []).map((page) => page.path)]) {
+			owners.set(path, owner);
+			folders.add(folderOf(path));
+		}
+	}
+	folders.delete("");
+	return {
+		manifest,
+		owners,
+		folders: [...folders]
+	};
+}
+/**
+* Tells why a stamp cannot be swapped in place: the set of files is not the one of the manifest
+* the page booted with. A manifest path the watch no longer stamps was removed or renamed, or its
+* nine-slice tag changed. A changed path the manifest does not know is a new asset when it lies
+* under a folder the manifest names, or where the scanner reads: the first file of an `assets/`
+* folder that had none counts too. The watch stamps every image of the game tree, so any other
+* unknown path (a favicon, an image of a feature outside its `assets/`) refuses nothing.
+*
+* @param index - The path index of the manifest.
+* @param stamps - The stamp that arrived.
+* @param changed - The paths whose bytes changed.
+* @returns The reason, or `undefined` when only bytes changed.
+*/
+function refusalOf$1(index, stamps, changed) {
+	for (const path of index.owners.keys()) if (!Object.hasOwn(stamps.files, path)) return `"${path}" left the game`;
+	for (const path of changed) {
+		if (index.owners.has(path)) continue;
+		if (isScannerPath(path) || index.folders.some((folder) => path.startsWith(folder))) return `"${path}" is not in the manifest`;
+	}
+}
+/**
+* Groups the changed files by their bundle. A font whose `.fnt` and pages changed in one save is
+* listed once: a font is replaced as a whole. A path the manifest does not know is left out.
+*
+* @param index - The path index of the manifest.
+* @param changed - The paths whose bytes changed.
+* @returns One batch per bundle, in the order the paths name them.
+*/
+function batchesOf(index, changed) {
+	const batches = /* @__PURE__ */ new Map();
+	for (const path of changed) {
+		const owner = index.owners.get(path);
+		if (owner === void 0) continue;
+		const { bundle, entry } = owner;
+		const batch = batches.get(bundle) ?? {
+			bundle,
+			entry,
+			owners: []
+		};
+		if (!batch.owners.includes(owner)) batch.owners.push(owner);
+		batches.set(bundle, batch);
+	}
+	return [...batches.values()];
+}
+//#endregion
+//#region src/plugins/assets/stamp.ts
+/** The module the keys watch writes, as the hot footer reports its path. */
+const STAMP_FILE = "/.moku/assets-stamp.ts";
+/**
+* Tells whether a value maps paths to stamps.
+*
+* @param value - The `files` member of a stamp module.
+* @returns True for a plain object whose values are all strings.
+* @example
+* ```ts
+* isStampMap({ "features/ui/assets/fx-spark.webp": "2554:1791536552578" }); // true
+* ```
+*/
+function isStampMap(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.values(value).every((stamp) => typeof stamp === "string");
+}
+/**
+* Tells whether a value is a list of paths.
+*
+* @param value - The `changed` member of a stamp module.
+* @returns True for an array of strings.
+* @example
+* ```ts
+* isPathList(["features/ui/assets/fx-spark.webp"]); // true
+* ```
+*/
+function isPathList(value) {
+	return Array.isArray(value) && value.every((path) => typeof path === "string");
+}
+/**
+* Tells the stamp of the keys watch from any other default export.
+*
+* @param value - The default export of the stamp module.
+* @returns True when it carries a `files` map of strings and a `changed` list of strings.
+* @example
+* ```ts
+* isAssetStamps({ files: { "features/ui/assets/popup.mp3": "8120:1791536000000" }, changed: [] }); // true
+* ```
+*/
+function isAssetStamps(value) {
+	if (typeof value !== "object" || value === null) return false;
+	if (!("files" in value) || !("changed" in value)) return false;
+	return isStampMap(value.files) && isPathList(value.changed);
+}
+/**
+* Reads the stamp out of a hot swap, when the saved module is the stamp of the keys watch.
+*
+* @param payload - The saved file and its new exports.
+* @returns The stamp, or `undefined` for any other file and for a module that carries none.
+* @example
+* ```ts
+* stampsOf({ file: "/game/features/hud/view.tsx", module: {} }); // undefined
+* ```
+*/
+function stampsOf(payload) {
+	if (!payload.file.replaceAll("\\", "/").endsWith(STAMP_FILE)) return void 0;
+	const stamps = payload.module.default;
+	return isAssetStamps(stamps) ? stamps : void 0;
+}
+/**
+* Works out which files a stamp changed, and keeps its map for the next one. Against the map
+* applied last it is every path whose stamp differs. The first update after boot has no map to
+* compare with, so the list of the keys watch stands.
+*
+* @param state - The plugin state.
+* @param stamps - The stamp that arrived.
+* @returns The changed paths.
+*/
+function changedPaths(state, stamps) {
+	const applied = state.stamps;
+	state.stamps = stamps.files;
+	if (applied === void 0) return stamps.changed;
+	return Object.keys(stamps.files).filter((path) => stamps.files[path] !== applied[path]);
+}
+//#endregion
+//#region src/plugins/assets/swap.ts
+/**
+* @file assets plugin — the dev hot swap of asset files. When the stamp of the keys watch changes
+* (`stamp.ts`), the changed files of the loaded bundles (`paths.ts`) are replaced here: a new
+* texture, font or sound per key, the old textures destroyed after the new ones are stored, then
+* `assets:replaced`. A file that fails is logged and its bundle keeps what it had. A changed set
+* of files reloads the page instead: a hook cannot refuse by throwing, the core bus catches what
+* a hook throws.
+*/
+/**
+* Reloads the page. This is how a swap refuses, and what it does when a replace breaks after its
+* files arrived: the page boots again with the new manifest and the new files. Headless and in a
+* test there is no page, so nothing happens.
+*/
+function reloadPage$1() {
+	globalThis.location?.reload();
+}
+/**
+* Says why a file could not be replaced.
+*
+* @param error - What the load threw.
+* @returns The message of an error, or the value as a string.
+* @example
+* ```ts
+* reasonOf(new Error("The source image could not be decoded.")); // "The source image could not be decoded."
+* ```
+*/
+function reasonOf$1(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Copies the io of a swap so every texture it uploads is remembered with the pixel size of its
+* image. The manifest needs that size, and the loaders of `tiers.ts` answer the texture alone;
+* the list is also what a swap that does not land gives back. The io is a plain record of
+* functions, so the copy carries the other four members as they are.
+*
+* @param io - The I/O seam of the plugin.
+* @param sizes - Filled with every texture this io creates.
+* @returns The io with a measuring `createTexture`.
+*/
+function measuringIo(io, sizes) {
+	return {
+		...io,
+		createTexture: (image, options) => {
+			const texture = io.createTexture(image, options);
+			sizes.set(texture, {
+				width: image.width,
+				height: image.height
+			});
+			return texture;
+		}
+	};
+}
+/**
+* Builds the running load the file loaders of `tiers.ts` take, for the files of one bundle.
+*
+* @param swap - The running swap.
+* @param bundle - Name of the bundle.
+* @param sizes - Filled with every texture the load creates.
+* @returns The running load.
+*/
+function loadingOf(swap, bundle, sizes) {
+	const { config } = swap.ctx;
+	return {
+		io: measuringIo(swap.io, sizes),
+		bundle,
+		base: resolveBaseUrl(config.baseUrl, config.manifest),
+		signal: new AbortController().signal,
+		assets: emptyAssets()
+	};
+}
+/**
+* Loads one changed file again, by what the manifest says it is. A font is read as a whole: its
+* `.fnt` and every page, whichever of them changed.
+*
+* @param run - The running load.
+* @param owner - The file to load.
+* @returns What the file brought.
+* @throws {Error} When a fetch or a decode fails, or the font lists no page.
+*/
+async function loadFresh(run, owner) {
+	const kind = kindOf$2(owner.file);
+	if (kind === "font") return {
+		kind,
+		owner,
+		font: await loadFont(run, owner.file)
+	};
+	if (kind === "audio") return {
+		kind,
+		owner,
+		audio: await loadSound(run, owner.file)
+	};
+	return {
+		kind,
+		owner,
+		texture: await loadImage(run, owner.path, nineOf(owner.file))
+	};
+}
+/**
+* Loads every changed file of one bundle in parallel and waits for all of them, so nothing is
+* still on the way when the bundle is stored or given back.
+*
+* @param run - The running load.
+* @param owners - The files to load.
+* @returns What arrived, and the files that failed.
+*/
+async function loadAll(run, owners) {
+	const fresh = [];
+	const failures = [];
+	await Promise.all(owners.map((owner) => loadFresh(run, owner).then((loaded) => fresh.push(loaded), (error) => failures.push({
+		path: owner.path,
+		reason: reasonOf$1(error)
+	}))));
+	return {
+		fresh,
+		failures
+	};
+}
+/**
+* Reads the record of a bundle once it stands still. A load that runs when the stamp arrives may
+* have fetched the old bytes, so it lands first.
+*
+* @param state - The plugin state.
+* @param bundle - Name of the bundle.
+* @returns The record when the bundle is loaded, else `undefined`: its next load reads the new
+*   bytes, the dev server answers every file with `no-store`.
+*/
+async function settledRecord(state, bundle) {
+	const record = state.records.get(bundle);
+	if (record?.status === "loading") await record.inflight?.promise;
+	return record?.status === "loaded" ? record : void 0;
+}
+/**
+* Writes the pixel size of a new image, and what it costs, into its manifest record.
+*
+* @param target - The record of a texture file or of a font page.
+* @param size - The size of the decoded image.
+*/
+function resize(target, size) {
+	if (target === void 0 || size === void 0) return;
+	target.width = size.width;
+	target.height = size.height;
+	target.mb = textureMb(size.width, size.height);
+}
+/**
+* Stores a new font under its key and frees the pages of the old one. The record of each page and
+* of the font follow the new images.
+*
+* @param io - The I/O seam of the plugin.
+* @param record - The record of the loaded bundle.
+* @param owner - The font file.
+* @param font - The font that was read again.
+* @param sizes - The pixel size of every new page.
+*/
+function storeFont(io, record, owner, font, sizes) {
+	const { file } = owner;
+	const pages = file.pages ?? [];
+	const old = record.fonts.get(file.key);
+	record.fonts.set(file.key, font);
+	for (const page of old?.pages ?? []) io.destroyTexture(page);
+	for (const [at, texture] of font.pages.entries()) resize(pages[at], sizes.get(texture));
+	file.mb = sumMb(pages);
+}
+/**
+* Stores what one changed file brought under its key. An old texture is destroyed only after the
+* new one is stored, so nothing ever answers a destroyed texture.
+*
+* @param io - The I/O seam of the plugin.
+* @param record - The record of the loaded bundle.
+* @param fresh - What the file brought.
+* @param sizes - The pixel size of every new texture.
+*/
+function store(io, record, fresh, sizes) {
+	const { file } = fresh.owner;
+	if (fresh.kind === "font") {
+		storeFont(io, record, fresh.owner, fresh.font, sizes);
+		return;
+	}
+	if (fresh.kind === "audio") {
+		record.audio.set(file.key, fresh.audio);
+		return;
+	}
+	const old = record.textures.get(file.key);
+	record.textures.set(file.key, fresh.texture);
+	if (old !== void 0) io.destroyTexture(old);
+	resize(file, sizes.get(fresh.texture));
+}
+/**
+* Makes the numbers and the picture follow the files that were stored: the megabytes of the
+* bundle, the budget, the views of the keys, the frame loop and the event.
+*
+* @param ctx - Domain context of the plugin.
+* @param batch - The bundle and its replaced files.
+* @param record - The record of the bundle.
+*/
+function publish(ctx, batch, record) {
+	const { bundle, entry } = batch;
+	const keys = batch.owners.map((owner) => owner.file.key);
+	entry.mb = sumMb([...entry.files, ...entry.pages ?? []]);
+	enforceBudget(ctx);
+	if (record.status !== "loaded") return;
+	ctx.deps.renderer.sync.textures.invalidate(keys);
+	ctx.deps.time.wake();
+	ctx.emit("assets:replaced", {
+		bundle,
+		keys
+	});
+}
+/**
+* Gives the new files of one bundle up: every file that failed is logged, and every texture the
+* swap uploaded goes back. Nothing was stored, so the bundle keeps what it had.
+*
+* @param swap - The running swap.
+* @param failures - The files that could not be read.
+* @param sizes - Every new texture of the bundle.
+*/
+function discard(swap, failures, sizes) {
+	for (const failure of failures) swap.ctx.log.error("assets:replace-failed", failure);
+	for (const texture of sizes.keys()) swap.io.destroyTexture(texture);
+}
+/**
+* Replaces the changed files of one bundle. Every file is loaded first and nothing is stored
+* before all of them are there. A file that fails is logged and the bundle keeps its old
+* textures, fonts and bytes: the new textures are given back, nothing is emitted and the page
+* stays. The stamp of the broken file is applied all the same, so it is read again only when it
+* is saved again. A bundle that was unloaded on the way gives its new textures back too.
+*
+* @param swap - The running swap.
+* @param batch - The bundle and its changed files.
+* @throws {Error} What the io, the renderer or the budget throws after the files arrived.
+*/
+async function replaceBundle(swap, batch) {
+	const { ctx, io } = swap;
+	const record = await settledRecord(ctx.state, batch.bundle);
+	if (record === void 0) return;
+	const sizes = /* @__PURE__ */ new Map();
+	const { fresh, failures } = await loadAll(loadingOf(swap, batch.bundle, sizes), batch.owners);
+	if (failures.length > 0 || record.status !== "loaded") {
+		discard(swap, failures, sizes);
+		return;
+	}
+	for (const loaded of fresh) store(io, record, loaded, sizes);
+	publish(ctx, batch, record);
+}
+/**
+* Runs one swap, bundle after bundle: a bundle with a file that failed does not stop the next
+* one. It never rejects, so the chain of swaps in the state cannot break. A throw after the files
+* arrived (from a destroy, the views or the budget) leaves a bundle whose stored state is not
+* known: every file of it is logged as failed, the page reloads and the swap stops there.
+*
+* @param swap - The running swap.
+* @param batches - The changed files, by bundle.
+*/
+async function replaceAll(swap, batches) {
+	for (const batch of batches) try {
+		await replaceBundle(swap, batch);
+	} catch (error) {
+		const reason = reasonOf$1(error);
+		for (const { path } of batch.owners) swap.ctx.log.error("assets:replace-failed", {
+			path,
+			reason
+		});
+		swap.reload();
+		return;
+	}
+}
+/**
+* Creates the handler of the dev hot swap of asset files. It acts only on the stamp of the keys
+* watch, and only with an io: a headless page has no file. What changed and whether the swap is
+* refused is decided at once; the replace itself waits for the swap before it, so two saves in a
+* row never overlap.
+*
+* @param ctx - Domain context of the plugin.
+* @param reload - What a refused or a broken swap calls. The page reload by default; a test
+*   passes a spy.
+* @returns The handler of `ui:hot-swap`.
+*/
+function createSwap$1(ctx, reload = reloadPage$1) {
+	let index;
+	return (payload) => {
+		const { state } = ctx;
+		const stamps = stampsOf(payload);
+		const io = state.io;
+		if (stamps === void 0 || io === void 0) return;
+		const changed = changedPaths(state, stamps);
+		if (index?.manifest !== state.manifest) index = indexPaths(state.manifest);
+		const reason = refusalOf$1(index, stamps, changed);
+		if (reason !== void 0) {
+			ctx.log.info("assets:swap-refused", { reason });
+			reload();
+			return;
+		}
+		const batches = batchesOf(index, changed);
+		if (batches.length === 0) return;
+		state.swapping = (state.swapping ?? Promise.resolve()).then(() => replaceAll({
+			ctx,
+			io,
+			reload
+		}, batches));
+	};
+}
+//#endregion
 //#region src/plugins/assets/handlers.ts
 /**
-* @file assets plugin — event handlers.
+* @file assets plugin — event handlers: the rest node that settles the memory, and the dev hot
+* swap that replaces the asset files a save changed.
 */
 /**
 * Creates the hook handlers. `flow:rest` is the one moment the graph stands still, so it is where
 * the memory is settled and the neighbourhood of the position is queued. The loading itself is a
-* background queue in the state and is never awaited here: an engine hook is synchronous.
+* background queue in the state and is never awaited here: an engine hook is synchronous. The
+* global `ui:hot-swap` is hooked with no `depends` on `ui`, as `effects` does: in a dev build it
+* brings the stamp of the keys watch, and the changed files are replaced behind it.
 *
-* The handler builds its domain context when it first fires, not while this factory runs: the
+* A handler builds its domain context when it first fires, not while this factory runs: the
 * kernel registers hooks before it builds the plugin APIs, so nothing is resolvable yet.
 *
 * @param ctx - Kernel context of the assets plugin.
-* @returns The one hook of the plugin.
+* @param reload - What a refused or a broken hot swap calls. The kernel passes nothing, which
+*   means the page reload; a test passes a spy.
+* @returns The two hooks of the plugin.
 */
-function createHandlers$4(ctx) {
+function createHandlers$4(ctx, reload) {
 	let assets;
-	return { 
-	/**
-	* Settles the texture memory and rebuilds the background preload.
-	*
-	* @param _payload - Where the graph rests. The position itself comes from the state.
-	*/
-"flow:rest": (_payload) => {
-		assets ??= withDeps$6(ctx);
-		if (assets.state.io === void 0) return;
-		enforceBudget(assets);
-		if (assets.deps.flow.state().mode === "fast") return;
-		startPreload(assets);
-	} };
+	let swap;
+	return {
+		/**
+		* Settles the texture memory and rebuilds the background preload.
+		*
+		* @param _payload - Where the graph rests. The position itself comes from the state.
+		*/
+		"flow:rest": (_payload) => {
+			assets ??= withDeps$6(ctx);
+			if (assets.state.io === void 0) return;
+			enforceBudget(assets);
+			if (assets.deps.flow.state().mode === "fast") return;
+			startPreload(assets);
+		},
+		/**
+		* Replaces the asset files a dev save changed, when the saved module is the stamp of the keys
+		* watch. Only dev emits the event; the swap answers at once and works behind it.
+		*
+		* @param payload - The saved file and its new exports.
+		*/
+		"ui:hot-swap": (payload) => {
+			if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__) {
+				assets ??= withDeps$6(ctx);
+				swap ??= createSwap$1(assets, reload);
+				swap(payload);
+			}
+		}
+	};
 }
 //#endregion
 //#region src/plugins/assets/state.ts
@@ -16550,7 +17128,9 @@ function createAssetsState() {
 		current: void 0,
 		useCounter: 0,
 		warned: emptySet$2(),
-		removers: []
+		removers: [],
+		stamps: void 0,
+		swapping: void 0
 	};
 }
 /**
@@ -16584,7 +17164,8 @@ const assetsPlugin = /*#__PURE__*/ createPlugin$1("assets", {
 	events: (register) => register.map({
 		"assets:bundle-loaded": "Every file of a bundle is a texture now",
 		"assets:bundle-progress": "One more file of a running bundle load settled",
-		"assets:bundle-unloaded": "The textures of a bundle were destroyed"
+		"assets:bundle-unloaded": "The textures of a bundle were destroyed",
+		"assets:replaced": "Files of a loaded bundle were replaced by a dev hot swap"
 	}),
 	createState: createAssetsState,
 	api: createAssetsApi,
@@ -17868,9 +18449,9 @@ async function stopAudio(state) {
 //#endregion
 //#region src/plugins/audio/handlers.ts
 /**
-* @file audio plugin — the four hooks. They are the whole of what drives this plugin: the player
-* sets the volumes, the graph sets the music, the OS sets the pause and the budget sets what is
-* still decoded.
+* @file audio plugin — the five hooks. They are the whole of what drives this plugin: the player
+* sets the volumes, the graph sets the music, the OS sets the pause, and the budget and a dev hot
+* swap set what is still decoded.
 */
 /**
 * Applies the volumes of the committed player. A `volumes` that throws — a save without the
@@ -17921,12 +18502,25 @@ function resumeAfterPause(ctx) {
 	});
 }
 /**
-* Creates the four hook handlers. Each one builds the domain context when it first fires, not
+* Forgets the decoded buffer and the one warning of every key named. A key that is no sound is in
+* neither, so it costs nothing. A source that is playing holds its own buffer and plays on.
+*
+* @param state - The plugin state.
+* @param keys - Asset keys whose bytes left or changed.
+*/
+function evict(state, keys) {
+	for (const key of keys) {
+		state.decoded.delete(key);
+		state.warned.delete(key);
+	}
+}
+/**
+* Creates the five hook handlers. Each one builds the domain context when it first fires, not
 * while this factory runs: the kernel registers hooks before it builds the plugin APIs, so
 * nothing is resolvable yet.
 *
 * @param ctx - Kernel context of the audio plugin.
-* @returns The four hooks of the plugin.
+* @returns The five hooks of the plugin.
 */
 function createHandlers$3(ctx) {
 	let audio;
@@ -17986,11 +18580,17 @@ function createHandlers$3(ctx) {
 		* @param payload - The bundle that left and the keys it carried.
 		*/
 		"assets:bundle-unloaded": (payload) => {
-			const state = domain().state;
-			for (const key of payload.keys) {
-				state.decoded.delete(key);
-				state.warned.delete(key);
-			}
+			evict(domain().state, payload.keys);
+		},
+		/**
+		* Drops the decoded sounds a dev hot swap replaced: `assets.audio(key)` already answers the
+		* new bytes, so the next play of a key decodes them. Nothing that is playing is stopped: a
+		* source keeps the buffer it started with and a streamed track keeps its Blob.
+		*
+		* @param payload - The bundle whose files were replaced and the keys with new bytes.
+		*/
+		"assets:replaced": (payload) => {
+			evict(domain().state, payload.keys);
 		}
 	};
 }
@@ -20694,10 +21294,24 @@ function stopEffects(state) {
 //#endregion
 //#region src/plugins/effects/handlers.ts
 /**
-* @file effects plugin — the two hooks: a bundle that left takes the effects drawn with its
-* textures along, particles and `Displacement` maps alike, whatever their space; a dev hot swap
-* replaces the registered emitters its module exports.
+* @file effects plugin — the three hooks: a bundle that left takes the effects drawn with its
+* textures along, particles and `Displacement` maps alike, whatever their space; so do the files
+* a dev hot swap replaced, whose effects are built again from the new textures; a dev hot swap of
+* a module replaces the registered emitters it exports.
+*/
+/**
+* Retires everything drawn with the textures of `keys`: the particle instances and their bakes,
+* the `Displacement` filters, and the one-shot warning of each key, so it can warn again. The
+* next frame builds each effect again from the texture its key answers then.
+*
+* @param effects - Domain context of the effects plugin.
+* @param keys - The asset keys whose textures are gone.
 */
+function retireKeys(effects, keys) {
+	retireParticleKeys(effects, keys);
+	retireFilterMaps(effects, keys);
+	for (const key of keys) effects.state.warned.delete(`texture:${key}`);
+}
 /**
 * Replaces every registered emitter the saved module exports and drops its bake, so the next
 * instance bakes the new config; a live instance keeps its own bake. An id no feature registered
@@ -20736,9 +21350,19 @@ function createHandlers$2(ctx) {
 		*/
 		"assets:bundle-unloaded": (payload) => {
 			effects ??= withDeps$3(ctx);
-			retireParticleKeys(effects, payload.keys);
-			retireFilterMaps(effects, payload.keys);
-			for (const key of payload.keys) effects.state.warned.delete(`texture:${key}`);
+			retireKeys(effects, payload.keys);
+		},
+		/**
+		* Retires the particle instances and the `Displacement` filters drawn with the textures a dev
+		* hot swap replaced and drops their bakes. The old textures are destroyed and the new ones
+		* stand under the same keys, so the next frame builds each effect again from the new one.
+		* Only dev emits it.
+		*
+		* @param payload - The bundle and the keys with new bytes.
+		*/
+		"assets:replaced": (payload) => {
+			effects ??= withDeps$3(ctx);
+			retireKeys(effects, payload.keys);
 		},
 		/**
 		* Replaces the registered emitters a dev hot swap brought. Only dev emits it.
@@ -24998,6 +25622,8 @@ function parseTags(source, warn) {
 const CACHE_SEPARATOR = String.fromCodePoint(0);
 /** How many laid-out blocks are kept. The oldest goes when a new one does not fit. */
 const CACHE_LIMIT = 1024;
+/** How every inline icon tag starts. A resolved text without it holds no icon. */
+const ICON_OPEN = "<icon=";
 /** The name the system is registered under; it shows up in a world error message. */
 const TEXT_SYSTEM_NAME = "text.resolve";
 /**
@@ -25302,9 +25928,36 @@ function rememberBound(ctx, entity, text, unit) {
 	seen.locale = ctx.deps.i18n.locale();
 }
 /**
+* Writes the string a bound label already shows once more, and measures it again. A mark on a
+* label whose number stands still means the picture under it moved: its font arrived or was
+* replaced, or its style was swapped. The display adapter rebuilds only what `changed(Text)`
+* names, so the same string is written.
+*
+* @param ctx - Domain context of the text plugin.
+* @param entity - The entity.
+* @param text - Its component value.
+*/
+function showAgain(ctx, entity, text) {
+	ctx.deps.world.ecs.set(entity, Text, { resolved: text.resolved });
+	ctx.state.measured.set(entity, sizeOf(layoutFor(ctx, text.resolved, text.style)));
+}
+/**
+* Reports a bound label whose style is not a digits style, once per style. An unknown style name
+* is not reported here: `styleOf` reports it by its name.
+*
+* @param ctx - Domain context of the text plugin.
+* @param styleName - The style name of the bound label.
+*/
+function warnWithoutDigits(ctx, styleName) {
+	const style = ctx.state.styles.get(styleName);
+	if (style === void 0 || style.digits) return;
+	warnOnce(ctx, `bind-style:${styleName}`, "text: bind on a style without digits", { style: styleName });
+}
+/**
 * One frame of a bound label: the value read every frame, the string built and written only
 * when its unit moved. A label that stands still costs a read and a few compares; no tag is
-* parsed, and the locale is read only for a `"duration"`.
+* parsed, and the locale is read only for a `"duration"`. A marked label that stands still is
+* written once with the string it shows.
 *
 * @param ctx - Domain context of the text plugin.
 * @param entity - The entity.
@@ -25313,13 +25966,15 @@ function rememberBound(ctx, entity, text, unit) {
 * @param frame - What this run of the system shares.
 */
 function stepBound(ctx, entity, text, bind, frame) {
-	const style = ctx.state.styles.get(text.style);
-	if (style !== void 0 && !style.digits) warnOnce(ctx, `bind-style:${text.style}`, "text: bind on a style without digits", { style: text.style });
+	warnWithoutDigits(ctx, text.style);
 	const value = boundValue(ctx, entity, bind, frame);
 	const format = value === void 0 ? "int" : formatOf(ctx, entity, bind, value);
 	const unit = value === void 0 ? void 0 : unitOf(value, format);
-	ctx.state.dirty.delete(entity);
-	if (isShown(ctx, entity, text, unit, format)) return;
+	const marked = ctx.state.dirty.delete(entity);
+	if (isShown(ctx, entity, text, unit, format)) {
+		if (marked) showAgain(ctx, entity, text);
+		return;
+	}
 	showBound(ctx, entity, text, value === void 0 ? "" : formatBound(value, format, (ms) => ctx.deps.i18n.duration(ms)), value);
 	rememberBound(ctx, entity, text, unit);
 }
@@ -25391,17 +26046,43 @@ function createTextSystem(ctx) {
 	});
 }
 /**
-* Marks labels for the next layout phase: every one of them, or only the ones whose content is a
-* message, which is what a locale change touches.
+* Marks labels for the next layout phase: every one of them, or only the ones `keep` names. A
+* locale change names the labels whose content is a message; a dev hot swap names the labels
+* drawn with a replaced font or icon.
 *
 * @param ctx - Domain context of the text plugin.
-* @param onlyMessages - True to leave the plain strings alone.
+* @param keep - Tells whether a label is marked. Left out, every label is.
+* @returns How many labels were marked.
 */
-function markDirty(ctx, onlyMessages = false) {
+function markDirty(ctx, keep = () => true) {
+	let marked = 0;
 	for (const [entity, text] of ctx.deps.world.ecs.query(Text)) {
-		if (onlyMessages && typeof text.content === "string") continue;
+		if (!keep(text)) continue;
 		ctx.state.dirty.add(entity);
+		marked += 1;
 	}
+	return marked;
+}
+/**
+* Tells whether a label is drawn with one of the asset keys: a font its style names, or an inline
+* icon of its resolved text. The text is read through the tag grammar, the way it is drawn, so an
+* escaped `\<icon=…>` is text and not an icon. A text that holds no `<icon=` at all is not read:
+* most labels have no icon, and this runs for every label of a swap.
+*
+* @param ctx - Domain context of the text plugin.
+* @param text - The component value of the label.
+* @param keys - The asset keys to look for.
+* @returns True when a glyph font or an icon of the label is one of `keys`.
+*/
+function drawsWith(ctx, text, keys) {
+	const style = styleOf$1(ctx, text.style);
+	if ([
+		style.font,
+		style.bold,
+		style.italic
+	].some((font) => font !== void 0 && keys.includes(font))) return true;
+	if (!text.resolved.includes(ICON_OPEN)) return false;
+	return parseTags(text.resolved, warnFor(ctx)).some((run) => run.kind === "icon" && keys.includes(run.key));
 }
 /**
 * Forgets an entity whose `Text` left. Works on the state alone, because it is also what the
@@ -25430,6 +26111,40 @@ const SYNTHETIC_ITALIC = -.2;
 /** What a shadow copy is painted with, so its tint alone gives it the shadow colour. */
 const WHITE = 16777215;
 /**
+* Reads one font when `assets` can answer for it: the advance table first, then the install in the
+* renderer. A font that has both already is left alone.
+*
+* @param ctx - Domain context of the text plugin.
+* @param key - The asset key of the font.
+* @returns True when its advance table arrived, so what was measured without it is stale.
+* @throws {Error} When the `.fnt` is in neither BMFont format.
+*/
+function installFont(ctx, key) {
+	const renderer = ctx.deps.renderer;
+	const needsTable = !ctx.state.tables.has(key);
+	const needsInstall = renderer.host.ready() && !ctx.state.installed.has(key);
+	if (!needsTable && !needsInstall) return false;
+	const font = ctx.deps.assets.font(key);
+	if (font === void 0) return false;
+	if (needsTable) ctx.state.tables.set(key, parseAdvances(font.fnt, key));
+	if (needsInstall) {
+		renderer.sync.fonts.install(key, font.fnt, font.texture);
+		ctx.state.installed.add(key);
+	}
+	return needsTable;
+}
+/**
+* Forgets one font: its advance table and the mark that the renderer holds it, so the next
+* `installFont` reads both again.
+*
+* @param ctx - Domain context of the text plugin.
+* @param key - The asset key of the font.
+*/
+function dropFont(ctx, key) {
+	ctx.state.tables.delete(key);
+	ctx.state.installed.delete(key);
+}
+/**
 * Reads the fonts of `fontKeys` that `assets` can answer for: the advance table first, then the
 * install in the renderer. Runs in `onStart` and on every bundle that lands.
 *
@@ -25437,24 +26152,8 @@ const WHITE = 16777215;
 * @throws {Error} When a `.fnt` is in neither BMFont format.
 */
 function installFonts(ctx) {
-	const renderer = ctx.deps.renderer;
-	const ready = renderer.host.ready();
 	let arrived = false;
-	for (const key of ctx.state.fontKeys) {
-		const needsTable = !ctx.state.tables.has(key);
-		const needsInstall = ready && !ctx.state.installed.has(key);
-		if (!needsTable && !needsInstall) continue;
-		const font = ctx.deps.assets.font(key);
-		if (font === void 0) continue;
-		if (needsTable) {
-			ctx.state.tables.set(key, parseAdvances(font.fnt, key));
-			arrived = true;
-		}
-		if (needsInstall) {
-			renderer.sync.fonts.install(key, font.fnt, font.texture);
-			ctx.state.installed.add(key);
-		}
-	}
+	for (const key of ctx.state.fontKeys) if (installFont(ctx, key)) arrived = true;
 	if (arrived) refresh(ctx);
 }
 /**
@@ -25467,8 +26166,7 @@ function releaseFonts(ctx, keys) {
 	let left = false;
 	for (const key of keys) {
 		if (!ctx.state.fontKeys.has(key)) continue;
-		ctx.state.tables.delete(key);
-		ctx.state.installed.delete(key);
+		dropFont(ctx, key);
 		left = true;
 	}
 	if (left) refresh(ctx);
@@ -25483,6 +26181,73 @@ function refresh(ctx) {
 	markDirty(ctx);
 }
 /**
+* Reloads the page. This is how a font replace that failed ends, so the game is not left drawing
+* with a font whose table was released. Headless and in a test there is no page, so nothing
+* happens.
+*/
+function reloadPage() {
+	globalThis.location?.reload();
+}
+/**
+* Says why a font could not be installed again.
+*
+* @param error - What the install threw.
+* @returns The message of an error, or the value as a string.
+* @example
+* ```ts
+* reasonOf(new Error("The page is gone.")); // "The page is gone."
+* ```
+*/
+function reasonOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Installs every replaced font again, one by one: its table and its mark go, then the new file
+* and the new page are read. No other font is touched and no label is marked here. The stamp of
+* the keys watch is written after a failed scan too, so a `.fnt` the scanner refused still gets
+* here, and reading it throws after its table was released. That font is logged and the page
+* reloads.
+*
+* @param ctx - Domain context of the text plugin.
+* @param fonts - The font keys among what a dev hot swap replaced.
+* @param reload - What a font that cannot be installed calls.
+* @returns False when a font failed, so the page is on its way out.
+*/
+function reinstallFonts(ctx, fonts, reload) {
+	for (const key of fonts) try {
+		dropFont(ctx, key);
+		installFont(ctx, key);
+	} catch (error) {
+		ctx.log.error("text:font-replace-failed", {
+			key,
+			reason: reasonOf(error)
+		});
+		reload();
+		return false;
+	}
+	return true;
+}
+/**
+* Applies what a dev hot swap replaced. `assets` answers the new font and the new texture of
+* every key already, and the old pages and textures are destroyed. A font among the keys is
+* installed again here, so the font registry of the renderer holds the new page at once. Only
+* the labels drawn with a replaced font or inline icon are marked, and the generation moves: the
+* next frame writes each of them, and the adapter builds it again from the new textures even when
+* its string stands still. A label of another font is not written and keeps its objects.
+*
+* @param ctx - Domain context of the text plugin.
+* @param keys - The asset keys with new bytes.
+* @param reload - What a font that cannot be installed calls. The page reload by default; a test
+*   passes a spy.
+*/
+function applyReplaced(ctx, keys, reload = reloadPage) {
+	const fonts = keys.filter((key) => ctx.state.fontKeys.has(key));
+	if (fonts.length > 0) ctx.state.cache.clear();
+	if (!reinstallFonts(ctx, fonts, reload)) return;
+	if (markDirty(ctx, (text) => drawsWith(ctx, text, keys)) === 0) return;
+	ctx.state.generation += 1;
+}
+/**
 * Where a line starts inside the widest one.
 *
 * @param style - The style of the label.
@@ -25698,7 +26463,7 @@ function buildRun(ctx, pixi, run, style, at) {
 	return objects;
 }
 /**
-* The style and the laid-out block of one component value.
+* The style and the laid-out block of one component value, under the generation of this moment.
 *
 * @param ctx - Domain context of the text plugin.
 * @param value - The component value.
@@ -25707,7 +26472,8 @@ function buildRun(ctx, pixi, run, style, at) {
 function labelOf(ctx, value) {
 	return {
 		style: styleOf$1(ctx, value.style),
-		layout: layoutFor(ctx, value.resolved, value.style)
+		layout: layoutFor(ctx, value.resolved, value.style),
+		generation: ctx.state.generation
 	};
 }
 /**
@@ -25821,10 +26587,27 @@ function samePoint(first, second) {
 	return first.x === second.x && first.y === second.y;
 }
 /**
+* Tells whether a container already shows a value: the string, the style name and the anchor it
+* was last updated with, drawn with the style object that is current and under the generation
+* that is current. A replaced style is a new object under the same name. A font or an icon a dev
+* hot swap replaced moves the generation, because the objects hold textures that are destroyed.
+*
+* @param ctx - Domain context of the text plugin.
+* @param container - The container of this label.
+* @param previous - The value the container was drawn from.
+* @param next - The value to draw now.
+* @returns True when nothing has to be drawn.
+*/
+function isCurrent(ctx, container, previous, next) {
+	const drawn = ctx.state.drawn.get(container);
+	return previous.resolved === next.resolved && previous.style === next.style && samePoint(previous.anchor, next.anchor) && drawn?.style === styleOf$1(ctx, next.style) && drawn.generation === ctx.state.generation;
+}
+/**
 * Draws a changed value into a container that holds a label already. A ticking counter keeps its
-* objects: with the same style object, the same anchor and the same lines and runs, the new text
-* and spots are written into them. Anything else frees the children and fills the container
-* again.
+* objects: with the same style object, the same generation, the same anchor and the same lines
+* and runs, the new text and spots are written into them. Anything else frees the children and
+* fills the container again. A label of an older generation is always filled again: writing the
+* string it shows already into a `BitmapText` rebuilds no glyph.
 *
 * @param ctx - Domain context of the text plugin.
 * @param pixi - The Pixi module the renderer loaded.
@@ -25835,7 +26618,7 @@ function samePoint(first, second) {
 function redraw(ctx, pixi, container, previous, next) {
 	const drawn = ctx.state.drawn.get(container);
 	const label = labelOf(ctx, next);
-	if (drawn?.style === label.style && samePoint(previous.anchor, next.anchor) && sameShape(drawn.layout, label.layout)) {
+	if (drawn?.style === label.style && drawn.generation === label.generation && samePoint(previous.anchor, next.anchor) && sameShape(drawn.layout, label.layout)) {
 		retext(ctx, pixi, container, next, label);
 		return;
 	}
@@ -25869,7 +26652,7 @@ function createTextAdapter(ctx) {
 			if (pixi === void 0 || object === void 0) return;
 			const container = asContainer(object);
 			container.alpha = next.alpha;
-			if (previous.resolved === next.resolved && previous.style === next.style && samePoint(previous.anchor, next.anchor) && ctx.state.drawn.get(container)?.style === styleOf$1(ctx, next.style)) return;
+			if (isCurrent(ctx, container, previous, next)) return;
 			redraw(ctx, pixi, container, previous, next);
 		},
 		destroy: (object) => {
@@ -26080,19 +26863,22 @@ function createTextApi(ctx) {
 //#endregion
 //#region src/plugins/text/handlers.ts
 /**
-* @file text plugin — the three hooks. None of them does work in place: a bundle brings fonts, a
-* bundle takes them away, a locale change marks the messages. The layout phase of the next frame
-* is where the strings are built again.
+* @file text plugin — the four hooks. None of them draws in place: a bundle brings fonts, a
+* bundle takes them away, a locale change marks the messages, a dev hot swap marks the labels of
+* a replaced font or icon. The layout phase of the next frame is where the strings are built
+* again.
 */
 /**
-* Creates the three hook handlers. Each one builds the domain context when it first fires, not
+* Creates the four hook handlers. Each one builds the domain context when it first fires, not
 * while this factory runs: the kernel registers hooks before it builds the plugin APIs, so
 * nothing is resolvable yet.
 *
 * @param ctx - Kernel context of the text plugin.
-* @returns The three hooks of the plugin.
+* @param reload - What a font that a dev hot swap replaced and that cannot be installed calls.
+*   The kernel passes nothing, which means the page reload; a test passes a spy.
+* @returns The four hooks of the plugin.
 */
-function createHandlers(ctx) {
+function createHandlers(ctx, reload) {
 	let text;
 	/**
 	* The domain context, built on the first hook that fires.
@@ -26122,6 +26908,15 @@ function createHandlers(ctx) {
 			releaseFonts(domain(), payload.keys);
 		},
 		/**
+		* Installs the fonts a dev hot swap replaced again and marks the labels drawn with a replaced
+		* font or inline icon. The next frame builds each of them again from the new textures.
+		*
+		* @param payload - The bundle and the asset keys that have new bytes.
+		*/
+		"assets:replaced": (payload) => {
+			applyReplaced(domain(), payload.keys, reload);
+		},
+		/**
 		* Marks every label whose content is a message. The next layout phase resolves them again,
 		* and `ui` solves once over the new sizes; no projection is re-run.
 		*
@@ -26129,7 +26924,7 @@ function createHandlers(ctx) {
 		*/
 		"i18n:locale-changed": (_payload) => {
 			const tctx = domain();
-			markDirty(tctx, true);
+			markDirty(tctx, (label) => typeof label.content !== "string");
 			tctx.state.cache.clear();
 			tctx.deps.time.wake();
 		}
@@ -26180,6 +26975,7 @@ function createTextState$1() {
 		cache: emptyMap$2(),
 		drawn: emptyWeakMap(),
 		dirty: emptySet$1(),
+		generation: 0,
 		warned: emptySet$1(),
 		removers: []
 	};
@@ -31844,6 +32640,8 @@ function createLayoutApi(ctx) {
 const HOT_GLOBAL = "__moku_hot";
 /** A strings module `assets:keys` generates; the group is its locale. */
 const STRINGS_FILE = /\/generated\/strings\.([\w-]+)\.ts$/;
+/** The stamp module the keys watch of `moku-game dev` writes: it names asset files, no view. */
+const ASSETS_STAMP = "/.moku/assets-stamp.ts";
 /**
 * The `kind` of every value a game registers by value at start: ECS component and tag types
 * (filters too), nodes, slots, flows, asset bundles and plugin owners. Any other `kind` marks
@@ -32002,6 +32800,41 @@ function localeOf(file) {
 	return STRINGS_FILE.exec(file.replaceAll("\\", "/"))?.[1];
 }
 /**
+* Tells whether the saved module is the stamp of the keys watch, read from its path with `/`
+* separators.
+*
+* @param file - The path of the saved module.
+* @returns True for `.moku/assets-stamp.ts` of a game.
+* @example
+* ```ts
+* isAssetsStamp("/game/.moku/assets-stamp.ts"); // true
+* ```
+*/
+function isAssetsStamp(file) {
+	return file.replaceAll("\\", "/").endsWith(ASSETS_STAMP);
+}
+/**
+* Starts the swaps of one module: its exports for the event, and nothing swapped yet.
+*
+* @param module - The exports of the saved module.
+* @returns The swaps, every list empty.
+* @example
+* ```ts
+* noSwaps({ GAP: 8 }).components; // []
+* ```
+*/
+function noSwaps(module) {
+	return {
+		module,
+		components: [],
+		projections: [],
+		animations: [],
+		emitters: [],
+		strings: [],
+		textStyles: []
+	};
+}
+/**
 * Files one export under the kind it is, in the order component, projection, animation, emitter,
 * strings, text styles. The `default` export of a strings file counts as strings.
 *
@@ -32041,15 +32874,7 @@ function sortExports(next, file) {
 	const exports = Object.entries(next);
 	if (exports.length === 0) return { reason: "no exports" };
 	const locale = localeOf(file);
-	const swaps = {
-		module: Object.fromEntries(exports),
-		components: [],
-		projections: [],
-		animations: [],
-		emitters: [],
-		strings: [],
-		textStyles: []
-	};
+	const swaps = noSwaps(Object.fromEntries(exports));
 	for (const entry of exports) {
 		const reason = fileExport(swaps, entry, locale);
 		if (reason !== void 0) return { reason };
@@ -32137,10 +32962,28 @@ function summaryOf(file, swaps) {
 	};
 }
 /**
+* Hands the stamp of the keys watch on: the event with the exports of the module, and the log
+* line the editor listens to, every list empty. Nothing is sorted, replaced or repainted: the
+* stamp names asset files, and `assets` hooks the event to replace them. A listener cannot refuse
+* by throwing, the bus catches what a hook throws, so `assets` reloads the page itself.
+*
+* @param ctx - Domain context of the ui plugin.
+* @param file - The path of the stamp module.
+* @param next - Its new module namespace.
+*/
+function forwardStamp(ctx, file, next) {
+	const swaps = noSwaps(Object.fromEntries(Object.entries(next)));
+	ctx.emit("ui:hot-swap", {
+		file,
+		module: swaps.module
+	});
+	ctx.log.info("ui:hot-swap", summaryOf(file, swaps));
+}
+/**
 * Builds the handler of one app: sort the exports, run the replaces that may throw, write the
 * components and the text styles, and repaint every view. The repaint runs for every module that
 * is not refused, so a module of styles only, whose bindings Bun already patched, shows on the
-* next frame too.
+* next frame too. The stamp of the keys watch is the one module that is only forwarded.
 *
 * @param ctx - Domain context of the ui plugin.
 * @param jsx - The jsx module, which owns the component registry and the roots.
@@ -32148,6 +32991,10 @@ function summaryOf(file, swaps) {
 */
 function createSwap(ctx, jsx) {
 	return (next, file) => {
+		if (isAssetsStamp(file) && hasMembers(next)) {
+			forwardStamp(ctx, file, next);
+			return;
+		}
 		const sorted = sortExports(next, file);
 		if ("reason" in sorted) refuse(ctx, file, sorted.reason);
 		replaceRefusable(ctx, file, sorted);