@moku-labs/game 0.13.1 → 0.13.3

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

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
 import { r as systemSource, t as memory } from "./memory-CWlqhS7l.mjs";
 import { a as finishDrafts, i as enableDraftPatches, n as deepFreeze, o as openDrafts, r as dropDrafts } from "./drafts-BawpSaVp.mjs";
-import { c as findNode, d as slotNames, f as compact, i as servePaused, l as framePath, n as captureFrame, o as collectFlows, p as pushEntry, r as serveCaptures, s as describeGraph, t as cancelCaptures, u as graphHash } from "./capture-fpd83Mi5.mjs";
+import { d as graphHash, f as isRestCheckpoint, h as pushEntry, i as servePaused, l as findNode, m as compact, n as captureFrame, o as collectFlows, p as slotNames, r as serveCaptures, s as describeGraph, t as cancelCaptures, u as framePath } from "./capture-D7XvoHdH.mjs";
 import { A as system, C as Exiting, D as component, E as Tree, T as Order, _ as Parent, a as visualOf$1, b as Transform, c as Text, g as NineSlice, h as Display, j as tag, k as resource, m as textFor, n as fitScaleOf, o as visualRectOf, p as readStyle, r as samePose, s as Countdown, t as CONTENT, u as builtInStyles, v as Shape, w as Layer, x as componentsFor, y as Sprite } from "./visual-dMW8iqAE.mjs";
 import { n as isDev } from "./dev-Cc50Dk7H.mjs";
 import { i as isComponentDefinition, n as flatten, r as defineComponent } from "./flatten-BkXuscAV.mjs";
@@ -1933,19 +1933,6 @@ function connectFlow(ctx) {
 	registerSchedule(flowCtx, fx);
 }
 //#endregion
-//#region src/plugins/flow/runner/loop-types.ts
-/** The stages of entering a node, in the order they run. */
-const stages = ["load", "scene"];
-/**
-* Does nothing. It stands in for an unsubscribe function until the real one arrives.
-*
-* @example
-* ```ts
-* const watch = { off: noop };
-* ```
-*/
-function noop() {}
-//#endregion
 //#region src/plugins/flow/runner/validate.ts
 /** Nodes of one flow above which `validate` warns. A flow holds 7 to 15 nodes. */
 const MAX_NODES = 15;
@@ -2400,6 +2387,16 @@ function collectGraph(ctx, features) {
 	return graph.flows;
 }
 /**
+* Renders the whole graph as JSON. It reads the flows as data, so it works before `run()`.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param features - Features API: owners and slot contributions.
+* @returns The graph.
+*/
+function graphOf(ctx, features) {
+	return describeGraph(collectGraph(ctx, features), features);
+}
+/**
 * Validates the collected graph. Warnings are logged, problems stop `run()` in one error.
 *
 * @param ctx - Domain context of the flow plugin.
@@ -2412,6 +2409,169 @@ function checkGraph(ctx, features) {
 	if (report.problems.length > 0) throw new Error(report.problems.join("\n"));
 }
 //#endregion
+//#region src/plugins/flow/runner/bookmark.ts
+/**
+* Reads the main flow of the config.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param method - Name of the API method that needs it, for the message.
+* @returns The top-level flow.
+* @throws {Error} When no main flow was configured.
+*/
+function mainFlow(ctx, method) {
+	const main = ctx.config.mainFlow;
+	if (main === void 0) throw new Error(`[game] flow.${method}() needs a main flow.\n  Pass it as pluginConfigs.flow.mainFlow.`);
+	return main;
+}
+/**
+* Names a checkpoint of the graph, for the message of a refused bookmark. Only a rest node is
+* one: a transit node that carries the flag is no place a restore may be sent to.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param modules - Injected sibling APIs.
+* @returns The path of the first rest checkpoint, or the start of the main flow.
+*/
+function someCheckpoint(ctx, modules) {
+	const main = mainFlow(ctx, "restore");
+	for (const flow of collectGraph(ctx, modules.features).values()) for (const [name, entry] of Object.entries(flow.nodes)) if (isRestCheckpoint(entry)) return flow.id === main.id ? name : `${flow.id}/${name}`;
+	return main.start;
+}
+/**
+* Looks up the node at a path. A sub-flow and a slot are no nodes: nothing runs at them.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param modules - Injected sibling APIs.
+* @param path - Path of a bookmark, or of its rest point.
+* @returns The node there, a rest node or a transit node, or `undefined` when the path names none.
+*/
+function nodeAt(ctx, modules, path) {
+	const entry = findNode(mainFlow(ctx, "restore"), path, modules.features.contributions)?.entry;
+	return entry?.kind === "node" ? entry : void 0;
+}
+/**
+* Finds the node a bookmark names.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param modules - Injected sibling APIs.
+* @param bookmark - The bookmark to enter.
+* @returns The node at the bookmark's path, a rest node or a transit node.
+* @throws {Error} When the path names no node of the graph.
+*/
+function bookmarkNode(ctx, modules, bookmark) {
+	const node = nodeAt(ctx, modules, bookmark.path);
+	if (node === void 0) throw new Error(`[game] The bookmark "${bookmark.path}" is not a node of the graph.\n  Restore a rest node, for example the checkpoint "${someCheckpoint(ctx, modules)}".`);
+	return node;
+}
+/**
+* Tells whether the graph is the one a bookmark was made for. The answer costs a description and
+* a hash of the whole graph, so one acceptance works it out once: see `askedOnce`.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param modules - Injected sibling APIs.
+* @param bookmark - The bookmark to compare with.
+* @returns True while the hash of `describe()` is the bookmark's.
+*/
+function sameGraph(ctx, modules, bookmark) {
+	return graphHash(graphOf(ctx, modules.features)) === bookmark.graph;
+}
+/**
+* Makes a question that is worked out at most once: at the first ask, and never when nobody asks.
+*
+* @param ask - Works the answer out.
+* @returns The question. Every ask after the first gets the first answer.
+* @example
+* ```ts
+* const same = askedOnce(() => true);
+* same() && same(); // true, and the answer was worked out once
+* ```
+*/
+function askedOnce(ask) {
+	const answer = { value: void 0 };
+	return () => {
+		answer.value ??= ask();
+		return answer.value;
+	};
+}
+/**
+* Checks that a bookmark may be entered: a rest checkpoint always, any other node only while the
+* graph is the one the bookmark was made for. A transit node is never taken for a checkpoint,
+* whatever its flag says: it is a place inside a transition, not a place a save may stand on.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param modules - Injected sibling APIs.
+* @param bookmark - The bookmark to enter.
+* @param unchanged - Asks whether the graph is the bookmark's own. Not asked for a checkpoint.
+* @returns The node the bookmark names.
+* @throws {Error} When the path is no node, or the graph changed since the bookmark.
+*/
+function checkBookmark(ctx, modules, bookmark, unchanged) {
+	const node = bookmarkNode(ctx, modules, bookmark);
+	if (isRestCheckpoint(node)) return node;
+	if (unchanged()) return node;
+	throw new Error(`[game] The bookmark "${bookmark.path}" was made for another graph.\n  Restore the checkpoint "${someCheckpoint(ctx, modules)}" instead.`);
+}
+/**
+* Builds the bookmark of the rest point before a transit node, for a bookmark that carries `rest`
+* and was made for another graph. That is one whose path names a transit node while the hash
+* differs, and one whose path names no node any more: a renamed or removed node is a changed
+* graph too. Only the position changes: the state stays the bookmark's.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param modules - Injected sibling APIs.
+* @param bookmark - The bookmark to enter.
+* @param unchanged - Asks whether the graph is the bookmark's own. Asked for a transit node only.
+* @returns The bookmark to enter instead, or `undefined` when the bookmark stands for itself.
+*/
+function restFallback(ctx, modules, bookmark, unchanged) {
+	const rest = bookmark.rest;
+	if (rest === void 0) return void 0;
+	const node = nodeAt(ctx, modules, bookmark.path);
+	if (node !== void 0 && (node.rest || unchanged())) return void 0;
+	return {
+		...bookmark,
+		path: rest.path,
+		input: rest.input
+	};
+}
+/**
+* Decides what the loop enters for a bookmark: the bookmark itself, or the rest point before it
+* when the graph changed under a bookmark that has one. Either one passes the same check, so the
+* fallback is entered only when it is a checkpoint, and the log says that it was taken.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param modules - Injected sibling APIs.
+* @param bookmark - The bookmark to enter.
+* @returns The bookmark the loop enters, and whether its node is a rest node.
+* @throws {Error} When neither the bookmark nor its rest point may be entered.
+*/
+function acceptBookmark(ctx, modules, bookmark) {
+	const unchanged = askedOnce(() => sameGraph(ctx, modules, bookmark));
+	const fallback = restFallback(ctx, modules, bookmark, unchanged);
+	const entered = fallback ?? bookmark;
+	const node = checkBookmark(ctx, modules, entered, unchanged);
+	if (fallback !== void 0) ctx.log.info("flow:restore-fell-back", {
+		from: bookmark.path,
+		to: fallback.path
+	});
+	return {
+		bookmark: entered,
+		rest: node.rest
+	};
+}
+//#endregion
+//#region src/plugins/flow/runner/loop-types.ts
+/** The stages of entering a node, in the order they run. */
+const stages = ["load", "scene"];
+/**
+* Does nothing. It stands in for an unsubscribe function until the real one arrives.
+*
+* @example
+* ```ts
+* const watch = { off: noop };
+* ```
+*/
+function noop() {}
+//#endregion
 //#region src/plugins/flow/runner/position.ts
 /**
 * Resolves what the deepest frame points at.
@@ -3075,8 +3235,27 @@ function guideAllow(payload) {
 	};
 }
 /**
+* Refuses an effect a body starts after its node was aborted. The rejection counts as handled
+* from the start: a body that does not await the effect leaves no unhandled rejection behind,
+* and a body that awaits it still gets the reason.
+*
+* @param signal - The aborted signal of the node.
+* @returns A promise rejected with the abort reason.
+* @example
+* ```ts
+* refuseEffect(AbortSignal.abort("restore")); // a promise rejected with "restore"
+* ```
+*/
+function refuseEffect(signal) {
+	const refused = Promise.reject(abortReason(signal));
+	refused.catch(noop);
+	return refused;
+}
+/**
 * Builds the `fx` of a node context: awaited effects by call, cosmetic hints by `emit`. A `guide`
-* narrows the gate while it runs; the runner lifts the narrow when the node is left.
+* narrows the gate while it runs; the runner lifts the narrow when the node is left. A body that
+* was aborted keeps running, since the loop only stops waiting for it, so its `fx` starts nothing
+* any more: the gate and the narrow belong to the node the loop entered after it.
 *
 * @param modules - Injected sibling APIs.
 * @param step - The node run in progress.
@@ -3084,12 +3263,13 @@ function guideAllow(payload) {
 */
 function nodeFx(modules, step) {
 	/**
-	* Awaits one effect.
+	* Awaits one effect. After the abort of the node it rejects with the abort reason instead.
 	*
 	* @param descriptor - The descriptor the node awaits.
 	* @returns The answer, the handler's value, or `undefined`.
 	*/
 	const run = (descriptor) => {
+		if (step.signal.aborted) return refuseEffect(step.signal);
 		if (descriptor.kind === "guide") {
 			const allow = guideAllow(descriptor.payload);
 			if (allow !== void 0) modules.gate.narrow(allow);
@@ -3599,19 +3779,23 @@ function enterSlot(ctx, modules, location, slot, safe) {
 	return "continue";
 }
 /**
-* Enters the node of a bookmark: the state is replaced, the rest point is marked and the position
-* becomes the bookmark's path.
+* Enters the node of a bookmark, a rest node or a transit node: the state is replaced, the rest
+* point is marked and the position becomes the bookmark's path. The mark is made for a transit
+* node too. A restore leaves the whole document waiting for the provider, and a rollback of the
+* node would drop it unsent; and the frames of the transit node are what a failure of it must
+* retry, since the restored state belongs to them. `flow:rest` and the rest seam fire once for
+* every node entered here; only a rest node is announced as a checkpoint.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param modules - Injected sibling APIs; the features API resolves a path through a slot.
 * @param bookmark - The bookmark to enter.
 * @throws {Error} When the graph has no node at the bookmark's path.
 */
-function enterBookmark$1(ctx, modules, bookmark) {
+function enterBookmark(ctx, modules, bookmark) {
 	const state = ctx.state.runner;
 	const location = findNode(requireMainFlow(ctx), bookmark.path, modules.features.contributions);
 	loopSeam(state).restoring = void 0;
-	if (location === void 0) throw new Error(`[game] The bookmark names no node "${bookmark.path}".\n  Bookmark a rest node of the running graph.`);
+	if (location === void 0) throw new Error(`[game] The bookmark names no node "${bookmark.path}".\n  Bookmark a node of the running graph.`);
 	ctx.deps.model.store.restore({
 		player: bookmark.player,
 		session: bookmark.session,
@@ -3622,10 +3806,9 @@ function enterBookmark$1(ctx, modules, bookmark) {
 	state.slotAfter = void 0;
 	state.restFrame = [...state.stack];
 	state.failures = 0;
-	const entry = location.entry;
 	ctx.emit("flow:rest", {
 		path: bookmark.path,
-		checkpoint: entry.kind === "node" && entry.checkpoint
+		checkpoint: isRestCheckpoint(location.entry)
 	});
 	notifyRest(state, bookmark.path);
 }
@@ -3643,7 +3826,7 @@ async function advance(ctx, modules, safe) {
 	if (stopped(state)) return "stop";
 	const restoring = state.seam?.restoring;
 	if (restoring !== void 0) {
-		enterBookmark$1(ctx, modules, restoring);
+		enterBookmark(ctx, modules, restoring);
 		return "continue";
 	}
 	const location = locateFrames(ctx, state.stack);
@@ -3685,12 +3868,15 @@ async function runLoop(ctx, modules) {
 }
 /**
 * Restores a bookmark through the running loop: the active node is aborted with reason
-* `"restore"`, its transaction is discarded, the state is replaced and the node is entered.
+* `"restore"`, its transaction is discarded, the state is replaced and the node is entered. An
+* edge that was already committed still arrives first, and the rest point it reaches is not the
+* bookmark's: the promise waits for the turn in which the loop takes the bookmark.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param _modules - Injected sibling APIs.
 * @param bookmark - The bookmark to enter.
-* @returns A promise that resolves once the loop rests at the bookmark's node.
+* @returns A promise that resolves once the loop entered the bookmark's node, before that node
+*   ran: the rest seam fired.
 * @throws {Error} When the loop is not running.
 */
 function restorePosition(ctx, _modules, bookmark) {
@@ -3702,6 +3888,7 @@ function restorePosition(ctx, _modules, bookmark) {
 		* Resolves once, when the loop rests at the restored node.
 		*/
 		const listener = () => {
+			if (seam.restoring !== void 0) return;
 			const index = seam.rest.indexOf(listener);
 			if (index !== -1) seam.rest.splice(index, 1);
 			resolve();
@@ -3722,7 +3909,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 +3950,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;
@@ -3871,24 +4058,37 @@ function watchEnd(running) {
 	return end;
 }
 /**
-* Waits for the next gate the loop opens. The listener takes itself off when it fires, so a walk
-* that ended meanwhile leaves nothing behind.
+* Watches for the next gate the loop opens. The listener leaves the seam when a gate wakes it. A
+* wait that something else ended calls `off()`: the gate that would take the listener off may
+* never come.
 *
 * @param seam - The seam of the running loop.
-* @returns A promise that resolves when the loop opens a gate.
+* @returns The promise of the next open gate, and the way to stop watching.
 */
 function nextGateOpen(seam) {
-	return new Promise((resolve) => {
-		/**
-		* Wakes the walk once the loop opened the gate.
-		*/
-		const listener = () => {
-			const index = seam.gateOpen.indexOf(listener);
-			if (index !== -1) seam.gateOpen.splice(index, 1);
-			resolve();
-		};
-		seam.gateOpen.push(listener);
+	const watch = { wake: void 0 };
+	/**
+	* Takes the listener off the seam. It may be gone already.
+	*/
+	const off = () => {
+		const index = seam.gateOpen.indexOf(listener);
+		if (index !== -1) seam.gateOpen.splice(index, 1);
+	};
+	/**
+	* Wakes the waiting side once the loop opened a gate, and leaves.
+	*/
+	function listener() {
+		off();
+		watch.wake?.();
+	}
+	const promise = new Promise((resolve) => {
+		watch.wake = resolve;
 	});
+	seam.gateOpen.push(listener);
+	return {
+		promise,
+		off
+	};
 }
 /**
 * Waits until the loop opens its gate. Between the edge it commits and the gate of the rest node
@@ -3902,7 +4102,40 @@ function nextGateOpen(seam) {
 async function reachGate(ctx, seam, ended) {
 	if (ctx.state.gate.open !== void 0) return;
 	if (ended.done) return;
-	await Promise.race([nextGateOpen(seam), ended.settled]);
+	const opened = nextGateOpen(seam);
+	try {
+		await Promise.race([opened.promise, ended.settled]);
+	} finally {
+		opened.off();
+	}
+}
+/**
+* Waits until a transit node the loop was sent into shows what it waits for: the gate it opens,
+* or, when it opens none, the next rest point or the end of the loop. `restore` waits here after
+* it entered a transit bookmark, so its caller reads a state with the open gate in it. There is no
+* timeout: a node that opens no gate, never rests and never ends keeps the wait pending, as its
+* body would. Call it only after the loop entered the node: a gate opened before that belongs to
+* the node the restore aborted.
+*
+* @param ctx - Domain context of the flow plugin.
+* @returns A promise that resolves at the open gate, at a rest point or at the end of the loop.
+*/
+async function reachGateOrRest(ctx) {
+	const running = ctx.state.runner.running;
+	if (running === void 0 || ctx.state.gate.open !== void 0) return;
+	const seam = loopSeam(ctx.state.runner);
+	const opened = nextGateOpen(seam);
+	const rested = watchRest(seam);
+	try {
+		await Promise.race([
+			opened.promise,
+			rested.next(),
+			watchEnd(running).settled
+		]);
+	} finally {
+		opened.off();
+		rested.off();
+	}
 }
 /**
 * The error of a step the loop never reached, naming where it stands instead.
@@ -4020,14 +4253,17 @@ async function playRoute(ctx, modules, route, running) {
 /**
 * Walks a route through the running loop: restores `from` when given, switches to fast mode,
 * waits until the loop rests at each step's `at` and answers through the gate, and substitutes
-* the result of every sub-flow node the route skips. The mode of the caller is put back
-* afterwards, also when a step rejects, and a substitution the route never reached is disarmed:
-* it must not skip a sub-flow in the live play that follows.
+* the result of every sub-flow node the route skips. A rest node `from` names is entered before
+* the switch: the stages of that node see the mode of the caller. A transit node is entered
+* after the switch, so it never starts live and never shows its popup. The mode of the caller
+* is put back afterwards, also when the bookmark is refused or a step rejects, and a
+* substitution the route never reached is disarmed: it must not skip a sub-flow in the live play
+* that follows.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param modules - Injected sibling APIs: features, fx, gate, inbox.
 * @param route - The player's answers and substituted results, in order.
-* @param start - Bookmark to enter first and the checked restore that enters it.
+* @param start - Bookmark to enter first, the restore that enters it and the kind of its node.
 * @returns The state the walk ended in.
 * @throws {Error} Before `run()` was called, when the bookmark is refused, and when a step's `at`
 *   is never reached.
@@ -4035,10 +4271,13 @@ async function playRoute(ctx, modules, route, running) {
 async function walkRoute(ctx, modules, route, start) {
 	const running = ctx.state.runner.running;
 	if (running === void 0) throw new Error("[game] flow.walk() needs a running graph.\n  Call flow.run() from the createApp onStart callback first.");
-	if (start !== void 0) await start.restore(start.from);
+	const entersBeforeSwitch = start !== void 0 && !start.transit;
+	const entersAfterSwitch = start !== void 0 && !entersBeforeSwitch;
+	if (entersBeforeSwitch) await start.restore(start.from);
 	const previous = ctx.state.fx.mode;
 	modules.fx.setMode("fast");
 	try {
+		if (entersAfterSwitch) await start.restore(start.from);
 		await playRoute(ctx, modules, route, running);
 	} finally {
 		loopSeam(ctx.state.runner).substitutions.clear();
@@ -4050,69 +4289,71 @@ async function walkRoute(ctx, modules, route, start) {
 //#region src/plugins/flow/runner/api.ts
 const noPayload = null;
 /**
-* Reads the main flow of the config.
+* Tells whether a frame points at a rest node.
 *
 * @param ctx - Domain context of the flow plugin.
-* @param method - Name of the API method that needs it, for the message.
-* @returns The top-level flow.
-* @throws {Error} When no main flow was configured.
+* @param frame - One level of a position.
+* @returns True when the entry of that frame is a node with `rest`.
 */
-function mainFlow(ctx, method) {
-	const main = ctx.config.mainFlow;
-	if (main === void 0) throw new Error(`[game] flow.${method}() needs a main flow.\n  Pass it as pluginConfigs.flow.mainFlow.`);
-	return main;
+function restsAt(ctx, frame) {
+	const entry = ctx.state.runner.flows.get(frame.flow)?.nodes[frame.node];
+	return entry !== void 0 && entry.kind === "node" && entry.rest;
 }
 /**
-* Renders the whole graph as JSON. It reads the flows as data, so it works before `run()`.
+* Tells whether the graph stands on a rest node. `setMode` is legal there and before `run()`.
 *
 * @param ctx - Domain context of the flow plugin.
-* @param modules - Injected sibling APIs.
-* @returns The graph.
+* @returns True while the position is empty or points at a rest node.
 */
-function graphOf(ctx, modules) {
-	return describeGraph(collectGraph(ctx, modules.features), modules.features);
+function resting(ctx) {
+	const frame = ctx.state.runner.stack.at(-1);
+	return frame === void 0 || restsAt(ctx, frame);
 }
 /**
-* Names a checkpoint of the graph, for the message of a refused bookmark.
+* Tells whether a transit node waits at the gate: an effect that takes answers is open inside
+* it. A rest node with its own gate open rests, so it does not count.
 *
 * @param ctx - Domain context of the flow plugin.
-* @param modules - Injected sibling APIs.
-* @returns The path of the first checkpoint, or the start of the main flow.
+* @returns True while the gate is open and the position is no rest node.
 */
-function someCheckpoint(ctx, modules) {
-	const main = mainFlow(ctx, "restore");
-	for (const flow of collectGraph(ctx, modules.features).values()) for (const [name, entry] of Object.entries(flow.nodes)) if (entry.kind === "node" && entry.checkpoint) return flow.id === main.id ? name : `${flow.id}/${name}`;
-	return main.start;
+function waitsInTransit(ctx) {
+	return ctx.state.gate.open !== void 0 && !resting(ctx);
 }
 /**
-* Checks that a bookmark may be entered: a checkpoint always, any other rest node only while the
-* graph is the one the bookmark was made for.
+* Reads the rest point before the transit node the graph stands in. The rest frame names a
+* transit node when the graph started at one or a restore entered one: no rest point came
+* before it then.
 *
 * @param ctx - Domain context of the flow plugin.
-* @param modules - Injected sibling APIs.
-* @param bookmark - The bookmark to enter.
-* @throws {Error} When the path is no rest node, or the graph changed since the bookmark.
+* @returns The last rest node and its input, or `undefined` when the rest frame names none.
 */
-function checkBookmark(ctx, modules, bookmark) {
-	const entry = findNode(mainFlow(ctx, "restore"), bookmark.path, modules.features.contributions)?.entry;
-	if (entry === void 0 || entry.kind !== "node" || !entry.rest) throw new Error(`[game] The bookmark "${bookmark.path}" is not a rest node of the graph.\n  Restore a rest node, for example the checkpoint "${someCheckpoint(ctx, modules)}".`);
-	if (entry.checkpoint) return;
-	if (graphHash(graphOf(ctx, modules)) === bookmark.graph) return;
-	throw new Error(`[game] The bookmark "${bookmark.path}" was made for another graph.\n  Restore the checkpoint "${someCheckpoint(ctx, modules)}" instead.`);
+function restBefore(ctx) {
+	const frames = ctx.state.runner.restFrame ?? [];
+	const frame = frames.at(-1);
+	if (frame === void 0 || !restsAt(ctx, frame)) return void 0;
+	return {
+		path: framePath(frames),
+		input: frame.input
+	};
 }
 /**
-* Makes a bookmark of the rest point the graph stands on.
+* Makes a bookmark of where the graph stands. While a transit node waits at the gate for the
+* answer of an effect it is that node, with the rest point before it; in every other moment it is
+* the last rest point. The state is the committed one in both cases: for a waiting transit node
+* that is the state it was entered with, since its own writes are still in the open transaction.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param modules - Injected sibling APIs.
-* @returns A rest node plus a state that really existed there.
+* @returns A node plus a state that really existed there.
 * @throws {Error} When the graph has no position yet.
 */
 function makeBookmark(ctx, modules) {
 	const state = ctx.state.runner;
-	const frames = state.restFrame ?? state.stack;
+	const waiting = waitsInTransit(ctx);
+	const frames = waiting ? state.stack : state.restFrame ?? state.stack;
 	if (frames.length === 0) throw new Error("[game] flow.bookmark() needs a position.\n  Call it while the graph rests at a node.");
 	const snapshot = ctx.deps.model.store.snapshot();
+	const rest = waiting ? restBefore(ctx) : void 0;
 	return {
 		path: framePath(frames),
 		input: frames.at(-1)?.input ?? noPayload,
@@ -4122,35 +4363,68 @@ function makeBookmark(ctx, modules) {
 			seed: snapshot.rng.seed,
 			streams: { ...snapshot.rng.streams }
 		},
-		graph: graphHash(graphOf(ctx, modules))
+		graph: graphHash(graphOf(ctx, modules.features)),
+		...rest === void 0 ? {} : { rest }
 	};
 }
 /**
-* Enters a bookmark the way the plugin's `restore` does: the bookmark is checked first, then the
-* running loop is sent to its node. `walk({ from })` enters through here as well, so both ways
-* into a position refuse the same bookmarks.
+* Sends the running loop to a bookmark that passed the check, the short way a walk needs: the
+* promise resolves as soon as the loop stands at the node, before the node ran. It stays an
+* `async` function of its own: the microtask turn it adds lets the loop start the stages of a
+* rest node before the walk goes on and switches to fast mode.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param modules - Injected sibling APIs.
-* @param bookmark - The bookmark to enter.
-* @returns A promise that resolves once the loop rests at the bookmark's node.
-* @throws {Error} When the bookmark names no rest node of this graph.
+* @param bookmark - The accepted bookmark.
+* @returns A promise that resolves once the loop entered the node.
 */
-async function enterBookmark(ctx, modules, bookmark) {
-	checkBookmark(ctx, modules, bookmark);
+async function enterAccepted(ctx, modules, bookmark) {
 	await restorePosition(ctx, modules, bookmark);
 }
 /**
-* Tells whether the graph stands on a rest node. `setMode` is legal there and before `run()`.
+* Walks a route from a bookmark. The bookmark passes the check `restore` runs, so both ways into
+* a position refuse the same bookmarks and take the same fallback. The walk is told which kind of
+* node it enters: a rest node is entered before the switch to fast mode, a transit node after it.
 *
 * @param ctx - Domain context of the flow plugin.
-* @returns True while the position is empty or points at a rest node.
+* @param modules - Injected sibling APIs.
+* @param route - The player's answers and substituted results, in order.
+* @param from - The bookmark to enter first.
+* @returns The state the walk ended in.
+* @throws {Error} When the bookmark may not be entered, and when a step's `at` is never reached.
 */
-function resting(ctx) {
-	const frame = ctx.state.runner.stack.at(-1);
-	if (frame === void 0) return true;
-	const entry = ctx.state.runner.flows.get(frame.flow)?.nodes[frame.node];
-	return entry !== void 0 && entry.kind === "node" && entry.rest;
+async function walkFrom(ctx, modules, route, from) {
+	const accepted = acceptBookmark(ctx, modules, from);
+	return walkRoute(ctx, modules, route, {
+		/**
+		* Enters the accepted bookmark. The walk never waits for a gate here: it answers the gates
+		* of its own route.
+		*
+		* @param bookmark - The bookmark to enter.
+		* @returns A promise that resolves once the loop entered its node.
+		*/
+		restore: (bookmark) => enterAccepted(ctx, modules, bookmark),
+		from: accepted.bookmark,
+		transit: !accepted.rest
+	});
+}
+/**
+* Restores a bookmark, the way the plugin's `restore` does. A rest node is entered as `walk`
+* enters it. A transit node shows nothing until it ran up to its gate, so for one the promise
+* waits on: for the gate the node opens, or the rest point or the end of the loop it reaches
+* without one. The wait starts only after the loop entered the node, so a gate the aborted old
+* node still opened is not taken for the new one.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param modules - Injected sibling APIs.
+* @param bookmark - The bookmark to enter.
+* @returns A promise that resolves once a rest node is entered, or a transit node waits.
+* @throws {Error} When the bookmark may not be entered, and before `run()`.
+*/
+async function restoreBookmark(ctx, modules, bookmark) {
+	const accepted = acceptBookmark(ctx, modules, bookmark);
+	await restorePosition(ctx, modules, accepted.bookmark);
+	if (!accepted.rest) await reachGateOrRest(ctx);
 }
 /**
 * Creates the runner API: `run` owns the one loop, `walk` and `restore` enter a position through
@@ -4179,21 +4453,12 @@ function createRunnerApi(ctx, modules) {
 		},
 		walk: (route, options) => {
 			const from = options?.from;
-			if (from === void 0) return walkRoute(ctx, modules, route);
-			return walkRoute(ctx, modules, route, {
-				/**
-				* Enters the bookmark the walk starts from, checked the way `restore` checks it.
-				*
-				* @param bookmark - The bookmark to enter.
-				* @returns A promise that resolves once the loop rests at its node.
-				*/
-				restore: (bookmark) => enterBookmark(ctx, modules, bookmark),
-				from
-			});
+			if (from === void 0 || state.running === void 0) return walkRoute(ctx, modules, route);
+			return walkFrom(ctx, modules, route, from);
 		},
 		bookmark: () => makeBookmark(ctx, modules),
-		restore: (bookmark) => enterBookmark(ctx, modules, bookmark),
-		describe: () => graphOf(ctx, modules),
+		restore: (bookmark) => restoreBookmark(ctx, modules, bookmark),
+		describe: () => graphOf(ctx, modules.features),
 		state: () => readState(ctx),
 		history: () => [...state.journal],
 		setMode: (mode) => {
@@ -4521,7 +4786,7 @@ const flowPlugin = /*#__PURE__*/ createPlugin$1("flow", {
 	},
 	events: (register) => register.map({
 		"flow:edge": "An edge was taken and its state committed",
-		"flow:rest": "The graph reached a rest node",
+		"flow:rest": "The graph reached a rest node, or entered the node of a bookmark",
 		"flow:error": "A node failed and the graph rolled back"
 	}),
 	createState: createFlowState,
@@ -8269,7 +8534,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 +8558,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 +8826,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 +8864,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 +9202,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 +10472,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 +10482,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 +12112,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 +14902,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 +15202,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 +15258,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 +15414,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 +15517,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 +15600,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 +16652,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
@@ -16406,102 +16734,617 @@ function unload(ctx, bundle) {
 		});
 		return;
 	}
-	if (isPermanent(entry.tier)) {
-		ctx.log.warn(REFUSED, {
-			bundle,
-			reason: "tier"
-		});
+	if (isPermanent(entry.tier)) {
+		ctx.log.warn(REFUSED, {
+			bundle,
+			reason: "tier"
+		});
+		return;
+	}
+	state.records.get(bundle)?.inflight?.controller.abort();
+	unloadBundle(ctx, bundle, "request");
+}
+/**
+* Tells whether a bundle is there. Headless every bundle of the manifest counts as loaded.
+*
+* @param ctx - Domain context of the plugin.
+* @param bundle - Name of the bundle.
+* @returns True when the bundle is loaded.
+*/
+function isLoaded(ctx, bundle) {
+	const state = ctx.state;
+	if (state.io === void 0) return state.manifest.bundles[bundle] !== void 0;
+	return state.records.get(bundle)?.status === "loaded";
+}
+/**
+* Reports what the loaded bundles cost.
+*
+* @param ctx - Domain context of the plugin.
+* @returns The used and allowed megabytes and one entry per loaded bundle, sorted by name.
+*/
+function usage(ctx) {
+	const bundles = [];
+	for (const [name, record] of ctx.state.records) {
+		const entry = ctx.state.manifest.bundles[name];
+		if (record.status !== "loaded" || entry === void 0) continue;
+		bundles.push({
+			name,
+			tier: entry.tier,
+			mb: entry.mb,
+			lastUsed: record.lastUsed
+		});
+	}
+	bundles.sort((left, right) => left.name.localeCompare(right.name));
+	return {
+		textureMb: usedMb(ctx.state),
+		budgetMb: ctx.config.textureBudgetMb,
+		bundles
+	};
+}
+/**
+* Creates the assets API: `app.assets`.
+*
+* @param ctx - Kernel context of the assets plugin.
+* @returns The plugin API.
+*/
+function createAssetsApi(ctx) {
+	const assets = withDeps$6(ctx);
+	return {
+		load: (bundle) => loadBundle(assets, bundle, void 0, "request"),
+		unload: (bundle) => unload(assets, bundle),
+		isLoaded: (bundle) => isLoaded(assets, bundle),
+		texture: (key) => lookupTexture(assets, key),
+		font: (key) => loadedRecord(assets, key)?.fonts.get(key),
+		audio: (key) => loadedRecord(assets, key)?.audio.get(key),
+		usage: () => usage(assets)
+	};
+}
+//#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;
 	}
-	state.records.get(bundle)?.inflight?.controller.abort();
-	unloadBundle(ctx, bundle, "request");
+	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));
 }
 /**
-* Tells whether a bundle is there. Headless every bundle of the manifest counts as loaded.
+* 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 bundle - Name of the bundle.
-* @returns True when the bundle is loaded.
+* @param batch - The bundle and its replaced files.
+* @param record - The record of the bundle.
 */
-function isLoaded(ctx, bundle) {
-	const state = ctx.state;
-	if (state.io === void 0) return state.manifest.bundles[bundle] !== void 0;
-	return state.records.get(bundle)?.status === "loaded";
+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
+	});
 }
 /**
-* Reports what the loaded bundles cost.
+* 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 ctx - Domain context of the plugin.
-* @returns The used and allowed megabytes and one entry per loaded bundle, sorted by name.
+* @param swap - The running swap.
+* @param failures - The files that could not be read.
+* @param sizes - Every new texture of the bundle.
 */
-function usage(ctx) {
-	const bundles = [];
-	for (const [name, record] of ctx.state.records) {
-		const entry = ctx.state.manifest.bundles[name];
-		if (record.status !== "loaded" || entry === void 0) continue;
-		bundles.push({
-			name,
-			tier: entry.tier,
-			mb: entry.mb,
-			lastUsed: record.lastUsed
-		});
+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;
 	}
-	bundles.sort((left, right) => left.name.localeCompare(right.name));
-	return {
-		textureMb: usedMb(ctx.state),
-		budgetMb: ctx.config.textureBudgetMb,
-		bundles
-	};
+	for (const loaded of fresh) store(io, record, loaded, sizes);
+	publish(ctx, batch, record);
 }
 /**
-* Creates the assets API: `app.assets`.
+* 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 ctx - Kernel context of the assets plugin.
-* @returns The plugin API.
+* @param swap - The running swap.
+* @param batches - The changed files, by bundle.
 */
-function createAssetsApi(ctx) {
-	const assets = withDeps$6(ctx);
-	return {
-		load: (bundle) => loadBundle(assets, bundle, void 0, "request"),
-		unload: (bundle) => unload(assets, bundle),
-		isLoaded: (bundle) => isLoaded(assets, bundle),
-		texture: (key) => lookupTexture(assets, key),
-		font: (key) => loadedRecord(assets, key)?.fonts.get(key),
-		audio: (key) => loadedRecord(assets, key)?.audio.get(key),
-		usage: () => usage(assets)
+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 +17393,9 @@ function createAssetsState() {
 		current: void 0,
 		useCounter: 0,
 		warned: emptySet$2(),
-		removers: []
+		removers: [],
+		stamps: void 0,
+		swapping: void 0
 	};
 }
 /**
@@ -16584,7 +17429,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,
@@ -16655,8 +17501,32 @@ async function untilAborted(ctx, bundle, signal) {
 	if (load.failed && !signal.aborted) throw load.error;
 }
 /**
+* Takes the expected scene and clears the record, so one `expect` mounts one scene.
+*
+* @param ctx - Domain context of the plugin.
+* @returns The scene id that was recorded or expected, or `undefined` when there was none.
+*/
+function takePending(ctx) {
+	const target = ctx.state.pending;
+	ctx.state.pending = void 0;
+	return target;
+}
+/**
+* Tells whether the node is a transit node of a fast walk: the walk passes through it and builds
+* no scene there.
+*
+* @param node - The node being entered.
+* @param run - The runner's mode and signal.
+* @returns True for a node without `rest` entered in fast mode.
+*/
+function isFastTransit(node, run) {
+	return run.mode === "fast" && !node.rest;
+}
+/**
 * Reads the scene the node asks for. In fast mode a transit node only records it: the walk passes
-* through many of them and the picture is built once, at the rest point.
+* through many of them and the picture is built once, at the rest point. In live mode a transit
+* node without a scene of its own takes the expected one, so a restore at a popup that waits for
+* its answer builds the scene under it; one with its own scene leaves the record alone.
 *
 * @param ctx - Domain context of the plugin.
 * @param node - The node being entered.
@@ -16665,32 +17535,33 @@ async function untilAborted(ctx, bundle, signal) {
 */
 function targetOf(ctx, node, run) {
 	const state = ctx.state;
-	if (run.mode === "fast" && !node.rest) {
-		if (node.scene !== void 0) state.pending = node.scene;
+	if (isFastTransit(node, run)) {
+		state.pending = node.scene ?? state.pending;
 		return;
 	}
-	if (!node.rest) return node.scene;
+	if (!node.rest) return node.scene ?? takePending(ctx);
 	const target = node.scene ?? state.pending;
 	state.pending = void 0;
 	if (target === void 0 && state.current === void 0) ctx.log.warn("scenes: a rest node was entered with no scene", { path: node.path });
 	return target;
 }
 /**
-* Reads the scene an `over` node asks for. An over node never switches a mounted scene; a rest
-* one takes the expected scene while nothing is mounted, so a restore at a popup builds the scene
-* under it. A scene the over node names itself is only warned about.
+* Reads the scene an `over` node asks for. An over node never switches a mounted scene; it takes
+* the expected scene while nothing is mounted, so a restore at a popup builds the scene under it,
+* whether the popup rests or waits for its answer. In fast mode an over transit node takes
+* nothing and leaves the record alone: a walk builds no scene on the way. A scene the over node
+* names itself is only warned about.
 *
 * @param ctx - Domain context of the plugin.
 * @param node - The over node being entered.
+* @param run - The runner's mode and signal.
 * @returns The expected scene id, or `undefined` when nothing has to happen.
 */
-function overTargetOf(ctx, node) {
-	const state = ctx.state;
+function overTargetOf(ctx, node, run) {
 	if (node.scene !== void 0) ctx.log.warn("scenes: an over node cannot name a scene", { path: node.path });
-	if (!node.rest || state.current !== void 0) return void 0;
-	const target = state.pending;
-	state.pending = void 0;
-	return target;
+	if (isFastTransit(node, run)) return void 0;
+	if (ctx.state.current !== void 0) return void 0;
+	return takePending(ctx);
 }
 /**
 * Builds the scene in one synchronous block: the layers, then the projections of the old scene
@@ -16736,7 +17607,7 @@ function apply(ctx, scene) {
 * ```
 */
 async function enterScene(ctx, node, run) {
-	const target = node.over ? overTargetOf(ctx, node) : targetOf(ctx, node, run);
+	const target = node.over ? overTargetOf(ctx, node, run) : targetOf(ctx, node, run);
 	if (target === void 0 || target === ctx.state.current) return;
 	const scene = ctx.state.scenes.get(target);
 	if (scene === void 0) throw new Error(`[game] Scene "${target}" is not registered.\n  List it in the scenes of a feature.`);
@@ -17868,9 +18739,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 +18792,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 +18870,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,11 +21584,25 @@ 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
 * warns `effects:hot-unknown-emitter`: a new emitter needs a feature, so a reload.
@@ -20736,9 +21640,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 +25912,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 +26218,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 +26256,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 +26336,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 +26401,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 +26442,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 +26456,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 +26471,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 +26753,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 +26762,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 +26877,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 +26908,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 +26942,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 +27153,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 +27198,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 +27214,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 +27265,7 @@ function createTextState$1() {
 		cache: emptyMap$2(),
 		drawn: emptyWeakMap(),
 		dirty: emptySet$1(),
+		generation: 0,
 		warned: emptySet$1(),
 		removers: []
 	};
@@ -31844,6 +32930,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 +33090,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 +33164,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 +33252,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 +33281,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);