@moku-labs/game 0.15.19 → 0.15.23

package/dist/{src-CXfBuKpl.mjs → src-hVe3f8GV.mjs}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
 import { r as systemSource, t as memory } from "./memory-CWlqhS7l.mjs";
 import { a as finishDrafts, i as enableDraftPatches, n as deepFreeze$1, o as openDrafts, r as dropDrafts } from "./drafts-BawpSaVp.mjs";
-import { d as graphHash, f as isRestCheckpoint, h as pushEntry, i as servePaused, l as findNode, m as compact, n as captureFrame, o as collectFlows, p as slotNames, r as serveCaptures, s as describeGraph, t as cancelCaptures, u as framePath } from "./capture-D7XvoHdH.mjs";
-import { $ 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-DNM5oFYx.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 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-kEC9nb-o.mjs";
 import { a as isDev } from "./dev-BNndV-hU.mjs";
 import { n as isComponentDefinition } from "./component-DGg5DqKK.mjs";
 import { n as flatten } from "./flatten-nUX9PpGo.mjs";
@@ -252,7 +252,7 @@ function createMeasureState() {
 *
 * @returns The page clock, ms.
 */
-function pageNow$1() {
+function pageNow() {
 	return globalThis.performance.now();
 }
 /**
@@ -277,7 +277,7 @@ function timePhase(ctx, record, callbacks, phase, start) {
 			error
 		});
 	}
-	const end = pageNow$1();
+	const end = pageNow();
 	record.phaseMs[phase] = end - start;
 	return end;
 }
@@ -294,7 +294,7 @@ function timePhase(ctx, record, callbacks, phase, start) {
 function runMeasuredFrame(ctx, measure, at, stepped) {
 	const { record } = measure;
 	const phases = capturePhases(ctx);
-	let mark = pageNow$1();
+	let mark = pageNow();
 	record.startMs = stepped ? 0 : mark - at;
 	mark = timePhase(ctx, record, phases[0], 0, mark);
 	mark = timePhase(ctx, record, phases[1], 1, mark);
@@ -324,7 +324,7 @@ function runMeasuredFrame(ctx, measure, at, stepped) {
 	} catch (error) {
 		ctx.log.error("time: measure listener failed", { error });
 	}
-	measure.listenersMs = pageNow$1() - mark;
+	measure.listenersMs = pageNow() - mark;
 	measure.lastAt = at;
 	measure.skipped = 0;
 }
@@ -595,6 +595,11 @@ const CAP_SLACK_SHARE = .12;
 const DISPLAY_SHARE = .25;
 /** …and at least this share of the window's drawn intervals: the p90 rule written as a count. */
 const DROP_SHARE = .1;
+/**
+* The drop window stays late this long before the rate drops, ms (F64): longer than the window, so one burst of late
+* frames (a mount, an upload, a GC) never drops the rate by itself; only a sustained slow run does.
+*/
+const DROP_HOLD_MS = 2e3;
 /** The least time at a rate before a return, ms. */
 const DWELL_BASE_MS = 5e3;
 /** The dwell never grows past this, ms. */
@@ -901,6 +906,7 @@ function createGovernor(floor) {
 		returnDrawn: 0,
 		returnMissed: 0,
 		returnHeavy: 0,
+		lateSince: NaN,
 		switchedAt: Number.NEGATIVE_INFINITY,
 		lastReturnAt: Number.NEGATIVE_INFINITY,
 		climbed: false,
@@ -977,7 +983,7 @@ function createRateState(config) {
 * @returns The page clock, ms.
 */
 function nowOf() {
-	return typeof globalThis.performance === "undefined" ? 0 : pageNow$1();
+	return typeof globalThis.performance === "undefined" ? 0 : pageNow();
 }
 /**
 * Empties both windows: evidence of one rate never judges another, and a resume is a new situation.
@@ -993,6 +999,7 @@ function emptyWindows(g) {
 	g.returnDrawn = 0;
 	g.returnMissed = 0;
 	g.returnHeavy = 0;
+	g.lateSince = NaN;
 }
 /**
 * Takes the oldest sample of the drop window out of its counts.
@@ -1326,15 +1333,36 @@ function isSample(ctx, g, intervalMs) {
 	return g.lastDrawn && !g.lastIdle && !g.lastProbed && intervalMs <= 500 && g.lastFps === rate.fps && rate.mode === "auto" && rate.display.hz !== null;
 }
 /**
-* Tells whether the drop window is late enough to step down: late intervals reach `max(8, 10 %)` of the second's.
+* Tells whether the drop window is late: late intervals reach `max(8, 10 %)` of the second's.
 *
 * @param g - The governor.
-* @returns True when the rate should drop one step.
+* @returns True when the window is late.
 */
-function shouldDrop(g) {
+function isLate(g) {
 	return g.dropMissed >= Math.max(8, Math.ceil(DROP_SHARE * g.dropDrawn));
 }
 /**
+* Tells whether the rate should step down (F64): the drop window has been late for 2 s in a row, so one burst of late
+* frames never drops it. Within 3 s of a step of the rule itself the first late window is enough: a return on
+* probation that fails, and the next step of a descent already under way. Notes when the window turned late.
+*
+* @param ctx - Domain context of the time plugin.
+* @param g - The governor.
+* @param at - The page time of the sample.
+* @returns True when the rate should drop one step.
+*/
+function shouldDrop(ctx, g, at) {
+	if (!isLate(g)) {
+		g.lateSince = NaN;
+		return false;
+	}
+	if (Number.isNaN(g.lateSince)) g.lateSince = at;
+	const { reason } = ctx.state.rate;
+	const afterRuleStep = (reason === "missed" || reason === "headroom") && at - g.switchedAt < 3e3;
+	const heldLate = at - g.lateSince >= DROP_HOLD_MS;
+	return afterRuleStep || heldLate;
+}
+/**
 * Tells whether the late frames of the drop window are GPU-bound: fewer than half of them kept the main thread longer
 * than their frame.
 *
@@ -1357,8 +1385,8 @@ function canReturn(g, at, scaleStep) {
 	return thermalRank(g.thermal) < HEAT_LIMIT_RANK && at - g.switchedAt >= (scaleStep ? 2 * g.dwellMs : g.dwellMs) && g.returnDrawn >= 90 && g.returnMissed <= 1 && (scaleStep || g.returnHeavy <= Math.floor(.1 * g.returnDrawn));
 }
 /**
-* Decides on the windows after a sample. Down one step when late intervals reach `max(8, 10 %)` of the second's: the
-* render scale when the window is GPU-bound and a lower scale is allowed, the rate otherwise. Up one step in the
+* Decides on the windows after a sample. Down one step when late intervals reach `max(8, 10 %)` of the second's
+* for 2 s in a row (at once within 3 s of a step of the rule): the render scale when the window is GPU-bound and a lower scale is allowed, the rate otherwise. Up one step in the
 * reverse of the way down, with 90 steady drawn frames in three seconds, at most one late and no heat: the rate first,
 * at the scale it dropped at, after the dwell and with a tenth heavy at most, then the scale after twice the dwell. A
 * probe of the higher rate so never starts at full scale, and its failure changes no resolution.
@@ -1369,13 +1397,14 @@ function canReturn(g, at, scaleStep) {
 */
 function decide(ctx, g, at) {
 	const { fps, scale } = ctx.state.rate;
-	if (shouldDrop(g)) {
+	if (shouldDrop(ctx, g, at)) {
 		const smaller = gpuBound(g) ? stepBelow(g.scales, scale) : void 0;
 		const lower = stepBelow(g.ladder, fps);
 		if (smaller !== void 0) switchRate(ctx, fps, smaller, "auto", "missed", at);
 		else if (lower !== void 0) switchRate(ctx, lower, scale, "auto", "missed", at);
 		return;
 	}
+	if (!Number.isNaN(g.lateSince)) return;
 	const higher = stepAbove(g.ladder, fps);
 	if (higher !== void 0 && canReturn(g, at, false)) {
 		switchRate(ctx, higher, scale, "auto", "headroom", at);
@@ -1650,12 +1679,12 @@ function runFrameWork(ctx, at) {
 	if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) {
 		const { measure } = ctx.state;
 		if (measure !== void 0 && measure.listeners.length > 0) {
-			runMeasuredFrame(ctx, measure, at ?? pageNow$1(), at === void 0);
+			runMeasuredFrame(ctx, measure, at ?? pageNow(), at === void 0);
 			return measure.record.workMs;
 		}
 	}
 	runPhases(ctx);
-	return at !== void 0 && ctx.state.rate.governor !== void 0 ? pageNow$1() - at : 0;
+	return at !== void 0 && ctx.state.rate.governor !== void 0 ? pageNow() - at : 0;
 }
 /**
 * Runs exactly one frame: advances `Time` by the scaled delta, then calls the six phases.
@@ -1849,7 +1878,7 @@ function createTimeApi(ctx) {
 			}
 			return noMeasure;
 		},
-		agentClock: () => typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ ? pageNow$1 : void 0,
+		agentClock: () => typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ ? pageNow : void 0,
 		chargeAgent: (ms) => {
 			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) {
 				const { measure } = ctx.state;
@@ -3050,7 +3079,7 @@ async function effectValue(state, log, descriptor, signal) {
 * @param work - The promise of the running effect.
 * @returns A promise that settles in the next `signals` phase after `work` settled.
 */
-function enqueue$1(state, work) {
+function enqueue$2(state, work) {
 	return new Promise((resolve, reject) => {
 		const pending = {
 			ready: false,
@@ -3191,7 +3220,7 @@ function createFxApi(ctx, deps) {
 			const shown = descriptor.kind === "guide" ? beginGuide(state, signal) : signal;
 			const work = effectValue(state, ctx.log, descriptor, shown);
 			if (state.mode === "fast" || !ctx.deps.time.isRunning()) return work;
-			return enqueue$1(state, work);
+			return enqueue$2(state, work);
 		},
 		buffer: (item) => {
 			if (state.mode === "fast") return;
@@ -5507,7 +5536,7 @@ function startDeadline(timeoutMs) {
 * @param running - The promise of `run()`.
 * @returns `true` when the loop settled, `false` when the deadline won and the loop still runs.
 */
-async function settle$2(ctx, running) {
+async function settle$3(ctx, running) {
 	const quiet = running.then(noop, noop);
 	const deadline = startDeadline(ctx.config.settleTimeoutMs);
 	try {
@@ -5536,7 +5565,7 @@ async function stopRunner(ctx) {
 		stop.abort("stop");
 		state.abort = stop;
 	}
-	const settled = running === void 0 || await settle$2(ctx, running);
+	const settled = running === void 0 || await settle$3(ctx, running);
 	state.running = void 0;
 	ctx.state.gate.held = void 0;
 	if (settled) state.abort = void 0;
@@ -14939,6 +14968,11 @@ function createHostApi(ctx, deps) {
 			});
 			return true;
 		},
+		initSource: (source) => {
+			const app = state.app;
+			if (!state.ready || app === void 0) return;
+			app.renderer.texture.initSource(source);
+		},
 		clearsCanvas: () => state.ready && state.app?.renderer.background.clearBeforeRender === true,
 		setResolution: (value, reason) => askResolution(state, value, reason),
 		overrideResolution: (value) => {
@@ -15058,7 +15092,10 @@ const KEY = {
 	qc: 25,
 	qd: 26,
 	qtx: 27,
-	qty: 28
+	qty: 28,
+	/** The canvas size at the take, CSS px: a picture cut to it is taken again when it changes (F53). */
+	sw: 29,
+	sh: 30
 };
 /** A whole number of texels within this much (P2.5). */
 const ON_GRID = 1 / 64;
@@ -15123,6 +15160,27 @@ function gridSpan(start, end, resolution) {
 	};
 }
 /**
+* A span on the canvas cut to the canvas and the padding around it (F53). Pixi's live filter pass cuts its target to
+* the viewport and pads it after, so it draws what lies within the padding of the canvas too: a glow just off the
+* screen still reaches in. A span wholly outside comes back empty: its end is not after its start.
+*
+* @param start - The span's start on the canvas, CSS px.
+* @param end - Its end.
+* @param size - The canvas size on that axis, CSS px.
+* @param padding - The padding of the filters, CSS px.
+* @returns The part of the span kept.
+* @example
+* ```ts
+* cutSpan(-40, 120, 100, 10); // { start: -10, end: 110 }
+* ```
+*/
+function cutSpan(start, end, size, padding) {
+	return {
+		start: Math.max(start, -padding),
+		end: Math.min(end, size + padding)
+	};
+}
+/**
 * The padding of a stack on the grid of its resolution: what stage 3 adds on each side of the subtree picture, so the
 * picture's bounds stay on that grid inside the output texture.
 *
@@ -15925,6 +15983,123 @@ function flushRanges(kctx) {
 	}
 }
 //#endregion
+//#region src/plugins/renderer/kept/drawn-bounds.ts
+/** Every flag of a node's display status: visible, renderable, not culled (Pixi's `localDisplayStatus`). */
+const SHOWN = 7;
+/** The effects of a node that holds none. */
+const NO_EFFECTS = [];
+/** The matrix of each depth of the walk, from the top's space to the node's. Grown once, then reused. */
+const MATRICES = [];
+/** The bounds a masked node's subtree is gathered in, one per depth. Grown once, then reused. */
+const MASKED = [];
+/** The bounds the last walk answered, made once. */
+const RESULT = [];
+/**
+* The matrix of a depth, made the first time the walk reaches it.
+*
+* @param pixi - The module that draws.
+* @param depth - The depth under the top.
+* @returns The matrix.
+*/
+function matrixAt(pixi, depth) {
+	const known = MATRICES[depth];
+	if (known !== void 0) return known;
+	const made = new pixi.Matrix();
+	MATRICES[depth] = made;
+	return made;
+}
+/**
+* The bounds a masked node of a depth gathers its subtree in, made the first time the walk needs it.
+*
+* @param pixi - The module that draws.
+* @param depth - The depth under the top.
+* @returns The bounds, cleared.
+*/
+function maskedAt(pixi, depth) {
+	const known = MASKED[depth];
+	if (known !== void 0) return known.clear();
+	const made = new pixi.Bounds();
+	MASKED[depth] = made;
+	return made;
+}
+/**
+* Tells whether Pixi skips a node and its subtree: hidden, not renderable, culled, or not measured (a mask).
+*
+* @param node - A node under the top.
+* @returns True when it adds nothing.
+*/
+function skipped(node) {
+	return node.localDisplayStatus !== SHOWN || !node.measurable;
+}
+/**
+* Adds what a node draws itself and what its children draw to the bounds, under the node's matrix.
+*
+* @param pixi - The module that draws.
+* @param node - The node, shown.
+* @param into - The bounds so far.
+* @param depth - Its depth under the top.
+* @param top - The top.
+*/
+function addContent(pixi, node, into, depth, top) {
+	const matrix = matrixAt(pixi, depth);
+	if (node.boundsArea) {
+		into.addRect(node.boundsArea, matrix);
+		return;
+	}
+	if (node.renderPipeId !== void 0) {
+		const own = node.bounds;
+		into.addFrame(own.minX, own.minY, own.maxX, own.maxY, matrix);
+	}
+	const children = node.children;
+	for (let index = 0; index < children.length; index += 1) {
+		const child = children[index];
+		if (child !== void 0) addDrawn$1(pixi, child, into, depth + 1, top);
+	}
+}
+/**
+* Adds what one node and its subtree draw to the bounds, in the top's space. The top itself is never skipped: it is
+* the root of the picture's render, drawn whatever its own flags say. A masked node gathers its subtree apart, then
+* the mask cuts it.
+*
+* @param pixi - The module that draws.
+* @param node - The node.
+* @param into - The bounds so far.
+* @param depth - Its depth under the top, 0 for the top.
+* @param top - The top: the space of the bounds, and the root a mask is measured from.
+*/
+function addDrawn$1(pixi, node, into, depth, top) {
+	if (depth > 0 && skipped(node)) return;
+	const matrix = matrixAt(pixi, depth);
+	if (depth === 0) matrix.identity();
+	else {
+		node.updateLocalTransform();
+		matrix.appendFrom(node.localTransform, matrixAt(pixi, depth - 1));
+	}
+	const effects = node.effects ?? NO_EFFECTS;
+	if (effects.length === 0) {
+		addContent(pixi, node, into, depth, top);
+		return;
+	}
+	const masked = maskedAt(pixi, depth);
+	addContent(pixi, node, masked, depth, top);
+	for (const effect of effects) effect.addLocalBounds?.(masked, top);
+	if (masked.isValid) into.addFrame(masked.minX, masked.minY, masked.maxX, masked.maxY);
+}
+/**
+* The bounds of what a subtree draws, in its top's own space: no node Pixi skips, masks applied.
+*
+* @param pixi - The module that draws.
+* @param top - The top of the subtree.
+* @returns The bounds, one object the next walk writes again; empty (`isValid` false) when nothing is drawn.
+*/
+function drawnBounds(pixi, top) {
+	const into = RESULT[0] ?? new pixi.Bounds();
+	RESULT[0] = into;
+	into.clear();
+	addDrawn$1(pixi, top, into, 0, top);
+	return into;
+}
+//#endregion
 //#region src/plugins/renderer/kept/state.ts
 /**
 * @file renderer/kept — the state of the kept-picture cache, and its stop from state alone.
@@ -16081,6 +16256,7 @@ const NOW = {
 	enabled: 0,
 	rs: 1,
 	P: 0,
+	alpha: NaN,
 	r: 1,
 	a: 1,
 	b: 0,
@@ -16109,27 +16285,42 @@ function resolutionOf$1(filter, resolution) {
 	return own === "inherit" ? resolution : own;
 }
 /**
-* Reads what the enabled filters of a stack draw with: how many, the smallest resolution, and the padding sum Pixi
-* pads by (whole pixels).
+* Reads what the enabled filters of a stack draw with: how many, the smallest resolution, the padding sum Pixi
+* pads by (whole pixels), and the alpha they multiply by while every one is an `AlphaFilter`.
 *
 * @param slots - The record's slots.
 * @param resolution - The renderer resolution.
+* @param alphaFilter - Pixi's `AlphaFilter` class.
 * @param into - Where the numbers go.
 */
-function readStack(slots, resolution, into) {
+function readStack(slots, resolution, alphaFilter, into) {
 	let enabled = 0;
 	let rs = Number.POSITIVE_INFINITY;
 	let padding = 0;
+	let alpha = 1;
 	for (let index = 0; index < slots.length; index += 1) {
 		const filter = slots[index]?.filter;
 		if (filter === void 0 || !filter.enabled) continue;
 		enabled += 1;
 		rs = Math.min(rs, resolutionOf$1(filter, resolution));
 		padding += filter.padding;
+		alpha *= filter instanceof alphaFilter ? filter.alpha : NaN;
 	}
 	into.enabled = enabled;
 	into.rs = enabled === 0 ? resolution : rs;
 	into.P = Math.trunc(padding);
+	into.alpha = alpha;
+}
+/**
+* Tells whether a stack draws as its subtree picture at an alpha (F54): every enabled filter an `AlphaFilter`, no
+* padding, at the renderer resolution. The quad then draws the picture itself at that alpha, as Pixi's alpha pass
+* draws its input: no stage 3, no pass when the alpha changes.
+*
+* @param now - This frame's numbers.
+* @returns True when it does.
+*/
+function drawsDirect(now) {
+	return !Number.isNaN(now.alpha) && now.P === 0 && now.rs === now.r;
 }
 /**
 * Tells whether a blend mode draws over what is under it as a picture does.
@@ -16283,7 +16474,7 @@ function holdsDisplay(kctx, top) {
 */
 function createRecord$1(kctx, pixi, entity, view, slots, category) {
 	const top = view.wrapper ?? view.object;
-	const key = (/* @__PURE__ */ new Float64Array(29)).fill(NaN);
+	const key = (/* @__PURE__ */ new Float64Array(31)).fill(NaN);
 	const record = {
 		entity,
 		top,
@@ -16316,6 +16507,8 @@ function createRecord$1(kctx, pixi, entity, view, slots, category) {
 		bytes: 0,
 		settle: false,
 		refused: 0,
+		cut: false,
+		direct: false,
 		displays: void 0
 	};
 	const { state } = kctx;
@@ -16441,7 +16634,8 @@ function linearDiffers(key, now, base, rsAt) {
 */
 function neededBytes(record, now, box) {
 	const { w1, h1, Ps } = box;
-	let bytes = textureBytes(w1, h1, now.rs) + textureBytes(w1 + 2 * Ps, h1 + 2 * Ps, now.r);
+	let bytes = textureBytes(w1, h1, now.rs);
+	if (!drawsDirect(now)) bytes += textureBytes(w1 + 2 * Ps, h1 + 2 * Ps, now.r);
 	const first = firstInputs(record.slots);
 	if (first !== void 0) for (let index = 0; index < first.inputs.count; index += 1) {
 		const scale = first.inputs.scaleOf(index) ?? 0;
@@ -16508,14 +16702,22 @@ function writeTakeKeys(record, now, box) {
 function takePicture(kctx, pixi, matrices, record, view, now) {
 	const { top } = record;
 	if (!kctx.ctx.config.onDemand && holdsDisplay(kctx, top)) return false;
-	const local = clippedToArea(top.getLocalBounds(), top.filterArea);
+	const drawn = drawnBounds(pixi, top);
+	if (!drawn.isValid) return false;
+	const local = clippedToArea(drawn, top.filterArea);
 	if (isEmptyBounds(local)) return false;
 	const box = linearBounds(now.a, now.b, now.c, now.d, local);
-	const x = gridSpan(now.tx + box.x0, now.tx + box.x1, now.rs);
-	const y = gridSpan(now.ty + box.y0, now.ty + box.y1, now.rs);
+	const screen = kctx.host.screen();
+	const width = screen?.width ?? Number.POSITIVE_INFINITY;
+	const height = screen?.height ?? Number.POSITIVE_INFINITY;
+	const Ps = paddingOnGrid(now.P, now.rs);
+	const across = cutSpan(now.tx + box.x0, now.tx + box.x1, width, Ps);
+	const down = cutSpan(now.ty + box.y0, now.ty + box.y1, height, Ps);
+	if (isEmptySpan(across) || isEmptySpan(down)) return false;
+	const x = gridSpan(across.start, across.end, now.rs);
+	const y = gridSpan(down.start, down.end, now.rs);
 	const w1 = x.texels / now.rs;
 	const h1 = y.texels / now.rs;
-	const Ps = paddingOnGrid(now.P, now.rs);
 	if (!fitsTexture(w1, h1, now.rs) || !fitsTexture(w1 + 2 * Ps, h1 + 2 * Ps, now.r)) return false;
 	const needed = neededBytes(record, now, {
 		w1,
@@ -16528,6 +16730,11 @@ function takePicture(kctx, pixi, matrices, record, view, now) {
 		return false;
 	}
 	record.refused = 0;
+	const cutAcross = across.start > now.tx + box.x0 || across.end < now.tx + box.x1;
+	const cutDown = down.start > now.ty + box.y0 || down.end < now.ty + box.y1;
+	record.cut = cutAcross || cutDown;
+	record.key[KEY.sw] = width;
+	record.key[KEY.sh] = height;
 	writeTakeKeys(record, now, {
 		x,
 		y,
@@ -16540,6 +16747,21 @@ function takePicture(kctx, pixi, matrices, record, view, now) {
 	return ok;
 }
 /**
+* Tells whether a span holds nothing: its end is not after its start. Pure.
+*
+* @param span - The span.
+* @param span.start - Its start.
+* @param span.end - Its end.
+* @returns True when it is empty.
+* @example
+* ```ts
+* isEmptySpan({ start: -10, end: -10 }); // true
+* ```
+*/
+function isEmptySpan(span) {
+	return span.end <= span.start;
+}
+/**
 * The local bounds of a top cut to its filter area, both in the top's own units: its filters draw nothing outside
 * the area. With no area the bounds are returned as they are. Pure.
 *
@@ -16591,6 +16813,13 @@ function renderStages(kctx, pixi, matrices, record, view, now) {
 	if (live) handFilters(kctx, pixi, record, view);
 	const first = firstInputs(record.slots);
 	let ok = renderStage1(kctx, pixi, matrices, record);
+	if (drawsDirect(now)) {
+		goDirect(kctx, record);
+		account(kctx, record);
+		if (!ok && live) putFiltersBack(kctx, record, view);
+		return ok;
+	}
+	record.direct = false;
 	if (ok && first !== void 0) renderStage2(kctx, pixi, matrices, record, {
 		inputs: first.inputs,
 		resolution: now.r,
@@ -16599,13 +16828,36 @@ function renderStages(kctx, pixi, matrices, record, view, now) {
 	else if (record.s2Of !== void 0) releaseInputs(kctx, record);
 	ok = ok && renderStage3(kctx, pixi, matrices, record, now);
 	account(kctx, record);
-	if (!ok && live) {
-		if (record.standIn !== void 0) record.standIn.filters = null;
-		kctx.sync.applyFilters(view, filtersOf$1(kctx.ctx.state.sync, record.entity), noMark$1, record.top);
-	}
+	if (!ok && live) putFiltersBack(kctx, record, view);
 	return ok;
 }
 /**
+* Puts the filters of a live record whose take failed back on its top: it draws live again.
+*
+* @param kctx - The kept context.
+* @param record - The record.
+* @param view - Its view.
+*/
+function putFiltersBack(kctx, record, view) {
+	if (record.standIn !== void 0) record.standIn.filters = null;
+	kctx.sync.applyFilters(view, filtersOf$1(kctx.ctx.state.sync, record.entity), noMark$1, record.top);
+}
+/**
+* Lets a record draw its subtree picture itself (F54): the pre-pass results and the filter output go, and the quad
+* shows the picture at the stack's alpha from now on.
+*
+* @param kctx - The kept context.
+* @param record - The record.
+*/
+function goDirect(kctx, record) {
+	if (record.s2Of !== void 0) releaseInputs(kctx, record);
+	if (record.s3 !== void 0) {
+		dropTexture(kctx, record.s3);
+		record.s3 = void 0;
+	}
+	record.direct = true;
+}
+/**
 * Ends the loan of stage 2 when the first filter with inputs left the stack: the results are destroyed.
 *
 * @param kctx - The kept context.
@@ -16641,7 +16893,8 @@ function account(kctx, record) {
 function placeQuad(sync, pixi, matrices, record, view) {
 	const { top, key } = record;
 	const parent = top.parent;
-	const output = record.s3 ?? pixi.Texture.EMPTY;
+	const output = (record.direct ? record.s1 : record.s3) ?? pixi.Texture.EMPTY;
+	const alpha = record.direct ? NOW.alpha : 1;
 	if (record.quad === void 0 || record.quad.destroyed) {
 		record.quad = new pixi.Sprite(output);
 		record.quad.label = `kept:${labelOf$3(top)}`;
@@ -16655,8 +16908,9 @@ function placeQuad(sync, pixi, matrices, record, view) {
 	}
 	if (quad.zIndex !== top.zIndex) quad.zIndex = top.zIndex;
 	if (quad.blendMode !== top.blendMode) quad.blendMode = top.blendMode;
+	if (quad.alpha !== alpha) quad.alpha = alpha;
 	const inverse = parent.getGlobalTransform(matrices.parent, false).invert();
-	const Ps = key[KEY.Ps] ?? 0;
+	const Ps = record.direct ? 0 : key[KEY.Ps] ?? 0;
 	const x = (key[KEY.X0] ?? 0) - Ps + NOW.tx - (key[KEY.tx] ?? 0);
 	const y = (key[KEY.Y0] ?? 0) - Ps + NOW.ty - (key[KEY.ty] ?? 0);
 	const { local } = matrices;
@@ -16800,6 +17054,17 @@ function noteMove(kctx, record) {
 	if (record.settle) kctx.demand.request();
 }
 /**
+* Tells whether the canvas has another size than at the take.
+*
+* @param kctx - The kept context.
+* @param key - The record's key.
+* @returns True when it does.
+*/
+function canvasChanged(kctx, key) {
+	const screen = kctx.host.screen();
+	return screen !== void 0 && (screen.width !== key[KEY.sw] || screen.height !== key[KEY.sh]);
+}
+/**
 * A kept record's frame (P4.3): a stage-1 change retakes (three in a row go live and calm); otherwise a new chain
 * version redoes stages 2 and 3, a filter value, the resolution, the padding or (placed) a move stage 3; at rest after
 * an off-grid move one settle retake is owed.
@@ -16816,8 +17081,12 @@ function stepKept$1(kctx, pixi, matrices, record, view) {
 		churn(kctx, pixi, matrices, record, view);
 		return;
 	}
-	record.churn = 0;
 	const moved = NOW.tx !== key[KEY.lastTx] || NOW.ty !== key[KEY.lastTy];
+	if (record.cut && (moved || canvasChanged(kctx, key))) {
+		churn(kctx, pixi, matrices, record, view);
+		return;
+	}
+	record.churn = 0;
 	if (!moved && record.settle) {
 		retakeOrGoLive(kctx, pixi, matrices, record, view);
 		return;
@@ -16835,6 +17104,12 @@ function stepKept$1(kctx, pixi, matrices, record, view) {
 */
 function refresh$1(kctx, pixi, matrices, record) {
 	const { key } = record;
+	if (drawsDirect(NOW)) {
+		if (record.direct) return;
+		goDirect(kctx, record);
+		account(kctx, record);
+		return;
+	}
 	const inputs = firstInputs(record.slots)?.inputs;
 	const stageTwoOwed = inputs !== void 0 && (record.dirtyS2 || inputs !== record.s2Of || inputs.version() !== record.s2InputsVersion || record.s1Version !== record.s2PictureVersion);
 	const inputsLeft = inputs === void 0 && record.s2Of !== void 0;
@@ -16846,6 +17121,7 @@ function refresh$1(kctx, pixi, matrices, record) {
 		padding: NOW.P
 	});
 	if (!stageThreeOwed) return;
+	record.direct = false;
 	renderStage3(kctx, pixi, matrices, record, NOW);
 	account(kctx, record);
 	if (!stageTwoOwed) kctx.state.refreshesOpen += 1;
@@ -16915,7 +17191,7 @@ function stepCalm(kctx, record) {
 function stepRecord(kctx, pixi, matrices, record, view) {
 	noteDrawing(kctx, record, BEFORE);
 	NOW.r = kctx.host.resolution();
-	readStack(record.slots, NOW.r, NOW);
+	readStack(record.slots, NOW.r, pixi.AlphaFilter, NOW);
 	if (eligible(kctx, record, view, NOW)) stepEligible(kctx, pixi, matrices, record, view);
 	else stepIneligible(kctx, record, view);
 	if (drawingChanged(kctx, record, BEFORE)) dirtyAbove(kctx, record);
@@ -17581,31 +17857,6 @@ function stopDemand(state) {
 	state.verify.reference = void 0;
 }
 //#endregion
-//#region src/plugins/renderer/monitor/clock.ts
-/**
-* @file renderer/monitor — the one renderer file that reads the page clock; lint L3 ignores it (eslint `ignores`). It
-* measures the page in agent builds: the agent phase, a line's `t`, an event's time between frames. Never a game's
-* state, whose time is `clock`.
-*/
-/**
-* Reads `globalThis.performance.now()` at call time, so a test stubs it.
-*
-* @returns Page-clock milliseconds.
-*/
-function pageNow() {
-	return globalThis.performance.now();
-}
-/**
-* Turns page-clock milliseconds into page epoch milliseconds, `performance.timeOrigin + ms`, rounded to 0.01 ms: the
-* `t` of every log line.
-*
-* @param pageMs - Page-clock milliseconds.
-* @returns Epoch milliseconds.
-*/
-function epochOf(pageMs) {
-	return Math.round((globalThis.performance.timeOrigin + pageMs) * 100) / 100;
-}
-//#endregion
 //#region src/plugins/renderer/reasons.ts
 /**
 * @file renderer plugin — the reasons a frame is drawn, in ring order: the monitor stores a reason by its index. A
@@ -19265,9 +19516,9 @@ function wrapDevice(pc, device) {
 		* @returns The pipeline.
 		*/
 		value: function countedPipeline(descriptor) {
-			const started = pageNow();
+			const started = pageNow$1();
 			const made = createRenderPipeline.call(this, descriptor);
-			recordCompile(sinks, pc.perf.frame, descriptor.label ?? null, pageNow() - started);
+			recordCompile(sinks, pc.perf.frame, descriptor.label ?? null, pageNow$1() - started);
 			return made;
 		}
 	});
@@ -19282,9 +19533,9 @@ function wrapDevice(pc, device) {
 		* @returns The module.
 		*/
 		value: function countedModule(descriptor) {
-			const started = pageNow();
+			const started = pageNow$1();
 			const made = createShaderModule.call(this, descriptor);
-			recordModule(sinks, pc.perf.frame, descriptor.label ?? null, pageNow() - started);
+			recordModule(sinks, pc.perf.frame, descriptor.label ?? null, pageNow$1() - started);
 			return made;
 		}
 	});
@@ -19312,9 +19563,9 @@ function wrapGl(pc, gl) {
 		* @param program - The program.
 		*/
 		value: function countedLink(program) {
-			const started = pageNow();
+			const started = pageNow$1();
 			linkProgram.call(this, program);
-			recordCompile(sinks, pc.perf.frame, null, pageNow() - started);
+			recordCompile(sinks, pc.perf.frame, null, pageNow$1() - started);
 		}
 	});
 	return () => {
@@ -19980,7 +20231,7 @@ function headerLine(pc, thermal) {
 	return {
 		v: 1,
 		kind: "header",
-		t: epochOf(pageNow()),
+		t: epochOf(pageNow$1()),
 		build: buildId(),
 		timeOrigin: globalThis.performance.timeOrigin,
 		engine: typeof __MOKU_GAME_ENGINE__ === "string" ? __MOKU_GAME_ENGINE__ : null,
@@ -20500,7 +20751,7 @@ function eventLine(name, detail, frame) {
 	return {
 		v: 1,
 		kind: "event",
-		t: epochOf(pageNow()),
+		t: epochOf(pageNow$1()),
 		build: buildId(),
 		frame,
 		name,
@@ -20518,7 +20769,7 @@ function markLine(label, auto) {
 	return {
 		v: 1,
 		kind: "mark",
-		t: epochOf(pageNow()),
+		t: epochOf(pageNow$1()),
 		build: buildId(),
 		label,
 		auto
@@ -20535,7 +20786,7 @@ function thermalLine(reading) {
 	return {
 		v: 1,
 		kind: "thermal",
-		t: epochOf(pageNow()),
+		t: epochOf(pageNow$1()),
 		build: buildId(),
 		status: reading.status,
 		headroom: reading.headroom,
@@ -20677,7 +20928,7 @@ function buildStartup(pc) {
 	return {
 		v: 1,
 		kind: "startup",
-		t: epochOf(pageNow()),
+		t: epochOf(pageNow$1()),
 		build: buildId(),
 		htmlMs: responseEnd === void 0 ? null : roundTo(responseEnd, 2),
 		script,
@@ -21104,7 +21355,7 @@ function writeKept(pc, slot) {
 * @param section - The `COST` index the time goes to.
 */
 function lap(perf, section) {
-	const now = pageNow();
+	const now = pageNow$1();
 	perf.sectionsMs[section] = cellF64(perf.sectionsMs, section) + now - cellF64(perf.staged, 2);
 	perf.staged[2] = now;
 }
@@ -21496,7 +21747,7 @@ function commitFrame(pc, measure) {
 	const sections = sinks.sections;
 	const slot = ring.written % ring.capacity;
 	const previous = ring.size === 0 ? -1 : ring.newest;
-	perf.staged[2] = pageNow();
+	perf.staged[2] = pageNow$1();
 	stageBudget(perf, measure);
 	writeMeasure(pc, slot, measure);
 	writeKept(pc, slot);
@@ -22116,7 +22367,7 @@ function notePauses(pc, reasons, paused, resumed) {
 	const detail = { reasons: [...reasons] };
 	if (paused) {
 		writeEvent(pc, "pause", detail);
-		pc.perf.staged[1] = pageNow();
+		pc.perf.staged[1] = pageNow$1();
 		flushPerf(pc);
 	} else if (resumed) {
 		writeEvent(pc, "resume", detail);
@@ -22138,7 +22389,7 @@ function noteChange(perf, change) {
 * @param perf - The perf state.
 */
 function beginAgent(perf) {
-	if (Number.isNaN(perf.agentStart)) perf.agentStart = pageNow();
+	if (Number.isNaN(perf.agentStart)) perf.agentStart = pageNow$1();
 }
 /**
 * Closes the open agent span: its time goes into the agent phase of the frame interval it falls in, and to
@@ -22149,7 +22400,7 @@ function beginAgent(perf) {
 function endAgent(pc) {
 	const { perf } = pc;
 	if (Number.isNaN(perf.agentStart)) return;
-	const span = pageNow() - perf.agentStart;
+	const span = pageNow$1() - perf.agentStart;
 	perf.agentStart = NaN;
 	perf.agentMs += span;
 	pc.ctx.deps.time.chargeAgent(span);
@@ -22192,7 +22443,7 @@ function attachFirst(pc) {
 		writeEvent(pc, "device-restored", { kind: host.kind() });
 	});
 	host.onTrim((reason, freedMb) => {
-		perf.problems.trimAt = pageNow();
+		perf.problems.trimAt = pageNow$1();
 		writeEvent(pc, "pool-trim", {
 			reason,
 			freedMb
@@ -22534,6 +22785,17 @@ function createMonitorApi(ctx, deps) {
 		}
 		if (pc === void 0) sinks.inFrame = false;
 	};
+	/**
+	* The agent span: `beginAgent` and `endAgent`, also the span the captures are taken in.
+	*/
+	const agentSpan = {
+		begin: () => {
+			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) beginAgent(pc.perf);
+		},
+		end: () => {
+			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) endAgent(pc);
+		}
+	};
 	return {
 		stats: () => {
 			const usage = deps.host.textures();
@@ -22587,12 +22849,8 @@ function createMonitorApi(ctx, deps) {
 		event: (name, detail = NO_DETAIL) => {
 			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) writeEvent(pc, name, detail);
 		},
-		beginAgent: () => {
-			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) beginAgent(pc.perf);
-		},
-		endAgent: () => {
-			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) endAgent(pc);
-		},
+		beginAgent: agentSpan.begin,
+		endAgent: agentSpan.end,
 		sections: (next) => {
 			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) {
 				if (next === void 0) return pc.perf.sections;
@@ -22626,7 +22884,7 @@ function createMonitorApi(ctx, deps) {
 			state.lastDrawn = drawn;
 			notePasses(drawn);
 			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) pc.perf.drawn = drawn;
-			if (drawn) serveCaptures(mctx);
+			if (drawn) serveCaptures(mctx, agentSpan);
 		},
 		waiting: () => state.captures.length > 0,
 		changed: (change) => {
@@ -22647,7 +22905,7 @@ function createMonitorApi(ctx, deps) {
 		},
 		flush: () => {
 			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) {
-				pc.perf.staged[1] = pageNow();
+				pc.perf.staged[1] = pageNow$1();
 				flushPerf(pc);
 			}
 		},
@@ -23728,7 +23986,7 @@ function variantsOf(sctx) {
 * @param subject - The subject.
 * @param variants - Its variants.
 */
-function enqueue(warm, subject, variants) {
+function enqueue$1(warm, subject, variants) {
 	for (const variant of variants) warm.queue.push({
 		subject,
 		variant
@@ -23770,7 +24028,7 @@ function abandon(warm) {
 *
 * @param sctx - Domain context of the sync module.
 */
-function startWarm$1(sctx) {
+function startWarm$2(sctx) {
 	const state = sctx.ctx.state.sync;
 	const { warm } = state;
 	dropObjects(warm);
@@ -23781,12 +24039,12 @@ function startWarm$1(sctx) {
 	warm.failed = false;
 	if (!canWarm(sctx)) return;
 	const variants = variantsOf(sctx);
-	for (const subject of CONTENT) enqueue(warm, subject, variants);
+	for (const subject of CONTENT) enqueue$1(warm, subject, variants);
 	const [font] = state.fonts.keys();
 	if (font !== void 0) {
 		warm.textFont = font;
 		warm.textQueued = true;
-		enqueue(warm, "text", variants);
+		enqueue$1(warm, "text", variants);
 	}
 	for (const filter of warm.filters) {
 		const entry = warm.waiting.get(filter);
@@ -23795,7 +24053,7 @@ function startWarm$1(sctx) {
 			resolve: []
 		});
 		else entry.left = variants.length;
-		enqueue(warm, filter, variants);
+		enqueue$1(warm, filter, variants);
 	}
 	sctx.deps.demand.request();
 }
@@ -23843,7 +24101,7 @@ function warmFilter(sctx, filter) {
 		entry.left = variants.length;
 		warm.filters.add(filter);
 		warm.waiting.set(filter, entry);
-		enqueue(warm, filter, variants);
+		enqueue$1(warm, filter, variants);
 		sctx.deps.demand.request();
 	}
 	return new Promise((resolve) => {
@@ -24153,6 +24411,419 @@ function clearFonts(state) {
 	state.fontCache = void 0;
 }
 //#endregion
+//#region src/plugins/renderer/sync/outline.ts
+/** Above every child of the wrapper, whatever `Order` a child carries. */
+const OUTLINE_Z = Number.MAX_SAFE_INTEGER;
+const CYAN = 65535;
+const RED = 16711680;
+/**
+* Writes the slice widths a texture asks for, in the units it is drawn in: its default borders divided
+* by the resolution of its source. A texture without borders gets 0 on every side, never Pixi's 10. Written in place,
+* so a nine-slice write allocates nothing.
+*
+* @param texture - The texture a nine-slice draws, or `undefined` while nothing can draw.
+* @param out - The widths to write.
+* @returns `out`.
+*/
+function bordersInto(texture, out) {
+	const borders = texture?.defaultBorders;
+	if (texture === void 0 || borders === void 0) {
+		out.left = 0;
+		out.top = 0;
+		out.right = 0;
+		out.bottom = 0;
+		return out;
+	}
+	const resolution = texture.source.resolution > 0 ? texture.source.resolution : 1;
+	out.left = borders.left / resolution;
+	out.top = borders.top / resolution;
+	out.right = borders.right / resolution;
+	out.bottom = borders.bottom / resolution;
+	return out;
+}
+/**
+* The factor Pixi shrinks the corners of a nine-slice by when two of them would overlap.
+*
+* @param size - The drawn size.
+* @param size.width - Drawn width.
+* @param size.height - Drawn height.
+* @param borders - The slice widths.
+* @returns 1 when the corners fit, less when they overlap.
+* @example
+* ```ts
+* sliceScale({ width: 100, height: 200 }, { left: 72, top: 76, right: 72, bottom: 76 }); // 0.6944
+* ```
+*/
+function sliceScale(size, borders) {
+	const across = borders.left + borders.right;
+	const down = borders.top + borders.bottom;
+	const scaleX = across > 0 && size.width < across ? size.width / across : 1;
+	const scaleY = down > 0 && size.height < down ? size.height / down : 1;
+	return Math.min(scaleX, scaleY);
+}
+/**
+* Strokes the bounds of a nine-slice and the four lines Pixi cuts it at, into the wrapper of its
+* view: cyan, red when the corners overlap or the texture is missing. The graphics is kept on the
+* view and redrawn in place.
+*
+* @param pixi - The Pixi module the renderer loaded.
+* @param wrapper - The wrapper of the view, which carries its pose.
+* @param view - The view of the nine-slice.
+* @param shape - Size, borders and whether the texture is missing.
+*/
+function drawOutline(pixi, wrapper, view, shape) {
+	const outline = view.outline ?? new pixi.Graphics();
+	const { width, height, borders } = shape;
+	const scale = sliceScale(shape, borders);
+	const left = borders.left * scale;
+	const right = width - borders.right * scale;
+	const top = borders.top * scale;
+	const bottom = height - borders.bottom * scale;
+	outline.label = `outline#${shape.entity}`;
+	outline.zIndex = OUTLINE_Z;
+	outline.clear();
+	outline.rect(0, 0, width, height).moveTo(left, 0).lineTo(left, height).moveTo(right, 0).lineTo(right, height).moveTo(0, top).lineTo(width, top).moveTo(0, bottom).lineTo(width, bottom);
+	outline.stroke({
+		color: shape.missing || scale < 1 ? RED : CYAN,
+		width: 1,
+		pixelLine: true
+	});
+	if (outline.parent !== wrapper) wrapper.addChild(outline);
+	view.outline = outline;
+}
+//#endregion
+//#region src/plugins/renderer/sync/hollow.ts
+/** The vertices across and down: the four cut lines of a nine-slice on each axis. */
+const SIDE = 4;
+/** The cells of the 3 × 3 slicing on each axis. */
+const CELLS = 3;
+/** The cell left out, row by row: the centre, (1, 1). */
+const CENTRE = 4;
+/** Indices of one quad: two triangles. */
+const QUAD = 6;
+/**
+* The index buffer of the rim: the two triangles of every cell of the 3 × 3 slicing but the centre, in Pixi's
+* `PlaneGeometry` winding. Static: written once per geometry.
+*
+* @returns 48 indices into the 16 vertices.
+* @example
+* ```ts
+* rimIndices().length; // 48
+* ```
+*/
+function rimIndices() {
+	const indices = /* @__PURE__ */ new Uint32Array(48);
+	let at = 0;
+	for (let cell = 0; cell < 9; cell += 1) {
+		if (cell === CENTRE) continue;
+		const topLeft = Math.floor(cell / CELLS) * SIDE + cell % CELLS;
+		const bottomLeft = topLeft + SIDE;
+		indices.set([
+			topLeft,
+			topLeft + 1,
+			bottomLeft,
+			topLeft + 1,
+			bottomLeft + 1,
+			bottomLeft
+		], at);
+		at += QUAD;
+	}
+	return indices;
+}
+/**
+* Writes one row of the grid: its four vertices, one per cut line across, at the same `y`.
+*
+* @param target - The 32 numbers of the grid: x and y of each vertex, row by row.
+* @param row - The row, 0 to 3.
+* @param y - The row's line down.
+* @param across - The cut lines across.
+*/
+function writeRow(target, row, y, across) {
+	const at = row * SIDE * 2;
+	target[at] = across.start;
+	target[at + 1] = y;
+	target[at + 2] = across.near;
+	target[at + 3] = y;
+	target[at + 4] = across.far;
+	target[at + 5] = y;
+	target[at + 6] = across.end;
+	target[at + 7] = y;
+}
+/**
+* Writes the 4 × 4 grid of the cut lines in place: Pixi's vertex order, row by row.
+*
+* @param target - The 32 numbers of the grid.
+* @param across - The cut lines across.
+* @param down - The cut lines down.
+*/
+function writeGrid(target, across, down) {
+	writeRow(target, 0, down.start, across);
+	writeRow(target, 1, down.near, across);
+	writeRow(target, 2, down.far, across);
+	writeRow(target, 3, down.end, across);
+}
+/**
+* Makes the class of the rim-only nine-slice over one loaded Pixi module.
+*
+* @param pixi - The Pixi module the renderer loaded.
+* @returns The class.
+*/
+function createHollowClass(pixi) {
+	/** A nine-slice that draws its rim alone: Pixi's mesh over the 16 vertices of the slicing and its eight border cells. */
+	class HollowNineSlice extends pixi.Mesh {
+		/** Tells the rim-only object from Pixi's `NineSliceSprite`. */
+		hollow = true;
+		/** The slice widths, in the units the panel is drawn in. */
+		borders = {
+			left: 0,
+			top: 0,
+			right: 0,
+			bottom: 0
+		};
+		/** The cut lines across, scratch of the next write. */
+		across = {
+			start: 0,
+			near: 0,
+			far: 0,
+			end: 0
+		};
+		/** The cut lines down, scratch of the next write. */
+		down = {
+			start: 0,
+			near: 0,
+			far: 0,
+			end: 0
+		};
+		/** The panel's width the positions are laid out for. */
+		boxWidth = 0;
+		/** The panel's height the positions are laid out for. */
+		boxHeight = 0;
+		/** False while Pixi's constructor writes the first texture: the geometry does not exist yet. */
+		built = false;
+		/**
+		* Builds the mesh over a geometry of its own, 0 × 0 with no border, its uvs cut for the texture.
+		*
+		* @param texture - The texture it draws first.
+		*/
+		constructor(texture) {
+			super({
+				geometry: new pixi.MeshGeometry({
+					positions: /* @__PURE__ */ new Float32Array(32),
+					uvs: /* @__PURE__ */ new Float32Array(32),
+					indices: rimIndices()
+				}),
+				texture
+			});
+			this.built = true;
+			this.layoutUvs();
+		}
+		/**
+		* The width of the left border column.
+		*
+		* @returns Units.
+		*/
+		get leftWidth() {
+			return this.borders.left;
+		}
+		/**
+		* Sets the width of the left border column: the positions and the uvs are written again.
+		*
+		* @param value - Units.
+		*/
+		set leftWidth(value) {
+			if (this.borders.left === value) return;
+			this.borders.left = value;
+			this.layoutAll();
+		}
+		/**
+		* The height of the top border row.
+		*
+		* @returns Units.
+		*/
+		get topHeight() {
+			return this.borders.top;
+		}
+		/**
+		* Sets the height of the top border row: the positions and the uvs are written again.
+		*
+		* @param value - Units.
+		*/
+		set topHeight(value) {
+			if (this.borders.top === value) return;
+			this.borders.top = value;
+			this.layoutAll();
+		}
+		/**
+		* The width of the right border column.
+		*
+		* @returns Units.
+		*/
+		get rightWidth() {
+			return this.borders.right;
+		}
+		/**
+		* Sets the width of the right border column: the positions and the uvs are written again.
+		*
+		* @param value - Units.
+		*/
+		set rightWidth(value) {
+			if (this.borders.right === value) return;
+			this.borders.right = value;
+			this.layoutAll();
+		}
+		/**
+		* The height of the bottom border row.
+		*
+		* @returns Units.
+		*/
+		get bottomHeight() {
+			return this.borders.bottom;
+		}
+		/**
+		* Sets the height of the bottom border row: the positions and the uvs are written again.
+		*
+		* @param value - Units.
+		*/
+		set bottomHeight(value) {
+			if (this.borders.bottom === value) return;
+			this.borders.bottom = value;
+			this.layoutAll();
+		}
+		/**
+		* The width of the panel, as on a `NineSliceSprite`: its box, never a scale.
+		*
+		* @returns Units.
+		*/
+		get width() {
+			return this.boxWidth;
+		}
+		/**
+		* Sets the width of the panel: the positions are written again.
+		*
+		* @param value - Units.
+		*/
+		set width(value) {
+			if (this.boxWidth === value) return;
+			this.boxWidth = value;
+			this.layoutPositions();
+		}
+		/**
+		* The height of the panel, as on a `NineSliceSprite`: its box, never a scale.
+		*
+		* @returns Units.
+		*/
+		get height() {
+			return this.boxHeight;
+		}
+		/**
+		* Sets the height of the panel: the positions are written again.
+		*
+		* @param value - Units.
+		*/
+		set height(value) {
+			if (this.boxHeight === value) return;
+			this.boxHeight = value;
+			this.layoutPositions();
+		}
+		/**
+		* The texture the rim is cut from.
+		*
+		* @returns The texture.
+		*/
+		get texture() {
+			return super.texture;
+		}
+		/**
+		* Sets the texture as Pixi's mesh does; the uvs are cut for its frame.
+		*
+		* @param value - The texture.
+		*/
+		set texture(value) {
+			super.texture = value;
+			if (this.built) this.layoutUvs();
+		}
+		/**
+		* Frees the mesh as Pixi does, and its own geometry with it.
+		*
+		* @param options - Pixi's destroy options; a texture is freed only when they ask.
+		*/
+		destroy(options) {
+			if (this.destroyed) return;
+			const geometry = this.geometry;
+			super.destroy(options);
+			geometry.destroy(true);
+		}
+		/** Writes the positions and the uvs again: a border changed. */
+		layoutAll() {
+			this.layoutPositions();
+			this.layoutUvs();
+		}
+		/**
+		* Writes the 16 positions in place: the cut lines at the borders, all four shrunk by one factor when two corners
+		* would overlap, as Pixi's `NineSliceGeometry` shrinks them.
+		*/
+		layoutPositions() {
+			const across = this.across;
+			const down = this.down;
+			const borders = this.borders;
+			const scale = sliceScale(this, borders);
+			across.start = 0;
+			across.near = borders.left * scale;
+			across.far = this.boxWidth - borders.right * scale;
+			across.end = this.boxWidth;
+			down.start = 0;
+			down.near = borders.top * scale;
+			down.far = this.boxHeight - borders.bottom * scale;
+			down.end = this.boxHeight;
+			writeGrid(this.geometry.positions, across, down);
+			this.geometry.getBuffer("aPosition").update();
+		}
+		/**
+		* Writes the 16 uvs in place: the texture's frame (its trim, when it has one) cut at the unscaled borders, as
+		* Pixi's `NineSliceGeometry` cuts it. Pixi maps them into an atlas page when it batches the mesh.
+		*/
+		layoutUvs() {
+			const across = this.across;
+			const down = this.down;
+			const borders = this.borders;
+			const texture = this.texture;
+			const width = texture.width;
+			const height = texture.height;
+			const trim = texture.trim;
+			const x = trim?.x ?? 0;
+			const y = trim?.y ?? 0;
+			const u0 = x / width;
+			const v0 = y / height;
+			const u1 = (x + (trim?.width ?? width)) / width;
+			const v1 = (y + (trim?.height ?? height)) / height;
+			const texelU = 1 / width;
+			const texelV = 1 / height;
+			across.start = u0;
+			across.near = u0 + texelU * borders.left;
+			across.far = u1 - texelU * borders.right;
+			across.end = u1;
+			down.start = v0;
+			down.near = v0 + texelV * borders.top;
+			down.far = v1 - texelV * borders.bottom;
+			down.end = v1;
+			writeGrid(this.geometry.uvs, across, down);
+			this.geometry.getBuffer("aUV").update();
+		}
+	}
+	return HollowNineSlice;
+}
+/**
+* Builds a rim-only nine-slice of Pixi's white texture, its class made at the first one over the loaded module.
+*
+* @param state - The sync branch of the plugin state, which keeps the class.
+* @param pixi - The Pixi module the renderer loaded.
+* @returns The object.
+*/
+function makeHollow(state, pixi) {
+	state.hollowClass ??= createHollowClass(pixi);
+	return new state.hollowClass(pixi.Texture.WHITE);
+}
+//#endregion
 //#region src/plugins/renderer/sync/labels.ts
 /**
 * Builds the label of one view.
@@ -24189,15 +24860,25 @@ function isGraphics(object) {
 	return "roundRect" in object;
 }
 /**
-* Tells whether a display object is a nine-slice sprite.
+* Tells whether a display object draws a nine-slice: Pixi's `NineSliceSprite`, or the engine's rim-only mesh of a
+* `hollow` one. Both carry the slice widths.
 *
 * @param object - The display object.
-* @returns True for a nine-slice sprite.
+* @returns True for either nine-slice object.
 */
 function isNineSlice(object) {
 	return "leftWidth" in object;
 }
 /**
+* Tells whether a display object is the engine's rim-only nine-slice (F59).
+*
+* @param object - The display object.
+* @returns True for the hollow mesh, false for Pixi's `NineSliceSprite` and every other object.
+*/
+function isHollow(object) {
+	return "hollow" in object;
+}
+/**
 * Takes a display object out of the Pixi tree. Pixi containers are not DOM nodes, so the DOM
 * helper the linter suggests does not exist on them.
 *
@@ -24248,18 +24929,20 @@ function dropOutline(view) {
 	view.outline = void 0;
 }
 /**
-* The pool an object belongs to: its class and the texture it draws.
+* The pool an object belongs to: its class and the texture it draws. A rim-only nine-slice has a pool of its own, so
+* a filled panel never gets a hollow object back, nor the other way round.
 *
 * @param kind - Which component gave the entity its display object.
 * @param textureKey - The asset key.
+* @param hollow - True for the rim-only object of a `NineSlice` with `hollow: true`.
 * @returns The pool key.
 * @example
 * ```ts
-* poolKeyOf("Sprite", "board.cell"); // "Sprite:board.cell"
+* poolKeyOf("NineSlice", "glass.frost", true); // "NineSlice.hollow:glass.frost"
 * ```
 */
-function poolKeyOf(kind, textureKey) {
-	return `${kind}:${textureKey}`;
+function poolKeyOf(kind, textureKey, hollow) {
+	return hollow ? `${kind}.hollow:${textureKey}` : `${kind}:${textureKey}`;
 }
 /**
 * Brings the object of a view that left back to the state a fresh one has: detached, drawn, opaque, unmoved, white.
@@ -24269,9 +24952,17 @@ function poolKeyOf(kind, textureKey) {
 * @param view - The view whose object goes back to its pool; its wrapper is gone already.
 */
 function resetObject(view) {
-	const object = view.object;
-	detach$1(object);
+	detach$1(view.object);
 	clearHidden(view);
+	resetNode(view.object);
+}
+/**
+* Brings a detached object back to a fresh one's pose and look: drawn, opaque, unmoved, white for a sprite and a
+* graphics.
+*
+* @param object - The object, out of the tree.
+*/
+function resetNode(object) {
 	object.visible = true;
 	object.alpha = 1;
 	object.rotation = 0;
@@ -24321,7 +25012,6 @@ function oldestPool(state) {
 * @param view - The view that left.
 */
 function release$1(sctx, view) {
-	const state = sctx.ctx.state.sync;
 	dropMask(view);
 	dropOutline(view);
 	clearFilters(view.object);
@@ -24344,15 +25034,50 @@ function release$1(sctx, view) {
 		view.display?.adapter.destroy(view.object);
 		return;
 	}
-	const groups = sctx.ctx.state.kept.madeGroups;
-	if (groups.has(view.object)) {
-		view.object.disableRenderGroup();
-		groups.delete(view.object);
-	}
+	dropGroup(sctx, view.object);
 	resetObject(view);
-	const pool = state.pools.get(view.poolKey) ?? emptyPool();
-	pool.push(view.object);
-	state.pools.set(view.poolKey, pool);
+	store$1(sctx, view.object, view.poolKey);
+}
+/**
+* Puts an object a view no longer draws with back into a pool, while the view goes on with another one: the
+* nine-slice whose `hollow` flipped (F59). Reset as `release` resets a view's object; its view keeps its hidden
+* reasons, which hang on the view's wrapper.
+*
+* @param sctx - Domain context of the sync module.
+* @param object - The object, still in the view's wrapper.
+* @param poolKey - The pool it belongs to.
+*/
+function releaseObject(sctx, object, poolKey) {
+	dropGroup(sctx, object);
+	detach$1(object);
+	resetNode(object);
+	store$1(sctx, object, poolKey);
+}
+/**
+* Takes away the render group the kept cache made of an object (spec 23 P9.3), before it is pooled.
+*
+* @param sctx - Domain context of the sync module.
+* @param object - The object.
+*/
+function dropGroup(sctx, object) {
+	const groups = sctx.ctx.state.kept.madeGroups;
+	if (!groups.has(object)) return;
+	object.disableRenderGroup();
+	groups.delete(object);
+}
+/**
+* Pushes a reset object into its pool and evicts the one that waited longest while the pools hold more than
+* `poolLimit`.
+*
+* @param sctx - Domain context of the sync module.
+* @param object - The reset object.
+* @param poolKey - Its pool.
+*/
+function store$1(sctx, object, poolKey) {
+	const state = sctx.ctx.state.sync;
+	const pool = state.pools.get(poolKey) ?? emptyPool();
+	pool.push(object);
+	state.pools.set(poolKey, pool);
 	state.pooled += 1;
 	while (state.pooled > sctx.ctx.config.poolLimit) {
 		const oldest = oldestPool(state);
@@ -24363,21 +25088,32 @@ function release$1(sctx, view) {
 }
 /**
 * Destroys the pooled objects that draw one of these keys, so a bundle that left frees its GPU
-* memory instead of waiting for a reuse that resolves nothing.
+* memory instead of waiting for a reuse that resolves nothing: sprites, nine-slices and rim-only nine-slices.
 *
 * @param state - The sync branch of the plugin state.
 * @param keys - The asset keys that went stale.
 */
 function dropPooled(state, keys) {
-	for (const key of keys) for (const kind of ["Sprite", "NineSlice"]) {
-		const pool = state.pools.get(poolKeyOf(kind, key));
-		if (pool === void 0) continue;
-		for (const object of pool) object.destroy({ texture: false });
-		state.pooled -= pool.length;
-		state.pools.delete(poolKeyOf(kind, key));
+	for (const key of keys) {
+		dropPool(state, poolKeyOf("Sprite", key, false));
+		dropPool(state, poolKeyOf("NineSlice", key, false));
+		dropPool(state, poolKeyOf("NineSlice", key, true));
 	}
 }
 /**
+* Destroys one pool and everything in it.
+*
+* @param state - The sync branch of the plugin state.
+* @param poolKey - The pool.
+*/
+function dropPool(state, poolKey) {
+	const pool = state.pools.get(poolKey);
+	if (pool === void 0) return;
+	for (const object of pool) object.destroy({ texture: false });
+	state.pooled -= pool.length;
+	state.pools.delete(poolKey);
+}
+/**
 * Destroys everything the pools hold. Works on the state alone, because `onStop` has no context.
 *
 * @param state - The sync branch of the plugin state.
@@ -24543,85 +25279,6 @@ function clearLayers(state) {
 	state.hudLayer = void 0;
 }
 //#endregion
-//#region src/plugins/renderer/sync/outline.ts
-/** Above every child of the wrapper, whatever `Order` a child carries. */
-const OUTLINE_Z = Number.MAX_SAFE_INTEGER;
-const CYAN = 65535;
-const RED = 16711680;
-/**
-* The slice widths a texture asks for, in the units it is drawn in: its default borders divided
-* by the resolution of its source. A texture without borders gets 0 on every side, never Pixi's 10.
-*
-* @param texture - The texture a nine-slice draws, or `undefined` while nothing can draw.
-* @returns The four widths.
-*/
-function bordersOf(texture) {
-	const borders = texture?.defaultBorders;
-	if (texture === void 0 || borders === void 0) return {
-		left: 0,
-		top: 0,
-		right: 0,
-		bottom: 0
-	};
-	const resolution = texture.source.resolution > 0 ? texture.source.resolution : 1;
-	return {
-		left: borders.left / resolution,
-		top: borders.top / resolution,
-		right: borders.right / resolution,
-		bottom: borders.bottom / resolution
-	};
-}
-/**
-* The factor Pixi shrinks the corners of a nine-slice by when two of them would overlap.
-*
-* @param size - The drawn size.
-* @param size.width - Drawn width.
-* @param size.height - Drawn height.
-* @param borders - The slice widths.
-* @returns 1 when the corners fit, less when they overlap.
-* @example
-* ```ts
-* sliceScale({ width: 100, height: 200 }, { left: 72, top: 76, right: 72, bottom: 76 }); // 0.6944
-* ```
-*/
-function sliceScale(size, borders) {
-	const across = borders.left + borders.right;
-	const down = borders.top + borders.bottom;
-	const scaleX = across > 0 && size.width < across ? size.width / across : 1;
-	const scaleY = down > 0 && size.height < down ? size.height / down : 1;
-	return Math.min(scaleX, scaleY);
-}
-/**
-* Strokes the bounds of a nine-slice and the four lines Pixi cuts it at, into the wrapper of its
-* view: cyan, red when the corners overlap or the texture is missing. The graphics is kept on the
-* view and redrawn in place.
-*
-* @param pixi - The Pixi module the renderer loaded.
-* @param wrapper - The wrapper of the view, which carries its pose.
-* @param view - The view of the nine-slice.
-* @param shape - Size, borders and whether the texture is missing.
-*/
-function drawOutline(pixi, wrapper, view, shape) {
-	const outline = view.outline ?? new pixi.Graphics();
-	const { width, height, borders } = shape;
-	const scale = sliceScale(shape, borders);
-	const left = borders.left * scale;
-	const right = width - borders.right * scale;
-	const top = borders.top * scale;
-	const bottom = height - borders.bottom * scale;
-	outline.label = `outline#${shape.entity}`;
-	outline.zIndex = OUTLINE_Z;
-	outline.clear();
-	outline.rect(0, 0, width, height).moveTo(left, 0).lineTo(left, height).moveTo(right, 0).lineTo(right, height).moveTo(0, top).lineTo(width, top).moveTo(0, bottom).lineTo(width, bottom);
-	outline.stroke({
-		color: shape.missing || scale < 1 ? RED : CYAN,
-		width: 1,
-		pixelLine: true
-	});
-	if (outline.parent !== wrapper) wrapper.addChild(outline);
-	view.outline = outline;
-}
-//#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;
@@ -26085,6 +26742,144 @@ function destroyTexture(state, texture) {
 	texture.destroy(true);
 }
 //#endregion
+//#region src/plugins/renderer/sync/upload.ts
+/** The calls of a source nobody waits for: none. */
+const NOBODY = Object.freeze([]);
+/**
+* The resolve of a waiter before its promise exists: answers nobody.
+*/
+function unanswered() {}
+/**
+* Creates the set of the sources uploaded on a device. It lives in its own non-exported function because lint rule L5
+* refuses a collection built inside an exported declaration.
+*
+* @returns An empty weak set.
+*/
+function emptyDone() {
+	return /* @__PURE__ */ new WeakSet();
+}
+/**
+* Counts one source for a call: queued once whoever names it first, waited for once by each call, however many of its
+* textures share it. A source uploaded on this device, or destroyed, is not waited for.
+*
+* @param upload - The upload branch of the sync state.
+* @param source - The source of one texture of the call.
+* @param waiter - The call.
+*/
+function enqueue(upload, source, waiter) {
+	if (source.destroyed || upload.done.has(source)) return;
+	let waiters = upload.waiting.get(source);
+	if (waiters === void 0) {
+		waiters = [];
+		upload.waiting.set(source, waiters);
+		upload.queue.push(source);
+	}
+	if (waiters.at(-1) === waiter) return;
+	waiters.push(waiter);
+	waiter.left += 1;
+}
+/**
+* Queues the sources of textures for the GPU; resolves true once each went through `initSource` (the body of
+* `TexturesApi.upload`). Answers false at once while nothing draws or with `uploads: 0`, and true at once when every
+* source is on this device already. Asks for a frame.
+*
+* @param sctx - Domain context of the sync module.
+* @param textures - The textures.
+* @returns Whether every source is on the GPU.
+*/
+function uploadTextures(sctx, textures) {
+	const { upload } = sctx.ctx.state.sync;
+	if (sctx.ctx.config.uploads === 0 || !sctx.deps.host.ready()) return Promise.resolve(false);
+	const waiter = {
+		left: 0,
+		resolve: unanswered
+	};
+	for (const texture of textures) enqueue(upload, texture.source, waiter);
+	if (waiter.left === 0) return Promise.resolve(true);
+	sctx.deps.demand.request();
+	return new Promise((resolve) => {
+		waiter.resolve = resolve;
+	});
+}
+/**
+* Uploads one source, the error of a throw logged: the source counts as done either way, so a failing one is logged
+* once and never stops the queue.
+*
+* @param sctx - Domain context of the sync module.
+* @param upload - The upload branch of the sync state.
+* @param source - The source.
+*/
+function put(sctx, upload, source) {
+	try {
+		sctx.deps.host.initSource(source);
+	} catch (error) {
+		sctx.ctx.log.warn("renderer:upload-failed", {
+			source: source.label,
+			error
+		});
+	}
+	upload.done.add(source);
+}
+/**
+* Counts a source off for the calls that wait for it; a call whose last source it was answers true.
+*
+* @param upload - The upload branch of the sync state.
+* @param source - The source uploaded or skipped.
+*/
+function settle$2(upload, source) {
+	const waiters = upload.waiting.get(source) ?? NOBODY;
+	upload.waiting.delete(source);
+	for (const waiter of waiters) {
+		waiter.left -= 1;
+		if (waiter.left === 0) waiter.resolve(true);
+	}
+}
+/**
+* Uploads up to `renderer.uploads` queued sources before the stage pass of a drawn frame; a source destroyed while it
+* waited is skipped and costs nothing of the budget. A queue that still holds sources asks for the next frame; one
+* that ran out empties. Reads two numbers and returns while the queue is empty.
+*
+* @param sctx - Domain context of the sync module.
+* @returns True when a source went to the GPU in this frame, so the frame is no sample of the adaptive rate.
+*/
+function uploadStep(sctx) {
+	const { upload } = sctx.ctx.state.sync;
+	if (upload.head >= upload.queue.length) return false;
+	const budget = sctx.ctx.config.uploads;
+	let made = 0;
+	while (made < budget && upload.head < upload.queue.length) {
+		const source = upload.queue[upload.head];
+		upload.head += 1;
+		if (source === void 0) continue;
+		if (!source.destroyed) {
+			put(sctx, upload, source);
+			made += 1;
+		}
+		settle$2(upload, source);
+	}
+	if (upload.head < upload.queue.length) {
+		sctx.deps.demand.request();
+		return made > 0;
+	}
+	upload.queue.length = 0;
+	upload.head = 0;
+	return made > 0;
+}
+/**
+* Ends the queue of a device that goes, from state alone (`onStop` has no context): every waiting call answers false,
+* the queue empties, and the sources uploaded on it are forgotten, since a new device holds none of them.
+*
+* @param state - The sync branch of the plugin state.
+*/
+function stopUploads(state) {
+	const { upload } = state;
+	for (const waiters of upload.waiting.values()) for (const waiter of waiters) waiter.resolve(false);
+	upload.waiting.clear();
+	upload.queue.length = 0;
+	upload.head = 0;
+	upload.done = emptyDone();
+}
+//#endregion
 //#region src/plugins/renderer/sync/views.ts
 /**
 * @file renderer/sync — one view per entity: build it from the components, write every value,
@@ -26104,6 +26899,23 @@ const PLACEHOLDER_BOX = Object.freeze({
 * sync pass).
 */
 const LAYOUT = createSpriteLayout();
+/** The slice widths of the nine-slice being written: per write, reused, as `LAYOUT`. */
+const BORDERS = {
+	left: 0,
+	top: 0,
+	right: 0,
+	bottom: 0
+};
+/** What the outline of the nine-slice being written is drawn from, written in place, as `LAYOUT`. */
+const OUTLINE = {
+	entity: 0,
+	width: 0,
+	height: 0,
+	borders: BORDERS,
+	missing: false
+};
+/** The box a clipping nine-slice masks its children with, as the shape value `applyClip` reads, written in place. */
+const NINE_CLIP = { ...Shape.defaults };
 /**
 * The depth of a wrapper's own visual among the wrapper's children: a child at `Order` 0 or more draws above it, one
 * at −1 or less below it, and a ui child at `zIndex` 0 (an `Order` between −0.5 and 0) above it too (spec 16 U1.8).
@@ -26204,26 +27016,31 @@ function visualOf(sctx, entity) {
 	if (sprite !== void 0) found.push({
 		kind: "Sprite",
 		textureKey: sprite.texture,
+		hollow: false,
 		display: void 0
 	});
 	if (nine !== void 0) found.push({
 		kind: "NineSlice",
 		textureKey: nine.texture,
+		hollow: nine.hollow === true,
 		display: void 0
 	});
 	if (ecs.has(entity, Shape)) found.push({
 		kind: "Shape",
 		textureKey: "",
+		hollow: false,
 		display: void 0
 	});
 	if (ecs.has(entity, Display)) found.push({
 		kind: "Display",
 		textureKey: "",
+		hollow: false,
 		display: void 0
 	});
 	for (const entry of adaptersOn(sctx, entity)) found.push({
 		kind: "adapter",
 		textureKey: "",
+		hollow: false,
 		display: entry
 	});
 	if (found.length > 1) sctx.ctx.log.warn("renderer: entity has more than one visual", {
@@ -26244,29 +27061,10 @@ function retargetKey(state, entity, view, key) {
 	if (view.textureKey === key) return;
 	untrackKey(state, entity, view.textureKey);
 	view.textureKey = key;
-	view.poolKey = poolKeyOf(view.kind, key);
+	view.poolKey = poolKeyOf(view.kind, key, isHollow(view.object));
 	if (key !== "") trackKey(state, entity, key);
 }
 /**
-* Resolves a key and says whether the placeholder had to step in.
-*
-* @param sctx - Domain context of the sync module.
-* @param key - The asset key.
-* @returns The texture to draw and whether it is the placeholder.
-*/
-function textureFor(sctx, key) {
-	const resolved = resolveTexture(sctx, key);
-	if (resolved !== void 0) return {
-		texture: resolved,
-		missing: false
-	};
-	warnMissing(sctx, key);
-	return {
-		texture: placeholderTexture(sctx),
-		missing: true
-	};
-}
-/**
 * Writes the texture and the tint of a sprite, each only when it differs from what Pixi holds.
 *
 * @param sctx - Domain context of the sync module.
@@ -26475,12 +27273,12 @@ function applyOutline(sctx, view, shape, debug, changed) {
 	sctx.ctx.state.sync.redraws += 1;
 }
 /**
-* Writes one number of a nine-slice only when it differs from what Pixi holds: Pixi rebuilds the
-* panel on every write of a width, even an equal one.
+* Writes one number of a nine-slice only when it differs from what the object holds: Pixi rebuilds the
+* panel on every write of a width, even an equal one, and the rim-only object rewrites its vertices.
 *
 * @param sctx - Domain context of the sync module.
 * @param entity - The entity.
-* @param object - The nine-slice sprite.
+* @param object - Pixi's nine-slice sprite, or the engine's rim-only one.
 * @param field - Which number.
 * @param value - The new number.
 * @returns True when it was written.
@@ -26494,7 +27292,9 @@ function writeSlice(sctx, entity, object, field, value) {
 /**
 * Writes the `NineSlice` component onto its display object and recomputes the hit box. Pixi reads
 * a texture's borders only in the constructor, so they are copied here on every write: a pooled
-* object, a new key and a reloaded bundle all get the insets of the texture they draw now.
+* object, a new key and a reloaded bundle all get the insets of the texture they draw now. A `hollow` that flipped
+* swaps the view's object first (F59). The hit box is the whole panel, hollow or not. A write that changes nothing,
+* or only the size, allocates nothing: the borders, the outline's shape and the clip's box are written in place.
 *
 * @param sctx - Domain context of the sync module.
 * @param entity - The entity.
@@ -26502,11 +27302,16 @@ function writeSlice(sctx, entity, object, field, value) {
 */
 function applyNineSlice(sctx, entity, view) {
 	const value = sctx.ctx.deps.world.ecs.get(entity, NineSlice);
+	if (value === void 0 || !isNineSlice(view.object)) return;
+	if (isHollow(view.object) !== (value.hollow === true)) swapSlice(sctx, entity, view);
 	const object = view.object;
-	if (value === void 0 || !isNineSlice(object)) return;
+	if (!isNineSlice(object)) return;
 	retargetKey(sctx.ctx.state.sync, entity, view, value.texture);
-	const { texture, missing } = textureFor(sctx, value.texture);
-	const borders = bordersOf(texture);
+	const resolved = resolveTexture(sctx, value.texture);
+	const missing = resolved === void 0;
+	if (missing) warnMissing(sctx, value.texture);
+	const texture = resolved ?? placeholderTexture(sctx);
+	const borders = bordersInto(texture, BORDERS);
 	view.placeholder = missing;
 	let changed = false;
 	if (texture !== void 0 && object.texture !== texture) {
@@ -26522,25 +27327,59 @@ function applyNineSlice(sctx, entity, view) {
 	applyAlpha(sctx, entity, view, value);
 	changed = writeSlice(sctx, entity, object, "width", value.width) || changed;
 	changed = writeSlice(sctx, entity, object, "height", value.height) || changed;
-	view.hitBox = {
-		x: 0,
-		y: 0,
-		width: value.width,
-		height: value.height
-	};
-	applyOutline(sctx, view, {
-		entity,
-		width: value.width,
-		height: value.height,
-		borders,
-		missing
-	}, value.debug, changed);
-	applyClip(sctx, entity, view, {
-		...Shape.defaults,
-		w: value.width,
-		h: value.height,
-		clip: value.clip
-	});
+	writeHitBox(view.hitBox, value.width, value.height);
+	OUTLINE.entity = entity;
+	OUTLINE.width = value.width;
+	OUTLINE.height = value.height;
+	OUTLINE.missing = missing;
+	applyOutline(sctx, view, OUTLINE, value.debug, changed);
+	NINE_CLIP.w = value.width;
+	NINE_CLIP.h = value.height;
+	NINE_CLIP.clip = value.clip;
+	applyClip(sctx, entity, view, NINE_CLIP);
+}
+/**
+* A new nine-slice object of one kind: the engine's rim-only mesh, or Pixi's `NineSliceSprite`; both of the white
+* texture until the first write.
+*
+* @param sctx - Domain context of the sync module.
+* @param pixi - The Pixi module.
+* @param hollow - True for the rim-only object.
+* @returns The object.
+*/
+function newSlice(sctx, pixi, hollow) {
+	return hollow ? makeHollow(sctx.ctx.state.sync, pixi) : new pixi.NineSliceSprite({ texture: pixi.Texture.WHITE });
+}
+/**
+* Gives a nine-slice view whose `hollow` flipped the other object (F59), on the write that flipped it: the view gets
+* its wrapper first (it keeps the pose, the alpha, the filters, the clip and the outline), then the other kind takes
+* the old object's place in it, out of its pool or new, and the old object goes back to its own pool. The entity, its
+* children and its hit box stay as they were; the caller writes the new object in full.
+*
+* @param sctx - Domain context of the sync module.
+* @param entity - The entity.
+* @param view - Its view, drawn by a nine-slice object.
+*/
+function swapSlice(sctx, entity, view) {
+	const pixi = sctx.deps.host.pixi();
+	const wrapper = ensureWrapper(sctx, entity);
+	if (pixi === void 0 || wrapper === void 0) return;
+	const state = sctx.ctx.state.sync;
+	const old = view.object;
+	const hollow = !isHollow(old);
+	const poolKey = poolKeyOf("NineSlice", view.textureKey, hollow);
+	const next = acquire(state, poolKey) ?? newSlice(sctx, pixi, hollow);
+	markView(sctx, entity);
+	next.label = old.label;
+	next.zIndex = old.zIndex;
+	wrapper.addChildAt(next, Math.max(0, wrapper.children.indexOf(old)));
+	state.entityOf.delete(old);
+	state.entityOf.set(next, entity);
+	view.object = next;
+	releaseObject(sctx, old, view.poolKey);
+	view.poolKey = poolKey;
+	writeRenderable(view);
+	applyTransform(sctx, entity, view);
 }
 /**
 * Gives a clipping view the masked container its children hang in, next to its own visual in the
@@ -26558,7 +27397,9 @@ function ensureClipped(pixi, entity, view, wrapper) {
 	const clipped = new pixi.Container();
 	clipped.label = `children#${entity}`;
 	clipped.sortableChildren = true;
-	for (const child of wrapper.children) if (child !== view.object && child !== view.outline) clipped.addChild(child);
+	let index = 0;
+	for (let child = wrapper.children[0]; child !== void 0; child = wrapper.children[index]) if (child === view.object || child === view.outline) index += 1;
+	else clipped.addChild(child);
 	wrapper.addChild(clipped);
 	view.clipped = clipped;
 	return clipped;
@@ -26990,6 +27831,7 @@ function attach$1(sctx, entity, view) {
 * @param visual - Which component gives the entity its object, and its texture key.
 * @param visual.kind - Which component gives the entity its object.
 * @param visual.textureKey - The asset key the object draws.
+* @param visual.hollow - True for the rim-only object of a hollow `NineSlice`.
 * @returns The object, or `undefined` while inert.
 */
 function makeObject(sctx, entity, visual) {
@@ -27003,7 +27845,7 @@ function makeObject(sctx, entity, visual) {
 	const pixi = sctx.deps.host.pixi();
 	if (pixi === void 0) return void 0;
 	if (visual.display !== void 0) return adapterObject(sctx, entity, visual.display);
-	const pooled = acquire(sctx.ctx.state.sync, poolKeyOf(visual.kind, visual.textureKey));
+	const pooled = acquire(sctx.ctx.state.sync, poolKeyOf(visual.kind, visual.textureKey, visual.hollow));
 	if (pooled !== void 0) return {
 		object: pooled,
 		value: void 0
@@ -27017,7 +27859,7 @@ function makeObject(sctx, entity, visual) {
 		value: void 0
 	};
 	return {
-		object: new pixi.NineSliceSprite({ texture: pixi.Texture.WHITE }),
+		object: newSlice(sctx, pixi, visual.hollow),
 		value: void 0
 	};
 }
@@ -27060,7 +27902,7 @@ function createView(sctx, entity) {
 	const view = {
 		object,
 		kind: visual.kind,
-		poolKey: poolKeyOf(visual.kind, visual.textureKey),
+		poolKey: poolKeyOf(visual.kind, visual.textureKey, visual.hollow),
 		layer: "",
 		textureKey: visual.textureKey,
 		wrapper: void 0,
@@ -27185,8 +28027,9 @@ function dropView(sctx, entity) {
 	release$1(sctx, view);
 }
 /**
-* Drops every view, every layer, every pool, every filter slot and filter area, and the warm-up (its waiting promises
-* answer false, its probe tree is destroyed). Works on the state alone,
+* Drops every view, every layer, every pool, every filter slot and filter area, the warm-up (its waiting promises
+* answer false, its probe tree is destroyed) and the upload queue (its waiting calls answer false). Works on the state
+* alone,
 * because `onStop` has no context. A `Display` object belongs to the game: it is detached, never
 * destroyed, and leaves without the filters, the filter area and the hidden reasons the renderer gave it.
 *
@@ -27231,6 +28074,7 @@ function stopSync(state) {
 	state.areas.clear();
 	state.viewlessEntries = false;
 	stopWarm(state);
+	stopUploads(state);
 	state.held.clear();
 	state.redraws = 0;
 	state.overdraw.listeners.length = 0;
@@ -27374,7 +28218,8 @@ function withDeps$8(ctx) {
 * takes the same path: the backing store changes, the frame and the scale do not), then the
 * overlay step (spec 22), then `kept` reads the marks before `demand` decides whether the frame is
 * drawn and clears them; a drawn frame draws the probes of the warm-up onto the canvas first (F4: the
-* stage pass clears them, in the same task, so they never show), then the kept pictures
+* stage pass clears them, in the same task, so they never show), then uploads the queued texture sources (F60), then
+* the kept pictures
 * (`kept.flush`, so the canvas stays one pass, E7), then the stage, then the pixel leg of the kept
 * oracle; `demand` settles the
 * frame (the dev check, the pixel oracle), and `monitor` closes it and hands a drawn one to a
@@ -27409,10 +28254,11 @@ function renderFrame(ctx, modules) {
 	const drawn = modules.demand.decide(modules.monitor.waiting());
 	if (drawn) {
 		const probed = modules.sync.warmStep();
+		const uploaded = modules.sync.uploadStep();
 		modules.kept.flush();
 		if (overdraw ? modules.sync.drawOverdraw(modules.host.render) : modules.host.render()) {
 			ctx.deps.time.frameDrawn();
-			if (probed) ctx.deps.time.frameProbed();
+			if (probed || uploaded) ctx.deps.time.frameProbed();
 		}
 		modules.kept.after();
 	}
@@ -29616,6 +30462,7 @@ function createSyncApi(ctx, deps) {
 	const forgetTree = () => {
 		deps.kept.reset();
 		forgetOverlays(state);
+		stopUploads(state);
 		state.held.clear();
 		for (const view of state.views.values()) {
 			state.viewOfTop.delete(view.wrapper ?? view.object);
@@ -29658,7 +30505,7 @@ function createSyncApi(ctx, deps) {
 		state.removed.clear();
 		state.reparented.clear();
 		state.outlinesStale = false;
-		startWarm$1(sctx);
+		startWarm$2(sctx);
 	};
 	return {
 		hitTest: (x, y, accept) => hitTest(sctx, x, y, accept),
@@ -29685,7 +30532,8 @@ function createSyncApi(ctx, deps) {
 				if (state.root === void 0) return;
 				for (const key of keys) state.invalidated.add(key);
 				dropPooled(state, keys);
-			}
+			},
+			upload: (textures) => uploadTextures(sctx, textures)
 		},
 		displays: { provide: (component, adapter) => provideDisplay(sctx, component, adapter, {
 			added: markAdded,
@@ -29733,6 +30581,7 @@ function createSyncApi(ctx, deps) {
 		stepFilters: () => applySwitched(state, deps.kept),
 		drainOverlayEvents: (monitor) => drainOverlayEvents(sctx, monitor),
 		warmStep: () => warmStep(sctx),
+		uploadStep: () => uploadStep(sctx),
 		onWarm: (fn) => {
 			state.warm.listeners.push(fn);
 		},
@@ -30524,8 +31373,22 @@ function createWarmState() {
 	};
 }
 /**
+* Creates the empty upload queue: nothing queued, nobody waiting, nothing uploaded. Its own non-exported function, as
+* `emptyMap`.
+*
+* @returns The upload branch of the sync state.
+*/
+function createUploadState() {
+	return {
+		queue: [],
+		head: 0,
+		waiting: emptyMap$6(),
+		done: emptyWeakSet()
+	};
+}
+/**
 * 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 redraw counted and no unseen walk kept.
+* filter area, no slice, no hidden mask, no overlay, no warm-up, no upload, no redraw counted and no unseen walk kept.
 *
 * @param debug - The debug switches of the config; copied, so the frozen config stays untouched.
 * @returns The sync branch of the plugin state.
@@ -30564,6 +31427,8 @@ function createSyncState(debug) {
 		areas: emptyMap$6(),
 		viewlessEntries: false,
 		warm: createWarmState(),
+		upload: createUploadState(),
+		hollowClass: void 0,
 		filterKinds: emptyWeakMap$1(),
 		filterOwners: emptyWeakMap$1(),
 		objectHidden: emptyWeakMap$1(),
@@ -30631,6 +31496,8 @@ const RING_FRAMES = {
 };
 /** The most probe draws of the warm-up a drawn frame may make. */
 const MAX_WARM = 16;
+/** The most textures the upload queue may put on the GPU in one drawn frame: about 9 ms each on a Galaxy A26. */
+const MAX_UPLOADS = 8;
 /**
 * Tells a finite number of at least 0 from anything else a config can hold.
 *
@@ -30677,14 +31544,14 @@ function checkAdaptiveScale(adaptiveScale) {
 }
 /**
 * Checks the numbers of the config a game can get wrong, at `createApp`, in every build: the
-* resolution cap, the pool trim, the adaptive render scale, the performance monitor, the budget of the kept pictures
-* and the probe draws of the warm-up.
+* resolution cap, the pool trim, the adaptive render scale, the performance monitor, the budget of the kept pictures,
+* the probe draws of the warm-up and the textures uploaded per drawn frame.
 *
 * @param config - The resolved plugin config.
 * @throws {Error} When `maxResolution` is not a number above 0, `poolTrim` or `adaptiveScale` fails its check,
 *   `monitor.budgetMs` is neither `"rate"` nor a number above 0, `monitor.frames` is not a whole
-*   number from 64 to 16384, `keptMb` is not a finite number of at least 0, or `warm` is not a
-*   whole number from 0 to 16.
+*   number from 64 to 16384, `keptMb` is not a finite number of at least 0, `warm` is not a
+*   whole number from 0 to 16, or `uploads` is not a whole number from 0 to 8.
 */
 function checkConfig(config) {
 	const { maxResolution, keptMb } = config;
@@ -30697,6 +31564,8 @@ function checkConfig(config) {
 	if (typeof keptMb !== "number" || !Number.isFinite(keptMb) || keptMb < 0) throw new Error(`[game] renderer.keptMb is ${String(keptMb)}.\n  Give the MiB kept pictures may hold, or 0 to keep none.`);
 	const { warm } = config;
 	if (!Number.isInteger(warm) || warm < 0 || warm > MAX_WARM) throw new Error(`[game] renderer.warm is ${String(warm)}.\n  Give the probe draws per frame, a whole number from 0 to 16.`);
+	const { uploads } = config;
+	if (!Number.isInteger(uploads) || uploads < 0 || uploads > MAX_UPLOADS) throw new Error(`[game] renderer.uploads is ${String(uploads)}.\n  Give the textures uploaded per drawn frame, a whole number from 0 to 8.`);
 }
 /**
 * Creates the initial renderer state: one branch per module, composed from the module state
@@ -30778,6 +31647,7 @@ const rendererPlugin = /*#__PURE__*/ createPlugin$1("renderer", {
 		onDemand: false,
 		keptMb: 64,
 		warm: 1,
+		uploads: 1,
 		adaptiveScale: {
 			floor: .75,
 			devices: "phone"
@@ -34291,8 +35161,9 @@ function reportSettled(ctx, progress, signal) {
 	ctx.emit("assets:bundle-progress", { ...progress });
 }
 /**
-* Publishes a loaded bundle: what was loaded moves into the record, `renderer` re-resolves the
-* keys, the event goes out, the frame loop wakes and the budget is enforced.
+* Publishes a loaded bundle: what was loaded moves into the record, a failure `ready` remembered
+* is forgotten, `renderer` re-resolves the keys, the event goes out, the frame loop wakes and the
+* budget is enforced.
 *
 * @param ctx - Domain context of the plugin.
 * @param bundle - Name of the bundle.
@@ -34309,6 +35180,7 @@ function finish$1(ctx, bundle, entry, assets, reason) {
 	record.status = "loaded";
 	record.inflight = void 0;
 	touch(ctx.state, record);
+	ctx.state.readyFailed.delete(bundle);
 	ctx.deps.renderer.sync.textures.invalidate(entry.files.map((file) => file.key));
 	ctx.emit("assets:bundle-loaded", {
 		bundle,
@@ -34646,6 +35518,8 @@ async function bootTiers(ctx) {
 */
 /** How many of the heaviest entries the over-budget warning names. */
 const HEAVIEST = 5;
+/** No feature holds a bundle: the stack as a leaving scene's non-`feature` bundle sees it. */
+const NO_FEATURES = Object.freeze(/* @__PURE__ */ new Set());
 /**
 * Adds up the estimated texture memory of every loaded bundle.
 *
@@ -34712,9 +35586,9 @@ function releaseAssets(io, assets) {
 	assets.audio.clear();
 }
 /**
-* Frees one loaded bundle: the textures are destroyed, every companion drops what travels with
-* it, `renderer` is told that its keys are gone and the event goes out. A bundle that is not
-* loaded is left alone.
+* Frees one loaded bundle: the textures are destroyed, its warm is forgotten, every companion drops
+* what travels with it, `renderer` is told that its keys are gone and the event goes out. A bundle
+* that is not loaded is left alone.
 *
 * @param ctx - Domain context of the plugin.
 * @param bundle - Name of the bundle.
@@ -34728,6 +35602,7 @@ function unloadBundle(ctx, bundle, reason) {
 	releaseAssets(state.io, record);
 	record.status = "idle";
 	record.lastUsed = 0;
+	state.warmed.delete(bundle);
 	unloadCompanions(ctx, state.companions, bundle);
 	const keys = entry.files.map((file) => file.key);
 	ctx.deps.renderer.sync.textures.invalidate(keys);
@@ -34875,10 +35750,13 @@ function nameSceneBundles(state, named) {
 /**
 * Lets the bundles a leaving scene named go once nothing carries `Exiting` any more: each loaded
 * `"leave"` bundle among them that nothing else holds is unloaded with the reason `"leave"`, at
-* once, not at the next rest. A bundle of another release stays, as it would have. The system
-* `assets.leave` calls it in every phase `sync`: after the reconcile of `layout`, which tags the
-* leaving elements `Exiting` in the frame after the switch, so the hold never ends before the leave
-* begins (F51b). It costs a length read while no scene leaves, and a count read while one does.
+* once, not at the next rest. Its feature on the stack holds only a `feature`-tier bundle, which
+* lives with its feature's flow: a scene's bundle goes with the scene, also while another scene of
+* its feature shows (the splash's 7.5 MiB under the ward). A bundle of another release stays, as
+* it would have. The system `assets.leave` calls it in every phase `sync`: after the reconcile of
+* `layout`, which tags the leaving elements `Exiting` in the frame after the switch, so the hold
+* never ends before the leave begins (F51b). It costs a length read while no scene leaves, and a
+* count read while one does.
 *
 * @param ctx - Domain context of the plugin.
 */
@@ -34889,7 +35767,10 @@ function releaseSceneLeft(ctx) {
 	state.sceneLeaving = [];
 	if (state.io === void 0) return;
 	const onStack = featuresOnStack(ctx);
-	for (const name of names) unloadIfLeft(ctx, name, onStack);
+	for (const name of names) {
+		const tier = state.manifest.bundles[name]?.tier;
+		unloadIfLeft(ctx, name, tier === "feature" ? onStack : NO_FEATURES);
+	}
 }
 /**
 * Unloads one bundle with the reason `"leave"` when it is a loaded `"leave"` bundle nobody holds.
@@ -35378,9 +36259,125 @@ function startPreload(ctx) {
 	runQueue(ctx, queue).catch(ignoreFailure$1);
 }
 //#endregion
+//#region src/plugins/assets/ready.ts
+/**
+* @file assets plugin — a bundle ready to show. `warm` loads a bundle and puts its textures on the
+* GPU before a scene shows them (F60): on a Galaxy A26 the frame that showed 6 cold textures took
+* 55 ms, 8 ms once they were uploaded before. The `ready` effect lets a node rest on that work and
+* stay answerable (F52). Nothing here is on the frame path: one promise per bundle, and the inbox
+* event is posted from a promise.
+*/
+/**
+* Runs one warm: loads the bundle when it is not loaded, then hands every texture and atlas page
+* of it to the renderer's upload queue. The answer of the upload is not read: when the renderer
+* could not upload, the first draw does. A failure drops the entry, so the next `warm` tries again.
+*
+* @param ctx - Domain context of the plugin.
+* @param bundle - Name of a bundle of the manifest.
+* @param entry - The entry of this warm in `state.warmed`.
+* @returns A promise that resolves once the upload answered.
+* @throws {Error} When the load fails or is aborted.
+*/
+async function runWarm(ctx, bundle, entry) {
+	try {
+		await loadBundle(ctx, bundle, void 0, "request");
+		const { textures, pages } = ctx.state.records.get(bundle) ?? emptyAssets();
+		await ctx.deps.renderer.sync.textures.upload([...textures.values(), ...pages.values()]);
+		entry.done = true;
+	} catch (error) {
+		if (ctx.state.warmed.get(bundle) === entry) ctx.state.warmed.delete(bundle);
+		throw error;
+	}
+}
+/**
+* Starts the one warm of a bundle and records it.
+*
+* @param ctx - Domain context of the plugin.
+* @param bundle - Name of a bundle of the manifest.
+* @returns The entry every later caller joins.
+*/
+function startWarm$1(ctx, bundle) {
+	const entry = {
+		promise: Promise.resolve(),
+		done: false
+	};
+	ctx.state.warmed.set(bundle, entry);
+	entry.promise = runWarm(ctx, bundle, entry);
+	return entry;
+}
+/**
+* Warms one bundle, or joins its running or finished warm. Headless it resolves at once, whatever
+* the name, as `load` does.
+*
+* @param ctx - Domain context of the plugin.
+* @param bundle - Name of a bundle of the manifest.
+* @returns A promise that resolves once the bundle is loaded and its textures went to the GPU.
+* @throws {Error} When the manifest has no such bundle, and when the load fails or is aborted.
+*/
+async function warmBundle(ctx, bundle) {
+	const state = ctx.state;
+	if (state.io === void 0) return;
+	if (state.manifest.bundles[bundle] === void 0) throw unknownBundle(bundle);
+	await (state.warmed.get(bundle) ?? startWarm$1(ctx, bundle)).promise;
+}
+/**
+* Tells whether the `ready` effect counts a bundle as there: loaded and warmed, or its last warm
+* for `ready` failed.
+*
+* @param state - The plugin state.
+* @param bundle - Name of a bundle of the manifest.
+* @returns True when a node need not rest on it.
+*/
+function isThere(state, bundle) {
+	if (state.readyFailed.has(bundle)) return true;
+	return state.records.get(bundle)?.status === "loaded" && state.warmed.get(bundle)?.done === true;
+}
+/**
+* Warms one bundle for the `ready` effect. It never rejects: a failure that is not an abort marks
+* the bundle failed and is logged, so the node resting on it moves on; an abort (an unload, a stop)
+* marks nothing, and the next `ready` starts the bundle again.
+*
+* @param ctx - Domain context of the plugin.
+* @param bundle - Name of a bundle of the manifest.
+* @returns A promise that resolves once the warm settled.
+*/
+async function warmForReady(ctx, bundle) {
+	try {
+		await warmBundle(ctx, bundle);
+	} catch (error) {
+		if (isAbortError(error)) return;
+		ctx.state.readyFailed.add(bundle);
+		ctx.log.warn("assets:ready-failed", {
+			bundle,
+			error: String(error)
+		});
+	}
+}
+/**
+* The handler of the `ready` effect (F52). Headless it answers `true` before any name check, as the
+* `load` effect does. Every bundle there: `true`, and nothing is posted. Otherwise it starts the
+* warm of each bundle that is not there, answers `false`, and posts `{ type: "ready" }` into
+* `flow.inbox` once all of them settled. The posting does not wait on the node's signal: the warm
+* is shared work, and the inbox keeps only the latest `ready`.
+*
+* @param ctx - Domain context of the plugin.
+* @param bundles - The bundle names of the descriptor.
+* @returns True when the node may go on, false when it should rest until the inbox event `ready`.
+* @throws {Error} When the manifest has no such bundle.
+*/
+function answerReady(ctx, bundles) {
+	const state = ctx.state;
+	if (state.io === void 0) return true;
+	for (const name of bundles) if (state.manifest.bundles[name] === void 0) throw unknownBundle(name);
+	const missing = bundles.filter((name) => !isThere(state, name));
+	if (missing.length === 0) return true;
+	Promise.all(missing.map((name) => warmForReady(ctx, name))).then(() => ctx.deps.flow.inbox.post({ type: "ready" }));
+	return false;
+}
+//#endregion
 //#region src/plugins/assets/lifecycle.ts
 /**
-* @file assets plugin — lifecycle: the six registrations of `onInit`, the boot of `onStart`
+* @file assets plugin — lifecycle: the seven registrations of `onInit`, the boot of `onStart`
 * and the teardown that frees every texture and cancels every fetch.
 */
 /**
@@ -35411,7 +36408,7 @@ function withDeps$6(ctx) {
 	};
 }
 /**
-* Reads the bundle names out of a `load` descriptor.
+* Reads the bundle names out of a `load` or a `ready` descriptor.
 *
 * @param descriptor - What the node awaited.
 * @returns The bundle names, in the order the node listed them.
@@ -35494,17 +36491,17 @@ async function enterNode(ctx, node, run) {
 	}
 }
 /**
-* Connects the plugin in `onInit`: the `load` stage of `onEnter`, the handler of the `load`
-* effect, the texture provider of `renderer`, the start and the end of an exit in `world`, counted,
-* and the system `assets.leave` of phase `sync`, which lets a leaving scene's bundles go once its
-* elements played their exit (F51). The six removers go to the state, because `onStop` has nothing
-* but the state.
+* Connects the plugin in `onInit`: the `load` stage of `onEnter`, the handlers of the `load` and
+* the `ready` effects (F52), both run in fast mode too, the texture provider of `renderer`, the
+* start and the end of an exit in `world`, counted, and the system `assets.leave` of phase `sync`,
+* which lets a leaving scene's bundles go once its elements played their exit (F51). The seven
+* removers go to the state, because `onStop` has nothing but the state.
 *
 * @param ctx - Kernel context of the assets plugin.
 */
 function connectAssets(ctx) {
 	const assets = withDeps$6(ctx);
-	assets.state.removers.push(assets.deps.flow.onEnter("load", (node, run) => enterNode(assets, node, run)), assets.deps.flow.fx.handle("load", (descriptor, run) => runLoadEffect(assets, descriptor, run), { runInFast: true }), assets.deps.renderer.sync.textures.provide((key) => lookupTexture(assets, key)), assets.deps.world.ecs.onAdded(Exiting, () => {
+	assets.state.removers.push(assets.deps.flow.onEnter("load", (node, run) => enterNode(assets, node, run)), assets.deps.flow.fx.handle("load", (descriptor, run) => runLoadEffect(assets, descriptor, run), { runInFast: true }), assets.deps.flow.fx.handle("ready", (descriptor) => answerReady(assets, bundlesOfDescriptor(descriptor)), { runInFast: true }), assets.deps.renderer.sync.textures.provide((key) => lookupTexture(assets, key)), assets.deps.world.ecs.onAdded(Exiting, () => {
 		assets.state.exiting += 1;
 	}), assets.deps.world.ecs.onRemoved(Exiting, () => {
 		assets.state.exiting -= 1;
@@ -35584,7 +36581,7 @@ async function startAssets(ctx) {
 }
 /**
 * Frees everything in `onStop`: the preload and every running load are aborted, every texture is
-* destroyed, the six registrations are removed and the registries are emptied, the companions
+* destroyed, the seven registrations are removed and the registries are emptied, the companions
 * too. A teardown context carries the state and nothing else, so no other plugin is called here:
 * no companion's `unload` either, its plugin stopped before this one.
 *
@@ -35607,6 +36604,8 @@ function releaseAll(state) {
 	state.featureOfFlow.clear();
 	state.pinned.clear();
 	state.warned.clear();
+	state.warmed.clear();
+	state.readyFailed.clear();
 	state.companions.length = 0;
 	state.current = void 0;
 	state.sceneId = void 0;
@@ -35753,6 +36752,7 @@ function createAssetsApi(ctx) {
 	const assets = withDeps$6(ctx);
 	return {
 		load: (bundle) => loadBundle(assets, bundle, void 0, "request"),
+		warm: (bundle) => warmBundle(assets, bundle),
 		unload: (bundle) => unload(assets, bundle),
 		isLoaded: (bundle) => isLoaded(assets, bundle),
 		texture: (key) => lookupTexture(assets, key),
@@ -36430,7 +37430,9 @@ function createAssetsState() {
 		sceneLeaving: [],
 		exiting: 0,
 		companions: [],
-		restPending: false
+		restPending: false,
+		readyFailed: emptySet$2(),
+		warmed: emptyMap$3()
 	};
 }
 /**
@@ -41339,7 +42341,7 @@ function complete(ectx) {
 	ectx.log.info("effects:checks", {
 		definitions: checks.checked,
 		broken: checks.failed,
-		ms: tenths(pageNow() - checks.startedAt)
+		ms: tenths(pageNow$1() - checks.startedAt)
 	});
 	checks.resolve();
 }
@@ -41482,7 +42484,7 @@ function checkGlsl(ectx, run, definition) {
 function startChecks(ectx) {
 	const { checks } = ectx.state;
 	const backend = ectx.deps.renderer.host.kind();
-	checks.startedAt = pageNow();
+	checks.startedAt = pageNow$1();
 	for (const definition of checkList(ectx)) {
 		if (checks.status.has(definition)) continue;
 		checks.status.set(definition, "pending");
@@ -41618,12 +42620,12 @@ async function gateChecks(ectx, node, run) {
 	if (!ectx.state.checks.started) startChecks(ectx);
 	const { checks } = ectx.state;
 	if (checks.waiting === 0) return;
-	const began = pageNow();
+	const began = pageNow$1();
 	await Promise.race([checks.settled, whenAborted(run.signal)]);
 	if (run.signal.aborted) return;
 	ectx.log.info("effects:mount-waited", {
 		node: node.path,
-		ms: tenths(pageNow() - began)
+		ms: tenths(pageNow$1() - began)
 	});
 }
 //#endregion
@@ -49781,9 +50783,23 @@ function buildRun(ctx, pixi, run, style, at) {
 	return objects;
 }
 /**
+* Tells whether a label of a `"box"` style is drawn outside a ui layout: it has no box, it is not
+* empty (ui lays an empty one out 0 wide), and no layout measured its style at a width (a laid-out
+* label that fits its row gets no box, F65).
+*
+* @param ctx - Domain context of the text plugin.
+* @param style - The style of the label.
+* @param value - The component value.
+* @returns True when the label wraps at no box for want of a layout.
+*/
+function isOutsideLayout(ctx, style, value) {
+	if (style.wrap !== "box") return false;
+	return (value.box ?? 0) <= 0 && value.resolved !== "" && !ctx.state.laidOut.has(value.style);
+}
+/**
 * The style and the laid-out block of one component value, under the generation of this moment.
-* A `"box"` style wraps at the box `ui` wrote; with none (a label outside a ui layout) it is one
-* line, and a dev warning says so once per style.
+* A `"box"` style wraps at the box `ui` wrote; with none it is one line, and a dev warning says
+* so once per style unless a layout measured that style at a width (a label that fits its row).
 *
 * @param ctx - Domain context of the text plugin.
 * @param value - The component value.
@@ -49791,7 +50807,7 @@ function buildRun(ctx, pixi, run, style, at) {
 */
 function labelOf(ctx, value) {
 	const style = styleOf$1(ctx, value.style);
-	if (style.wrap === "box" && (value.box ?? 0) <= 0 && value.resolved !== "") warnOnce(ctx, `wrap-box:${value.style}`, "text: wrap \"box\" outside layout", { style: value.style });
+	if (isOutsideLayout(ctx, style, value)) warnOnce(ctx, `wrap-box:${value.style}`, "text: wrap \"box\" outside layout", { style: value.style });
 	return {
 		style,
 		layout: layoutFor(ctx, value.resolved, value.style, value.box),
@@ -50159,6 +51175,7 @@ function stopText(state) {
 	state.added.length = 0;
 	state.rewrite.length = 0;
 	state.warned.clear();
+	state.laidOut.clear();
 }
 //#endregion
 //#region src/plugins/text/api.ts
@@ -50183,6 +51200,7 @@ function createTextApi(ctx) {
 	return {
 		measure: (content, style, width = 0) => {
 			const tctx = text();
+			if (width > 0) tctx.state.laidOut.add(style);
 			return sizeOf(layoutFor(tctx, sourceOf(tctx, content), style, width));
 		},
 		hasGlyph: (char, style) => hasGlyphOf(text(), char, style),
@@ -50311,6 +51329,7 @@ function createTextState$1() {
 		rewrite: [],
 		generation: 0,
 		warned: emptySet$1(),
+		laidOut: emptySet$1(),
 		removers: []
 	};
 }
@@ -52766,6 +53785,26 @@ function nineSliceClipped(element) {
 	};
 }
 /**
+* Reports an element whose style is `hollow` but names no nine-slice: only a nine-slice has a
+* centre to leave out, so the field does nothing there. `hollow: false` asks for nothing either way.
+*
+* @param element - The element to check.
+* @returns The finding, or `undefined`.
+* @example
+* ```ts
+* hollowWithoutNineSlice({ key: "memFrost", type: "stack", style: { hollow: true } } as Element);
+* // { rule: "hollow-without-nine-slice", key: "memFrost", detail: "stack" }
+* ```
+*/
+function hollowWithoutNineSlice(element) {
+	if (element.style.hollow !== true || element.style.nineSlice !== void 0) return void 0;
+	return {
+		rule: "hollow-without-nine-slice",
+		key: nameOf(element),
+		detail: element.type
+	};
+}
+/**
 * Reports a root element whose style sets a `zIndex`: a root draws at the order of its layer,
 * so the value is ignored.
 *
@@ -52786,7 +53825,7 @@ function zIndexOnRoot(element) {
 	};
 }
 /**
-* Runs the five rules over every live element.
+* Runs the six rules over every live element.
 *
 * @param ctx - Domain context of the ui plugin.
 * @returns One finding per rule and element, in element order.
@@ -52801,6 +53840,7 @@ function runLint(ctx) {
 			textOverflow(ctx, element),
 			absoluteWithoutReason(element),
 			nineSliceClipped(element),
+			hollowWithoutNineSlice(element),
 			zIndexOnRoot(element)
 		]) if (finding !== void 0) findings.push(finding);
 	}
@@ -55453,33 +56493,40 @@ function createReconciler(ctx, modules, fields) {
 	*
 	* @param element - The element that left the description.
 	* @param cause - Why it leaves: `"change"` for a commit, `"mount"` when it goes with its screen.
+	* @param leads - The element is the top of a root that goes with its screen.
 	*/
-	function exitElement(element, cause) {
+	function exitElement(element, cause, leads = false) {
 		forgetSubtree(element);
 		forgetInstances(state, element.identity);
 		state.exiting.add(element.entity);
-		exitSubtree(element, cause);
+		exitSubtree(element, cause, false, leads);
 	}
 	/**
 	* Plays the exit hook of an element and of everything under it, each told why it leaves. A child
-	* keeps its rect and its `Exiting` tag until the whole subtree stopped moving.
+	* keeps its rect and its `Exiting` tag until the whole subtree stopped moving. Under the top of a
+	* root that goes with its screen and plays an exit of its own, the elements stand and go with it
+	* (F55b): an exit of theirs would change the subtree in every frame of the top's, so a kept
+	* picture of it would be drawn live through its filters.
 	*
 	* @param element - The element that leaves, or one of its children.
 	* @param cause - Why the subtree leaves.
+	* @param stands - The element stands under an exit that leads the leave: its own hook does not play.
+	* @param leads - The element is the top of a root that goes with its screen.
 	*/
-	function exitSubtree(element, cause) {
+	function exitSubtree(element, cause, stands, leads) {
 		dropHost(state, element.entity);
 		state.scrolls.delete(element.entity);
-		if (overlayOf(element) === void 0) modules.layout.exit(element, cause);
+		if (overlayOf(element) === void 0) modules.layout.exit(element, cause, void 0, stands);
 		else {
 			const span = createSpan();
-			modules.layout.exit(element, cause, span);
+			modules.layout.exit(element, cause, span, stands);
 			exitOverlay(ctx, modules.layout, element, span);
 		}
 		if (element.type === "input") fields.exit(element);
+		const under = stands || leads && !modules.layout.settled(element);
 		for (const child of element.children) {
 			const childElement = state.elements.get(child);
-			if (childElement !== void 0) exitSubtree(childElement, cause);
+			if (childElement !== void 0) exitSubtree(childElement, cause, under, false);
 		}
 	}
 	/**
@@ -56186,7 +57233,7 @@ function createReconciler(ctx, modules, fields) {
 		state.removing.add(entity);
 		hostsMoved(state);
 		if (element !== void 0) {
-			exitElement(element, cause);
+			exitElement(element, cause, cause === "mount");
 			if (cause === "mount" && !modules.layout.settled(element)) state.leading.add(element.entity);
 		}
 		ctx.deps.time.wake();
@@ -57174,15 +58221,16 @@ const EXIT_WAITS_FOREVER = "ui:exit-waits-forever";
 * @param element - The element that left the description.
 * @param cause - Why it leaves: a `when: "change"` hook plays nothing for `"mount"`, and the next sweep takes it.
 * @param span - Notes the longest finite track the exit hook starts, for the level of an overlay.
+* @param stands - The element stands and goes with the exit over it: its own exit hook does not play (F55b).
 */
-function beginExit(ctx, state, element, cause, span) {
+function beginExit(ctx, state, element, cause, span, stands = false) {
 	detachNode(state, element);
 	element.dropKey?.();
 	element.dropKey = void 0;
 	if (!element.live) return;
 	ctx.deps.world.ecs.tag(element.entity, Exiting);
 	element.handles = keptExtras(ctx, element);
-	const hook = element.motion?.exit;
+	const hook = stands ? void 0 : element.motion?.exit;
 	play(ctx, element, hook === void 0 ? void 0 : (view) => hook(view, element.node, void 0, cause), span);
 }
 /**
@@ -58611,7 +59659,7 @@ function createLayoutApi(ctx) {
 		changeExtra: (element, name, values, hint) => playExtraChange(ctx, element, name, values, hint),
 		repose: (element, parent, hooked, hint) => repose(ctx, element, parent, hooked, hint),
 		lift: (element, units) => liftRest(ctx, element, units),
-		exit: (element, cause, span) => beginExit(ctx, state, element, cause, span),
+		exit: (element, cause, span, stands) => beginExit(ctx, state, element, cause, span, stands),
 		playTrack: (element, hook) => {
 			play(ctx, element, hook);
 		},
@@ -59985,19 +61033,48 @@ function load(bundle) {
 	};
 }
 /**
-* Binds `defineBundles` and `load` to one game's bundle keys. Type-only: the same functions.
+* Creates the effect a node awaits to rest on bundles and stay answerable (F52). The handler of the
+* kind `"ready"` is registered by this plugin and runs in fast mode too. It answers `true` when every
+* bundle is loaded and its textures went to the GPU (`assets.warm`), or its last load failed, so a
+* node never hangs on it. Otherwise it starts what is missing, answers `false`, and posts the world
+* event `ready` into `flow.inbox` once all of it settled: the node rests on `inbox: ["ready"]`
+* meanwhile, and Back still answers. A headless `assets` answers `true`; an app without `assets`,
+* such as the headless app of `game.headless()`, resolves `undefined`, hence `=== false`. A name
+* the manifest lacks throws, as for `load`.
+*
+* @param bundle - One bundle name, or a list of them.
+* @returns The descriptor a transit node awaits.
+* @example
+* ```ts
+* ready("ep01.memory"); // { kind: "ready", payload: { bundles: ["ep01.memory"] } }
+* // The transit node in front of the rest node `wait` (inbox: ["elapsed", "ready"]):
+* if ((await fx(ready(["ep01.memory", "ui"]))) === false) return out.wait(); // false: still loading
+* return out.open(); // true: loaded and on the GPU
+* ```
+*/
+function ready(bundle) {
+	return {
+		kind: "ready",
+		payload: { bundles: typeof bundle === "string" ? [bundle] : [...bundle] }
+	};
+}
+/**
+* Binds `defineBundles`, `load` and `ready` to one game's bundle keys. Type-only: the same
+* functions.
 *
-* @returns The two helpers whose keys are checked by the compiler.
+* @returns The three helpers whose keys are checked by the compiler.
 * @example
 * ```ts
-* const { load } = bundlesFor<"board" | "board.chains">();
+* const { load, ready } = bundlesFor<"board" | "board.chains">();
 * load("board.chains"); // { kind: "load", payload: { bundles: ["board.chains"] } }
+* ready("board"); // { kind: "ready", payload: { bundles: ["board"] } }
 * ```
 */
 function bundlesFor() {
 	return {
 		defineBundles,
-		load
+		load,
+		ready
 	};
 }
 //#endregion
@@ -61203,6 +62280,7 @@ function cubicBezier(x1, y1, x2, y2) {
 * | renderer | monitor | { budgetMs: "rate", frames: 1024, stillFrames: 60, stillMpx: 0.25, churnPerSecond: 4, churnSeconds: 3, churnAfterTrimMs: 1000 }, the performance log of an agent build, the thresholds of its `problem` rules and `sections`, the sections it starts with (`MonitorSections`, every one on when left out); shallow merge: a game that sets `monitor` gives `budgetMs` and `frames`, a threshold it leaves out keeps its default, a section it leaves out is on |
 * | renderer | keptMb | 64, MiB the kept pictures may hold: a filtered view that did not change is drawn from its picture, the least recently drawn goes first; 0 keeps none |
 * | renderer | warm | 1, probe draws a drawn frame that create the GPU pipelines while the game loads; 0 creates each in the first frame that needs it |
+* | renderer | uploads | 1, texture sources `sync.textures.upload` puts on the GPU a drawn frame (~9 ms each on the A26); 0 turns the queue off |
 * | input | tapSlopPx | 12 |
 * | input | longPressMs | 450 |
 * | input | dragStartPx | 8 |
@@ -61360,4 +62438,4 @@ const screen = [
 	uiPlugin
 ];
 //#endregion
-export { spawn as $, exit as $t, types_exports$11 as A, Outline as At, textPlugin as B, rendererPlugin as Bt, types_exports$4 as C, Emitter as Ct, types_exports$8 as D, Displacement as Dt, types_exports$7 as E, ColorMatrix as Et, types_exports$16 as F, assetsPlugin as Ft, frames as G, PERF_GAP_BUCKETS as Gt, HAPTIC_KINDS as H, frameAt as Ht, types_exports$17 as I, animPlugin as It, parallel as J, SHADER_WHATS as Jt, haptic as K, PERF_LOG_VERSION as Kt, uiPlugin as L, AnimPlayer as Lt, types_exports$13 as M, debugPlugin as Mt, types_exports$14 as N, audioPlugin as Nt, types_exports$9 as O, Glow as Ot, types_exports$15 as P, scenesPlugin as Pt, sfx as Q, refuseStart as Qt, resolve as R, Animation as Rt, types_exports$3 as S, effectsPlugin as St, types_exports$6 as T, Blur as Tt, defineAnimation as U, MONITOR_SECTIONS as Ut, platformPlugin as V, PASS_KINDS as Vt, external as W, PERF_CAUSES as Wt, sequence as X, worldPlugin as Xt, play$1 as Y, DEMAND_REASONS as Yt, set as Z, flowPlugin as Zt, defineBundles as _, Traceable as _t, cubicBezier as a, lifecyclePlugin as an, inputPlugin as at, types_exports$1 as b, messageArgument as bt, hint as c, Held as ct, defineScene as d, PointerOver as dt, slot as en, spawned as et, tr as f, Pressable as ft, music as g, Touchable as gt, defineEmitter as h, Tappable as ht, screen as i, SaveUnreadableError as in, wait as it, types_exports$12 as j, defineFilter as jt, types_exports$10 as k, Noise as kt, schedule as l, Hovered as lt, flattenFeatures as m, Swipeable as mt, createPlugin as n, type as nn, tween as nt, defineEffect as o, timePlugin as on, Draggable as ot, defineFeature as p, Pressed as pt, mark as q, PROBLEM_RULES as qt, defineGame as r, modelPlugin as rn, use as rt, guide as s, clockPlugin as sn, DropTarget as st, createApp as t, to as tn, stagger as tt, projection as u, Pointer as ut, load as v, Traced as vt, types_exports$5 as w, Alpha as wt, types_exports$2 as x, messageDuration as xt, types_exports as y, i18nPlugin as yt, defineMotion as z, Frames as zt };
+export { sfx as $, refuseStart as $t, types_exports$10 as A, Noise as At, defineMotion as B, Frames as Bt, types_exports$3 as C, effectsPlugin as Ct, types_exports$7 as D, ColorMatrix as Dt, types_exports$6 as E, Blur as Et, types_exports$15 as F, scenesPlugin as Ft, external as G, PERF_CAUSES as Gt, platformPlugin as H, PASS_KINDS as Ht, types_exports$16 as I, assetsPlugin as It, mark as J, PROBLEM_RULES as Jt, frames as K, PERF_GAP_BUCKETS as Kt, types_exports$17 as L, animPlugin as Lt, types_exports$12 as M, defineFilter as Mt, types_exports$13 as N, debugPlugin as Nt, types_exports$8 as O, Displacement as Ot, types_exports$14 as P, audioPlugin as Pt, set as Q, flowPlugin as Qt, uiPlugin as R, AnimPlayer as Rt, types_exports$2 as S, messageDuration as St, types_exports$5 as T, Alpha as Tt, HAPTIC_KINDS as U, frameAt as Ut, textPlugin as V, rendererPlugin as Vt, defineAnimation as W, MONITOR_SECTIONS as Wt, play$1 as X, DEMAND_REASONS as Xt, parallel as Y, SHADER_WHATS as Yt, sequence as Z, worldPlugin as Zt, defineBundles as _, Touchable as _t, cubicBezier as a, SaveUnreadableError as an, wait as at, types_exports as b, i18nPlugin as bt, hint as c, clockPlugin as cn, DropTarget as ct, defineScene as d, Pointer as dt, exit as en, spawn as et, tr as f, PointerOver as ft, music as g, Tappable as gt, defineEmitter as h, Swipeable as ht, screen as i, modelPlugin as in, use as it, types_exports$11 as j, Outline as jt, types_exports$9 as k, Glow as kt, schedule as l, Held as lt, flattenFeatures as m, Pressed as mt, createPlugin as n, to as nn, stagger as nt, defineEffect as o, lifecyclePlugin as on, inputPlugin as ot, defineFeature as p, Pressable as pt, haptic as q, PERF_LOG_VERSION as qt, defineGame as r, type as rn, tween as rt, guide as s, timePlugin as sn, Draggable as st, createApp as t, slot as tn, spawned as tt, projection as u, Hovered as ut, load as v, Traceable as vt, types_exports$4 as w, Emitter as wt, types_exports$1 as x, messageArgument as xt, ready as y, Traced as yt, resolve as z, Animation as zt };