@moku-labs/game 0.15.39 → 0.15.41

package/dist/{src-B2vblgmb.mjs → src-CWVwT9UM.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-BhDjJH2R.mjs";
 import { r as systemSource, t as memory } from "./memory-CWlqhS7l.mjs";
 import { a as finishDrafts, i as enableDraftPatches, n as deepFreeze$1, o as openDrafts, r as dropDrafts } from "./drafts-BawpSaVp.mjs";
-import { _ as pushEntry, c as collectFlows, d as findNode, f as framePath, g as compact, h as slotNames, i as servePaused, l as describeGraph, m as isRestCheckpoint, n as captureFrame, o as epochOf, p as graphHash, r as serveCaptures, s as pageNow$1, t as cancelCaptures } from "./capture-PTJXDpxK.mjs";
+import { _ as compact, c as collectFlows, d as findNode, f as framePath, g as slotNames, h as restlessCapOf, i as servePaused, l as describeGraph, m as isRestCheckpoint, n as captureFrame, o as epochOf, p as graphHash, r as serveCaptures, s as pageNow$1, t as cancelCaptures, v as pushEntry } from "./capture-BtS6_oWr.mjs";
 import { $ as component, A as localPoseOf, B as OverlayLevel, C as builtInStyles, D as textFor, E as readStyle, F as rootPoseOf, G as arcDefaults, H as Shape, I as Display, J as Exiting, K as componentsFor, L as HudPart, M as poseUnder, N as rootPointOf, O as applyPose, P as rootPoseInto, Q as Tree, R as NineSlice, U as Sprite, V as Parent, W as Transform, X as Now, Y as Layer, Z as Order, _ as uiFor, a as visualOf$1, b as Countdown, c as Covered, d as LocalWrite, f as Scroll, h as UiCounters, i as samePose, it as tag, j as parentOf$1, k as isLeaving, l as DebugTrigger, m as UI_OWNER, n as drawnRect, nt as system, o as visualRectOf, p as ScrollState, r as fitScaleOf, rt as systemsFor, s as Box, t as CONTENT$1, tt as resource, u as Escapable, x as Text, z as Overlay } from "./visual-ClVRMUAi.mjs";
 import { a as isDev } from "./dev-BNndV-hU.mjs";
 import { n as isComponentDefinition } from "./component-DGg5DqKK.mjs";
@@ -2444,7 +2444,7 @@ var SaveUnreadableError = class extends Error {
 * isRecord(["key"]); // false: an array is not a record
 * ```
 */
-function isRecord$4(value) {
+function isRecord$5(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 /**
@@ -2459,7 +2459,7 @@ function isRecord$4(value) {
 * ```
 */
 function readStreams(value) {
-	if (!isRecord$4(value)) return void 0;
+	if (!isRecord$5(value)) return void 0;
 	const streams = {};
 	for (const [id, state] of Object.entries(value)) {
 		if (typeof state !== "number") return void 0;
@@ -2483,9 +2483,9 @@ function readStreams(value) {
 * ```
 */
 function readSaveDoc(state, savedVersion, schemaVersion) {
-	const record = isRecord$4(state) ? state : void 0;
+	const record = isRecord$5(state) ? state : void 0;
 	const branch = record ? record.rng : void 0;
-	const rng = isRecord$4(branch) ? branch : void 0;
+	const rng = isRecord$5(branch) ? branch : void 0;
 	const streams = readStreams(rng ? rng.streams : void 0);
 	if (!record || record.player === void 0 || !rng || typeof rng.seed !== "number" || !streams) throw new SaveUnreadableError(savedVersion, schemaVersion, /* @__PURE__ */ new Error("[game] The save is not a document of the shape { player, rng }.\n  Restore the backup or start a new save."));
 	return {
@@ -3673,7 +3673,7 @@ function nextNodes(flow, name) {
 */
 function targetProblem(flow, name, outcome, target) {
 	if (typeof target !== "string" && target.kind === "exit") {
-		if (target.outcome in flow.outcomes) return void 0;
+		if (Object.hasOwn(flow.outcomes, target.outcome)) return void 0;
 		return `[game] Flow "${flow.id}": exit("${target.outcome}") of node "${name}" names no outcome of the flow.\n  Declare outcomes.${target.outcome} on flow "${flow.id}".`;
 	}
 	const next = typeof target === "string" ? target : target.target;
@@ -3743,7 +3743,7 @@ function nodeProblems(flow) {
 		if (entry.kind === "slot" && !entry.name) problems.push(`[game] Flow "${flow.id}": the slot node "${name}" has no slot name.\n  Give it a name: slot("${name}").`);
 		if (entry.kind !== "node") continue;
 		for (const type of entry.inbox) {
-			if (type in entry.outcomes) continue;
+			if (Object.hasOwn(entry.outcomes, type)) continue;
 			problems.push(`[game] Flow "${flow.id}": inbox type "${type}" of node "${name}" is not an outcome.\n  Add outcomes.${type} to node "${name}".`);
 		}
 		if (entry.rest && !entry.run && Object.keys(entry.outcomes).length === 0) problems.push(`[game] Flow "${flow.id}": rest node "${name}" has neither outcomes nor a run body.\n  Declare outcomes or add a run body.`);
@@ -3889,6 +3889,138 @@ function featureProblems(flows, features) {
 	return problems;
 }
 /**
+* Names the outcomes of a table besides `done`: what a slot declares, or what a contributed flow
+* may leave its slot on.
+*
+* @param outcomes - The outcome table of a slot or a flow.
+* @returns The outcome names other than `done`, in declaration order.
+* @example
+* ```ts
+* declaredOutcomes({ done: type(), shop: type() }); // ["shop"]
+* ```
+*/
+function declaredOutcomes(outcomes) {
+	return Object.keys(outcomes).filter((name) => name !== "done");
+}
+/**
+* Tells whether two lists hold the same names, in any order.
+*
+* @param first - One list of names.
+* @param second - The other list.
+* @returns True when every name of one is in the other and the lengths match.
+* @example
+* ```ts
+* sameNames(["shop", "board"], ["board", "shop"]); // true
+* ```
+*/
+function sameNames$1(first, second) {
+	return first.length === second.length && first.every((name) => second.includes(name));
+}
+/**
+* Collects every slot node of the graph by slot name: the flow that holds it and what it
+* declares, in the order the graph declares them.
+*
+* @param flows - Every collected flow by id.
+* @returns Slot name to its slot nodes, at least one each.
+*/
+function slotDeclarations(flows) {
+	const declarations = /* @__PURE__ */ new Map();
+	for (const flow of flows.values()) for (const entry of Object.values(flow.nodes)) {
+		if (entry.kind !== "slot") continue;
+		const declaration = {
+			flow: flow.id,
+			declared: declaredOutcomes(entry.outcomes)
+		};
+		const list = declarations.get(entry.name);
+		if (list === void 0) declarations.set(entry.name, [declaration]);
+		else list.push(declaration);
+	}
+	return declarations;
+}
+/**
+* Reports the contributions of a slot that declares outcomes and that may leave it on an outcome
+* the slot does not declare: the loop would have no edge for it.
+*
+* @param slotName - Name of the slot.
+* @param declared - The outcomes the slot declares besides `done`.
+* @param contributions - The contributions of the slot.
+* @returns One sentence per contribution and outcome.
+*/
+function undeclaredExits(slotName, declared, contributions) {
+	const problems = [];
+	for (const { feature, flow } of contributions) for (const outcome of declaredOutcomes(flow.outcomes)) {
+		if (declared.includes(outcome)) continue;
+		problems.push(`[game] Slot "${slotName}": flow "${flow.id}" of feature "${feature}" exits "${outcome}", which the slot does not declare.\n  Declare slot("${slotName}", { ${outcome}: type() }) or exit "done".`);
+	}
+	return problems;
+}
+/**
+* Reports the named outcomes of slots: one slot name declared with different outcomes in two
+* places, and a contribution of a slot that declares outcomes which may leave it on another one.
+* A slot that declares none takes any contribution: what it ignores is a warning.
+*
+* @param flows - Every collected flow by id.
+* @param features - Features API, read for the contributions of every slot.
+* @returns One sentence per problem.
+*/
+function slotOutcomeProblems(flows, features) {
+	const problems = [];
+	for (const [slotName, [first, ...others]] of slotDeclarations(flows)) {
+		for (const other of others) {
+			if (sameNames$1(first.declared, other.declared)) continue;
+			problems.push(`[game] Slot "${slotName}" declares different outcomes in flow "${first.flow}" and flow "${other.flow}".\n  Declare the slot once and use it in both flows.`);
+		}
+		if (first.declared.length === 0) continue;
+		problems.push(...undeclaredExits(slotName, first.declared, features.contributions(slotName)));
+	}
+	return problems;
+}
+/**
+* Warns about the named exits of contributions that a slot declaring no outcomes ignores: the
+* slot hands over to its next contribution as after `done`.
+*
+* @param slotName - Name of the slot.
+* @param contributions - The contributions of the slot.
+* @returns One warning per contribution and outcome.
+*/
+function ignoredExits(slotName, contributions) {
+	return contributions.flatMap(({ flow }) => declaredOutcomes(flow.outcomes).map((outcome) => `[game] Slot "${slotName}": flow "${flow.id}" exits "${outcome}", which the slot ignores.\n  Declare slot("${slotName}", { ${outcome}: type() }) to route it, or exit "done".`));
+}
+/**
+* Warns about contributions without `when` in a slot that declares outcomes: a named exit leaves
+* the slot, so a later one runs only when the one before it exits `done`.
+*
+* @param slotName - Name of the slot.
+* @param contributions - The contributions of the slot, in order.
+* @returns One warning per contribution without `when` after the first one.
+*/
+function unguardedContributions(slotName, contributions) {
+	const warnings = [];
+	let earlier;
+	for (const contribution of contributions) {
+		if (contribution.when !== void 0) continue;
+		if (earlier !== void 0) warnings.push(`[game] Slot "${slotName}": the flows "${earlier.flow.id}" and "${contribution.flow.id}" have no when.\n  A named exit leaves the slot, so "${contribution.flow.id}" runs only when "${earlier.flow.id}" exits done; give them when.`);
+		earlier = contribution;
+	}
+	return warnings;
+}
+/**
+* Warns about the named outcomes of slots: a named exit a slot that declares none ignores, and
+* contributions without `when` in a slot that declares some.
+*
+* @param flows - Every collected flow by id.
+* @param features - Features API, read for the contributions of every slot.
+* @returns One warning per finding.
+*/
+function slotOutcomeWarnings(flows, features) {
+	const warnings = [];
+	for (const [slotName, [first]] of slotDeclarations(flows)) {
+		const contributions = features.contributions(slotName);
+		warnings.push(...first.declared.length === 0 ? ignoredExits(slotName, contributions) : unguardedContributions(slotName, contributions));
+	}
+	return warnings;
+}
+/**
 * Reads the scene id of one entry of a feature's `scenes` list. The list holds whatever
 * `defineScene` returns; validation reads the `id` and ignores everything else.
 *
@@ -4035,12 +4167,14 @@ function sizeWarnings(flow) {
 * Validates the whole graph at `run()` and returns every problem as one `[game] …` sentence:
 * unreachable node, outcome without an edge, missing target, barrier edge that does not reach a
 * rest node of the same flow, cycle with no rest node, slot without a name, equal contribution
-* `order`, one flow contributed twice to a slot, `inbox` type that is not an outcome, rest node
-* with neither `run` nor outcomes, a `recover` on a node that is not a rest node, a scene id no
-* feature registers, an `over` node that names a scene, `safeNode` that is not a checkpoint,
-* colliding ids. A `recover` on a node that is not the safe node is a warning: it never runs
-* there. Types are bypassed by JSON data and casts, so this runs even though the edge table is
-* checked at compile time.
+* `order`, one flow contributed twice to a slot, one slot name declared with different outcomes,
+* a contribution of a slot that declares outcomes which exits another one, `inbox` type that is
+* not an outcome, rest node with neither `run` nor outcomes, a `recover` on a node that is not a
+* rest node, a scene id no feature registers, an `over` node that names a scene, `safeNode` that
+* is not a checkpoint, colliding ids. A `recover` on a node that is not the safe node is a
+* warning: it never runs there. So are a named exit a slot that declares no outcomes ignores, and
+* two contributions without `when` in a slot that declares some. Types are bypassed by JSON data
+* and casts, so this runs even though the edge table is checked at compile time.
 *
 * @param flows - Every collected flow by id, the main flow first.
 * @param features - Features API: slot contributions and feature names.
@@ -4054,8 +4188,8 @@ function validateGraph(flows, features, config) {
 		problems.push(...edgeProblems(flow), ...nodeProblems(flow), ...recoverProblems(flow), ...reachProblems(flow), ...cycleProblems(flow));
 		warnings.push(...sizeWarnings(flow));
 	}
-	warnings.push(...slotNameWarnings(flows, features), ...recoverWarnings(flows, features, config));
-	problems.push(...flowIdProblems(flows), ...featureProblems(flows, features), ...sceneProblems(flows, features), ...safeNodeProblems(config, features));
+	warnings.push(...slotNameWarnings(flows, features), ...slotOutcomeWarnings(flows, features), ...recoverWarnings(flows, features, config));
+	problems.push(...flowIdProblems(flows), ...featureProblems(flows, features), ...slotOutcomeProblems(flows, features), ...sceneProblems(flows, features), ...safeNodeProblems(config, features));
 	return {
 		problems,
 		warnings
@@ -4545,7 +4679,9 @@ function pickContribution(ctx, features, slotName, from) {
 }
 /**
 * Follows one result to the next position: a node of the same flow, a mapped node, or the exit of
-* a sub-flow, which hands the outcome to the parent.
+* a sub-flow, which hands the outcome to the parent. The exit of a slot contribution returns to
+* the slot: on `done` or an outcome the slot does not declare to continue it, on a declared
+* outcome to leave it.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param frames - The position being planned; mutated.
@@ -4560,19 +4696,78 @@ function planFrom(ctx, frames, location, outcome, payload, depth) {
 	const target = location.flow.edges[location.name]?.[outcome];
 	if (target === void 0) return { problem: `[game] Flow "${location.flow.id}": outcome "${outcome}" of node "${location.name}" has no edge.\n  Add edges.${location.name}.${outcome}.` };
 	if (typeof target === "string") return enterTarget(ctx, frames, location.flow, target, payload);
-	if (target.kind === "map") {
-		const mapped = target.map(payload);
-		const input = mapped === void 0 ? null : mapped;
-		if (!isJson$1(input)) return { problem: `[game] The mapper of edge "${location.name}.${outcome}" returned a value that is not JSON.\n  Return plain JSON from to("${target.target}", ...).` };
-		return enterTarget(ctx, frames, location.flow, target.target, input);
-	}
+	if (target.kind === "map") return enterMapped(ctx, frames, location, outcome, target, payload);
 	frames.pop();
 	const parent = locateFrames(ctx, frames);
 	if (parent === void 0) return { problem: `[game] The main flow "${location.flow.id}" left with outcome "${target.outcome}".\n  Give the top-level flow an edge instead of exit("${target.outcome}").` };
-	if (parent.entry.kind === "slot") return continueSlot(frames, location.flow.id);
+	if (parent.entry.kind === "slot") return leavesSlot(parent.entry, target.outcome) ? leaveSlot(frames, target.outcome, payload) : continueSlot(frames, location.flow.id);
 	return planFrom(ctx, frames, parent, target.outcome, payload, depth + 1);
 }
 /**
+* Follows a `to()` edge: maps the payload and enters the target with it. The mapper is game code:
+* a throw, or a result that is not JSON, is a problem, and the node fails like any other.
+*
+* @param ctx - Domain context of the flow plugin.
+* @param frames - The position being planned; mutated.
+* @param location - Where the result was produced.
+* @param outcome - Outcome name of the result.
+* @param target - The mapped target of the edge.
+* @param payload - Payload of the result, handed to the mapper.
+* @returns The plan, or the problem that stops it.
+*/
+function enterMapped(ctx, frames, location, outcome, target, payload) {
+	let mapped;
+	try {
+		mapped = target.map(payload);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { problem: `[game] The mapper of edge "${location.name}.${outcome}" threw: ${message}.\n  Return plain JSON from to("${target.target}", ...).` };
+	}
+	const input = mapped === void 0 ? null : mapped;
+	if (!isJson$1(input)) return { problem: `[game] The mapper of edge "${location.name}.${outcome}" returned a value that is not JSON.\n  Return plain JSON from to("${target.target}", ...).` };
+	return enterTarget(ctx, frames, location.flow, target.target, input);
+}
+/**
+* Tells whether a contribution that exits `outcome` leaves its slot at once: the slot declares the
+* outcome, and it is not `done`, which hands over to the next contribution. Own keys only:
+* `"constructor" in outcomes` is true for every object.
+*
+* @param slot - The slot the contribution runs in.
+* @param outcome - The outcome the contribution exited with.
+* @returns True when the slot takes its own edge of that outcome next.
+* @example
+* ```ts
+* leavesSlot(slot("episodeStep", { shop: type() }), "shop"); // true
+* leavesSlot(slot("episodeStep", { shop: type() }), "done"); // false: the next contribution runs
+* ```
+*/
+function leavesSlot(slot, outcome) {
+	return outcome !== "done" && Object.hasOwn(slot.outcomes, outcome);
+}
+/**
+* Plans the early leave of a slot: a contribution exited an outcome the slot declares. The plan
+* stands on the slot node like `continueSlot`, without `after`, and carries the outcome and its
+* payload: the loop takes the slot's own edge with them after the commit, so the later
+* contributions do not run and the next entry of the slot starts at its first one.
+*
+* @param frames - The position, already popped back to the slot node.
+* @param outcome - The declared outcome the contribution left on.
+* @param payload - Its payload, handed on to the slot's edge.
+* @returns The plan that stands on the slot node.
+*/
+function leaveSlot(frames, outcome, payload) {
+	return {
+		stack: frames,
+		next: framePath(frames),
+		rest: false,
+		checkpoint: false,
+		leave: {
+			outcome,
+			payload
+		}
+	};
+}
+/**
 * Plans the return to a slot after one of its contributions ended. The next contribution is NOT
 * picked here: `when` reads the committed state, and a plan is made before the commit of the edge.
 * So the plan stands on the slot node and names the contribution that ended; the loop picks the
@@ -4609,7 +4804,7 @@ function asError$4(value) {
 /**
 * Commits the transaction of one node, releases its hints, journals the edge and emits
 * `flow:edge`. This is the only commit of the engine: the edge of a node, and the recovery edge
-* of the safe node, both go through it.
+* of the safe node, both go through it. It counts the edge among those since the last rest node.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param modules - Injected sibling APIs.
@@ -4619,6 +4814,7 @@ function asError$4(value) {
 */
 function commitEdge(ctx, modules, step, next) {
 	const commit = step.transaction.commit();
+	ctx.state.runner.restless += 1;
 	ctx.deps.time.wake();
 	modules.fx.release();
 	const entry = pushEntry(ctx.state.runner, {
@@ -4682,6 +4878,8 @@ function handleFailure(ctx, modules, transaction, error, path, safe) {
 	});
 	state.stack = [...target];
 	state.slotAfter = void 0;
+	state.slotLeave = void 0;
+	state.restless = 0;
 	if (!retry) {
 		safe.inside = true;
 		safe.recover = true;
@@ -4707,9 +4905,11 @@ function handleAbort(modules, transaction, reason) {
 }
 /**
 * Moves the position to a planned place and, when that place is a rest node, makes it the rest
-* point of the loop: the frame rollback and `bookmark` return to, a zeroed failure count, a
-* compacted journal at a checkpoint, `flow:rest` and the walk's rest listeners. The caller marks the
-* rest point in the store first. Used by the edge, and by the loop when it enters a slot.
+* point of the loop: the frame rollback and `bookmark` return to, a zeroed failure count, a zeroed
+* count of edges without a rest, a compacted journal at a checkpoint, `flow:rest` and the walk's
+* rest listeners. The caller marks the rest point in the store first. Used by the edge, and by the
+* loop when it enters a slot. A slot it stands on keeps the contribution that ended, or the
+* declared outcome one left on, for the next turn.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param plan - Where the loop stands now.
@@ -4718,9 +4918,11 @@ function arrive(ctx, plan) {
 	const state = ctx.state.runner;
 	state.stack = plan.stack;
 	state.slotAfter = plan.after;
+	state.slotLeave = plan.leave;
 	if (!plan.rest) return;
 	state.restFrame = [...plan.stack];
 	state.failures = 0;
+	state.restless = 0;
 	if (plan.checkpoint) compact(state);
 	ctx.emit("flow:rest", {
 		path: plan.next,
@@ -4730,7 +4932,9 @@ function arrive(ctx, plan) {
 }
 /**
 * Takes the edge of one result: plan, commit, mark the barrier or the rest point, move the
-* position and announce a rest node.
+* position and announce a rest node. A plan with a problem fails the node, and so does an edge
+* beyond the cap of edges without a rest node: a loop of transit nodes that never rests would
+* freeze the game.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param modules - Injected sibling APIs.
@@ -4742,6 +4946,10 @@ async function finishNode(ctx, modules, step, safe) {
 	const state = ctx.state.runner;
 	const plan = planFrom(ctx, [...state.stack], step.location, step.result.outcome, step.result.payload, 0);
 	if ("problem" in plan) return handleFailure(ctx, modules, step.transaction, new Error(plan.problem), step.path, safe);
+	if (state.restless >= state.restlessCap) {
+		const restless = `[game] ${state.restlessCap} edges without a rest node, at "${step.path}".\n  Put a rest node in the loop.`;
+		return handleFailure(ctx, modules, step.transaction, new Error(restless), step.path, safe);
+	}
 	const entry = commitEdge(ctx, modules, step, plan.next);
 	if (step.barrier) await ctx.deps.model.store.markBarrier(`${step.path}#${entry.index}@${step.now}`);
 	else if (plan.rest) ctx.deps.model.store.markRest();
@@ -4891,27 +5099,47 @@ function to(target, map) {
 	};
 }
 /**
-* Defines an extension point: a node whose body is "run the contributions of this slot in order".
-* Its single outcome is `done`.
+* Builds the slot. The body works on the widened shapes the runner reads: the signature above has
+* already kept `done` out of the declared outcomes for a typed caller, and the check here refuses
+* it past a cast.
 *
 * @param name - Slot name features contribute to.
+* @param outcomes - The named outcomes besides `done`.
 * @returns The slot node as plain data.
-* @example
-* ```ts
-* // The main flow leaves room after a finished order. Features contribute sub-flows to it.
-* nodes: { boot, home, board: boardFlow, afterOrder: slot("afterOrder") }
-* // slot("afterOrder"): { kind: "slot", name: "afterOrder", input: …, outcomes: { done: … } }
-* ```
+* @throws {TypeError} When `outcomes` declares `done`.
 */
-function slot(name) {
+function slot(name, outcomes) {
+	if (outcomes !== void 0 && Object.hasOwn(outcomes, "done")) throw new TypeError(`[game] Slot "${name}" declares the outcome "done".\n  done is every slot's own outcome; remove it from slot("${name}", ...).`);
 	return {
 		kind: "slot",
 		name,
 		input: type(),
-		outcomes: { done: type() }
+		outcomes: {
+			done: type(),
+			...outcomes
+		}
 	};
 }
 /**
+* Builds the entry. The body works on the widened shapes the runner reads: the signature above
+* has already checked the flow against the slot.
+*
+* @param host - The slot node the flow runs in.
+* @param spec - The flow, its `order` and an optional `when`.
+* @returns The entry under the slot's name.
+*/
+function contribution(host, spec) {
+	const { flow, order, when } = spec;
+	return { [host.name]: when === void 0 ? {
+		flow,
+		order
+	} : {
+		flow,
+		order,
+		when
+	} };
+}
+/**
 * Builds the `out` of a node context: one method per declared outcome. A method called without
 * data produces a `null` payload. Called by the loop when it enters a node, never by a game.
 *
@@ -5676,7 +5904,8 @@ function enterSubFlow(ctx, modules, location, sub, safe) {
 }
 /**
 * Enters a slot: the first contribution whose `when` passes, or the slot's `done` edge when the
-* slot has no contribution to run.
+* slot has no contribution to run. When a contribution just left on an outcome the slot declares,
+* the slot takes its own edge of that outcome instead, with the contribution's payload.
 *
 * @param ctx - Domain context of the flow plugin.
 * @param modules - Injected sibling APIs.
@@ -5687,6 +5916,14 @@ function enterSubFlow(ctx, modules, location, sub, safe) {
 */
 function enterSlot(ctx, modules, location, slot, safe) {
 	const state = ctx.state.runner;
+	const leave = state.slotLeave;
+	if (leave !== void 0) {
+		state.slotLeave = void 0;
+		return applyResult(ctx, modules, location, leave, safe, {
+			barrier: false,
+			now: ctx.deps.clock.now()
+		});
+	}
 	const finished = state.slotAfter;
 	const contributions = modules.features.contributions(slot.name);
 	const from = finished === void 0 ? 0 : contributions.findIndex((item) => item.flow.id === finished) + 1;
@@ -5742,8 +5979,10 @@ function enterBookmark(ctx, modules, bookmark, safe) {
 	ctx.deps.model.store.markRest();
 	state.stack = framesOf(location.trail, bookmark.input);
 	state.slotAfter = void 0;
+	state.slotLeave = void 0;
 	state.restFrame = [...state.stack];
 	state.failures = 0;
+	state.restless = 0;
 	ctx.emit("flow:rest", {
 		path: bookmark.path,
 		checkpoint: isRestCheckpoint(location.entry)
@@ -5759,7 +5998,7 @@ function enterBookmark(ctx, modules, bookmark, safe) {
 * @returns `"stop"` when the runner was stopped, `"continue"` otherwise.
 * @throws {Error} When the position names no node of the graph.
 */
-async function advance(ctx, modules, safe) {
+async function advance$1(ctx, modules, safe) {
 	const state = ctx.state.runner;
 	if (stopped(state)) return "stop";
 	const restoring = state.seam?.restoring;
@@ -5777,7 +6016,8 @@ async function advance(ctx, modules, safe) {
 * Runs the graph until aborted: enter node, `onEnter` stages, begin a transaction, await the
 * body, commit on the edge, release hints, journal, emit `flow:edge`, follow the edge. An error
 * discards, rolls back, is logged and retries, then enters `safeNode`, whose `recover` runs first
-* as one committed edge; a failure inside `safeNode` rejects.
+* as one committed edge; a failure inside `safeNode` rejects. More edges without a rest node than
+* the graph's cap is such an error too.
 * Abort reasons: `"stop"` ends the loop, `"inbox"` turns the event into the outcome, `"restore"`
 * enters the bookmark's frame.
 *
@@ -5791,6 +6031,7 @@ async function runLoop(ctx, modules) {
 	const state = ctx.state.runner;
 	state.flows = collectGraph(ctx, modules.features);
 	checkGraph(ctx, modules.features);
+	state.restlessCap = restlessCapOf(main, modules.features.contributions);
 	modules.features.seal();
 	await ctx.deps.model.store.load();
 	state.stack = [{
@@ -5800,13 +6041,15 @@ async function runLoop(ctx, modules) {
 	}];
 	state.restFrame = [...state.stack];
 	state.slotAfter = void 0;
+	state.slotLeave = void 0;
 	state.failures = 0;
+	state.restless = 0;
 	const safe = {
 		inside: false,
 		recover: false
 	};
 	const loop = { running: true };
-	while (loop.running) loop.running = await advance(ctx, modules, safe) === "continue";
+	while (loop.running) loop.running = await advance$1(ctx, modules, safe) === "continue";
 }
 /**
 * Restores a bookmark through the running loop: the active node is aborted with reason
@@ -6680,6 +6923,9 @@ function createInboxState() {
 //#endregion
 //#region src/plugins/flow/runner/state.ts
 /**
+* @file flow/runner — state factory.
+*/
+/**
 * Creates the empty flow registry. It lives in its own function because the plugin's lint rule
 * L5 refuses a collection built inside an exported declaration.
 *
@@ -6709,6 +6955,9 @@ function createRunnerState() {
 		stack: [],
 		restFrame: void 0,
 		slotAfter: void 0,
+		slotLeave: void 0,
+		restless: 0,
+		restlessCap: 64,
 		journal: [],
 		journalIndex: 0,
 		running: void 0,
@@ -24939,7 +25188,7 @@ function finishRun(warm) {
 * @param pixi - The module that draws.
 * @returns The tree, or `undefined` when it cannot be built.
 */
-function objectsOf(sctx, pixi) {
+function objectsOf$1(sctx, pixi) {
 	const { warm } = sctx.ctx.state.sync;
 	if (warm.objects !== void 0) return warm.objects;
 	try {
@@ -24967,7 +25216,7 @@ function warmStep(sctx) {
 	const { warm } = sctx.ctx.state.sync;
 	if (warm.head >= warm.queue.length) return false;
 	const pixi = sctx.deps.host.pixi();
-	const objects = pixi === void 0 ? void 0 : objectsOf(sctx, pixi);
+	const objects = pixi === void 0 ? void 0 : objectsOf$1(sctx, pixi);
 	if (pixi === void 0 || objects === void 0) return false;
 	const budget = sctx.ctx.config.warm;
 	let drawn = 0;
@@ -26026,6 +26275,1003 @@ function clearLayers(state) {
 	state.hudLayer = void 0;
 }
 //#endregion
+//#region src/plugins/renderer/sync/shape-path.ts
+/**
+* @file renderer/sync — the path of a `Shape`: a rectangle, a rounded rectangle or a triangle,
+* its fill, and its stroke, solid or dashed, or an arc, a stroke alone. A dashed stroke walks the
+* outline (straight edges, and rounded corners sampled as arcs) and strokes one open line per dash.
+* An arc runs on the circle inscribed in its box, from 12 o'clock clockwise.
+*/
+/** Chords per rounded corner of a dashed outline: under 0.3 u off the arc at a 48 u radius. */
+const CORNER_SAMPLES = 8;
+/** The gap between two dashes, as a fraction of the dash length. */
+const GAP_RATIO = .5;
+/** Segments of a full ring: a ring of 28 u across strays under 0.03 u off its circle. */
+const RING_SEGMENTS = 48;
+/** The fewest segments of an arc that draws: a sliver still bends. */
+const ARC_MIN_SEGMENTS = 2;
+/** 12 o'clock, where an arc starts: Pixi's angles run clockwise from 3 o'clock. */
+const TWELVE = -Math.PI / 2;
+/**
+* The corner radius the rectangle is drawn with: Pixi clamps it to half the shorter side.
+*
+* @param value - The shape value.
+* @returns The radius in reference units, 0 for square corners.
+* @example
+* ```ts
+* radiusOf({ ...Shape.defaults, w: 100, h: 20, radius: 40 }); // 10
+* ```
+*/
+function radiusOf(value) {
+	return Math.max(0, Math.min(value.radius, value.w / 2, value.h / 2));
+}
+/**
+* The closed outline of a shape as points, clockwise from the top left (from the end of the top
+* left corner on a rounded rectangle); the last point repeats the first.
+*
+* @param value - The shape value.
+* @returns The points of the outline.
+* @example
+* ```ts
+* outlineOf({ ...Shape.defaults, kind: "triangle", w: 60, h: 40 });
+* // [{ x: 0, y: 0 }, { x: 60, y: 20 }, { x: 0, y: 40 }, { x: 0, y: 0 }]
+* ```
+*/
+function outlineOf(value) {
+	const { w, h } = value;
+	if (value.kind === "triangle") return [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: w,
+			y: h / 2
+		},
+		{
+			x: 0,
+			y: h
+		},
+		{
+			x: 0,
+			y: 0
+		}
+	];
+	const radius = radiusOf(value);
+	if (radius === 0) return [
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: w,
+			y: 0
+		},
+		{
+			x: w,
+			y: h
+		},
+		{
+			x: 0,
+			y: h
+		},
+		{
+			x: 0,
+			y: 0
+		}
+	];
+	const corners = [
+		{
+			edge: {
+				x: w - radius,
+				y: 0
+			},
+			center: {
+				x: w - radius,
+				y: radius
+			}
+		},
+		{
+			edge: {
+				x: w,
+				y: h - radius
+			},
+			center: {
+				x: w - radius,
+				y: h - radius
+			}
+		},
+		{
+			edge: {
+				x: radius,
+				y: h
+			},
+			center: {
+				x: radius,
+				y: h - radius
+			}
+		},
+		{
+			edge: {
+				x: 0,
+				y: radius
+			},
+			center: {
+				x: radius,
+				y: radius
+			}
+		}
+	];
+	const points = [{
+		x: radius,
+		y: 0
+	}];
+	for (const [index, { edge, center }] of corners.entries()) {
+		const from = -Math.PI / 2 + index * Math.PI / 2;
+		points.push(edge);
+		for (let sample = 1; sample <= CORNER_SAMPLES; sample += 1) {
+			const angle = from + sample * Math.PI / 2 / CORNER_SAMPLES;
+			points.push({
+				x: center.x + radius * Math.cos(angle),
+				y: center.y + radius * Math.sin(angle)
+			});
+		}
+	}
+	return points;
+}
+/**
+* Adds a point to a line unless the line already ends there.
+*
+* @param line - The line.
+* @param point - The point.
+*/
+function extend(line, point) {
+	const last = line.at(-1);
+	if (last?.x !== point.x || last.y !== point.y) line.push(point);
+}
+/**
+* Cuts a polyline into dashes of `dash` length with gaps of half a dash, starting with a dash at
+* its first point. A dash bends round the corners it crosses; the last one may be shorter.
+*
+* @param outline - The points of the polyline.
+* @param dash - The dash length, above 0.
+* @returns One open line per dash.
+* @example
+* ```ts
+* dashesOf([{ x: 0, y: 0 }, { x: 40, y: 0 }], 10);
+* // [[{ x: 0, y: 0 }, { x: 10, y: 0 }], [{ x: 15, y: 0 }, { x: 25, y: 0 }], [{ x: 30, y: 0 }, { x: 40, y: 0 }]]
+* ```
+*/
+function dashesOf(outline, dash) {
+	const first = outline[0];
+	if (first === void 0) return [];
+	const dashes = [];
+	let line = [first];
+	let left = dash;
+	for (let index = 1; index < outline.length; index += 1) {
+		let from = outline[index - 1] ?? first;
+		const to = outline[index] ?? first;
+		let length = Math.hypot(to.x - from.x, to.y - from.y);
+		while (length > left) {
+			from = {
+				x: from.x + (to.x - from.x) * left / length,
+				y: from.y + (to.y - from.y) * left / length
+			};
+			length -= left;
+			if (line === void 0) {
+				line = [from];
+				left = dash;
+			} else {
+				extend(line, from);
+				dashes.push(line);
+				line = void 0;
+				left = dash * GAP_RATIO;
+			}
+		}
+		left -= length;
+		if (line !== void 0) extend(line, to);
+	}
+	if (line !== void 0 && line.length > 1) dashes.push(line);
+	return dashes;
+}
+/**
+* Draws the path of a shape and fills it in a colour at the alpha given. At alpha 0 the path stays unfilled, so only
+* a stroke shows. A clip mask is drawn here too, never dashed; the path of an arc here is its box, which is what it
+* clips its children to. A fill-only shape is drawn white and coloured by the object's tint, so a colour change draws
+* no path (spec 26 R2.1).
+*
+* @param object - The graphics to draw on.
+* @param value - The shape value.
+* @param fillAlpha - The alpha of the fill: the value's own for the shape, 1 for a clip mask.
+* @param color - The colour of the fill: the value's own by default, white for a tinted shape.
+*/
+function drawShapePath(object, value, fillAlpha, color = value.fill) {
+	object.clear();
+	if (value.kind === "triangle") object.moveTo(0, 0).lineTo(value.w, value.h / 2).lineTo(0, value.h).closePath();
+	else if (value.kind === "rect" && value.radius > 0) object.roundRect(0, 0, value.w, value.h, value.radius);
+	else object.rect(0, 0, value.w, value.h);
+	if (fillAlpha <= 0) return;
+	object.fill(fillAlpha < 1 ? {
+		color,
+		alpha: fillAlpha
+	} : { color });
+}
+/**
+* Strokes the outline drawn by `drawShapePath`: solid over the same path, or, with a `dash`, as
+* one open line per dash on a new path. Nothing without a stroke width.
+*
+* @param object - The graphics the shape was drawn on.
+* @param value - The shape value.
+*/
+function strokeShape(object, value) {
+	if (value.strokeWidth <= 0) return;
+	const style = {
+		color: value.stroke,
+		width: value.strokeWidth
+	};
+	if (value.dash <= 0) {
+		object.stroke(style);
+		return;
+	}
+	object.beginPath();
+	for (const [start, ...rest] of dashesOf(outlineOf(value), value.dash)) {
+		if (start === void 0) continue;
+		object.moveTo(start.x, start.y);
+		for (const point of rest) object.lineTo(point.x, point.y);
+	}
+	object.stroke(style);
+}
+/**
+* The share of the circle an arc sweeps, clamped to 0..1: anything not above 0, `NaN` too, is 0; a whole ring when
+* the value leaves it out.
+*
+* @param value - The shape value.
+* @returns The share.
+* @example
+* ```ts
+* sweepOf({ ...Shape.defaults, kind: "arc", sweep: 1.4 }); // 1
+* ```
+*/
+function sweepOf(value) {
+	const sweep = value.sweep ?? arcDefaults.sweep;
+	if (Number.isNaN(sweep) || sweep <= 0) return 0;
+	return Math.min(sweep, 1);
+}
+/**
+* The radius of the circle an arc runs on: inscribed in the shorter side of its box, inside its stroke.
+*
+* @param value - The shape value.
+* @returns The radius in reference units; 0 or below when the stroke leaves no circle.
+* @example
+* ```ts
+* arcRadiusOf({ ...Shape.defaults, kind: "arc", w: 28, h: 40, strokeWidth: 2 }); // 13
+* ```
+*/
+function arcRadiusOf(value) {
+	return (Math.min(value.w, value.h) - value.strokeWidth) / 2;
+}
+/**
+* Tells whether an arc draws nothing: no stroke width, no sweep, or no circle inside its stroke.
+*
+* @param value - The shape value, an arc.
+* @returns True for an arc whose `Graphics` would hold no instruction.
+* @example
+* ```ts
+* isEmptyArc({ ...Shape.defaults, kind: "arc", w: 28, h: 28, strokeWidth: 2, sweep: 0 }); // true
+* ```
+*/
+function isEmptyArc(value) {
+	return value.strokeWidth <= 0 || sweepOf(value) <= 0 || arcRadiusOf(value) <= 0;
+}
+/**
+* Strokes an arc: from 12 o'clock clockwise over its share of the circle, in segments as many as its angle needs (48
+* for a ring, at least 2), ended by its `cap`. A full ring is closed and has no ends. Nothing for an empty arc. Drawn
+* only when the shape changed: never rebuilt per frame.
+*
+* @param object - The graphics, cleared.
+* @param value - The shape value, an arc.
+*/
+function strokeArc(object, value) {
+	if (isEmptyArc(value)) return;
+	const sweep = sweepOf(value);
+	const radius = arcRadiusOf(value);
+	const ring = sweep >= 1;
+	const segments = Math.max(ARC_MIN_SEGMENTS, Math.ceil(sweep * RING_SEGMENTS));
+	const step = sweep * 2 * Math.PI / segments;
+	const centreX = value.w / 2;
+	const centreY = value.h / 2;
+	const last = ring ? segments - 1 : segments;
+	object.moveTo(centreX, centreY - radius);
+	for (let index = 1; index <= last; index += 1) {
+		const angle = TWELVE + index * step;
+		object.lineTo(centreX + radius * Math.cos(angle), centreY + radius * Math.sin(angle));
+	}
+	if (ring) {
+		object.closePath();
+		object.stroke({
+			color: value.stroke,
+			width: value.strokeWidth
+		});
+		return;
+	}
+	object.stroke({
+		color: value.stroke,
+		width: value.strokeWidth,
+		cap: value.cap ?? arcDefaults.cap
+	});
+}
+/**
+* Paints a shape on its graphics: an arc as its stroke alone, every other kind as its path, its fill in a colour at its
+* own fill alpha, and its stroke. The one call that draws a shape's visual.
+*
+* @param object - The graphics.
+* @param value - The shape value.
+* @param color - The colour of the fill: white for a tinted shape, the value's own otherwise.
+*/
+function paintShape(object, value, color) {
+	if (value.kind === "arc") {
+		object.clear();
+		strokeArc(object, value);
+		return;
+	}
+	drawShapePath(object, value, value.fillAlpha, color);
+	strokeShape(object, value);
+}
+//#endregion
+//#region src/plugins/renderer/sync/textures.ts
+/** The colour a missing texture is drawn in. */
+const PLACEHOLDER_TINT = 16711935;
+/**
+* Creates an empty set. It lives in its own non-exported function because lint rule L5 refuses a
+* collection built inside an exported declaration.
+*
+* @returns An empty set.
+*/
+function emptySet$5() {
+	return /* @__PURE__ */ new Set();
+}
+/**
+* Asks the providers from the newest to the oldest. The first answer wins, so a bundle loaded
+* later shadows an older one.
+*
+* @param sctx - Domain context of the sync module.
+* @param key - The asset key.
+* @returns The texture, or `undefined` when nothing answered.
+*/
+function resolveTexture(sctx, key) {
+	const providers = sctx.ctx.state.sync.providers;
+	for (let index = providers.length - 1; index >= 0; index -= 1) {
+		const texture = providers[index]?.(key);
+		if (texture !== void 0) return texture;
+	}
+}
+/**
+* The 1x1 white texture the placeholder is drawn with.
+*
+* @param sctx - Domain context of the sync module.
+* @returns The texture, or `undefined` while inert.
+*/
+function placeholderTexture(sctx) {
+	return sctx.deps.host.pixi()?.Texture.WHITE;
+}
+/**
+* Reports a key no provider answers. One key warns once, however many views use it.
+*
+* @param sctx - Domain context of the sync module.
+* @param key - The asset key.
+*/
+function warnMissing(sctx, key) {
+	const warned = sctx.ctx.state.sync.warned;
+	if (key === "" || warned.has(key)) return;
+	warned.add(key);
+	sctx.ctx.log.warn("renderer: no texture for asset key", { key });
+}
+/**
+* Remembers that an entity draws a key, so `invalidate` finds it again.
+*
+* @param state - The sync branch of the plugin state.
+* @param entity - The entity.
+* @param key - The asset key.
+*/
+function trackKey(state, entity, key) {
+	const users = state.byKey.get(key) ?? emptySet$5();
+	users.add(entity);
+	state.byKey.set(key, users);
+}
+/**
+* Forgets that an entity draws a key.
+*
+* @param state - The sync branch of the plugin state.
+* @param entity - The entity.
+* @param key - The asset key.
+*/
+function untrackKey(state, entity, key) {
+	const users = state.byKey.get(key);
+	if (users === void 0) return;
+	users.delete(entity);
+	if (users.size === 0) state.byKey.delete(key);
+}
+/**
+* The Pixi module of a renderer that draws. A texture made while it does not would be lost with
+* the device, so the member that asked throws.
+*
+* @param sctx - Domain context of the sync module.
+* @param member - The `textures` member that asked, for the message.
+* @returns The Pixi module.
+* @throws {Error} When the renderer does not draw.
+*/
+function drawingPixi(sctx, member) {
+	const pixi = sctx.deps.host.pixi();
+	if (pixi === void 0 || !sctx.deps.host.ready()) throw new Error(`[game] renderer.sync.textures.${member} needs a ready renderer.\n  Check app.renderer.host.ready() first.`);
+	return pixi;
+}
+/**
+* The default borders of a texture, from the four numbers `nine` gives.
+*
+* @param nine - Left, top, right and bottom in pixels.
+* @returns The borders, as Pixi reads them.
+* @example
+* ```ts
+* defaultBordersOf([24, 20, 16, 12]); // { left: 24, top: 20, right: 16, bottom: 12 }
+* ```
+*/
+function defaultBordersOf(nine) {
+	return {
+		left: nine[0],
+		top: nine[1],
+		right: nine[2],
+		bottom: nine[3]
+	};
+}
+/**
+* Makes a Pixi texture out of a decoded image, on behalf of `assets`.
+*
+* @param sctx - Domain context of the sync module.
+* @param image - The decoded image.
+* @param options - Nine-slice borders in pixels, and whether Pixi generates the mip chain.
+* @returns The new texture.
+* @throws {Error} When the renderer does not draw.
+*/
+function createTexture(sctx, image, options) {
+	const pixi = drawingPixi(sctx, "create");
+	const base = options?.mips === true ? pixi.Texture.from({
+		resource: image,
+		autoGenerateMipmaps: true
+	}) : pixi.Texture.from(image);
+	const nine = options?.nine;
+	if (nine === void 0) return base;
+	const bordered = new pixi.Texture({
+		source: base.source,
+		defaultBorders: defaultBordersOf(nine)
+	});
+	base.destroy(false);
+	return bordered;
+}
+/**
+* Tells whether a frame lies inside a page of the given size. A negative number, or one that is
+* not a number, lies outside.
+*
+* @param frame - The frame in page pixels.
+* @param page - The size of the page.
+* @param page.width - Width of the page in pixels.
+* @param page.height - Height of the page in pixels.
+* @returns True when the whole frame is on the page.
+* @example
+* ```ts
+* frameFits({ x: 256, y: 384, width: 256, height: 128 }, { width: 512, height: 512 }); // true
+* ```
+*/
+function frameFits(frame, page) {
+	return frame.x >= 0 && frame.y >= 0 && frame.width >= 0 && frame.height >= 0 && frame.x + frame.width <= page.width && frame.y + frame.height <= page.height;
+}
+/**
+* Cuts a texture out of an atlas page, on behalf of `assets`. The slice shares the page's source,
+* its frame is offset by the page's own frame, and it is marked as a slice so `destroyTexture`
+* frees only the wrapper.
+*
+* @param sctx - Domain context of the sync module.
+* @param page - The page texture.
+* @param frame - The frame in page pixels.
+* @param options - Nine-slice borders, in pixels.
+* @returns The slice.
+* @throws {Error} When the renderer does not draw, and when the frame does not fit in the page.
+*/
+function sliceTexture(sctx, page, frame, options) {
+	const pixi = drawingPixi(sctx, "slice");
+	if (!frameFits(frame, page)) throw new Error(`[game] renderer.sync.textures.slice: frame ${frame.x},${frame.y} ${frame.width}x${frame.height} is outside page ${page.width}x${page.height}.\n  Run "bun run assets:pack".`);
+	const nine = options?.nine;
+	const slice = new pixi.Texture({
+		source: page.source,
+		frame: new pixi.Rectangle(page.frame.x + frame.x, page.frame.y + frame.y, frame.width, frame.height),
+		...nine === void 0 ? {} : { defaultBorders: defaultBordersOf(nine) }
+	});
+	sctx.ctx.state.sync.slices.add(slice);
+	return slice;
+}
+/**
+* The cache key of one crop: the asset key and the box it covers.
+*
+* @param key - The asset key.
+* @param width - Width of the box.
+* @param height - Height of the box.
+* @returns The key of the crop.
+* @example
+* ```ts
+* frameKeyOf("board.bg", 1080, 1920); // "board.bg@1080x1920"
+* ```
+*/
+function frameKeyOf(key, width, height) {
+	return `${key}@${width}x${height}`;
+}
+/**
+* The texture a `"cover"` sprite draws: the part of `base` inside `crop`, sharing its source. One
+* crop per asset key and box, shared by every entity that shows it; the entity is added to its
+* users. A key that answers a new base has been invalidated, so every view of it resolves again
+* in this pass and joins the new crop; the old crop goes at once.
+*
+* @param sctx - Domain context of the sync module.
+* @param entity - The entity that shows the crop.
+* @param key - The asset key the base was resolved for.
+* @param base - The texture the key resolves to.
+* @param box - The box the sprite covers, which names the crop.
+* @param box.width - Width of the box.
+* @param box.height - Height of the box.
+* @param crop - The part of the base to show, in texture pixels.
+* @returns The crop and its `frames` key, or the base and `""` while inert.
+*/
+function coverTexture(sctx, entity, key, base, box, crop) {
+	const frames = sctx.ctx.state.sync.frames;
+	const frameKey = frameKeyOf(key, box.width, box.height);
+	const cached = frames.get(frameKey);
+	if (cached?.base === base) {
+		cached.users.add(entity);
+		return {
+			texture: cached.texture,
+			frameKey
+		};
+	}
+	const pixi = sctx.deps.host.pixi();
+	if (pixi === void 0) return {
+		texture: base,
+		frameKey: ""
+	};
+	if (cached !== void 0) cached.texture.destroy(false);
+	const texture = new pixi.Texture({
+		source: base.source,
+		frame: new pixi.Rectangle(base.frame.x + crop.x, base.frame.y + crop.y, crop.width, crop.height)
+	});
+	const users = emptySet$5();
+	users.add(entity);
+	frames.set(frameKey, {
+		base,
+		texture,
+		users
+	});
+	return {
+		texture,
+		frameKey
+	};
+}
+/**
+* Lets an entity go of the crop it showed. The last user frees the crop, keeping the source it
+* shares with its base.
+*
+* @param state - The sync branch of the plugin state.
+* @param entity - The entity that no longer shows it.
+* @param frameKey - The `frames` key of the crop; `""` for none.
+*/
+function releaseCover(state, entity, frameKey) {
+	const frame = state.frames.get(frameKey);
+	if (frame === void 0) return;
+	frame.users.delete(entity);
+	if (frame.users.size > 0) return;
+	frame.texture.destroy(false);
+	state.frames.delete(frameKey);
+}
+/**
+* Frees the crops cut from one texture, keeping the source they share with it.
+*
+* @param state - The sync branch of the plugin state.
+* @param base - The texture that goes.
+*/
+function releaseFrames$1(state, base) {
+	for (const [frameKey, frame] of state.frames) {
+		if (frame.base !== base) continue;
+		frame.texture.destroy(false);
+		state.frames.delete(frameKey);
+	}
+}
+/**
+* Frees every crop. Works on the state alone, because `onStop` has no context.
+*
+* @param state - The sync branch of the plugin state.
+*/
+function clearFrames(state) {
+	for (const frame of state.frames.values()) frame.texture.destroy(false);
+	state.frames.clear();
+}
+/**
+* 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 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.
+*/
+function destroyTexture(state, texture) {
+	releaseFrames$1(state, texture);
+	if (texture.destroyed) return;
+	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/leave.ts
+/** Label of the container the look hangs in, last on the stage. */
+const TOP_LABEL = "renderer.leave";
+/** Clock milliseconds of one turn of the loader. */
+const TURN_MS = 1e3;
+/** A whole turn, in radians. */
+const TURN$1 = 2 * Math.PI;
+/** The engine's ring: three quarters of a white circle 96 u across, 10 u wide, round ends, turned about its centre. */
+const RING = Object.freeze({
+	kind: "arc",
+	w: 96,
+	h: 96,
+	fill: 16777215,
+	fillAlpha: 0,
+	alpha: 1,
+	radius: 0,
+	stroke: 16777215,
+	strokeWidth: 10,
+	dash: 0,
+	clip: false,
+	sweep: .75,
+	cap: "round"
+});
+/**
+* Makes the engine's objects of the picture, once per application: the top container with the veil and the frame, and
+* in the frame the holder of a lifted layer, the ring and the spinner. Nothing hangs on the stage yet.
+*
+* @param sctx - Domain context of the sync module.
+* @returns The objects, or `undefined` while nothing draws (inert, a lost device).
+*/
+function objectsOf(sctx) {
+	const leave = sctx.ctx.state.sync.leave;
+	if (leave.objects !== void 0) return leave.objects;
+	const pixi = sctx.deps.host.pixi();
+	if (pixi === void 0 || sctx.deps.host.stage() === void 0) return void 0;
+	const top = new pixi.Container();
+	const veil = new pixi.Sprite(pixi.Texture.WHITE);
+	const frame = new pixi.Container();
+	const held = new pixi.Container();
+	const ring = new pixi.Graphics();
+	const spinner = new pixi.Sprite(pixi.Texture.WHITE);
+	top.label = TOP_LABEL;
+	veil.label = `${TOP_LABEL}.cover`;
+	veil.anchor.set(0, 0);
+	held.label = `${TOP_LABEL}.layer`;
+	ring.label = `${TOP_LABEL}.ring`;
+	paintShape(ring, RING, RING.stroke);
+	ring.pivot.set(RING.w / 2, RING.h / 2);
+	spinner.label = `${TOP_LABEL}.texture`;
+	spinner.anchor.set(.5, .5);
+	frame.addChild(held);
+	frame.addChild(ring);
+	frame.addChild(spinner);
+	top.addChild(veil);
+	top.addChild(frame);
+	leave.objects = {
+		top,
+		veil,
+		frame,
+		held,
+		ring,
+		spinner
+	};
+	return leave.objects;
+}
+/**
+* What the loader of a look draws once due: a game texture, a layer above the veil, or the engine's ring. A texture key
+* no provider answers is warned once and draws the ring.
+*
+* @param sctx - Domain context of the sync module.
+* @param look - The look being shown.
+* @returns The loader's kind, and the texture of a `"texture"` loader.
+*/
+function loaderOf$1(sctx, look) {
+	const loader = look.loader;
+	if (loader === void 0) return { loader: "none" };
+	if (loader.texture === void 0) return { loader: loader.due === void 0 ? "ring" : "layer" };
+	const texture = resolveTexture(sctx, loader.texture);
+	if (texture !== void 0) return {
+		loader: "texture",
+		texture
+	};
+	warnMissing(sctx, loader.texture);
+	return { loader: "ring" };
+}
+/**
+* Puts a layer the look drew above the veil back under the root, at the place of its layer: the layer list of the
+* scene orders the root's children. A layer the list of a swap took back already, or let go, is left alone.
+*
+* @param sctx - Domain context of the sync module.
+* @param run - The look whose layer goes back.
+*/
+function unlift(sctx, run) {
+	const lifted = run.lifted;
+	if (lifted === void 0) return;
+	delete run.lifted;
+	const state = sctx.ctx.state.sync;
+	if (lifted.parent !== state.leave.objects?.held) return;
+	const name = run.layer;
+	const at = state.layerList?.findIndex((spec) => spec.name === name) ?? -1;
+	const root = state.root;
+	state.passesVersion += 1;
+	if (root === void 0 || at === -1) {
+		detach$1(lifted);
+		return;
+	}
+	root.addChildAt(lifted, Math.min(at, root.children.length));
+}
+/**
+* Takes the look down at once: its layer goes back, its objects leave the stage and are kept for the next look, and the
+* spinner lets the game's texture go. A frame is asked for, so the screen without it is drawn.
+*
+* @param sctx - Domain context of the sync module.
+*/
+function takeDown(sctx) {
+	const leave = sctx.ctx.state.sync.leave;
+	const run = leave.run;
+	if (run !== void 0) unlift(sctx, run);
+	delete leave.run;
+	const objects = leave.objects;
+	if (objects !== void 0) {
+		detach$1(objects.top);
+		const white = placeholderTexture(sctx);
+		if (white !== void 0) objects.spinner.texture = white;
+	}
+	sctx.deps.demand.request();
+}
+/**
+* Moves the veil's level on the clock: up to 1 over `inMs` before the swap, down to 0 over `outMs` after it.
+*
+* @param run - The running look.
+* @param now - The clock now, ms.
+* @returns True when the level moved: the frame is drawn.
+*/
+function advance(run, now) {
+	const cover = run.look.cover;
+	const elapsed = Math.max(0, now - run.steppedAt);
+	const before = run.level;
+	run.steppedAt = now;
+	if (cover === void 0) return false;
+	if (run.landed) run.level = cover.outMs > 0 ? Math.max(0, before - elapsed / cover.outMs) : 0;
+	else run.level = cover.inMs > 0 ? Math.min(1, before + elapsed / cover.inMs) : 1;
+	return run.level !== before;
+}
+/**
+* Hangs the look last on the stage and over the canvas as it stands: the veil covers the screen, the frame carries the
+* root's transform, so what it holds lands where the scene's reference units do.
+*
+* @param sctx - Domain context of the sync module.
+* @param objects - The engine's objects.
+* @param stage - The stage of the application.
+* @param screen - The canvas in CSS pixels, the stage's own space.
+* @param screen.x - Its left edge.
+* @param screen.y - Its top edge.
+* @param screen.width - Its width.
+* @param screen.height - Its height.
+*/
+function hang$1(sctx, objects, stage, screen) {
+	if (stage.children.at(-1) !== objects.top) stage.addChild(objects.top);
+	objects.veil.position.set(screen.x, screen.y);
+	objects.veil.scale.set(screen.width, screen.height);
+	sctx.deps.viewport.apply(objects.frame);
+}
+/**
+* Asks a `"layer"` loader's `due`, once, the first frame it is due: what it draws is made now, and it answers the
+* layer that holds it. No layer, or a throw (logged), draws the ring instead.
+*
+* @param sctx - Domain context of the sync module.
+* @param run - The running look, its loader due.
+*/
+function ask(sctx, run) {
+	run.asked = true;
+	let layer;
+	try {
+		layer = run.look.loader?.due?.();
+	} catch (error) {
+		sctx.ctx.log.error("renderer: the loader of a scene being left threw", { error });
+	}
+	if (layer === void 0) run.loader = "ring";
+	else run.layer = layer;
+}
+/**
+* Writes the veil of a running look: its colour, and its alpha at the level it stands at; hidden for a look without one.
+*
+* @param objects - The engine's objects.
+* @param run - The running look.
+*/
+function paintVeil(objects, run) {
+	const cover = run.look.cover;
+	objects.veil.visible = cover !== void 0;
+	if (cover === void 0) return;
+	objects.veil.tint = cover.color;
+	objects.veil.alpha = cover.alpha * run.level;
+}
+/**
+* Keeps the layer of a shown `"layer"` loader in the holder above the veil until the swap. A layer the scene does not
+* declare draws nothing.
+*
+* @param sctx - Domain context of the sync module.
+* @param objects - The engine's objects.
+* @param run - The running look, its loader shown.
+*/
+function lift(sctx, objects, run) {
+	const state = sctx.ctx.state.sync;
+	const container = run.layer === void 0 ? void 0 : layerContainer(state, run.layer);
+	if (container === void 0 || container.parent === objects.held) return;
+	objects.held.addChild(container);
+	run.lifted = container;
+	state.passesVersion += 1;
+}
+/**
+* Turns the ring or the spinner at the centre of the frame: one turn a second from the switch start.
+*
+* @param objects - The engine's objects.
+* @param run - The running look, its loader shown.
+* @param now - The clock now, ms.
+* @param size - The frame in reference units.
+*/
+function turn(objects, run, now, size) {
+	const angle = (now - run.startedAt) % TURN_MS / TURN_MS * TURN$1;
+	const turned = run.loader === "ring" ? objects.ring : objects.spinner;
+	if (run.texture !== void 0 && objects.spinner.texture !== run.texture) objects.spinner.texture = run.texture;
+	turned.position.set(size.width / 2, size.height / 2);
+	turned.rotation = angle;
+}
+/**
+* Shows the loader once the switch took `afterMs`, until the swap: a layer loader asks its `due` then and lifts the
+* layer it answers above the veil; a ring or a texture turns. A loader that comes or goes moves the walks of `shown`,
+* so the loops of a lifted layer's views run while it shows.
+*
+* @param sctx - Domain context of the sync module.
+* @param objects - The engine's objects.
+* @param run - The running look.
+* @param now - The clock now, ms.
+* @returns True when the loader came, went or turns in this frame: the frame is drawn.
+*/
+function paintLoader(sctx, objects, run, now) {
+	const afterMs = run.look.loader?.afterMs ?? 0;
+	const shown = !run.landed && run.loader !== "none" && now - run.startedAt >= afterMs;
+	const due = shown && run.loader === "layer";
+	if (due && !run.asked) ask(sctx, run);
+	if (due) lift(sctx, objects, run);
+	const toggled = shown !== run.shown;
+	if (toggled) {
+		run.shown = shown;
+		sctx.ctx.state.sync.passesVersion += 1;
+	}
+	const isLayer = shown && run.loader === "layer";
+	objects.held.visible = isLayer;
+	objects.ring.visible = shown && run.loader === "ring";
+	objects.spinner.visible = shown && run.loader === "texture";
+	if (!shown || isLayer) return toggled;
+	turn(objects, run, now, sctx.deps.viewport.size());
+	return true;
+}
+/**
+* Shows a look from now, in place of one that runs: the veil fades in from where it stands (0, or the level of a veil
+* still fading out after the last swap), the loader waits for its `afterMs`. Inert, nothing is kept.
+*
+* @param sctx - Domain context of the sync module.
+* @param look - The veil and the loader, resolved.
+*/
+function showLeave(sctx, look) {
+	const state = sctx.ctx.state.sync;
+	if (state.root === void 0) return;
+	const before = state.leave.run;
+	if (before !== void 0) unlift(sctx, before);
+	const now = sctx.ctx.deps.clock.now();
+	const level = before?.look.cover === void 0 ? 0 : before.level;
+	const loader = loaderOf$1(sctx, look);
+	state.leave.run = {
+		look,
+		startedAt: now,
+		steppedAt: now,
+		level,
+		landed: false,
+		asked: false,
+		shown: false,
+		...loader
+	};
+	sctx.deps.demand.request();
+}
+/**
+* The swap came: the loader goes at once and the veil fades out over its `outMs` from where it stands; a look without
+* a veil, or with `outMs: 0`, is taken down at once. Nothing runs, or the swap was told already: nothing happens.
+*
+* @param sctx - Domain context of the sync module.
+*/
+function landLeave(sctx) {
+	const run = sctx.ctx.state.sync.leave.run;
+	if (run === void 0 || run.landed) return;
+	const cover = run.look.cover;
+	if (cover === void 0 || cover.outMs <= 0) {
+		takeDown(sctx);
+		return;
+	}
+	unlift(sctx, run);
+	run.landed = true;
+	run.steppedAt = sctx.ctx.deps.clock.now();
+	sctx.deps.demand.request();
+}
+/**
+* The switch ended without a swap: the veil and the loader go at once. Nothing runs: nothing happens.
+*
+* @param sctx - Domain context of the sync module.
+*/
+function dropLeave(sctx) {
+	if (sctx.ctx.state.sync.leave.run === void 0) return;
+	takeDown(sctx);
+}
+/**
+* The look of this frame, before the decision: the veil's level from the clock, the loader once due, both placed over
+* the canvas as it stands, and a frame asked for while either moves. A look whose veil faded out after the swap is
+* taken down. One field read and no allocation while no look runs; a lost device leaves the look waiting for the
+* restore, which makes its objects again.
+*
+* @param sctx - Domain context of the sync module.
+*/
+function stepLeave(sctx) {
+	const run = sctx.ctx.state.sync.leave.run;
+	if (run === void 0) return;
+	const objects = objectsOf(sctx);
+	const stage = sctx.deps.host.stage();
+	const screen = sctx.deps.host.screen();
+	if (objects === void 0 || stage === void 0 || screen === void 0) return;
+	const now = sctx.ctx.deps.clock.now();
+	const moved = advance(run, now);
+	if (run.landed && run.level <= 0) {
+		takeDown(sctx);
+		return;
+	}
+	hang$1(sctx, objects, stage, screen);
+	paintVeil(objects, run);
+	const loading = paintLoader(sctx, objects, run, now);
+	if (moved || loading) sctx.deps.demand.request();
+}
+/**
+* Forgets the objects of a lost application: they go with its stage, and so does a layer lifted above the veil. The
+* running look stays: the step makes its objects again on the restored device.
+*
+* @param state - The sync branch of the plugin state.
+*/
+function forgetLeave$1(state) {
+	delete state.leave.objects;
+	if (state.leave.run !== void 0) delete state.leave.run.lifted;
+}
+/**
+* Drops the look and frees the engine's objects when the plugin stops. A lifted layer is the layer table's and the
+* spinner's texture is the game's: neither is freed with them.
+*
+* @param state - The sync branch of the plugin state.
+*/
+function stopLeave(state) {
+	const objects = state.leave.objects;
+	delete state.leave.run;
+	delete state.leave.objects;
+	if (objects === void 0) return;
+	objects.held.removeChildren();
+	objects.top.destroy({ children: true });
+}
+//#endregion
 //#region src/plugins/renderer/sync/overlay-range.ts
 /** A range retaken for a mark in this many frames in a row is drawn live instead (O8.4; spec 23's `CHURN_LIMIT`). */
 const RETAKE_STREAK = 3;
@@ -26718,349 +27964,6 @@ function stopOverlays(state) {
 	overlay.range = void 0;
 }
 //#endregion
-//#region src/plugins/renderer/sync/shape-path.ts
-/**
-* @file renderer/sync — the path of a `Shape`: a rectangle, a rounded rectangle or a triangle,
-* its fill, and its stroke, solid or dashed, or an arc, a stroke alone. A dashed stroke walks the
-* outline (straight edges, and rounded corners sampled as arcs) and strokes one open line per dash.
-* An arc runs on the circle inscribed in its box, from 12 o'clock clockwise.
-*/
-/** Chords per rounded corner of a dashed outline: under 0.3 u off the arc at a 48 u radius. */
-const CORNER_SAMPLES = 8;
-/** The gap between two dashes, as a fraction of the dash length. */
-const GAP_RATIO = .5;
-/** Segments of a full ring: a ring of 28 u across strays under 0.03 u off its circle. */
-const RING_SEGMENTS = 48;
-/** The fewest segments of an arc that draws: a sliver still bends. */
-const ARC_MIN_SEGMENTS = 2;
-/** 12 o'clock, where an arc starts: Pixi's angles run clockwise from 3 o'clock. */
-const TWELVE = -Math.PI / 2;
-/**
-* The corner radius the rectangle is drawn with: Pixi clamps it to half the shorter side.
-*
-* @param value - The shape value.
-* @returns The radius in reference units, 0 for square corners.
-* @example
-* ```ts
-* radiusOf({ ...Shape.defaults, w: 100, h: 20, radius: 40 }); // 10
-* ```
-*/
-function radiusOf(value) {
-	return Math.max(0, Math.min(value.radius, value.w / 2, value.h / 2));
-}
-/**
-* The closed outline of a shape as points, clockwise from the top left (from the end of the top
-* left corner on a rounded rectangle); the last point repeats the first.
-*
-* @param value - The shape value.
-* @returns The points of the outline.
-* @example
-* ```ts
-* outlineOf({ ...Shape.defaults, kind: "triangle", w: 60, h: 40 });
-* // [{ x: 0, y: 0 }, { x: 60, y: 20 }, { x: 0, y: 40 }, { x: 0, y: 0 }]
-* ```
-*/
-function outlineOf(value) {
-	const { w, h } = value;
-	if (value.kind === "triangle") return [
-		{
-			x: 0,
-			y: 0
-		},
-		{
-			x: w,
-			y: h / 2
-		},
-		{
-			x: 0,
-			y: h
-		},
-		{
-			x: 0,
-			y: 0
-		}
-	];
-	const radius = radiusOf(value);
-	if (radius === 0) return [
-		{
-			x: 0,
-			y: 0
-		},
-		{
-			x: w,
-			y: 0
-		},
-		{
-			x: w,
-			y: h
-		},
-		{
-			x: 0,
-			y: h
-		},
-		{
-			x: 0,
-			y: 0
-		}
-	];
-	const corners = [
-		{
-			edge: {
-				x: w - radius,
-				y: 0
-			},
-			center: {
-				x: w - radius,
-				y: radius
-			}
-		},
-		{
-			edge: {
-				x: w,
-				y: h - radius
-			},
-			center: {
-				x: w - radius,
-				y: h - radius
-			}
-		},
-		{
-			edge: {
-				x: radius,
-				y: h
-			},
-			center: {
-				x: radius,
-				y: h - radius
-			}
-		},
-		{
-			edge: {
-				x: 0,
-				y: radius
-			},
-			center: {
-				x: radius,
-				y: radius
-			}
-		}
-	];
-	const points = [{
-		x: radius,
-		y: 0
-	}];
-	for (const [index, { edge, center }] of corners.entries()) {
-		const from = -Math.PI / 2 + index * Math.PI / 2;
-		points.push(edge);
-		for (let sample = 1; sample <= CORNER_SAMPLES; sample += 1) {
-			const angle = from + sample * Math.PI / 2 / CORNER_SAMPLES;
-			points.push({
-				x: center.x + radius * Math.cos(angle),
-				y: center.y + radius * Math.sin(angle)
-			});
-		}
-	}
-	return points;
-}
-/**
-* Adds a point to a line unless the line already ends there.
-*
-* @param line - The line.
-* @param point - The point.
-*/
-function extend(line, point) {
-	const last = line.at(-1);
-	if (last?.x !== point.x || last.y !== point.y) line.push(point);
-}
-/**
-* Cuts a polyline into dashes of `dash` length with gaps of half a dash, starting with a dash at
-* its first point. A dash bends round the corners it crosses; the last one may be shorter.
-*
-* @param outline - The points of the polyline.
-* @param dash - The dash length, above 0.
-* @returns One open line per dash.
-* @example
-* ```ts
-* dashesOf([{ x: 0, y: 0 }, { x: 40, y: 0 }], 10);
-* // [[{ x: 0, y: 0 }, { x: 10, y: 0 }], [{ x: 15, y: 0 }, { x: 25, y: 0 }], [{ x: 30, y: 0 }, { x: 40, y: 0 }]]
-* ```
-*/
-function dashesOf(outline, dash) {
-	const first = outline[0];
-	if (first === void 0) return [];
-	const dashes = [];
-	let line = [first];
-	let left = dash;
-	for (let index = 1; index < outline.length; index += 1) {
-		let from = outline[index - 1] ?? first;
-		const to = outline[index] ?? first;
-		let length = Math.hypot(to.x - from.x, to.y - from.y);
-		while (length > left) {
-			from = {
-				x: from.x + (to.x - from.x) * left / length,
-				y: from.y + (to.y - from.y) * left / length
-			};
-			length -= left;
-			if (line === void 0) {
-				line = [from];
-				left = dash;
-			} else {
-				extend(line, from);
-				dashes.push(line);
-				line = void 0;
-				left = dash * GAP_RATIO;
-			}
-		}
-		left -= length;
-		if (line !== void 0) extend(line, to);
-	}
-	if (line !== void 0 && line.length > 1) dashes.push(line);
-	return dashes;
-}
-/**
-* Draws the path of a shape and fills it in a colour at the alpha given. At alpha 0 the path stays unfilled, so only
-* a stroke shows. A clip mask is drawn here too, never dashed; the path of an arc here is its box, which is what it
-* clips its children to. A fill-only shape is drawn white and coloured by the object's tint, so a colour change draws
-* no path (spec 26 R2.1).
-*
-* @param object - The graphics to draw on.
-* @param value - The shape value.
-* @param fillAlpha - The alpha of the fill: the value's own for the shape, 1 for a clip mask.
-* @param color - The colour of the fill: the value's own by default, white for a tinted shape.
-*/
-function drawShapePath(object, value, fillAlpha, color = value.fill) {
-	object.clear();
-	if (value.kind === "triangle") object.moveTo(0, 0).lineTo(value.w, value.h / 2).lineTo(0, value.h).closePath();
-	else if (value.kind === "rect" && value.radius > 0) object.roundRect(0, 0, value.w, value.h, value.radius);
-	else object.rect(0, 0, value.w, value.h);
-	if (fillAlpha <= 0) return;
-	object.fill(fillAlpha < 1 ? {
-		color,
-		alpha: fillAlpha
-	} : { color });
-}
-/**
-* Strokes the outline drawn by `drawShapePath`: solid over the same path, or, with a `dash`, as
-* one open line per dash on a new path. Nothing without a stroke width.
-*
-* @param object - The graphics the shape was drawn on.
-* @param value - The shape value.
-*/
-function strokeShape(object, value) {
-	if (value.strokeWidth <= 0) return;
-	const style = {
-		color: value.stroke,
-		width: value.strokeWidth
-	};
-	if (value.dash <= 0) {
-		object.stroke(style);
-		return;
-	}
-	object.beginPath();
-	for (const [start, ...rest] of dashesOf(outlineOf(value), value.dash)) {
-		if (start === void 0) continue;
-		object.moveTo(start.x, start.y);
-		for (const point of rest) object.lineTo(point.x, point.y);
-	}
-	object.stroke(style);
-}
-/**
-* The share of the circle an arc sweeps, clamped to 0..1: anything not above 0, `NaN` too, is 0; a whole ring when
-* the value leaves it out.
-*
-* @param value - The shape value.
-* @returns The share.
-* @example
-* ```ts
-* sweepOf({ ...Shape.defaults, kind: "arc", sweep: 1.4 }); // 1
-* ```
-*/
-function sweepOf(value) {
-	const sweep = value.sweep ?? arcDefaults.sweep;
-	if (Number.isNaN(sweep) || sweep <= 0) return 0;
-	return Math.min(sweep, 1);
-}
-/**
-* The radius of the circle an arc runs on: inscribed in the shorter side of its box, inside its stroke.
-*
-* @param value - The shape value.
-* @returns The radius in reference units; 0 or below when the stroke leaves no circle.
-* @example
-* ```ts
-* arcRadiusOf({ ...Shape.defaults, kind: "arc", w: 28, h: 40, strokeWidth: 2 }); // 13
-* ```
-*/
-function arcRadiusOf(value) {
-	return (Math.min(value.w, value.h) - value.strokeWidth) / 2;
-}
-/**
-* Tells whether an arc draws nothing: no stroke width, no sweep, or no circle inside its stroke.
-*
-* @param value - The shape value, an arc.
-* @returns True for an arc whose `Graphics` would hold no instruction.
-* @example
-* ```ts
-* isEmptyArc({ ...Shape.defaults, kind: "arc", w: 28, h: 28, strokeWidth: 2, sweep: 0 }); // true
-* ```
-*/
-function isEmptyArc(value) {
-	return value.strokeWidth <= 0 || sweepOf(value) <= 0 || arcRadiusOf(value) <= 0;
-}
-/**
-* Strokes an arc: from 12 o'clock clockwise over its share of the circle, in segments as many as its angle needs (48
-* for a ring, at least 2), ended by its `cap`. A full ring is closed and has no ends. Nothing for an empty arc. Drawn
-* only when the shape changed: never rebuilt per frame.
-*
-* @param object - The graphics, cleared.
-* @param value - The shape value, an arc.
-*/
-function strokeArc(object, value) {
-	if (isEmptyArc(value)) return;
-	const sweep = sweepOf(value);
-	const radius = arcRadiusOf(value);
-	const ring = sweep >= 1;
-	const segments = Math.max(ARC_MIN_SEGMENTS, Math.ceil(sweep * RING_SEGMENTS));
-	const step = sweep * 2 * Math.PI / segments;
-	const centreX = value.w / 2;
-	const centreY = value.h / 2;
-	const last = ring ? segments - 1 : segments;
-	object.moveTo(centreX, centreY - radius);
-	for (let index = 1; index <= last; index += 1) {
-		const angle = TWELVE + index * step;
-		object.lineTo(centreX + radius * Math.cos(angle), centreY + radius * Math.sin(angle));
-	}
-	if (ring) {
-		object.closePath();
-		object.stroke({
-			color: value.stroke,
-			width: value.strokeWidth
-		});
-		return;
-	}
-	object.stroke({
-		color: value.stroke,
-		width: value.strokeWidth,
-		cap: value.cap ?? arcDefaults.cap
-	});
-}
-/**
-* Paints a shape on its graphics: an arc as its stroke alone, every other kind as its path, its fill in a colour at its
-* own fill alpha, and its stroke. The one call that draws a shape's visual.
-*
-* @param object - The graphics.
-* @param value - The shape value.
-* @param color - The colour of the fill: white for a tinted shape, the value's own otherwise.
-*/
-function paintShape(object, value, color) {
-	if (value.kind === "arc") {
-		object.clear();
-		strokeArc(object, value);
-		return;
-	}
-	drawShapePath(object, value, value.fillAlpha, color);
-	strokeShape(object, value);
-}
-//#endregion
 //#region src/plugins/renderer/sync/sizing.ts
 /**
 * Creates a layout to write into, every field present.
@@ -27196,299 +28099,6 @@ function layoutSpriteInto(out, texture, value) {
 	return out;
 }
 //#endregion
-//#region src/plugins/renderer/sync/textures.ts
-/** The colour a missing texture is drawn in. */
-const PLACEHOLDER_TINT = 16711935;
-/**
-* Creates an empty set. It lives in its own non-exported function because lint rule L5 refuses a
-* collection built inside an exported declaration.
-*
-* @returns An empty set.
-*/
-function emptySet$5() {
-	return /* @__PURE__ */ new Set();
-}
-/**
-* Asks the providers from the newest to the oldest. The first answer wins, so a bundle loaded
-* later shadows an older one.
-*
-* @param sctx - Domain context of the sync module.
-* @param key - The asset key.
-* @returns The texture, or `undefined` when nothing answered.
-*/
-function resolveTexture(sctx, key) {
-	const providers = sctx.ctx.state.sync.providers;
-	for (let index = providers.length - 1; index >= 0; index -= 1) {
-		const texture = providers[index]?.(key);
-		if (texture !== void 0) return texture;
-	}
-}
-/**
-* The 1x1 white texture the placeholder is drawn with.
-*
-* @param sctx - Domain context of the sync module.
-* @returns The texture, or `undefined` while inert.
-*/
-function placeholderTexture(sctx) {
-	return sctx.deps.host.pixi()?.Texture.WHITE;
-}
-/**
-* Reports a key no provider answers. One key warns once, however many views use it.
-*
-* @param sctx - Domain context of the sync module.
-* @param key - The asset key.
-*/
-function warnMissing(sctx, key) {
-	const warned = sctx.ctx.state.sync.warned;
-	if (key === "" || warned.has(key)) return;
-	warned.add(key);
-	sctx.ctx.log.warn("renderer: no texture for asset key", { key });
-}
-/**
-* Remembers that an entity draws a key, so `invalidate` finds it again.
-*
-* @param state - The sync branch of the plugin state.
-* @param entity - The entity.
-* @param key - The asset key.
-*/
-function trackKey(state, entity, key) {
-	const users = state.byKey.get(key) ?? emptySet$5();
-	users.add(entity);
-	state.byKey.set(key, users);
-}
-/**
-* Forgets that an entity draws a key.
-*
-* @param state - The sync branch of the plugin state.
-* @param entity - The entity.
-* @param key - The asset key.
-*/
-function untrackKey(state, entity, key) {
-	const users = state.byKey.get(key);
-	if (users === void 0) return;
-	users.delete(entity);
-	if (users.size === 0) state.byKey.delete(key);
-}
-/**
-* The Pixi module of a renderer that draws. A texture made while it does not would be lost with
-* the device, so the member that asked throws.
-*
-* @param sctx - Domain context of the sync module.
-* @param member - The `textures` member that asked, for the message.
-* @returns The Pixi module.
-* @throws {Error} When the renderer does not draw.
-*/
-function drawingPixi(sctx, member) {
-	const pixi = sctx.deps.host.pixi();
-	if (pixi === void 0 || !sctx.deps.host.ready()) throw new Error(`[game] renderer.sync.textures.${member} needs a ready renderer.\n  Check app.renderer.host.ready() first.`);
-	return pixi;
-}
-/**
-* The default borders of a texture, from the four numbers `nine` gives.
-*
-* @param nine - Left, top, right and bottom in pixels.
-* @returns The borders, as Pixi reads them.
-* @example
-* ```ts
-* defaultBordersOf([24, 20, 16, 12]); // { left: 24, top: 20, right: 16, bottom: 12 }
-* ```
-*/
-function defaultBordersOf(nine) {
-	return {
-		left: nine[0],
-		top: nine[1],
-		right: nine[2],
-		bottom: nine[3]
-	};
-}
-/**
-* Makes a Pixi texture out of a decoded image, on behalf of `assets`.
-*
-* @param sctx - Domain context of the sync module.
-* @param image - The decoded image.
-* @param options - Nine-slice borders in pixels, and whether Pixi generates the mip chain.
-* @returns The new texture.
-* @throws {Error} When the renderer does not draw.
-*/
-function createTexture(sctx, image, options) {
-	const pixi = drawingPixi(sctx, "create");
-	const base = options?.mips === true ? pixi.Texture.from({
-		resource: image,
-		autoGenerateMipmaps: true
-	}) : pixi.Texture.from(image);
-	const nine = options?.nine;
-	if (nine === void 0) return base;
-	const bordered = new pixi.Texture({
-		source: base.source,
-		defaultBorders: defaultBordersOf(nine)
-	});
-	base.destroy(false);
-	return bordered;
-}
-/**
-* Tells whether a frame lies inside a page of the given size. A negative number, or one that is
-* not a number, lies outside.
-*
-* @param frame - The frame in page pixels.
-* @param page - The size of the page.
-* @param page.width - Width of the page in pixels.
-* @param page.height - Height of the page in pixels.
-* @returns True when the whole frame is on the page.
-* @example
-* ```ts
-* frameFits({ x: 256, y: 384, width: 256, height: 128 }, { width: 512, height: 512 }); // true
-* ```
-*/
-function frameFits(frame, page) {
-	return frame.x >= 0 && frame.y >= 0 && frame.width >= 0 && frame.height >= 0 && frame.x + frame.width <= page.width && frame.y + frame.height <= page.height;
-}
-/**
-* Cuts a texture out of an atlas page, on behalf of `assets`. The slice shares the page's source,
-* its frame is offset by the page's own frame, and it is marked as a slice so `destroyTexture`
-* frees only the wrapper.
-*
-* @param sctx - Domain context of the sync module.
-* @param page - The page texture.
-* @param frame - The frame in page pixels.
-* @param options - Nine-slice borders, in pixels.
-* @returns The slice.
-* @throws {Error} When the renderer does not draw, and when the frame does not fit in the page.
-*/
-function sliceTexture(sctx, page, frame, options) {
-	const pixi = drawingPixi(sctx, "slice");
-	if (!frameFits(frame, page)) throw new Error(`[game] renderer.sync.textures.slice: frame ${frame.x},${frame.y} ${frame.width}x${frame.height} is outside page ${page.width}x${page.height}.\n  Run "bun run assets:pack".`);
-	const nine = options?.nine;
-	const slice = new pixi.Texture({
-		source: page.source,
-		frame: new pixi.Rectangle(page.frame.x + frame.x, page.frame.y + frame.y, frame.width, frame.height),
-		...nine === void 0 ? {} : { defaultBorders: defaultBordersOf(nine) }
-	});
-	sctx.ctx.state.sync.slices.add(slice);
-	return slice;
-}
-/**
-* The cache key of one crop: the asset key and the box it covers.
-*
-* @param key - The asset key.
-* @param width - Width of the box.
-* @param height - Height of the box.
-* @returns The key of the crop.
-* @example
-* ```ts
-* frameKeyOf("board.bg", 1080, 1920); // "board.bg@1080x1920"
-* ```
-*/
-function frameKeyOf(key, width, height) {
-	return `${key}@${width}x${height}`;
-}
-/**
-* The texture a `"cover"` sprite draws: the part of `base` inside `crop`, sharing its source. One
-* crop per asset key and box, shared by every entity that shows it; the entity is added to its
-* users. A key that answers a new base has been invalidated, so every view of it resolves again
-* in this pass and joins the new crop; the old crop goes at once.
-*
-* @param sctx - Domain context of the sync module.
-* @param entity - The entity that shows the crop.
-* @param key - The asset key the base was resolved for.
-* @param base - The texture the key resolves to.
-* @param box - The box the sprite covers, which names the crop.
-* @param box.width - Width of the box.
-* @param box.height - Height of the box.
-* @param crop - The part of the base to show, in texture pixels.
-* @returns The crop and its `frames` key, or the base and `""` while inert.
-*/
-function coverTexture(sctx, entity, key, base, box, crop) {
-	const frames = sctx.ctx.state.sync.frames;
-	const frameKey = frameKeyOf(key, box.width, box.height);
-	const cached = frames.get(frameKey);
-	if (cached?.base === base) {
-		cached.users.add(entity);
-		return {
-			texture: cached.texture,
-			frameKey
-		};
-	}
-	const pixi = sctx.deps.host.pixi();
-	if (pixi === void 0) return {
-		texture: base,
-		frameKey: ""
-	};
-	if (cached !== void 0) cached.texture.destroy(false);
-	const texture = new pixi.Texture({
-		source: base.source,
-		frame: new pixi.Rectangle(base.frame.x + crop.x, base.frame.y + crop.y, crop.width, crop.height)
-	});
-	const users = emptySet$5();
-	users.add(entity);
-	frames.set(frameKey, {
-		base,
-		texture,
-		users
-	});
-	return {
-		texture,
-		frameKey
-	};
-}
-/**
-* Lets an entity go of the crop it showed. The last user frees the crop, keeping the source it
-* shares with its base.
-*
-* @param state - The sync branch of the plugin state.
-* @param entity - The entity that no longer shows it.
-* @param frameKey - The `frames` key of the crop; `""` for none.
-*/
-function releaseCover(state, entity, frameKey) {
-	const frame = state.frames.get(frameKey);
-	if (frame === void 0) return;
-	frame.users.delete(entity);
-	if (frame.users.size > 0) return;
-	frame.texture.destroy(false);
-	state.frames.delete(frameKey);
-}
-/**
-* Frees the crops cut from one texture, keeping the source they share with it.
-*
-* @param state - The sync branch of the plugin state.
-* @param base - The texture that goes.
-*/
-function releaseFrames$1(state, base) {
-	for (const [frameKey, frame] of state.frames) {
-		if (frame.base !== base) continue;
-		frame.texture.destroy(false);
-		state.frames.delete(frameKey);
-	}
-}
-/**
-* Frees every crop. Works on the state alone, because `onStop` has no context.
-*
-* @param state - The sync branch of the plugin state.
-*/
-function clearFrames(state) {
-	for (const frame of state.frames.values()) frame.texture.destroy(false);
-	state.frames.clear();
-}
-/**
-* 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 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.
-*/
-function destroyTexture(state, texture) {
-	releaseFrames$1(state, texture);
-	if (texture.destroyed) return;
-	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/upload.ts
 /** The calls of a source nobody waits for: none. */
 const NOBODY = Object.freeze([]);
@@ -28875,6 +29485,7 @@ function stopSync(state) {
 	state.redraws = 0;
 	state.overdraw.listeners.length = 0;
 	clearLayers(state);
+	stopLeave(state);
 	destroyPools(state);
 	state.root?.destroy({ children: true });
 	state.root = void 0;
@@ -29044,6 +29655,7 @@ function renderFrame(ctx, modules) {
 	modules.sync.stepFilters();
 	modules.sync.stepOverlays();
 	modules.sync.drainOverlayEvents(modules.monitor);
+	modules.sync.stepLeave();
 	modules.kept.collect();
 	const overdraw = modules.sync.overdrawing();
 	if (overdraw) modules.demand.request();
@@ -29847,7 +30459,7 @@ function boundsOf(sctx, entity) {
 * @param entity - The entity.
 * @returns The layer name, or `undefined` when the root has no `Layer`.
 */
-function layerOf(sctx, entity) {
+function layerOf$1(sctx, entity) {
 	const ecs = sctx.ctx.deps.world.ecs;
 	let top = entity;
 	for (let depth = 0; depth < MAX_DEPTH$3; depth += 1) {
@@ -30474,7 +31086,7 @@ function stepParts(sctx) {
 		const view = state.views.get(entity);
 		if (view === void 0) continue;
 		const key = ecs.get(entity, HudPart)?.key ?? "";
-		if (hud === void 0 || layerOf(sctx, entity) !== hud) {
+		if (hud === void 0 || layerOf$1(sctx, entity) !== hud) {
 			warnOutside(sctx, entity, key);
 			applyHud(sctx, entity, view, 1);
 			continue;
@@ -31519,6 +32131,7 @@ function createSyncApi(ctx, deps) {
 		destroyPools(state);
 		clearLayers(state);
 		forgetBuild(state);
+		forgetLeave$1(state);
 		state.root = void 0;
 		state.passesVersion += 1;
 	};
@@ -31612,11 +32225,17 @@ function createSyncApi(ctx, deps) {
 			area: (entity, area) => setArea(sctx, entity, area),
 			warm: (filter) => warmFilter(sctx, filter)
 		},
+		leave: {
+			show: (look) => showLeave(sctx, look),
+			land: () => landLeave(sctx),
+			drop: () => dropLeave(sctx)
+		},
 		renderPasses: () => renderPassesOf(state, ctx.state.kept),
 		root: () => state.root,
 		layerContainer: (name) => layerContainer(state, name),
-		layerOf: (entity) => layerOf(sctx, entity),
+		layerOf: (entity) => layerOf$1(sctx, entity),
 		stepOverlays: () => stepOverlays(sctx),
+		stepLeave: () => stepLeave(sctx),
 		stepFilters: () => applySwitched(state, deps.kept),
 		drainOverlayEvents: (monitor) => drainOverlayEvents(sctx, monitor),
 		warmStep: () => warmStep(sctx),
@@ -32205,6 +32824,7 @@ function exposeSync(sync) {
 		fonts: sync.fonts,
 		debug: sync.debug,
 		filters: sync.filters,
+		leave: sync.leave,
 		renderPasses: sync.renderPasses,
 		loopsHeld: sync.loopsHeld,
 		displayOf: sync.displayOf
@@ -32446,8 +33066,8 @@ function createAsideQueue() {
 }
 /**
 * Creates the initial sync state: no root, no layers, no view, no orphan, no pool, no provider, no filter, no
-* filter area, no slice, no hidden mask, no overlay, no warm-up, no upload, no redraw counted, no unseen walk kept and
-* no scene build.
+* filter area, no slice, no hidden mask, no overlay, no warm-up, no upload, no redraw counted, no unseen walk kept,
+* no scene build and no picture of a scene being left.
 *
 * @param debug - The debug switches of the config; copied, so the frozen config stays untouched.
 * @returns The sync branch of the plugin state.
@@ -32512,6 +33132,7 @@ function createSyncState(debug) {
 			count: 0,
 			reported: false
 		},
+		leave: {},
 		cleanups: []
 	};
 }
@@ -35179,7 +35800,7 @@ const NO_ANIMATION_ID = "[game] A play effect carries no animation id.\n  Build
 * isRecord([1, 2]); // false
 * ```
 */
-function isRecord$3(value) {
+function isRecord$4(value) {
 	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 /**
@@ -35304,7 +35925,7 @@ function stepAnim(actx, rt, time) {
 * @returns True when it carries an id and a build function.
 */
 function isAnimation(entry) {
-	return isRecord$3(entry) && typeof entry.id === "string" && typeof entry.build === "function";
+	return isRecord$4(entry) && typeof entry.id === "string" && typeof entry.build === "function";
 }
 /**
 * Reads the `animations` of every feature into the registry, in feature order.
@@ -35331,7 +35952,7 @@ function registerAnimations(actx) {
 */
 function readTarget$1(entry) {
 	if (typeof entry === "number") return entry;
-	if (!isRecord$3(entry)) return void 0;
+	if (!isRecord$4(entry)) return void 0;
 	if (typeof entry.projection === "string" && typeof entry.key === "string") return {
 		projection: entry.projection,
 		key: entry.key
@@ -35347,7 +35968,7 @@ function readTarget$1(entry) {
 */
 function readSlots(value) {
 	const slots = {};
-	if (!isRecord$3(value)) return slots;
+	if (!isRecord$4(value)) return slots;
 	for (const [name, entry] of Object.entries(value)) {
 		if (Array.isArray(entry)) {
 			slots[name] = entry.map((item) => readTarget$1(item)).filter((target) => target !== void 0);
@@ -35365,7 +35986,7 @@ function readSlots(value) {
 * @returns The animation id and its slots, or `undefined` for a foreign payload.
 */
 function readPlayPayload(payload) {
-	if (!isRecord$3(payload) || typeof payload.animation !== "string") return void 0;
+	if (!isRecord$4(payload) || typeof payload.animation !== "string") return void 0;
 	return {
 		animation: payload.animation,
 		slots: readSlots(payload.slots)
@@ -35689,7 +36310,7 @@ function emptyManifest() {
 * @param value - Anything that came out of JSON.
 * @returns True for an object that is not an array.
 */
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -35729,7 +36350,7 @@ function stringAt(source, key) {
 * @returns The four borders, or `undefined`.
 */
 function parseNine(value) {
-	if (!isRecord$2(value)) return void 0;
+	if (!isRecord$3(value)) return void 0;
 	return {
 		left: numberAt(value, "left"),
 		top: numberAt(value, "top"),
@@ -35744,7 +36365,7 @@ function parseNine(value) {
 * @returns The frame, or `undefined`.
 */
 function parseAtlas(value) {
-	if (!isRecord$2(value)) return void 0;
+	if (!isRecord$3(value)) return void 0;
 	return {
 		page: stringAt(value, "page"),
 		x: numberAt(value, "x"),
@@ -35771,7 +36392,7 @@ function parseKind(value) {
 */
 function parseFontPages(value) {
 	if (!Array.isArray(value)) return void 0;
-	return value.filter((entry) => isRecord$2(entry)).map((entry) => ({
+	return value.filter((entry) => isRecord$3(entry)).map((entry) => ({
 		path: stringAt(entry, "path"),
 		width: numberAt(entry, "width"),
 		height: numberAt(entry, "height"),
@@ -35786,7 +36407,7 @@ function parseFontPages(value) {
 */
 function parseAtlasPages(value) {
 	if (!Array.isArray(value)) return void 0;
-	return value.filter((entry) => isRecord$2(entry)).map((entry) => ({
+	return value.filter((entry) => isRecord$3(entry)).map((entry) => ({
 		id: stringAt(entry, "id"),
 		path: stringAt(entry, "path"),
 		width: numberAt(entry, "width"),
@@ -35802,7 +36423,7 @@ function parseAtlasPages(value) {
 * @returns The file, or `undefined` when the element is not an object.
 */
 function parseFile(raw) {
-	if (!isRecord$2(raw)) return void 0;
+	if (!isRecord$3(raw)) return void 0;
 	const kind = parseKind(raw.kind);
 	const pages = parseFontPages(raw.pages);
 	const nine = parseNine(raw.nine);
@@ -35873,7 +36494,7 @@ function textAt(source, key) {
 * @throws {Error} When the entry is not an object or its tier is unknown.
 */
 function parseBundle(name, raw) {
-	if (!isRecord$2(raw)) throw new Error(`[game] assets: bundle "${name}" of the manifest is not an object.\n  Rebuild the manifest with "bun run assets:keys".`);
+	if (!isRecord$3(raw)) throw new Error(`[game] assets: bundle "${name}" of the manifest is not an object.\n  Rebuild the manifest with "bun run assets:keys".`);
 	const files = (Array.isArray(raw.files) ? raw.files : []).map((entry) => parseFile(entry)).filter((file) => file !== void 0).toSorted((left, right) => left.key.localeCompare(right.key));
 	const pages = parseAtlasPages(raw.pages);
 	const parent = textAt(raw, "parent");
@@ -35914,9 +36535,9 @@ function parseVersion(value) {
 * ```
 */
 function parseManifest(raw) {
-	if (!isRecord$2(raw)) throw new Error("[game] assets: the manifest is not an object.\n  Point \"manifest\" at a manifest.json, or pass the parsed object.");
+	if (!isRecord$3(raw)) throw new Error("[game] assets: the manifest is not an object.\n  Point \"manifest\" at a manifest.json, or pass the parsed object.");
 	const version = parseVersion(raw.version);
-	const source = isRecord$2(raw.bundles) ? raw.bundles : {};
+	const source = isRecord$3(raw.bundles) ? raw.bundles : {};
 	const bundles = {};
 	for (const name of Object.keys(source).toSorted((left, right) => left.localeCompare(right))) bundles[name] = parseBundle(name, source[name]);
 	return {
@@ -39101,6 +39722,468 @@ function dropBuild(build) {
 	build.resolve();
 }
 //#endregion
+//#region src/plugins/scenes/leave.ts
+/**
+* What a game gets when it writes nothing: black at 45 %, 150 ms in and out, the engine's ring once the switch took
+* 400 ms. The level under `config.leave`, and where a part written over `false` starts. `index.ts` writes the same
+* value inline as the plugin's default config; a test pins the two equal.
+*/
+const FALLBACK_LEAVE = Object.freeze({
+	cover: Object.freeze({
+		color: 0,
+		alpha: .45,
+		inMs: 150,
+		outMs: 150
+	}),
+	loader: Object.freeze({ afterMs: 400 })
+});
+/**
+* Merges one level's veil over the one below, field by field. `false` turns it off; a veil written over `false`
+* starts from the engine's.
+*
+* @param below - The veil of the levels below, or `false`.
+* @param over - What this level writes: nothing, `false` or fields.
+* @returns The veil, or `false`.
+* @example
+* ```ts
+* coverOver(false, { alpha: 0.6 }); // { color: 0, alpha: 0.6, inMs: 150, outMs: 150 }
+* ```
+*/
+function coverOver(below, over) {
+	if (over === void 0) return below;
+	if (over === false) return false;
+	const base = below === false ? FALLBACK_LEAVE.cover : below;
+	return {
+		color: over.color ?? base.color,
+		alpha: over.alpha ?? base.alpha,
+		inMs: over.inMs ?? base.inMs,
+		outMs: over.outMs ?? base.outMs
+	};
+}
+/**
+* The look of a loader: its projection, else its texture, else nothing (the engine's ring).
+*
+* @param loader - A level that names a look, or the level below.
+* @returns At most one of the two fields.
+* @example
+* ```ts
+* lookOf({ texture: "ui.loader.ring", projection: "loading" }); // { projection: "loading" }
+* ```
+*/
+function lookOf(loader) {
+	if (loader.projection !== void 0) return { projection: loader.projection };
+	if (loader.texture !== void 0) return { texture: loader.texture };
+	return {};
+}
+/**
+* Merges one level's loader over the one below. `afterMs` is a field of its own; `texture` and `projection` are one
+* choice: a level that names either replaces both of the level below. `false` turns it off; a loader written over
+* `false` starts from the engine's.
+*
+* @param below - The loader of the levels below, or `false`.
+* @param over - What this level writes: nothing, `false` or fields.
+* @returns The loader, or `false`.
+* @example
+* ```ts
+* loaderOver({ afterMs: 400, projection: "loading" }, { texture: "ui.loader.ring" }); // { afterMs: 400, texture: "ui.loader.ring" }
+* ```
+*/
+function loaderOver(below, over) {
+	if (over === void 0) return below;
+	if (over === false) return false;
+	const base = below === false ? FALLBACK_LEAVE.loader : below;
+	const named = over.texture !== void 0 || over.projection !== void 0;
+	return {
+		afterMs: over.afterMs ?? base.afterMs,
+		...lookOf(named ? over : base)
+	};
+}
+/**
+* Resolves what a switch shows over the scene being left: the scene's `leave` over the config's over the engine's,
+* field by field. `false` at a level turns both parts off there.
+*
+* @param config - `config.leave`.
+* @param scene - The `leave` of the scene being left.
+* @returns Both parts, each resolved or `false`; `undefined` when both are off.
+* @example
+* ```ts
+* leaveOf({ loader: false }, { cover: { alpha: 0.6 } }); // { cover: { color: 0, alpha: 0.6, inMs: 150, outMs: 150 }, loader: false }
+* ```
+*/
+function leaveOf(config, scene) {
+	let cover = FALLBACK_LEAVE.cover;
+	let loader = FALLBACK_LEAVE.loader;
+	for (const level of [config, scene]) if (level === false) {
+		cover = false;
+		loader = false;
+	} else if (level !== void 0) {
+		cover = coverOver(cover, level.cover);
+		loader = loaderOver(loader, level.loader);
+	}
+	if (cover === false && loader === false) return void 0;
+	return {
+		cover,
+		loader
+	};
+}
+/**
+* The layer a mounted projection's views draw in, read from its first view.
+*
+* @param ctx - Domain context of the plugin.
+* @param name - The projection.
+* @returns The layer, or `undefined` while it has no view.
+*/
+function layerOf(ctx, name) {
+	const { projection, ecs } = ctx.deps.world;
+	const entity = projection.entitiesOf(name)[0];
+	return entity === void 0 ? void 0 : ecs.get(entity, Layer)?.name;
+}
+/**
+* Unmounts the loader projection a switch mounted, once: one it did not mount is left alone.
+*
+* @param ctx - Domain context of the plugin.
+* @param leaving - The look of the switch.
+*/
+function unmountLoader(ctx, leaving) {
+	const name = leaving.projection;
+	if (name === void 0) return;
+	delete leaving.projection;
+	ctx.deps.world.projection.unmount([name]);
+}
+/**
+* Mounts a loader projection for the switch, unless it is mounted already (by another owner): such a one is drawn as it
+* is and never unmounted by the switch. A mount that throws (an unknown name, a layer the scene being left does not
+* declare) is warned.
+*
+* @param ctx - Domain context of the plugin.
+* @param name - The loader projection.
+* @param from - The scene being left.
+* @param leaving - The look of the switch: it keeps the name to unmount at the end.
+* @returns False when the mount threw.
+*/
+function mountOnce(ctx, name, from, leaving) {
+	const projection = ctx.deps.world.projection;
+	if (projection.entitiesOf(name).length > 0) return true;
+	try {
+		projection.mount([name], ctx.state.owner);
+	} catch (error) {
+		ctx.log.warn("scenes:loader-unmounted", {
+			projection: name,
+			scene: from.id,
+			error
+		});
+		return false;
+	}
+	leaving.projection = name;
+	return true;
+}
+/**
+* Tells whether a projection of the scene being left draws in a layer: lifted above the veil, that layer would take
+* the scene's own views with it.
+*
+* @param ctx - Domain context of the plugin.
+* @param from - The scene being left.
+* @param layer - The layer of the loader.
+* @returns True when one of its projections has a view in that layer.
+*/
+function sharesLayer(ctx, from, layer) {
+	return from.projections.some((other) => layerOf(ctx, other) === layer);
+}
+/**
+* Mounts a loader projection once its loader is due, called by the renderer in that frame, and answers the layer its
+* views draw in, which the renderer draws above the veil. A mount that throws, a layer a projection of the scene being
+* left draws in too, and a projection with no view give the engine's ring. A switch that ended meanwhile mounts
+* nothing.
+*
+* @param ctx - Domain context of the plugin.
+* @param name - The loader projection.
+* @param from - The scene being left.
+* @param leaving - The look of the switch: it keeps the name to unmount at the end.
+* @returns The layer, or `undefined` for the ring.
+*/
+function mountLoader(ctx, name, from, leaving) {
+	if (leaving.done || !mountOnce(ctx, name, from, leaving)) return void 0;
+	const layer = layerOf(ctx, name);
+	if (layer === void 0 || !sharesLayer(ctx, from, layer)) return layer;
+	ctx.log.warn("scenes:loader-layer-shared", {
+		projection: name,
+		layer,
+		scene: from.id
+	});
+	unmountLoader(ctx, leaving);
+}
+/**
+* The renderer's loader of a resolved one: a texture as it is, nothing for the ring, and for a projection the `due`
+* the renderer calls once the loader is due, which mounts it then: a switch done sooner never runs its `from` and
+* `view`. A projection a scene of the switch lists is no loader: warned, the ring.
+*
+* @param ctx - Domain context of the plugin.
+* @param loader - The resolved loader.
+* @param between - The scene being left and the scene being switched to.
+* @param between.from - The scene being left.
+* @param between.to - The scene being switched to.
+* @param leaving - The look of the switch.
+* @returns What the renderer draws.
+*/
+function loaderLook(ctx, loader, between, leaving) {
+	const { afterMs, texture, projection } = loader;
+	const { from, to } = between;
+	if (texture !== void 0) return {
+		afterMs,
+		texture
+	};
+	if (projection === void 0) return { afterMs };
+	if (from.projections.includes(projection) || to.projections.includes(projection)) {
+		ctx.log.warn("scenes:loader-listed", {
+			projection,
+			from: from.id,
+			to: to.id
+		});
+		return { afterMs };
+	}
+	return {
+		afterMs,
+		due: () => mountLoader(ctx, projection, from, leaving)
+	};
+}
+/**
+* Tells whether a switch shows anything over the scene being left: a real change of scene, a live run that was not
+* aborted, a world that runs live, a drawing renderer. The first scene of a run, a fast walk, a world walking fast or
+* paused and a headless app show nothing.
+*
+* @param ctx - Domain context of the plugin.
+* @param run - The runner's mode and signal.
+* @returns The scene being left, or `undefined` when nothing is shown.
+*/
+function leftScene(ctx, run) {
+	const current = ctx.state.current;
+	if (current === void 0 || run.mode !== "live" || run.signal.aborted) return void 0;
+	if (ctx.deps.world.ecs.mode() !== "live" || !ctx.deps.renderer.host.ready()) return void 0;
+	return ctx.state.scenes.get(current);
+}
+/**
+* Shows the veil and the loader of a switch that starts now, before its bundles are awaited: the scene being left
+* decides. A loader projection is mounted only once its loader is due. An abort of the node drops both at once, from
+* its listener.
+*
+* @param ctx - Domain context of the plugin.
+* @param scene - The scene being switched to.
+* @param run - The runner's mode and signal.
+* @returns The look of the switch, or `undefined` when it shows nothing.
+*/
+function startLeave(ctx, scene, run) {
+	const from = leftScene(ctx, run);
+	if (from === void 0) return void 0;
+	const leave = leaveOf(ctx.config.leave, from.leave);
+	if (leave === void 0) return void 0;
+	const listening = new AbortController();
+	const leaving = {
+		done: false,
+		off: () => listening.abort()
+	};
+	const look = {};
+	if (leave.cover !== false) look.cover = leave.cover;
+	if (leave.loader !== false) look.loader = loaderLook(ctx, leave.loader, {
+		from,
+		to: scene
+	}, leaving);
+	ctx.deps.renderer.sync.leave.show(look);
+	run.signal.addEventListener("abort", () => endLeave(ctx, leaving, "drop"), {
+		once: true,
+		signal: listening.signal
+	});
+	ctx.state.leaving = leaving;
+	return leaving;
+}
+/**
+* Ends the look of a switch once: `"land"` at the swap (the loader goes, the veil fades out over the next scene),
+* `"drop"` on an abort or a throw (both go at once). A loader projection mounted for the wait is unmounted. A look
+* ended already, or a switch that showed nothing, is left alone.
+*
+* @param ctx - Domain context of the plugin.
+* @param leaving - The look of the switch.
+* @param how - `"land"` after the swap, `"drop"` without one.
+*/
+function endLeave(ctx, leaving, how) {
+	if (leaving === void 0 || leaving.done) return;
+	leaving.done = true;
+	leaving.off();
+	if (ctx.state.leaving === leaving) delete ctx.state.leaving;
+	const leave = ctx.deps.renderer.sync.leave;
+	if (how === "land") leave.land();
+	else leave.drop();
+	unmountLoader(ctx, leaving);
+}
+/**
+* Forgets the look of a running switch when the plugin stops: its abort listener goes and a later end does nothing.
+* Nothing else is called: a teardown context may not call another plugin; the renderer drops the look at its own stop,
+* and `world.onStop` the loader projection.
+*
+* @param state - The plugin state.
+*/
+function forgetLeave(state) {
+	const leaving = state.leaving;
+	if (leaving === void 0) return;
+	leaving.done = true;
+	leaving.off();
+	delete state.leaving;
+}
+//#endregion
+//#region src/plugins/scenes/leave-check.ts
+/** The largest colour, `0xffffff`. */
+const MAX_COLOR = 16777215;
+/**
+* Tells whether a value is a finite number of at least 0: a duration.
+*
+* @param value - The value.
+* @returns True for a finite number `>= 0`.
+* @example
+* ```ts
+* isDuration(-1); // false
+* ```
+*/
+function isDuration(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+/**
+* Tells whether a value is an alpha: a number from 0 to 1.
+*
+* @param value - The value.
+* @returns True for a number in `[0, 1]`.
+* @example
+* ```ts
+* isAlpha(1.2); // false
+* ```
+*/
+function isAlpha(value) {
+	return typeof value === "number" && value >= 0 && value <= 1;
+}
+/**
+* Tells whether a value is a colour `0xRRGGBB`: a whole number from 0 to `0xffffff`.
+*
+* @param value - The value.
+* @returns True for a colour.
+* @example
+* ```ts
+* isColor(0x0b1020); // true
+* ```
+*/
+function isColor$1(value) {
+	return Number.isInteger(value) && typeof value === "number" && value >= 0 && value <= MAX_COLOR;
+}
+/**
+* Tells whether a value is a name: a string that is not empty.
+*
+* @param value - The value.
+* @returns True for a string with at least one character.
+* @example
+* ```ts
+* isName(""); // false
+* ```
+*/
+function isName(value) {
+	return typeof value === "string" && value.length > 0;
+}
+/**
+* Tells whether a value is a plain object a field can be read from.
+*
+* @param value - The value.
+* @returns True for an object that is no array and not `null`.
+* @example
+* ```ts
+* isRecord([]); // false
+* ```
+*/
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** The fields of a veil. */
+const COVER_RULES = Object.freeze({
+	color: {
+		ok: isColor$1,
+		hint: "a colour from 0x000000 to 0xffffff"
+	},
+	alpha: {
+		ok: isAlpha,
+		hint: "the alpha the veil fades in to, a number from 0 to 1"
+	},
+	inMs: {
+		ok: isDuration,
+		hint: "the milliseconds of the fade-in, 0 or more"
+	},
+	outMs: {
+		ok: isDuration,
+		hint: "the milliseconds of the fade-out, 0 or more"
+	}
+});
+/** The fields of a loader. */
+const LOADER_RULES = Object.freeze({
+	afterMs: {
+		ok: isDuration,
+		hint: "the milliseconds the loader waits for, 0 or more"
+	},
+	texture: {
+		ok: isName,
+		hint: "an asset key such as \"ui.loader.ring\""
+	},
+	projection: {
+		ok: isName,
+		hint: "the name of a registered projection such as \"loading\""
+	}
+});
+/**
+* Builds the error of a field of the wrong shape.
+*
+* @param where - Where the part was written.
+* @param value - What the field holds.
+* @param hint - What to give instead.
+* @returns The error, in the engine's two-line format.
+* @example
+* ```ts
+* wrong("scenes.leave.cover.alpha", 2, "a number from 0 to 1").message;
+* // '[game] scenes.leave.cover.alpha is 2.\n  Give a number from 0 to 1.'
+* ```
+*/
+function wrong(where, value, hint) {
+	return /* @__PURE__ */ new Error(`[game] ${where} is ${String(value)}.\n  Give ${hint}.`);
+}
+/**
+* Checks one part of a `leave`: nothing, `false`, or an object whose every field it knows has the right shape.
+*
+* @param where - Where the part was written, `scenes.leave.cover`.
+* @param part - What the part holds.
+* @param rules - The fields of the part.
+* @throws {Error} For a part that is neither `false` nor an object, and for the first field of the wrong shape.
+*/
+function checkPart(where, part, rules) {
+	if (part === void 0 || part === false) return;
+	if (!isRecord$2(part)) throw wrong(where, part, "an object of its fields, or false");
+	for (const [field, rule] of Object.entries(rules)) {
+		const value = part[field];
+		if (value !== void 0 && !rule.ok(value)) throw wrong(`${where}.${field}`, value, rule.hint);
+	}
+}
+/**
+* Checks a `leave` a game wrote: nothing, `false`, or an object whose `cover` and `loader` are each nothing, `false`
+* or an object of the right fields: a colour, an alpha from 0 to 1, durations of 0 or more, and names that are not
+* empty.
+*
+* @param where - Where it was written, for the message: `scenes.leave`, or `Scene "board": leave`.
+* @param leave - What was written.
+* @throws {Error} For the first part or field of the wrong shape.
+* @example
+* ```ts
+* checkLeave("scenes.leave", { cover: { alpha: 2 } });
+* // throws '[game] scenes.leave.cover.alpha is 2.\n  Give the alpha the veil fades in to, a number from 0 to 1.'
+* ```
+*/
+function checkLeave(where, leave) {
+	if (leave === void 0 || leave === false) return;
+	if (!isRecord$2(leave)) throw wrong(where, leave, "{ cover, loader } or false");
+	checkPart(`${where}.cover`, leave.cover, COVER_RULES);
+	checkPart(`${where}.loader`, leave.loader, LOADER_RULES);
+}
+//#endregion
 //#region src/plugins/scenes/switch.ts
 /**
 * A promise that resolves when the node was aborted. Already aborted resolves at once.
@@ -39298,11 +40381,31 @@ async function standUp(ctx, scene, named, run) {
 	swapIn(ctx, scene, named);
 }
 /**
-* Switches to another scene: it reads what the scene names from the committed state, awaits all
-* of it and only then builds the scene. In live mode it waits between the two for the textures of
-* those bundles to reach the GPU; a fast walk does not, so tests and restores keep their pace. An
-* aborted node, or a plugin stopped during the wait, returns without touching anything. A live
-* switch with a drawing renderer resolves at the commit of the scene built aside, frames later.
+* Awaits every bundle the scene names and only then builds the scene. In live mode it waits between
+* the two for the textures of those bundles to reach the GPU; a fast walk does not, so tests and
+* restores keep their pace. An aborted node, or a plugin stopped during the wait, returns without
+* touching anything. A live switch with a drawing renderer resolves at the commit of the scene
+* built aside, frames later.
+*
+* @param ctx - Domain context of the plugin.
+* @param scene - The scene to mount.
+* @param named - The bundles it names, read from the committed state.
+* @param run - The runner's mode and signal.
+* @returns A promise that resolves once the scene stands, or the node was aborted.
+* @throws {Error} Whatever a load, the mount or the build threw.
+*/
+async function loadAndStand(ctx, scene, named, run) {
+	await untilAborted(ctx, named, run.signal);
+	if (run.mode === "live" && !run.signal.aborted) await untilWarmed(ctx, named, run.signal);
+	const stopped = ctx.state.teardown === void 0;
+	if (run.signal.aborted || stopped) return;
+	await standUp(ctx, scene, named, run);
+}
+/**
+* Switches to another scene: it reads what the scene names from the committed state, shows the
+* veil and the loader of the scene being left at once (a cold first visit reacts in the next
+* frame), then awaits the bundles and builds the scene (`loadAndStand`). The look lands when the
+* scene stands, and is dropped when the switch ends without it or throws.
 *
 * @param ctx - Domain context of the plugin.
 * @param target - Id of the scene to mount.
@@ -39314,11 +40417,15 @@ async function switchTo(ctx, target, run) {
 	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.`);
 	const named = namedBundles(scene, committedState(ctx));
-	await untilAborted(ctx, named, run.signal);
-	if (run.mode === "live" && !run.signal.aborted) await untilWarmed(ctx, named, run.signal);
-	const stopped = ctx.state.teardown === void 0;
-	if (run.signal.aborted || stopped) return;
-	await standUp(ctx, scene, named, run);
+	let leaving;
+	try {
+		leaving = startLeave(ctx, scene, run);
+		await loadAndStand(ctx, scene, named, run);
+	} catch (error) {
+		endLeave(ctx, leaving, "drop");
+		throw error;
+	}
+	endLeave(ctx, leaving, ctx.state.current === scene.id ? "land" : "drop");
 }
 /**
 * Reads again what the mounted scene names, at a node that keeps it: a bundle it names now and
@@ -39432,15 +40539,17 @@ function readScenes(ctx) {
 	}
 }
 /**
-* Refuses a building budget a frame cannot count down, in `onInit`, so `createApp` throws: neither
-* `"auto"` nor a finite number above 0. A game written in plain JS passes anything, so the config
-* is a boundary.
+* Refuses a config a switch cannot run with, in `onInit`, so `createApp` throws: a building budget
+* that is neither `"auto"` nor a finite number above 0, and a `leave` of the wrong shape. A game
+* written in plain JS passes anything, so the config is a boundary.
 *
 * @param config - The resolved config of the plugin.
-* @throws {Error} When `buildMs` is neither `"auto"` nor a finite number above 0.
+* @throws {Error} When `buildMs` is neither `"auto"` nor a finite number above 0, and for a `leave`
+*   `checkLeave` refuses.
 */
 function checkConfig(config) {
 	const value = config.buildMs;
+	checkLeave("scenes.leave", config.leave);
 	if (value === "auto") return;
 	if (isPositiveFinite(value)) return;
 	throw new Error(`[game] scenes.buildMs is ${String(value)}.\n  Give "auto" or the milliseconds a frame may spend on the next scene, a finite number above 0 such as 4.`);
@@ -39464,7 +40573,8 @@ function startScenes(ctx) {
 }
 /**
 * Removes the `onEnter` callback in `onStop` and forgets every scene and the bundles the mounted
-* one named. A running build loses its frame callback and its switch returns. Nothing is unmounted
+* one named. A running build loses its frame callback and its switch returns; the look of a running
+* switch loses its abort listener (the renderer drops it at its own stop). Nothing is unmounted
 * or discarded: a teardown context may not call another plugin, and `world.onStop` clears every
 * entity and the build table anyway.
 *
@@ -39482,6 +40592,7 @@ function stopScenes(teardown) {
 	state.teardown = void 0;
 	dropBuild(state.build);
 	delete state.build;
+	forgetLeave(state);
 	state.scenes.clear();
 	state.current = void 0;
 	state.pending = void 0;
@@ -39550,6 +40661,9 @@ function createScenesState() {
 *
 * // A game gives the next scene a fixed 3 ms of each frame (two thirds of it by default) while the old one stays on the screen.
 * createApp({ plugins: [...screen, boardFeature], pluginConfigs: { scenes: { buildMs: 3 } } });
+*
+* // No veil and no loader over a scene being left, on any switch.
+* createApp({ plugins: [...screen, boardFeature], pluginConfigs: { scenes: { leave: false } } });
 * ```
 */
 const scenesPlugin = /*#__PURE__*/ createPlugin$1("scenes", {
@@ -39561,7 +40675,18 @@ const scenesPlugin = /*#__PURE__*/ createPlugin$1("scenes", {
 		modelPlugin,
 		rendererPlugin
 	],
-	config: { buildMs: "auto" },
+	config: {
+		buildMs: "auto",
+		leave: {
+			cover: {
+				color: 0,
+				alpha: .45,
+				inMs: 150,
+				outMs: 150
+			},
+			loader: { afterMs: 400 }
+		}
+	},
 	events: (register) => register.map({ "scenes:changed": "The mounted scene changed" }),
 	createState: createScenesState,
 	api: createScenesApi,
@@ -64680,14 +65805,15 @@ function namesOf(id, layers, projections) {
 * layer names come from the keys of `layers` and that `ui`, so a projection whose `layer` or
 * `lift` is not among them does not compile — and throws here for a caller without types.
 * `bundles` names bundles that depend on the committed state: the scene is mounted once those
-* are in too.
+* are in too. `leave` is what a live switch shows over the scene when it is left, merged over the
+* config's: `false` shows nothing.
 *
 * @param id - Id of the scene. A node names it with `defineNode({ scene: id })`.
-* @param scene - The bundle, the optional bundles of state, the layers, the projections and the
-*   optional music key.
+* @param scene - The bundle, the optional bundles of state, the layers, the projections, the
+*   optional music key and the optional `leave`.
 * @returns The scene as frozen data, ready for the `scenes` key of a feature.
 * @throws {Error} For an integer-like layer name, for a `layer` or `lift` that is not declared, for two HUD layers,
-*   an `above` other than `"overlays"`, and a `ui` declared after the HUD layer.
+*   an `above` other than `"overlays"`, a `ui` declared after the HUD layer, and a `leave` of the wrong shape.
 * @example
 * ```ts
 * // features/board/view/scene.ts of a game.
@@ -64712,18 +65838,28 @@ function namesOf(id, layers, projections) {
 *   projections: [wardRoom, wardGlows]
 * });
 * wardScene.bundles?.({ player: {}, session: { episode: "ep02" } }); // ["ep02"]
+*
+* // Leaving the board dims it in navy and turns the game's ring texture once the switch took 400 ms.
+* defineScene("board", {
+*   bundle: "board",
+*   layers: { cells: {} },
+*   projections: [],
+*   leave: { cover: { color: 0x0b1020, alpha: 0.6 }, loader: { texture: "ui.loader.ring" } }
+* }).leave; // { cover: { color: 0x0b1020, alpha: 0.6 }, loader: { texture: "ui.loader.ring" } }
 * ```
 */
 function defineScene(id, scene) {
 	const layers = layersOf(id, scene.layers);
 	const projections = scene.projections;
+	checkLeave(`Scene "${id}": leave`, scene.leave);
 	return Object.freeze({
 		id,
 		bundle: scene.bundle,
 		music: scene.music,
 		layers: Object.freeze(layers),
 		projections: Object.freeze(namesOf(id, layers, projections)),
-		...scene.bundles === void 0 ? {} : { bundles: scene.bundles }
+		...scene.bundles === void 0 ? {} : { bundles: scene.bundles },
+		...scene.leave === void 0 ? {} : { leave: scene.leave }
 	});
 }
 /**
@@ -65156,6 +66292,7 @@ function cubicBezier(x1, y1, x2, y2) {
 * | assets | baseUrl | undefined |
 * | assets | io | undefined, the browser fetch and the renderer textures |
 * | scenes | buildMs | "auto", two thirds of a frame ((1000 / time.rate().fps) * 2 / 3, 11.1 ms at 60 Hz), read at each build start; a number fixes it |
+* | scenes | leave | { cover: { color: 0x000000, alpha: 0.45, inMs: 150, outMs: 150 }, loader: { afterMs: 400 } }, what a live switch shows over the scene being left: a veil from its start and a loader (the engine's ring, a `texture` or a `projection`) once it took `afterMs`; a scene's `leave` is merged over it field by field, a field left out keeps this default, `false` turns a part or the whole off |
 * | anim | maxTracks | 2000 |
 * | anim | reducedMotion | false |
 * | i18n | locale | "en" |
@@ -65300,4 +66437,4 @@ const screen = [
 	uiPlugin
 ];
 //#endregion
-export { sfx as $, flowPlugin as $t, types_exports$10 as A, Glow as At, defineMotion as B, Animation as Bt, types_exports$3 as C, messageDuration as Ct, types_exports$7 as D, Blur as Dt, types_exports$6 as E, Alpha as Et, types_exports$15 as F, audioPlugin as Ft, external as G, MONITOR_SECTIONS as Gt, platformPlugin as H, rendererPlugin as Ht, types_exports$16 as I, scenesPlugin as It, mark as J, PERF_LOG_VERSION as Jt, frames as K, PERF_CAUSES as Kt, types_exports$17 as L, assetsPlugin as Lt, types_exports$12 as M, Outline as Mt, types_exports$13 as N, defineFilter as Nt, types_exports$8 as O, ColorMatrix as Ot, types_exports$14 as P, debugPlugin as Pt, set as Q, worldPlugin as Qt, uiPlugin as R, animPlugin as Rt, types_exports$2 as S, messageArgument as St, types_exports$5 as T, Emitter as Tt, HAPTIC_KINDS as U, PASS_KINDS as Ut, textPlugin as V, Frames as Vt, defineAnimation as W, frameAt as Wt, play$1 as X, SHADER_WHATS as Xt, parallel as Y, PROBLEM_RULES as Yt, sequence as Z, DEMAND_REASONS as Zt, defineBundles as _, Tappable as _t, cubicBezier as a, modelPlugin as an, use as at, types_exports as b, Traced as bt, hint as c, timePlugin as cn, Draggable as ct, defineScene as d, Hovered as dt, refuseStart as en, spawn as et, tr as f, Pointer as ft, music as g, Swipeable as gt, defineEmitter as h, Pressed as ht, screen as i, type as in, tween as it, types_exports$11 as j, Noise as jt, types_exports$9 as k, Displacement as kt, schedule as l, clockPlugin as ln, DropTarget as lt, flattenFeatures as m, Pressable as mt, createPlugin as n, slot as nn, stagger as nt, defineEffect as o, SaveUnreadableError as on, wait as ot, defineFeature as p, PointerOver as pt, haptic as q, PERF_GAP_BUCKETS as qt, defineGame as r, to as rn, stopSfx as rt, guide as s, lifecyclePlugin as sn, inputPlugin as st, createApp as t, exit as tn, spawned as tt, projection as u, Held as ut, load as v, Touchable as vt, types_exports$4 as w, effectsPlugin as wt, types_exports$1 as x, i18nPlugin as xt, ready as y, Traceable as yt, resolve as z, AnimPlayer as zt };
+export { sfx as $, flowPlugin as $t, types_exports$10 as A, Glow as At, defineMotion as B, Animation as Bt, types_exports$3 as C, messageDuration as Ct, types_exports$7 as D, Blur as Dt, types_exports$6 as E, Alpha as Et, types_exports$15 as F, audioPlugin as Ft, external as G, MONITOR_SECTIONS as Gt, platformPlugin as H, rendererPlugin as Ht, types_exports$16 as I, scenesPlugin as It, mark as J, PERF_LOG_VERSION as Jt, frames as K, PERF_CAUSES as Kt, types_exports$17 as L, assetsPlugin as Lt, types_exports$12 as M, Outline as Mt, types_exports$13 as N, defineFilter as Nt, types_exports$8 as O, ColorMatrix as Ot, types_exports$14 as P, debugPlugin as Pt, set as Q, worldPlugin as Qt, uiPlugin as R, animPlugin as Rt, types_exports$2 as S, messageArgument as St, types_exports$5 as T, Emitter as Tt, HAPTIC_KINDS as U, PASS_KINDS as Ut, textPlugin as V, Frames as Vt, defineAnimation as W, frameAt as Wt, play$1 as X, SHADER_WHATS as Xt, parallel as Y, PROBLEM_RULES as Yt, sequence as Z, DEMAND_REASONS as Zt, defineBundles as _, Tappable as _t, cubicBezier as a, type as an, use as at, types_exports as b, Traced as bt, hint as c, lifecyclePlugin as cn, Draggable as ct, defineScene as d, Hovered as dt, refuseStart as en, spawn as et, tr as f, Pointer as ft, music as g, Swipeable as gt, defineEmitter as h, Pressed as ht, screen as i, to as in, tween as it, types_exports$11 as j, Noise as jt, types_exports$9 as k, Displacement as kt, schedule as l, timePlugin as ln, DropTarget as lt, flattenFeatures as m, Pressable as mt, createPlugin as n, exit as nn, stagger as nt, defineEffect as o, modelPlugin as on, wait as ot, defineFeature as p, PointerOver as pt, haptic as q, PERF_GAP_BUCKETS as qt, defineGame as r, slot as rn, stopSfx as rt, guide as s, SaveUnreadableError as sn, inputPlugin as st, createApp as t, contribution as tn, spawned as tt, projection as u, clockPlugin as un, Held as ut, load as v, Touchable as vt, types_exports$4 as w, effectsPlugin as wt, types_exports$1 as x, i18nPlugin as xt, ready as y, Traceable as yt, resolve as z, AnimPlayer as zt };