@moku-labs/game 0.15.39 → 0.15.40

package/dist/{src-B2vblgmb.mjs → src-Cz-QeLTp.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 {
@@ -5759,7 +5759,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;
@@ -5806,7 +5806,7 @@ async function runLoop(ctx, modules) {
 		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
@@ -24939,7 +24939,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 +24967,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 +26026,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 +27715,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 +27850,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 +29236,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 +29406,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 +30210,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 +30837,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 +31882,7 @@ function createSyncApi(ctx, deps) {
 		destroyPools(state);
 		clearLayers(state);
 		forgetBuild(state);
+		forgetLeave$1(state);
 		state.root = void 0;
 		state.passesVersion += 1;
 	};
@@ -31612,11 +31976,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 +32575,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 +32817,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 +32883,7 @@ function createSyncState(debug) {
 			count: 0,
 			reported: false
 		},
+		leave: {},
 		cleanups: []
 	};
 }
@@ -35179,7 +35551,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 +35676,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 +35703,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 +35719,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 +35737,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 +36061,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 +36101,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 +36116,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 +36143,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 +36158,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 +36174,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 +36245,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 +36286,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 +39473,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 +40132,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 +40168,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 +40290,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 +40324,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 +40343,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 +40412,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 +40426,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 +65556,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 +65589,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 +66043,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" |