@moku-labs/game 0.13.2 → 0.14.0

package/dist/{src-CltFFKtc.mjs → src-Dgmdzl8R.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,28 +3868,55 @@ 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. A loop that
+* ends before that turn ends the wait too, after a stop or a fatal error. Nothing is entered
+* then, and the bookmark is dropped: the seam outlives the loop, and the next `run()` would enter
+* a bookmark nobody waits for.
 *
 * @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. It also resolves when the loop ended first, with nothing entered.
 * @throws {Error} When the loop is not running.
 */
 function restorePosition(ctx, _modules, bookmark) {
 	const state = ctx.state.runner;
-	if (state.running === void 0) throw new Error("[game] flow.restore() needs a running graph.\n  Call flow.run() from the createApp onStart callback first.");
+	const running = state.running;
+	if (running === void 0) throw new Error("[game] flow.restore() needs a running graph.\n  Call flow.run() from the createApp onStart callback first.");
 	const seam = loopSeam(state);
 	const entered = new Promise((resolve) => {
+		/**
+		* Takes the listener off the rest seam.
+		*
+		* @returns True when it was still there, false when it had already left.
+		*/
+		const dropListener = () => {
+			const index = seam.rest.indexOf(listener);
+			if (index === -1) return false;
+			seam.rest.splice(index, 1);
+			return true;
+		};
 		/**
 		* Resolves once, when the loop rests at the restored node.
 		*/
 		const listener = () => {
-			const index = seam.rest.indexOf(listener);
-			if (index !== -1) seam.rest.splice(index, 1);
+			if (seam.restoring !== void 0) return;
+			dropListener();
+			resolve();
+		};
+		/**
+		* Ends the wait when the loop ended, resolved or rejected, before it took the bookmark.
+		*/
+		const finish = () => {
+			if (!dropListener()) return;
+			if (seam.restoring === bookmark) seam.restoring = void 0;
 			resolve();
 		};
 		seam.rest.push(listener);
+		running.then(finish, finish);
 	});
 	seam.restoring = bookmark;
 	state.abort?.abort("restore");
@@ -3871,24 +4081,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 +4125,41 @@ 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. After a loop that ended before the enter it returns at once: the
+* end of the loop is already there.
+*
+* @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 +4277,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 +4295,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 +4313,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 +4387,71 @@ 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. A loop that ends first resolves it
+* too, with nothing entered: the walk then finds its route not reached.
 *
 * @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, or ended first.
 */
-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. A loop that ends before it entered the node
+* ends both waits: nothing is entered, and the wait for the gate returns at once.
+*
+* @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, or the
+*   loop ended first.
+* @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 +4480,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 +4813,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,
@@ -17236,8 +17528,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.
@@ -17246,32 +17562,32 @@ 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 takes the expected scene and clears the
+* record, whatever is mounted, so a restore at a popup builds the scene under it, whether the
+* popup rests or waits for its answer. With nothing expected it switches nothing. 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;
+	return takePending(ctx);
 }
 /**
 * Builds the scene in one synchronous block: the layers, then the projections of the old scene
@@ -17298,9 +17614,9 @@ function apply(ctx, scene) {
 	});
 }
 /**
-* The `scene` stage of entering a node: the whole switch. An `over` node never switches a mounted
-* scene, a node without a scene keeps the current one, and an aborted node returns without
-* touching anything.
+* The `scene` stage of entering a node: the whole switch. An `over` node switches only to an
+* expected scene, a node without a scene and with nothing expected keeps the current one, and an
+* aborted node returns without touching anything.
 *
 * @param ctx - Domain context of the plugin.
 * @param node - The node being entered.
@@ -17317,7 +17633,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.`);