@moku-labs/game 0.15.5 → 0.15.7

package/dist/{src-DnclBdeU.mjs → src-nJYt0LMr.mjs}

@@ -598,6 +598,16 @@ const DROP_SHARE = .1;
 const DWELL_BASE_MS = 5e3;
 /** The dwell never grows past this, ms. */
 const DWELL_MAX_MS = 12e4;
+/** The render scales the adaptive rule steps through, highest first: shares of the canvas resolution. */
+const SCALE_STEPS = Object.freeze([
+	1,
+	.85,
+	.75,
+	.6,
+	.5
+]);
+/** No scale to step through: the renderer allows none. */
+const NO_SCALES = Object.freeze([]);
 /** The thermal statuses in order of heat: Android's `THERMAL_STATUS_*` numbers are their indexes. */
 const THERMAL_STATUSES = [
 	"none",
@@ -632,6 +642,22 @@ function ladderOf(displayHz, maxFps, floor) {
 	return Object.freeze(steps);
 }
 /**
+* The render scales the rule may choose down to a floor, highest first, frozen; none when 1 alone reaches it. A floor
+* between two steps stops at the step above it (the renderer's config only takes a step). Allocates: called when the
+* renderer allows a floor, never per frame.
+*
+* @param floor - The lowest scale the renderer allows.
+* @returns The scales.
+* @example
+* ```ts
+* scaleStepsOf(0.75); // [1, 0.85, 0.75]
+* ```
+*/
+function scaleStepsOf(floor) {
+	const steps = SCALE_STEPS.filter((step) => step >= floor);
+	return steps.length > 1 ? Object.freeze(steps) : NO_SCALES;
+}
+/**
 * The index in `DISPLAY_RATES` a tick interval votes for: the rate whose period is within `DISPLAY_TOLERANCE` of
 * it, or -1. An indexed loop: no allocation.
 *
@@ -789,17 +815,20 @@ function thermalTarget(ladder, status, fps) {
 //#region src/plugins/time/rate.ts
 /**
 * @file time — the adaptive frame rate (spec 21 G3–G6): the governor that drops to the next divisor of the display
-* rate when drawn frames come late and returns one step after steady room, the display rate learned from the ticks
-* in every app (and with the governor from the native shell), the thermal input, and `setRate`. Every number of the
-* per-frame path lives in the governor and the display state, allocated once; a frame allocates nothing here. Only a
-* change allocates: its payload, the snapshot, the request.
+* rate when drawn frames come late and returns one step after steady room, on a GPU-bound screen the render scale
+* stepped before the rate, the back-off of failed returns, the display rate learned from the ticks in every app (and
+* with the governor from the native shell), the thermal input, and `setRate`. Every number of the per-frame path lives
+* in the governor and the display state, allocated once; a frame allocates nothing here. Only a change allocates: its
+* payload, the snapshot, the request.
 */
-/** The ladder before the display rate is known, and always without `adaptive`. */
+/** The ladder before the display rate is known, and always without `adaptive`; the scales the renderer allows none of. */
 const NO_STEPS = Object.freeze([]);
 /** Bit of a sample that came late. */
 const MISSED = 1;
 /** Bit of a sample whose frame was heavy for the higher rate. */
 const HEAVY = 2;
+/** Bit of a late sample whose frame kept the main thread longer than its frame. */
+const BUSY = 4;
 /** The thermal rank from which the rule never steps up: `"moderate"` and every hotter status. */
 const HEAT_LIMIT_RANK = 2;
 /** Milliseconds in a second: turns a rate into the period of one frame. */
@@ -852,6 +881,7 @@ function createGovernor(floor) {
 	return {
 		floor,
 		ladder: NO_STEPS,
+		scales: NO_STEPS,
 		thermal: null,
 		lastDrawn: false,
 		lastIdle: false,
@@ -865,12 +895,14 @@ function createGovernor(floor) {
 		dropTail: 0,
 		dropDrawn: 0,
 		dropMissed: 0,
+		dropBusy: 0,
 		returnTail: 0,
 		returnDrawn: 0,
 		returnMissed: 0,
 		returnHeavy: 0,
 		switchedAt: Number.NEGATIVE_INFINITY,
 		lastReturnAt: Number.NEGATIVE_INFINITY,
+		climbed: false,
 		dwellMs: DWELL_BASE_MS,
 		requested: 0,
 		requestSeq: 0
@@ -906,7 +938,8 @@ function snapshotOf(rate) {
 		ladder: governor?.ladder ?? NO_STEPS,
 		thermal: governor?.thermal ?? null,
 		asked,
-		heldBy: asked !== null && hz !== null && asked > hz ? "panel" : null
+		heldBy: asked !== null && hz !== null && asked > hz ? "panel" : null,
+		scale: rate.scale
 	});
 }
 /**
@@ -923,6 +956,7 @@ function createRateState(config) {
 	const mode = floor === void 0 ? "fixed" : "auto";
 	const parts = {
 		fps: config.maxFps,
+		scale: 1,
 		mode,
 		reason: "start",
 		display: createDisplayState(),
@@ -953,6 +987,7 @@ function emptyWindows(g) {
 	g.dropTail = g.written;
 	g.dropDrawn = 0;
 	g.dropMissed = 0;
+	g.dropBusy = 0;
 	g.returnTail = g.written;
 	g.returnDrawn = 0;
 	g.returnMissed = 0;
@@ -967,6 +1002,7 @@ function dropOldest(g) {
 	const flags = g.sampleFlags[g.dropTail % 512] ?? 0;
 	g.dropDrawn -= 1;
 	if ((flags & MISSED) !== 0) g.dropMissed -= 1;
+	if ((flags & BUSY) !== 0) g.dropBusy -= 1;
 	g.dropTail += 1;
 }
 /**
@@ -1022,8 +1058,19 @@ function evidenceOf(g, reason) {
 	};
 }
 /**
-* The dwell's bookkeeping of a switch: a drop soon after a return doubles it (a failed return), a drop after a long
-* hold resets it, a return notes when it happened, `setRate` starts it over; the display and the heat leave it.
+* Starts the back-off over: the base dwell, no return to judge.
+*
+* @param g - The governor.
+*/
+function resetDwell(g) {
+	g.dwellMs = DWELL_BASE_MS;
+	g.lastReturnAt = Number.NEGATIVE_INFINITY;
+	g.climbed = false;
+}
+/**
+* The dwell's bookkeeping of a switch: the first drop after a return judges it (held less than a minute it failed and
+* the dwell doubles, held longer the dwell starts over), the steps down after it leave the dwell, a return notes when
+* it happened, `setRate` starts it over; the display and the heat leave it.
 *
 * @param g - The governor.
 * @param reason - The reason of the switch.
@@ -1031,19 +1078,16 @@ function evidenceOf(g, reason) {
 */
 function keepDwell(g, reason, at) {
 	switch (reason) {
-		case "missed": {
-			const held = at - g.lastReturnAt;
-			if (held < 1e4) g.dwellMs = Math.min(2 * g.dwellMs, DWELL_MAX_MS);
-			else if (held >= 6e4) g.dwellMs = DWELL_BASE_MS;
+		case "missed":
+			if (g.climbed) g.dwellMs = at - g.lastReturnAt < 6e4 ? Math.min(2 * g.dwellMs, DWELL_MAX_MS) : DWELL_BASE_MS;
+			g.climbed = false;
 			break;
-		}
 		case "headroom":
 			g.lastReturnAt = at;
+			g.climbed = true;
 			break;
 		case "forced":
-		case "auto":
-			g.dwellMs = DWELL_BASE_MS;
-			g.lastReturnAt = Number.NEGATIVE_INFINITY;
+		case "auto": resetDwell(g);
 	}
 }
 /**
@@ -1082,22 +1126,25 @@ function requestRate(ctx) {
 	followNativeRate(ctx, (answer) => readAnswer(ctx, g, seq, answer));
 }
 /**
-* The one place the rate or its mode changes (the governor, the display, the heat and `setRate` call it). Nothing
-* when both stay. Otherwise the dwell is kept, both windows are emptied and the next interval is skipped, the
-* snapshot is rebuilt, `time:rate` is emitted with the evidence, the change is logged and the shell is asked for the
-* new rate. The new cap applies from the next tick: the frame that is due still runs.
+* The one place the rate, the render scale or the mode changes (the governor, the display, the heat and `setRate`
+* call it). Nothing when all stay. Otherwise the dwell is kept, both windows are emptied and the next interval is
+* skipped, the snapshot is rebuilt, `time:rate` is emitted with the evidence, the change is logged and the shell is
+* asked for the new rate. The new cap applies from the next tick: the frame that is due still runs, at the new scale.
 *
 * @param ctx - Domain context of the time plugin.
 * @param to - The new rate.
+* @param scale - The new render scale.
 * @param mode - The new mode.
 * @param reason - Why.
 * @param at - When, on the page clock.
 */
-function switchRate(ctx, to, mode, reason, at) {
+function switchRate(ctx, to, scale, mode, reason, at) {
 	const { rate } = ctx.state;
-	if (to === rate.fps && mode === rate.mode) return;
+	if (to === rate.fps && scale === rate.scale && mode === rate.mode) return;
 	const g = rate.governor;
 	const from = rate.fps;
+	const fromScale = rate.scale;
+	const scaleOnly = to === from && mode === rate.mode;
 	const evidence = evidenceOf(g, reason);
 	if (g !== void 0) {
 		keepDwell(g, reason, at);
@@ -1106,6 +1153,7 @@ function switchRate(ctx, to, mode, reason, at) {
 		emptyWindows(g);
 	}
 	rate.fps = to;
+	rate.scale = scale;
 	rate.mode = mode;
 	rate.reason = reason;
 	rate.snapshot = snapshotOf(rate);
@@ -1117,8 +1165,15 @@ function switchRate(ctx, to, mode, reason, at) {
 		displayHz: rate.display.hz,
 		thermal: g?.thermal ?? null,
 		window: evidence,
-		dwellMs: g?.dwellMs ?? 0
+		dwellMs: g?.dwellMs ?? 0,
+		scale
+	});
+	if (scale !== fromScale) ctx.log.info("time: render scale", {
+		from: fromScale,
+		to: scale,
+		reason
 	});
+	if (scaleOnly) return;
 	ctx.log.info("time: frame rate", {
 		from,
 		to,
@@ -1137,7 +1192,7 @@ function applyThermal(ctx, g) {
 	const { rate } = ctx.state;
 	if (rate.mode !== "auto" || g.ladder.length === 0) return;
 	const to = thermalTarget(g.ladder, g.thermal, rate.fps);
-	if (to < rate.fps) switchRate(ctx, to, "auto", "thermal", nowOf());
+	if (to < rate.fps) switchRate(ctx, to, rate.scale, "auto", "thermal", nowOf());
 }
 /**
 * Stores a new thermal status of the shell and applies it. A status the shell sent wrong, and the same status
@@ -1182,7 +1237,7 @@ function learnDisplay(ctx, hz, at) {
 	if (g !== void 0) g.ladder = ladderOf(hz, ctx.config.maxFps, g.floor);
 	rate.snapshot = snapshotOf(rate);
 	if (g === void 0 || rate.mode !== "auto") return;
-	if (!g.ladder.includes(rate.fps)) switchRate(ctx, g.ladder.find((step) => step <= rate.fps) ?? g.ladder.at(-1) ?? rate.fps, "auto", "display", at);
+	if (!g.ladder.includes(rate.fps)) switchRate(ctx, g.ladder.find((step) => step <= rate.fps) ?? g.ladder.at(-1) ?? rate.fps, rate.scale, "auto", "display", at);
 	if (first) applyThermal(ctx, g);
 }
 /**
@@ -1279,31 +1334,54 @@ function shouldDrop(g) {
 	return g.dropMissed >= Math.max(8, Math.ceil(DROP_SHARE * g.dropDrawn));
 }
 /**
-* Tells whether the return window has room to step up: no heat, the dwell passed, 90 drawn frames in three seconds
-* with at most one late and a tenth heavy.
+* 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.
+*
+* @param g - The governor.
+* @returns True when the scale, not the rate, should give.
+*/
+function gpuBound(g) {
+	return 2 * g.dropBusy < g.dropMissed;
+}
+/**
+* Tells whether the return window has room to step up: no heat, the dwell passed (twice the dwell for a step of the
+* scale), 90 drawn frames in three seconds with at most one late, and for a step of the rate a tenth heavy at most.
 *
 * @param g - The governor.
 * @param at - The page time of the sample.
-* @returns True when the rate may return one step.
+* @param scaleStep - The step up is one of the render scale: it costs the GPU, not the main thread.
+* @returns True when the rule may return one step.
 */
-function canReturn(g, at) {
-	return thermalRank(g.thermal) < HEAT_LIMIT_RANK && at - g.switchedAt >= g.dwellMs && g.returnDrawn >= 90 && g.returnMissed <= 1 && g.returnHeavy <= Math.floor(.1 * g.returnDrawn);
+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,
-* up one step after the dwell with 90 steady drawn frames in three seconds, at most one late and a tenth heavy, and
-* no heat.
+* 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
+* 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.
 *
 * @param ctx - Domain context of the time plugin.
 * @param g - The governor.
 * @param at - The page time of the sample.
 */
 function decide(ctx, g, at) {
-	const { fps } = ctx.state.rate;
-	const lower = stepBelow(g.ladder, fps);
+	const { fps, scale } = ctx.state.rate;
+	if (shouldDrop(g)) {
+		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;
+	}
 	const higher = stepAbove(g.ladder, fps);
-	if (lower !== void 0 && shouldDrop(g)) switchRate(ctx, lower, "auto", "missed", at);
-	else if (higher !== void 0 && canReturn(g, at)) switchRate(ctx, higher, "auto", "headroom", at);
+	if (higher !== void 0 && canReturn(g, at, false)) {
+		switchRate(ctx, higher, scale, "auto", "headroom", at);
+		return;
+	}
+	const larger = stepAbove(g.scales, scale);
+	if (larger !== void 0 && canReturn(g, at, true)) switchRate(ctx, fps, larger, "auto", "headroom", at);
 }
 /**
 * Judges the interval from the last run frame's start to this one: the first after a change is skipped, one that is
@@ -1325,10 +1403,11 @@ function judgeFrame$1(ctx, g, intervalMs, at) {
 	const higher = stepAbove(g.ladder, fps);
 	const missed = intervalMs > missLineMs(fps, ctx.state.rate.display.hz ?? fps);
 	const heavy = higher !== void 0 && g.lastWorkMs > .5 * SECOND_MS$1 / higher;
+	const busy = missed && g.lastWorkMs > SECOND_MS$1 / fps;
 	const slot = g.written % 512;
 	evict$2(g, at);
 	g.sampleAt[slot] = at;
-	g.sampleFlags[slot] = (missed ? MISSED : 0) | (heavy ? HEAVY : 0);
+	g.sampleFlags[slot] = (missed ? MISSED : 0) | (heavy ? HEAVY : 0) | (busy ? BUSY : 0);
 	g.written += 1;
 	g.dropDrawn += 1;
 	g.returnDrawn += 1;
@@ -1337,6 +1416,7 @@ function judgeFrame$1(ctx, g, intervalMs, at) {
 		g.returnMissed += 1;
 	}
 	if (heavy) g.returnHeavy += 1;
+	if (busy) g.dropBusy += 1;
 	decide(ctx, g, at);
 }
 /**
@@ -1358,6 +1438,39 @@ function closeFrame(ctx, g, workMs) {
 	g.lastWorkMs = Math.max(0, workMs - agentMs);
 }
 /**
+* Starts the governor over for a new scene: the back-off of failed returns goes back to the base dwell, both windows
+* are emptied and the next interval is skipped, so the new screen is judged on its own frames. The rate and the scale
+* stay. Nothing without a governor.
+*
+* @param rate - The rate state.
+*/
+function sceneRate(rate) {
+	const g = rate.governor;
+	if (g === void 0) return;
+	resetDwell(g);
+	g.skipNext = true;
+	emptyWindows(g);
+}
+/**
+* Sets the render scales the rule may step through, down to `floor`. A scale under the new floor goes up to it at
+* once, quietly: the caller draws at what it decided. Nothing without a governor.
+*
+* @param rate - The rate state.
+* @param floor - The lowest scale the renderer allows; 1 allows none.
+* @returns The frame rate after the call.
+*/
+function allowScale(rate, floor) {
+	const g = rate.governor;
+	if (g === void 0) return rate.snapshot;
+	g.scales = scaleStepsOf(floor);
+	const lowest = g.scales.at(-1) ?? 1;
+	if (rate.scale < lowest) {
+		rate.scale = lowest;
+		rate.snapshot = snapshotOf(rate);
+	}
+	return rate.snapshot;
+}
+/**
 * Restarts the tick history of the display after a resume and, with a governor, its windows, and skips the next
 * interval: a return from the background is a new situation. The display rate already known stays.
 *
@@ -1403,10 +1516,10 @@ function resumeAuto(ctx) {
 	const { maxFps } = ctx.config;
 	const g = ctx.state.rate.governor;
 	if (g === void 0) {
-		switchRate(ctx, maxFps, "fixed", "auto", nowOf());
+		switchRate(ctx, maxFps, 1, "fixed", "auto", nowOf());
 		return;
 	}
-	switchRate(ctx, autoRate(g, maxFps), "auto", "auto", nowOf());
+	switchRate(ctx, autoRate(g, maxFps), 1, "auto", "auto", nowOf());
 }
 /**
 * Forces the rate (the exact cap, never above `maxFps`) or gives it back to the config with `"auto"`.
@@ -1420,7 +1533,7 @@ function setRateChoice(ctx, choice) {
 	const value = choice;
 	if (!isChoice(value)) throw new Error(`[game] time.setRate takes "auto", 30, 60 or 120.\n  Pass one of them, not ${String(value)}.`);
 	const { rate } = ctx.state;
-	if (value !== "auto") switchRate(ctx, Math.min(value, ctx.config.maxFps), "forced", "forced", nowOf());
+	if (value !== "auto") switchRate(ctx, Math.min(value, ctx.config.maxFps), 1, "forced", "forced", nowOf());
 	else if (rate.mode === "forced") resumeAuto(ctx);
 	return rate.snapshot;
 }
@@ -1694,7 +1807,7 @@ function countFrameListeners(ctx) {
 }
 /**
 * Creates the time API: frame callbacks per phase, the `Time` resource, scale, pause and
-* resume, `wake` for the idle cap, the measurement of an agent build, the frame rate, and `step`
+* resume, `wake` for the idle cap, the measurement of an agent build, the frame rate and its render scale, and `step`
 * for tests and tools.
 *
 * @param ctx - Domain context of the time plugin.
@@ -1744,6 +1857,8 @@ function createTimeApi(ctx) {
 		},
 		rate: () => ctx.state.rate.snapshot,
 		setRate: (choice) => setRateChoice(ctx, choice),
+		allowScale: (floor) => allowScale(ctx.state.rate, floor),
+		sceneChanged: () => sceneRate(ctx.state.rate),
 		frameDrawn: () => {
 			ctx.state.rate.drawnNow = true;
 		},
@@ -1907,7 +2022,7 @@ const timePlugin = /*#__PURE__*/ createPlugin$1("time", {
 	},
 	events: (register) => register.map({
 		"time:thermal": "The native shell reported a thermal reading",
-		"time:rate": "The loop's frame rate changed"
+		"time:rate": "The loop's frame rate or render scale changed"
 	}),
 	createState: createTimeState,
 	api: createTimeApi,
@@ -12317,7 +12432,7 @@ function withinRatio(differing, bytes) {
 * @param host - The host module (`resolution()`).
 * @returns Device pixels per CSS pixel; `undefined` for the half resolution of `host.pixels`.
 */
-function readResolution(ctx, host) {
+function readResolution$1(ctx, host) {
 	return hasPictures(ctx.state.kept) ? host.resolution() : void 0;
 }
 /**
@@ -12341,7 +12456,7 @@ function hasPictures(kept) {
 * @param decided - The decision of this frame, changed in place when a missed frame is drawn.
 */
 function verifyFrame(ctx, state, host, decided) {
-	const resolution = readResolution(ctx, host);
+	const resolution = readResolution$1(ctx, host);
 	if (decided.reason !== "none") {
 		state.verify.reference = host.pixels(resolution);
 		return;
@@ -12845,7 +12960,541 @@ function installRebindingRenderGroupPipe(pixi) {
 	};
 }
 //#endregion
+//#region src/plugins/renderer/host/render-pass.ts
+/** Pixi's `CLEAR.NONE`. */
+const CLEAR_NONE = 0;
+/** Pixi's `CLEAR.ALL`: colour, depth and stencil. */
+const CLEAR_ALL = 17664;
+/** Pixi's `CLEAR.COLOR`. */
+const CLEAR_COLOR = 16384;
+/**
+* The `CLEAR` bits of a pass's clear, as Pixi reads a boolean. `clearBits(true); // 17664`
+*
+* @param clear - The clear Pixi was handed.
+* @returns The bits.
+*/
+function clearBits(clear) {
+	if (clear === true) return CLEAR_ALL;
+	if (clear === false) return CLEAR_NONE;
+	return clear;
+}
+/**
+* Builds the classes of the lazy canvas pass from the module object, at call time, because the bases arrive with the
+* lazily loaded module. Each system keeps its base's `static extension` object as it is, so the registry files it
+* under the same type and name. They cost one test of two booleans per pipeline request, and nothing else per draw.
+*
+* @param pixi - The loaded Pixi module.
+* @returns The render target system and the pipeline system.
+*/
+function createLazyCanvasClasses(pixi) {
+	/**
+	* Pixi's WebGPU adaptor, which begins a pass on the canvas at its first draw and sets the canvas's stencil and depth
+	* operations by the rule of the file. One per renderer.
+	*/
+	class LazyCanvasAdaptor extends pixi.GpuRenderTargetAdaptor {
+		/** The canvas is bound and its pass has not begun: the pipeline system begins it at the first draw. */
+		pending = false;
+		/** A pipeline that tests or writes depth was asked for: the canvas keeps its depth from then on. */
+		depthUsed = false;
+		/** The renderer: Pixi's own `_renderer` is private. */
+		gpu = void 0;
+		/** The render target system: Pixi's own `_renderTargetSystem` is private. */
+		targets = void 0;
+		/** The renderer's pipeline system is the lazy one: only then does a pass wait for a draw. */
+		hooked = false;
+		/** The canvas whose pass is pending or whose clear is owed. */
+		canvas = void 0;
+		/** The `CLEAR` bits the canvas owes. */
+		owed = CLEAR_NONE;
+		/** The colour of the owed clear, copied, when one was given. */
+		owedColor = [
+			0,
+			0,
+			0,
+			0
+		];
+		/** `owedColor` holds the colour of the owed clear. */
+		owedColorSet = false;
+		/** The viewport of the canvas's pass to come, copied from the bind that deferred it. */
+		view = new pixi.Rectangle();
+		/** The canvas whose pass this adaptor began and has not ended. */
+		openCanvas = void 0;
+		/** The open canvas pass stores its stencil. */
+		keepStencil = false;
+		/** The open canvas pass stores its depth. */
+		keepDepth = false;
+		/** The pass being begun stores its stencil. */
+		planStencil = false;
+		/** The pass being begun stores its depth. */
+		planDepth = false;
+		/** The canvas pass that ended last stored its depth. */
+		depthStored = false;
+		/** A canvas pass began since the last `renderEnd`. */
+		acquired = false;
+		/** A mask was pushed on the canvas in the last frame drawn on it. */
+		maskedBefore = false;
+		/** A mask was pushed on the canvas in this frame. */
+		maskedNow = false;
+		/** The root bind of the canvas emitted no target change: the stencil system hears of it when its pass begins. */
+		changeOwed = false;
+		/**
+		* Keeps the renderer and the render target system, then lets Pixi subscribe the adaptor.
+		*
+		* @param renderer - The WebGPU renderer.
+		* @param renderTargetSystem - Its render target system.
+		*/
+		init(renderer, renderTargetSystem) {
+			super.init(renderer, renderTargetSystem);
+			this.gpu = renderer;
+			this.targets = renderTargetSystem;
+		}
+		/** Forgets every pass of the old device, then lets Pixi drop its restore helper. */
+		contextChange() {
+			super.contextChange();
+			this.pending = false;
+			this.canvas = void 0;
+			this.owed = CLEAR_NONE;
+			this.owedColorSet = false;
+			this.openCanvas = void 0;
+			this.depthStored = false;
+			this.changeOwed = false;
+		}
+		/**
+		* Tells whether the root bind of a render may skip its target change: the root is a canvas whose pass is deferred.
+		* The adaptor then owes the stencil system the change, until the canvas pass begins or another target is bound.
+		*
+		* @param root - The root target of the render.
+		* @returns True when the bind may skip the change.
+		*/
+		owesChange(root) {
+			this.changeOwed = this.defers(root);
+			return this.changeOwed;
+		}
+		/**
+		* Begins a pass as Pixi does on any target but the canvas inside a frame. On the canvas it reuses an open pass as
+		* Pixi does, and otherwise ends the open pass and defers the canvas's, its clear owed.
+		*
+		* @param renderTarget - The target.
+		* @param clear - What to clear.
+		* @param clearColor - The colour to clear to.
+		* @param viewport - The viewport.
+		* @param mipLevel - The mip level.
+		* @param layer - The array layer.
+		*/
+		startRenderPass(renderTarget, clear = true, clearColor, viewport, mipLevel = 0, layer = 0) {
+			if (viewport === void 0 || mipLevel !== 0 || layer !== 0 || !this.defers(renderTarget)) {
+				this.pending = false;
+				this.openCanvas = void 0;
+				this.changeOwed = false;
+				super.startRenderPass(renderTarget, clear, clearColor, viewport, mipLevel, layer);
+				return;
+			}
+			const bits = clearBits(clear);
+			if (this.canvas !== void 0 && this.canvas !== renderTarget) this.settleCanvas();
+			if (bits === CLEAR_NONE && this.isOpen(renderTarget)) {
+				this.beginCanvas(renderTarget, CLEAR_NONE, void 0, viewport);
+				return;
+			}
+			this.finishRenderPass();
+			this.canvas = renderTarget;
+			this.pending = true;
+			this.owe(bits, clearColor);
+			this.view.copyFrom(viewport);
+		}
+		/** Ends the open pass, as Pixi does. */
+		finishRenderPass() {
+			super.finishRenderPass();
+			this.openCanvas = void 0;
+		}
+		/**
+		* Copies out of a render target, as Pixi does. A copy that reads or writes the canvas first pays the clear it owes,
+		* or a first pass it never had; a canvas that had its pass in this render and owes nothing begins no empty one.
+		*
+		* @param source - The target copied from.
+		* @param destination - The texture copied into.
+		* @param from - The origin in the source.
+		* @param size - The size of the copy.
+		* @param to - The origin in the destination.
+		* @returns The destination.
+		*/
+		copyToTexture(source, destination, from, size, to) {
+			const canvas = this.canvas;
+			if (canvas !== void 0 && (source === canvas || destination.source === canvas.colorTexture) && (this.owed !== CLEAR_NONE || !this.acquired)) this.payOwed(canvas);
+			return super.copyToTexture(source, destination, from, size, to);
+		}
+		/**
+		* Copies a render target's depth, as Pixi does; a copy of the canvas's depth makes the canvas keep its depth from
+		* then on, and pays the clear it owes first.
+		*
+		* @param source - The target copied from.
+		* @param destination - The depth texture copied into.
+		* @param from - The origin in the source.
+		* @param size - The size of the copy.
+		* @param to - The origin in the destination.
+		*/
+		copyDepthTexture(source, destination, from, size, to) {
+			if (this.isCanvas(source)) {
+				this.depthUsed = true;
+				if (source === this.canvas) this.payOwed(source);
+			}
+			super.copyDepthTexture(source, destination, from, size, to);
+		}
+		/** Begins the pending canvas pass, with the clear it owes: a draw is about to be recorded into it. */
+		beginPending() {
+			const target = this.canvas;
+			if (!this.pending || target === void 0) return;
+			const bits = this.owed;
+			const color = this.owedColorSet ? this.owedColor : void 0;
+			this.pending = false;
+			this.canvas = void 0;
+			this.owed = CLEAR_NONE;
+			this.owedColorSet = false;
+			this.beginCanvas(target, bits, color, this.view);
+		}
+		/**
+		* A pipeline that tests or writes depth was asked for: the canvas keeps its depth from now on, and an open canvas
+		* pass that discards it begins again, with the depth cleared, as nothing wrote it yet, and stored.
+		*/
+		useDepth() {
+			this.depthUsed = true;
+			const canvas = this.openCanvas;
+			if (canvas?.depthStencilAttachment !== void 0 && !this.keepDepth && this.passOpen()) this.restart(canvas);
+		}
+		/**
+		* A stencil mask is about to be pushed on the bound target: on the canvas, the stencil is kept from now on.
+		*
+		* @param target - The bound target.
+		*/
+		maskPushes(target) {
+			if (this.isCanvas(target)) this.maskedNow = true;
+		}
+		/**
+		* A stencil mask was pushed on the bound target: an open canvas pass that discards its stencil begins again, the
+		* stencil cleared, as no mask was open, and stored, before the mask is drawn. A pending canvas pass whose target
+		* change is owed begins now, so the stencil system knows its target before it sets the mask's mode.
+		*
+		* @param target - The bound target.
+		*/
+		maskPushed(target) {
+			if (this.changeOwed && this.pending && this.canvas === target) this.beginPending();
+			else if (this.openCanvas === target && !this.keepStencil && this.passOpen()) this.restart(target);
+		}
+		/**
+		* The end of a render call: pays the clear the canvas owes, gives a canvas that saw no pass one, so the frame
+		* clears and presents it as Pixi's does, and moves the mask memory on after a frame drawn on the canvas.
+		*
+		* @param root - The root target of the render call.
+		*/
+		settle(root) {
+			this.settleCanvas();
+			this.acquired = false;
+			if (this.isCanvas(root)) {
+				this.maskedBefore = this.maskedNow;
+				this.maskedNow = false;
+			}
+		}
+		/**
+		* Tells whether a pass on a target waits for its first draw: the target is a canvas without multisampling, and the
+		* renderer's pipeline system is the lazy one that begins it.
+		*
+		* @param target - The target.
+		* @returns True when the pass is deferred.
+		*/
+		defers(target) {
+			if (!this.hooked) this.hooked = this.gpu?.pipeline instanceof LazyCanvasPipeline;
+			return this.hooked && this.isCanvas(target);
+		}
+		/**
+		* Tells whether a target is a canvas without multisampling: Pixi gives a canvas's GPU target its context.
+		*
+		* @param target - The target.
+		* @returns True for such a canvas.
+		*/
+		isCanvas(target) {
+			const targets = this.targets;
+			if (targets === void 0) return false;
+			const gpuTarget = targets.getGpuRenderTarget(target);
+			return gpuTarget.contexts.length > 0 && !gpuTarget.msaa;
+		}
+		/**
+		* Tells whether a pass of the encoder is open.
+		*
+		* @returns True while one is.
+		*/
+		passOpen() {
+			const encoder = this.gpu?.encoder;
+			return encoder !== void 0 && encoder.renderPassEncoder !== null;
+		}
+		/**
+		* Tells whether the pass this adaptor began on a canvas is still open.
+		*
+		* @param target - The canvas.
+		* @returns True when its pass is open.
+		*/
+		isOpen(target) {
+			return this.openCanvas === target && this.passOpen();
+		}
+		/**
+		* Adds a clear to the one the canvas owes; a colour clear given a colour keeps a copy of it.
+		*
+		* @param bits - The `CLEAR` bits.
+		* @param color - The colour, when one was given.
+		*/
+		owe(bits, color) {
+			const colour = bits & CLEAR_COLOR;
+			this.owed |= bits;
+			if (colour === 0) return;
+			this.owedColorSet = Array.isArray(color);
+			if (!Array.isArray(color)) return;
+			this.owedColor[0] = color[0];
+			this.owedColor[1] = color[1];
+			this.owedColor[2] = color[2];
+			this.owedColor[3] = color[3];
+		}
+		/**
+		* Begins a pass on the canvas through Pixi, with the stencil and depth operations of the rule set on its
+		* depth-stencil attachment first, where Pixi's descriptor reads them; a clear Pixi was asked for still wins. Pixi
+		* reuses an open pass when nothing is cleared and nothing changed; a pass that really began is recorded.
+		*
+		* @param target - The canvas.
+		* @param bits - The `CLEAR` bits.
+		* @param color - The clear colour, when one was given.
+		* @param viewport - The viewport.
+		*/
+		beginCanvas(target, bits, color, viewport) {
+			const gpu = this.gpu;
+			const targets = this.targets;
+			if (gpu === void 0 || targets === void 0) return;
+			this.planDepthStencil(target, targets);
+			const before = gpu.encoder.renderPassEncoder;
+			if (viewport !== this.view) this.view.copyFrom(viewport);
+			super.startRenderPass(target, bits, color, viewport, 0, 0);
+			this.openCanvas = target;
+			if (gpu.encoder.renderPassEncoder !== before) this.began(target, targets);
+		}
+		/**
+		* Sets the stencil and depth operations of the rule on the canvas's depth-stencil attachment, made first when
+		* Pixi would make it, and keeps what the pass stores.
+		*
+		* @param target - The canvas.
+		* @param targets - The render target system.
+		*/
+		planDepthStencil(target, targets) {
+			if ((target.stencil || target.depth) && target.depthStencilAttachment === void 0) target.ensureDepthStencilTexture();
+			const attachment = target.depthStencilAttachment;
+			const masked = targets.getGpuRenderTarget(target).maskStackIndex !== 0;
+			this.planStencil = masked || this.maskedBefore || this.maskedNow;
+			this.planDepth = this.depthUsed && attachment !== void 0;
+			if (attachment === void 0) return;
+			attachment.stencilLoadOp = masked ? "load" : "clear";
+			attachment.stencilStoreOp = this.planStencil ? "store" : "discard";
+			attachment.depthLoadOp = this.depthStored ? "load" : "clear";
+			attachment.depthStoreOp = this.planDepth ? "store" : "discard";
+		}
+		/**
+		* Records a canvas pass that really began (Pixi did not reuse the open one), and tells the stencil system of the
+		* canvas when the root bind owes it the change, now that there is a pass to set its reference on.
+		*
+		* @param target - The canvas.
+		* @param targets - The render target system.
+		*/
+		began(target, targets) {
+			this.acquired = true;
+			this.keepStencil = this.planStencil;
+			this.keepDepth = this.planDepth;
+			this.depthStored = this.planDepth;
+			if (this.changeOwed) {
+				this.changeOwed = false;
+				targets.onRenderTargetChange.emit(target);
+			}
+		}
+		/**
+		* Begins and ends one pass on a canvas now, with the clear it owes, and leaves the canvas bound with nothing owed.
+		*
+		* @param target - The canvas.
+		*/
+		payOwed(target) {
+			const bits = this.owed;
+			const color = this.owedColorSet ? this.owedColor : void 0;
+			this.owed = CLEAR_NONE;
+			this.owedColorSet = false;
+			this.beginCanvas(target, bits, color, this.view);
+			this.finishRenderPass();
+		}
+		/**
+		* Ends the canvas's wait: pays the clear it owes, or a first pass it never had, and forgets it.
+		*/
+		settleCanvas() {
+			const target = this.canvas;
+			if (target === void 0) return;
+			if (this.owed !== CLEAR_NONE || !this.acquired) this.payOwed(target);
+			this.pending = false;
+			this.canvas = void 0;
+		}
+		/**
+		* Begins the open canvas pass again with nothing cleared, by the rule as it stands now, and sets its stencil
+		* reference again: a new pass starts from 0, and Pixi sets it only when the mode or the target changes.
+		*
+		* @param target - The canvas.
+		*/
+		restart(target) {
+			const gpu = this.gpu;
+			const targets = this.targets;
+			if (gpu === void 0 || targets === void 0) return;
+			this.finishRenderPass();
+			this.beginCanvas(target, CLEAR_NONE, void 0, this.view);
+			gpu.encoder.setStencilReference(targets.getGpuRenderTarget(target).stencilReference);
+		}
+	}
+	/** Pixi's WebGPU render target system over the lazy adaptor, which settles the canvas at the end of a render. */
+	class LazyCanvasTargets extends pixi.GpuRenderTargetSystem {
+		static extension = pixi.GpuRenderTargetSystem.extension;
+		/** The adaptor, typed as the lazy one. */
+		lazy;
+		/**
+		* Makes Pixi's system, then puts the lazy adaptor in the place of Pixi's.
+		*
+		* @param renderer - The WebGPU renderer.
+		*/
+		constructor(renderer) {
+			super(renderer);
+			const lazy = new LazyCanvasAdaptor();
+			lazy.init(renderer, this);
+			this.adaptor = lazy;
+			this.lazy = lazy;
+		}
+		/**
+		* Starts a render as Pixi does; a root canvas whose pass is deferred is marked bound first, so Pixi's bind of it
+		* emits no target change: the adaptor emits it when the pass begins.
+		*
+		* @param options - The root binding.
+		*/
+		renderStart(options) {
+			const root = this.getRenderTarget(options.target);
+			if (this.renderTarget !== root && Boolean(root.flipY) === Boolean(options.flipY) && this.lazy.owesChange(root)) this.renderTarget = root;
+			super.renderStart(options);
+		}
+		/** The end of a render call, before the encoder submits it: the canvas settles. */
+		renderEnd() {
+			this.lazy.settle(this.rootRenderTarget);
+		}
+		/** Makes sure the bound target has a stencil for a mask about to be pushed, and keeps it by the rule. */
+		ensureDepthStencil() {
+			const target = this.renderTarget;
+			this.lazy.maskPushes(target);
+			super.ensureDepthStencil();
+			this.lazy.maskPushed(target);
+		}
+	}
+	/** Pixi's WebGPU pipeline system, which begins a deferred canvas pass before a draw or a stencil reference needs it. */
+	class LazyCanvasPipeline extends pixi.PipelineSystem {
+		static extension = pixi.PipelineSystem.extension;
+		/** The renderer: Pixi's own `_renderer` is private. */
+		host;
+		/** The lazy adaptor of the renderer, once found. */
+		lazy = void 0;
+		/**
+		* Keeps the renderer it is made for.
+		*
+		* @param renderer - The WebGPU renderer.
+		*/
+		constructor(renderer) {
+			super(renderer);
+			this.host = renderer;
+		}
+		/**
+		* Notes a state that tests or writes depth, begins a pending canvas pass, then answers Pixi's pipeline. Its five
+		* arguments are named, not spread: a rest array would be made at every draw.
+		*
+		* @param geometry - The geometry.
+		* @param program - The program.
+		* @param state - The state.
+		* @param topology - The topology.
+		* @param overrides - The shader overrides.
+		* @returns The pipeline.
+		*/
+		getPipeline(geometry, program, state, topology, overrides) {
+			const lazy = this.lazy ?? this.link();
+			if (lazy !== void 0) {
+				if (!lazy.depthUsed && (state.depthTest || state.depthMask)) lazy.useDepth();
+				if (lazy.pending) lazy.beginPending();
+			}
+			return super.getPipeline(geometry, program, state, topology, overrides);
+		}
+		/**
+		* Begins a pending canvas pass, then answers Pixi's buffer names: the first call of a batch or a graphics draw.
+		*
+		* @param geometry - The geometry.
+		* @param program - The program.
+		* @returns The names of the buffers to bind.
+		*/
+		getBufferNamesToBind(geometry, program) {
+			this.beginPending();
+			return super.getBufferNamesToBind(geometry, program);
+		}
+		/**
+		* Begins a pending canvas pass, then sets the stencil mode: the stencil system sets its reference on the pass next.
+		*
+		* @param stencilMode - The stencil mode.
+		*/
+		setStencilMode(stencilMode) {
+			this.beginPending();
+			super.setStencilMode(stencilMode);
+		}
+		/**
+		* Begins a pending canvas pass, then answers Pixi's key: a render bundle is recorded or replayed next.
+		*
+		* @returns The key.
+		*/
+		get bundleStateKey() {
+			this.beginPending();
+			return super.bundleStateKey;
+		}
+		/** Begins the pending canvas pass of the renderer, when there is one. */
+		beginPending() {
+			const lazy = this.lazy ?? this.link();
+			if (lazy?.pending === true) lazy.beginPending();
+		}
+		/**
+		* Finds the renderer's lazy adaptor, once its render target system exists.
+		*
+		* @returns The adaptor, or `undefined` while there is none.
+		*/
+		link() {
+			const adaptor = this.host.renderTarget.adaptor;
+			if (adaptor instanceof LazyCanvasAdaptor) this.lazy = adaptor;
+			return this.lazy;
+		}
+	}
+	return {
+		targets: LazyCanvasTargets,
+		pipeline: LazyCanvasPipeline
+	};
+}
+/**
+* Swaps Pixi's WebGPU render target and pipeline systems for the lazy canvas ones in the module's extension registry,
+* and registers Pixi's stencil system again after them: the registry appends a class it is given, and the stencil
+* system subscribes to the render target system when it is made, so it must come later. Every application made
+* afterwards defers its canvas pass. The registry is global to the module object, so the remover matters: it puts
+* Pixi's own classes back, the stencil system again last.
+*
+* @param pixi - The loaded Pixi module.
+* @returns The remover.
+* @throws {TypeError} When the module has none of the classes to subclass.
+*/
+function installLazyCanvasPass(pixi) {
+	const lazy = createLazyCanvasClasses(pixi);
+	pixi.extensions.remove(pixi.GpuRenderTargetSystem, pixi.GpuStencilSystem, pixi.PipelineSystem);
+	pixi.extensions.add(lazy.targets, pixi.GpuStencilSystem, lazy.pipeline);
+	return () => {
+		pixi.extensions.remove(lazy.targets, pixi.GpuStencilSystem, lazy.pipeline);
+		pixi.extensions.add(pixi.GpuRenderTargetSystem, pixi.GpuStencilSystem, pixi.PipelineSystem);
+	};
+}
+//#endregion
 //#region src/plugins/renderer/host/resolution.ts
+/** The short side, in CSS pixels, at or under which a coarse pointer is a phone: the rule of `effects.phone`. */
+const PHONE_SIDE$1 = 820;
 /**
 * Device pixels per CSS pixel of the window; 1 without a window. Moved here from `host/init.ts`.
 *
@@ -12855,20 +13504,67 @@ function devicePixels() {
 	return typeof globalThis.devicePixelRatio === "number" ? globalThis.devicePixelRatio : 1;
 }
 /**
-* The resolution to draw at: the override, else the device pixels under the cap.
+* The resolution to draw at: the override, else the device pixels under the cap at the render scale.
 *
 * @param state - The resolution state of the host.
 * @param state.dpr - Device pixels per CSS pixel.
 * @param state.cap - The cap of `maxResolution`.
 * @param state.override - The switch of `monitor.setResolution`, when set.
+* @param state.scale - The render scale of the adaptive frame rate.
 * @returns The target resolution.
 * @example
 * ```ts
-* targetResolution({ dpr: 2.81, cap: 2, override: undefined }); // 2
+* targetResolution({ dpr: 2.81, cap: 2, override: undefined, scale: 0.75 }); // 1.5
 * ```
 */
 function targetResolution(state) {
-	return state.override ?? Math.min(state.dpr, state.cap);
+	return state.override ?? Math.min(state.dpr, state.cap) * state.scale;
+}
+/**
+* Tells a phone: a coarse pointer and a short side of at most 820 CSS px, the rule `effects` reads for `phone: "auto"`.
+* False without a window.
+*
+* @returns True on a phone.
+*/
+function isPhone() {
+	if (typeof globalThis.matchMedia !== "function") return false;
+	return globalThis.matchMedia("(pointer: coarse)").matches && Math.min(globalThis.innerWidth, globalThis.innerHeight) <= PHONE_SIDE$1;
+}
+/**
+* The lowest render scale the adaptive frame rate may choose on this device: the floor of `adaptiveScale` where its
+* `devices` take this one, otherwise 1, none.
+*
+* @param config - The resolved plugin config.
+* @returns The floor; 1 allows no scale.
+*/
+function scaleFloorOf(config) {
+	const { adaptiveScale } = config;
+	if (adaptiveScale === false) return 1;
+	return adaptiveScale.devices === "all" || isPhone() ? adaptiveScale.floor : 1;
+}
+/**
+* Follows the render scale `time:rate` carries: remembers it and asks for the target with reason `"rate"`. The
+* override still wins.
+*
+* @param state - The host branch of the plugin state.
+* @param scale - The render scale the adaptive frame rate chose.
+* @returns True when a change is now pending.
+*/
+function followScale(state, scale) {
+	if (scale === state.resolution.scale) return false;
+	state.resolution.scale = scale;
+	return askResolution(state, targetResolution(state.resolution), "rate");
+}
+/**
+* Lets the adaptive frame rate step the render scale down to the floor of this device, or to none while the override
+* holds, and takes the scale it answers: a scale it withdrew is 1 again.
+*
+* @param ctx - Domain context of the renderer plugin.
+*/
+function allowRuleScale(ctx) {
+	const { resolution } = ctx.state.host;
+	const floor = resolution.override === void 0 ? resolution.floor : 1;
+	resolution.scale = ctx.deps.time.allowScale(floor).scale;
 }
 /**
 * The one mechanism: remembers a resolution for the next frame. Nothing is applied here. While no
@@ -13461,7 +14157,8 @@ function createPoolState() {
 /**
 * Creates the initial host state: no Pixi, no application, nothing drawn, nothing listening, no
 * counting, no bitmap text pipe and no render-group pipe installed, the resolution of a page without a window (device
-* pixels 1, cap 2, no override, nothing pending), no own GPU, no kept picture and no pool trim yet.
+* pixels 1, cap 2, no override, nothing pending, the whole scale, no scale allowed yet), no own GPU, no kept picture
+* and no pool trim yet.
 *
 * @returns The host branch of the plugin state.
 */
@@ -13483,11 +14180,14 @@ function createHostState() {
 		uninstallPasses: void 0,
 		uninstallSdfText: void 0,
 		uninstallRenderGroup: void 0,
+		uninstallRenderPass: void 0,
 		resolution: {
 			dpr: 1,
 			cap: 2,
 			override: void 0,
-			pending: void 0
+			pending: void 0,
+			scale: 1,
+			floor: 1
 		},
 		onResolutionChange: [],
 		ownGpu: void 0,
@@ -13604,11 +14304,42 @@ function installRenderGroup(ctx, pixi) {
 	}
 }
 /**
+* Swaps Pixi's WebGPU render target and pipeline systems for the renderer's, which begin the canvas's render pass at
+* its first draw and keep the canvas's stencil and depth only where something reads them (B3). Like the batched text it
+* runs before `new Application()`, once per host state, in every build. A Pixi without the pieces draws on with its own
+* systems, with a warning.
+*
+* @param ctx - Domain context of the renderer plugin.
+* @param pixi - The module the application is built from.
+*/
+function installRenderPass(ctx, pixi) {
+	const state = ctx.state.host;
+	if (state.uninstallRenderPass !== void 0) return;
+	try {
+		state.uninstallRenderPass = installLazyCanvasPass(pixi);
+	} catch (error) {
+		ctx.log.warn("renderer: the canvas pass begins at render start", { error });
+	}
+}
+/**
+* Tells whether a feature brings a filter that reads what was drawn under its view (`defineFilter({ backdrop: true })`).
+* Pixi's WebGL renderer copies that from its back buffer, and skips such a filter, with a warning, without one; the back
+* buffer costs a full-screen copy per drawn frame, so it is asked for only then. WebGPU copies from the canvas and
+* ignores the option.
+*
+* @param features - Every feature of the game, its sub-features included.
+* @returns True when one of their filters is a backdrop.
+*/
+function wantsBackBuffer(features) {
+	for (const feature of features) for (const entry of feature.description.filters ?? []) if ("backdrop" in entry.filter && entry.filter.backdrop === true) return true;
+	return false;
+}
+/**
 * Loads Pixi once, creates the application and appends its canvas, at the target resolution of
 * now: a restore after a lost device comes back at it, override included. Pixi picks WebGL by
 * itself when WebGPU is missing, so only a device with neither ends up in the catch of the
 * caller. An agent build marks the Pixi load and the init on the page's timeline and hands Pixi
-* the engine's own device.
+* the engine's own device. A game with a backdrop filter gets Pixi's WebGL back buffer.
 *
 * @param ctx - Domain context of the renderer plugin.
 * @param mount - Where the canvas goes.
@@ -13625,6 +14356,7 @@ async function createApplication(ctx, mount, deps) {
 	installTextBatch(ctx, pixi);
 	installCounting$1(ctx, pixi, deps);
 	installRenderGroup(ctx, pixi);
+	installRenderPass(ctx, pixi);
 	state.resolution.dpr = devicePixels();
 	state.resolution.cap = ctx.config.maxResolution;
 	state.resolution.pending = void 0;
@@ -13636,7 +14368,8 @@ async function createApplication(ctx, mount, deps) {
 		resolution: targetResolution(state.resolution),
 		autoDensity: true,
 		autoStart: false,
-		sharedTicker: false
+		sharedTicker: false,
+		useBackBuffer: wantsBackBuffer(ctx.deps.flow.features.all())
 	};
 	await (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ ? initTimed(ctx, app, options) : app.init(options));
 	state.app = app;
@@ -13668,8 +14401,8 @@ function destroyApplication(state) {
 /**
 * Undoes everything `init` created. Works on the state alone, because `onStop` has no context.
 * `ready` drops first, so a device that goes away during the teardown is ignored. The draw
-* counter, the batched text and the render-group pipe swap Pixi's own classes back, so the next application on
-* the page starts from them. The pool trim starts over and its listeners go; Pixi's pool itself is left.
+* counter, the batched text, the render-group pipe and the lazy canvas pass swap Pixi's own classes back, so the next
+* application on the page starts from them. The pool trim starts over and its listeners go; Pixi's pool itself is left.
 *
 * @param state - The host branch of the plugin state.
 */
@@ -13687,6 +14420,8 @@ function stopHost(state) {
 	state.uninstallSdfText = void 0;
 	state.uninstallRenderGroup?.();
 	state.uninstallRenderGroup = void 0;
+	state.uninstallRenderPass?.();
+	state.uninstallRenderPass = void 0;
 	state.unsupported?.remove();
 	state.unsupported = void 0;
 	state.onReady.length = 0;
@@ -14199,6 +14934,7 @@ function createHostApi(ctx, deps) {
 		setResolution: (value, reason) => askResolution(state, value, reason),
 		overrideResolution: (value) => {
 			state.resolution.override = value;
+			allowRuleScale(ctx);
 			refreshResolution(ctx, "debug");
 			return targetResolution(state.resolution);
 		},
@@ -14256,6 +14992,8 @@ function createHostApi(ctx, deps) {
 			watchDevice(ctx, restart);
 			watchVisibility(ctx);
 			watchPixelRatio(ctx);
+			state.resolution.floor = scaleFloorOf(ctx.config);
+			allowRuleScale(ctx);
 			state.ready = true;
 			for (const fn of state.onReady) fn();
 		}
@@ -15357,7 +16095,7 @@ const BEFORE = {
 * @param resolution - The target's resolution.
 * @returns Texels per CSS px.
 */
-function resolutionOf(filter, resolution) {
+function resolutionOf$1(filter, resolution) {
 	const own = filter.resolution;
 	return own === "inherit" ? resolution : own;
 }
@@ -15377,7 +16115,7 @@ function readStack(slots, resolution, into) {
 		const filter = slots[index]?.filter;
 		if (filter === void 0 || !filter.enabled) continue;
 		enabled += 1;
-		rs = Math.min(rs, resolutionOf(filter, resolution));
+		rs = Math.min(rs, resolutionOf$1(filter, resolution));
 		padding += filter.padding;
 	}
 	into.enabled = enabled;
@@ -21697,7 +22435,7 @@ const NO_DETAIL = Object.freeze({});
 /** The fewest device pixels per CSS pixel `setResolution` draws at. */
 const MIN_RESOLUTION = .5;
 /** The most device pixels per CSS pixel `setResolution` draws at. */
-const MAX_RESOLUTION = 4;
+const MAX_RESOLUTION$1 = 4;
 /**
 * Message of a resolution `setResolution` refuses.
 *
@@ -21705,7 +22443,7 @@ const MAX_RESOLUTION = 4;
 * @returns The message.
 */
 function resolutionMessage(value) {
-	return `[game] renderer.monitor.setResolution(${String(value)}) needs a number from ${MIN_RESOLUTION} to ${MAX_RESOLUTION}.\n  Pass undefined to go back to maxResolution.`;
+	return `[game] renderer.monitor.setResolution(${String(value)}) needs a number from ${MIN_RESOLUTION} to ${MAX_RESOLUTION$1}.\n  Pass undefined to go back to maxResolution.`;
 }
 /**
 * Tells whether `setResolution` takes a value: a number from `MIN_RESOLUTION` to `MAX_RESOLUTION`, or `undefined` to
@@ -21719,7 +22457,7 @@ function resolutionMessage(value) {
 * ```
 */
 function takesResolution(value) {
-	return value === void 0 || typeof value === "number" && value >= MIN_RESOLUTION && value <= MAX_RESOLUTION;
+	return value === void 0 || typeof value === "number" && value >= MIN_RESOLUTION && value <= MAX_RESOLUTION$1;
 }
 /**
 * Creates the monitor module: the counters of the renderer, the capture of a frame, and the
@@ -29683,9 +30421,9 @@ function createRendererApi(ctx) {
 //#region src/plugins/renderer/handlers.ts
 /**
 * @file renderer plugin — the hooks: a pause hands the captures still waiting for a drawn frame
-* their picture, since no frame comes while the clock is paused, and trims Pixi's texture pool. In an agent build the
-* performance monitor also hears the pause stack, the flow path, the thermal readings and the
-* changes of the frame rate.
+* their picture, since no frame comes while the clock is paused, and trims Pixi's texture pool; a change of the frame
+* rate brings the render scale the adaptive rule chose. In an agent build the performance monitor also hears the pause
+* stack, the flow path, the thermal readings, the changes of the frame rate and of the scale.
 */
 /**
 * Creates the hooks of the renderer. `time` is resolved when a hook fires, not while this factory
@@ -29743,13 +30481,23 @@ function createHandlers$5(ctx) {
 			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) monitorOf().thermal(reading);
 		},
 		/**
-		* Writes a change of the frame rate as a `rate` event line, the payload as its detail. Agent
-		* builds only.
+		* Draws at the render scale the change carries from the next frame, in every build. An agent build writes the
+		* change as a `rate` event line, the payload as its detail, and a move of the scale as a `scale` line.
 		*
 		* @param change - The change `time:rate` carried.
 		*/
 		"time:rate": (change) => {
-			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) monitorOf().event("rate", change);
+			const from = ctx.state.host.resolution.scale;
+			followScale(ctx.state.host, change.scale);
+			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) {
+				monitorOf().event("rate", change);
+				if (change.scale !== from) monitorOf().event("scale", {
+					from,
+					to: change.scale,
+					reason: change.reason,
+					fps: change.to
+				});
+			}
 		}
 	};
 }
@@ -29974,12 +30722,28 @@ function checkPoolTrim(poolTrim) {
 	if (!isCount(aboveMb)) throw new Error(`[game] renderer.poolTrim.aboveMb is ${String(aboveMb)}.\n  Give the MiB the targets must grow by, 0 or more.`);
 }
 /**
+* Checks the adaptive render scale of the config: `false`, or a floor that is a step of the scale and the devices it
+* applies to.
+*
+* @param adaptiveScale - What the config holds.
+* @throws {Error} When it is neither `false` nor an object, the floor is not 1, 0.85, 0.75, 0.6 or 0.5, or the
+*   devices are neither `"phone"` nor `"all"`.
+*/
+function checkAdaptiveScale(adaptiveScale) {
+	if (adaptiveScale === false) return;
+	if (typeof adaptiveScale !== "object" || adaptiveScale === null) throw new Error(`[game] renderer.adaptiveScale is ${String(adaptiveScale)}.\n  Give { floor, devices } or false.`);
+	const floor = "floor" in adaptiveScale ? adaptiveScale.floor : void 0;
+	const devices = "devices" in adaptiveScale ? adaptiveScale.devices : void 0;
+	if (typeof floor !== "number" || !SCALE_STEPS.includes(floor)) throw new Error(`[game] renderer.adaptiveScale.floor is ${String(floor)}.\n  Give a step of the scale: 1, 0.85, 0.75, 0.6 or 0.5.`);
+	if (devices !== "phone" && devices !== "all") throw new Error(`[game] renderer.adaptiveScale.devices is ${String(devices)}.\n  Give "phone" or "all".`);
+}
+/**
 * Checks the numbers of the config a game can get wrong, at `createApp`, in every build: the
-* resolution cap, the pool trim, 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
+* and the probe draws of the warm-up.
 *
 * @param config - The resolved plugin config.
-* @throws {Error} When `maxResolution` is not a number above 0, `poolTrim` fails its check,
+* @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.
@@ -29989,6 +30753,7 @@ function checkConfig(config) {
 	const { budgetMs, frames } = config.monitor;
 	if (!Number.isFinite(maxResolution) || maxResolution <= 0) throw new Error(`[game] renderer.maxResolution is ${maxResolution}.\n  Give a number above 0.`);
 	checkPoolTrim(config.poolTrim);
+	checkAdaptiveScale(config.adaptiveScale);
 	if (budgetMs !== "rate" && !(Number.isFinite(budgetMs) && budgetMs > 0)) throw new Error(`[game] renderer.monitor.budgetMs is ${String(budgetMs)}.\n  Give the frame budget in milliseconds, or "rate" for one frame of the current rate.`);
 	if (!Number.isInteger(frames) || frames < RING_FRAMES.min || frames > RING_FRAMES.max) throw new Error(`[game] renderer.monitor.frames is ${frames}.\n  Give a whole number from 64 to 16384.`);
 	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.`);
@@ -30074,7 +30839,11 @@ const rendererPlugin = /*#__PURE__*/ createPlugin$1("renderer", {
 		},
 		onDemand: false,
 		keptMb: 64,
-		warm: 1
+		warm: 1,
+		adaptiveScale: {
+			floor: .75,
+			devices: "phone"
+		}
 	},
 	events: (register) => register.map({ "renderer:device-lost": "The GPU device or context was lost; the game is paused" }),
 	createState: createRendererState,
@@ -35880,7 +36649,7 @@ function leavingOf(previous, scene) {
 * Builds the scene in one synchronous block: the layers, then the projections only the old scene
 * lists out, then the list of the new scene in (a projection both list stays and takes its new
 * place), the new scene to the world's systems, then the list the scene names to `assets`, then
-* the frame loop out of its idle cap, and only then the event.
+* the frame loop out of its idle cap and the adaptive frame rate told of the new screen, and only then the event.
 *
 * @param ctx - Domain context of the plugin.
 * @param scene - The scene whose bundles are there.
@@ -35899,6 +36668,7 @@ function apply(ctx, scene, named) {
 	state.named = named;
 	ctx.deps.assets.sceneBundles(named);
 	ctx.deps.time.wake();
+	ctx.deps.time.sceneChanged();
 	ctx.emit("scenes:changed", {
 		from,
 		to: scene.id,
@@ -37645,96 +38415,6 @@ function createEffectsApi(ctx) {
 	};
 }
 //#endregion
-//#region src/plugins/effects/filters/glsl.ts
-/**
-* The head of every filter's GLSL. `#version 300 es` comes first, so Pixi compiles both stages
-* as GLSL ES 3.0 and the dev check compiles the same text; `highp` matches the `f32` of the WGSL
-* twin and the precision of the uniforms the vertex stage shares. Then the texture coordinate of
-* `defaultFilterVert`, the output, the input texture and the global filter uniforms as `vec4`.
-*/
-const GLSL_HEADER = `#version 300 es
-precision highp float;
-
-in vec2 vTextureCoord;
-out vec4 finalColor;
-
-uniform sampler2D uTexture;
-uniform vec4 uInputSize;
-uniform vec4 uInputPixel;
-uniform vec4 uInputClamp;
-uniform vec4 uOutputFrame;
-uniform vec4 uGlobalFrame;
-uniform vec4 uOutputTexture;
-
-`;
-/** The GLSL type of each uniform type: a number is a `float`, a colour or a tuple a vector. */
-const GLSL_TYPES = {
-	f32: "float",
-	"vec2<f32>": "vec2",
-	"vec3<f32>": "vec3",
-	"vec4<f32>": "vec4"
-};
-/**
-* One `uniform` line per uniform, in declaration order, under the bare names the group keys.
-* Nothing without uniforms.
-*
-* @param uniforms - The uniforms in declaration order.
-* @returns The GLSL lines, or `""`.
-* @example
-* ```ts
-* glslUniforms([{ name: "color", type: "vec3<f32>", form: "color", size: 3 }]); // "uniform vec3 color;\n\n"
-* ```
-*/
-function glslUniforms(uniforms) {
-	if (uniforms.length === 0) return "";
-	return `${uniforms.map((uniform) => `uniform ${GLSL_TYPES[uniform.type]} ${uniform.name};\n`).join("")}\n`;
-}
-/**
-* The engine's half of each input in GLSL: the texture, and the function that reads it at the body's uv, its scale
-* and its clamp applied. The two uniforms it reads are declared before it by `glslUniforms`. Nothing without inputs.
-*
-* @param inputs - The inputs in declaration order.
-* @returns The GLSL lines, or `""`.
-* @example
-* ```ts
-* glslInputs([blurInput]).startsWith("uniform sampler2D blurTexture;"); // true
-* ```
-*/
-function glslInputs(inputs) {
-	return inputs.map((input) => `uniform sampler2D ${input.texture};\n\nvec4 ${input.sample}(vec2 uv) {\n  return textureLod(${input.texture}, clamp(uv * uInputSize.xy * ${input.scale.name}, ${input.clamp.name}.xy, ${input.clamp.name}.zw), 0.0);\n}
-
-`).join("");
-}
-/** The GLSL twin of `canvasPixel(uv)`: the pixel's canvas position in CSS px (spec 23 P8.3). */
-const GLSL_CANVAS_PIXEL = `vec2 canvasPixel(vec2 uv) {
-  return uOutputFrame.xy + keptOrigin + uv * uInputSize.xy;
-}
-
-`;
-/**
-* The whole GLSL of a filter: the header, the uniforms (then the scale and the clamp of each input, then the
-* engine's `keptOrigin` of a body that calls `canvasPixel`), the inputs, the helper, the body.
-*
-* @param uniforms - The uniforms in declaration order.
-* @param inputs - The inputs in declaration order.
-* @param body - The fragment body the game wrote.
-* @param origin - The `keptOrigin` uniform, for a body that calls `canvasPixel`.
-* @returns The GLSL fragment source the `GlProgram` is built from.
-* @example
-* ```ts
-* assembleGlsl([], [], body).endsWith(body); // true
-* ```
-*/
-function assembleGlsl(uniforms, inputs, body, origin) {
-	const declared = glslUniforms([
-		...uniforms,
-		...inputs.flatMap((input) => [input.scale, input.clamp]),
-		...origin === void 0 ? [] : [origin]
-	]);
-	const helper = origin === void 0 ? "" : GLSL_CANVAS_PIXEL;
-	return `${GLSL_HEADER}${declared}${glslInputs(inputs)}${helper}${body}`;
-}
-//#endregion
 //#region src/plugins/effects/filters/wgsl.ts
 /**
 * The head of every filter shader: the global filter uniforms and the input texture and sampler
@@ -37811,30 +38491,165 @@ const CANVAS_PIXEL = `fn canvasPixel(uv: vec2<f32>) -> vec2<f32> {
   return gfu.uOutputFrame.xy + fu.keptOrigin + uv * gfu.uInputSize.xy;
 }
 
+`;
+/**
+* The engine's uniform a backdrop's `sampleBack` scales its uv by: one over the size of the back texture's backing,
+* CSS px. Filled by every apply from the texture Pixi copied.
+*/
+const BACK_SCALE = Object.freeze({
+	name: "backScale",
+	type: "vec2<f32>",
+	form: "vector",
+	size: 2
+});
+/** The engine's uniform a backdrop's `sampleBack` clamps to: half a texel inside the copied part of the back texture. */
+const BACK_CLAMP = Object.freeze({
+	name: "backClamp",
+	type: "vec4<f32>",
+	form: "vector",
+	size: 4
+});
+/**
+* What a backdrop's body reads what was drawn under its view through: the texture Pixi's filter system copies the
+* canvas into and binds at group 0 binding 3 (`Filter.blendRequired`), sampled at the body's uv with the engine's
+* scale and clamp, as an input is.
+*/
+const SAMPLE_BACK = `@group(0) @binding(3) var uBackTexture: texture_2d<f32>;
+
+fn sampleBack(uv: vec2<f32>) -> vec4<f32> {
+  return textureSampleLevel(uBackTexture, uSampler, clamp(uv * gfu.uInputSize.xy * fu.backScale, fu.backClamp.xy, fu.backClamp.zw), 0.0);
+}
+
 `;
 /**
 * The whole source of a filter: the header, the uniform struct (the uniforms, then the scale and the clamp of each
-* input, then the engine's `keptOrigin` of a body that calls `canvasPixel`), the input bindings, the helper, the
-* body. A body without the helper assembles byte-identically to one without the cache.
+* input, then a backdrop's back scale and clamp, then the engine's `keptOrigin` of a body that calls `canvasPixel`),
+* the input bindings, a backdrop's `sampleBack`, the `canvasPixel` helper, the body. A body without either helper
+* assembles byte-identically to one without the cache and without the backdrop.
 *
 * @param uniforms - The uniforms in declaration order.
 * @param inputs - The inputs in declaration order.
 * @param body - The fragment body the game wrote.
 * @param origin - The `keptOrigin` uniform, for a body that calls `canvasPixel`.
+* @param backdrop - True for a filter that reads what was drawn under its view.
 * @returns The WGSL source both stages are built from.
 * @example
 * ```ts
-* assemble([], [], body).endsWith(body); // true
+* assemble([], [], body, undefined, true).includes("fn sampleBack(uv: vec2<f32>) -> vec4<f32>"); // true
 * ```
 */
-function assemble(uniforms, inputs, body, origin) {
+function assemble(uniforms, inputs, body, origin, backdrop = false) {
 	const struct = uniformStruct([
 		...uniforms,
 		...inputs.flatMap((input) => [input.scale, input.clamp]),
+		...backdrop ? [BACK_SCALE, BACK_CLAMP] : [],
 		...origin === void 0 ? [] : [origin]
 	]);
+	const back = backdrop ? SAMPLE_BACK : "";
 	const helper = origin === void 0 ? "" : CANVAS_PIXEL;
-	return `${HEADER}${struct}${inputBindings(inputs)}${helper}${body}`;
+	return `${HEADER}${struct}${inputBindings(inputs)}${back}${helper}${body}`;
+}
+//#endregion
+//#region src/plugins/effects/filters/glsl.ts
+/**
+* The head of every filter's GLSL. `#version 300 es` comes first, so Pixi compiles both stages
+* as GLSL ES 3.0 and the dev check compiles the same text; `highp` matches the `f32` of the WGSL
+* twin and the precision of the uniforms the vertex stage shares. Then the texture coordinate of
+* `defaultFilterVert`, the output, the input texture and the global filter uniforms as `vec4`.
+*/
+const GLSL_HEADER = `#version 300 es
+precision highp float;
+
+in vec2 vTextureCoord;
+out vec4 finalColor;
+
+uniform sampler2D uTexture;
+uniform vec4 uInputSize;
+uniform vec4 uInputPixel;
+uniform vec4 uInputClamp;
+uniform vec4 uOutputFrame;
+uniform vec4 uGlobalFrame;
+uniform vec4 uOutputTexture;
+
+`;
+/** The GLSL type of each uniform type: a number is a `float`, a colour or a tuple a vector. */
+const GLSL_TYPES = {
+	f32: "float",
+	"vec2<f32>": "vec2",
+	"vec3<f32>": "vec3",
+	"vec4<f32>": "vec4"
+};
+/**
+* One `uniform` line per uniform, in declaration order, under the bare names the group keys.
+* Nothing without uniforms.
+*
+* @param uniforms - The uniforms in declaration order.
+* @returns The GLSL lines, or `""`.
+* @example
+* ```ts
+* glslUniforms([{ name: "color", type: "vec3<f32>", form: "color", size: 3 }]); // "uniform vec3 color;\n\n"
+* ```
+*/
+function glslUniforms(uniforms) {
+	if (uniforms.length === 0) return "";
+	return `${uniforms.map((uniform) => `uniform ${GLSL_TYPES[uniform.type]} ${uniform.name};\n`).join("")}\n`;
+}
+/**
+* The engine's half of each input in GLSL: the texture, and the function that reads it at the body's uv, its scale
+* and its clamp applied. The two uniforms it reads are declared before it by `glslUniforms`. Nothing without inputs.
+*
+* @param inputs - The inputs in declaration order.
+* @returns The GLSL lines, or `""`.
+* @example
+* ```ts
+* glslInputs([blurInput]).startsWith("uniform sampler2D blurTexture;"); // true
+* ```
+*/
+function glslInputs(inputs) {
+	return inputs.map((input) => `uniform sampler2D ${input.texture};\n\nvec4 ${input.sample}(vec2 uv) {\n  return textureLod(${input.texture}, clamp(uv * uInputSize.xy * ${input.scale.name}, ${input.clamp.name}.xy, ${input.clamp.name}.zw), 0.0);\n}
+
+`).join("");
+}
+/** The GLSL twin of `canvasPixel(uv)`: the pixel's canvas position in CSS px (spec 23 P8.3). */
+const GLSL_CANVAS_PIXEL = `vec2 canvasPixel(vec2 uv) {
+  return uOutputFrame.xy + keptOrigin + uv * uInputSize.xy;
+}
+
+`;
+/** The GLSL twin of `sampleBack(uv)`: what was drawn under the view, at the body's uv, scaled and clamped. */
+const GLSL_SAMPLE_BACK = `uniform sampler2D uBackTexture;
+
+vec4 sampleBack(vec2 uv) {
+  return textureLod(uBackTexture, clamp(uv * uInputSize.xy * backScale, backClamp.xy, backClamp.zw), 0.0);
+}
+
+`;
+/**
+* The whole GLSL of a filter: the header, the uniforms (then the scale and the clamp of each input, then a backdrop's
+* back scale and clamp, then the engine's `keptOrigin` of a body that calls `canvasPixel`), the inputs, a backdrop's
+* `sampleBack`, the `canvasPixel` helper, the body.
+*
+* @param uniforms - The uniforms in declaration order.
+* @param inputs - The inputs in declaration order.
+* @param body - The fragment body the game wrote.
+* @param origin - The `keptOrigin` uniform, for a body that calls `canvasPixel`.
+* @param backdrop - True for a filter that reads what was drawn under its view.
+* @returns The GLSL fragment source the `GlProgram` is built from.
+* @example
+* ```ts
+* assembleGlsl([], [], body, undefined, true).includes("uniform sampler2D uBackTexture;"); // true
+* ```
+*/
+function assembleGlsl(uniforms, inputs, body, origin, backdrop = false) {
+	const declared = glslUniforms([
+		...uniforms,
+		...inputs.flatMap((input) => [input.scale, input.clamp]),
+		...backdrop ? [BACK_SCALE, BACK_CLAMP] : [],
+		...origin === void 0 ? [] : [origin]
+	]);
+	const back = backdrop ? GLSL_SAMPLE_BACK : "";
+	const helper = origin === void 0 ? "" : GLSL_CANVAS_PIXEL;
+	return `${GLSL_HEADER}${declared}${glslInputs(inputs)}${back}${helper}${body}`;
 }
 //#endregion
 //#region src/plugins/effects/filters/define.ts
@@ -37859,9 +38674,10 @@ const MAIN_GLSL = /\bvoid\s+main\s*\(/;
 /**
 * Names a uniform cannot take: the two fields every filter component carries, and the names the
 * shader headers declare, which a game uniform would clash with (on WebGL only, for most). The
-* GLSL header also declares `finalColor` and `vTextureCoord`.
+* GLSL header also declares `finalColor` and `vTextureCoord`; a backdrop's, `uBackTexture`,
+* `backScale`, `backClamp` and `sampleBack`.
 */
-const RESERVED_NAME = /^(?:enabled|order|uInputSize|uInputPixel|uInputClamp|uOutputFrame|uGlobalFrame|uOutputTexture|uTexture|uSampler|finalColor|vTextureCoord|keptOrigin|canvasPixel)$/;
+const RESERVED_NAME = /^(?:enabled|order|uInputSize|uInputPixel|uInputClamp|uOutputFrame|uGlobalFrame|uOutputTexture|uTexture|uSampler|finalColor|vTextureCoord|keptOrigin|canvasPixel|uBackTexture|backScale|backClamp|sampleBack)$/;
 /**
 * What a body reads of the screen: the root target's frame, the fragment position, the output target's size, the
 * origin of the output frame (its size `.zw` is the same in a picture and live).
@@ -37945,21 +38761,22 @@ function worstOf(a, b) {
 }
 /**
 * What the kept-picture cache may do with a filter, from what the game declared and what its bodies read only, never
-* the engine's header (LEAD-FIXES-4 item 3): `cache: false` is `"screen"`; a body that reads the screen and declares
-* nothing is `"screen"` too (the safe direction); a body that calls `canvasPixel` is `"placed"`, as is
-* `cache: "placed"`; everything else is `"local"`.
+* the engine's header (LEAD-FIXES-4 item 3): a backdrop and `cache: false` are `"screen"`; a body that reads the
+* screen and declares nothing is `"screen"` too (the safe direction); a body that calls `canvasPixel` is `"placed"`,
+* as is `cache: "placed"`; everything else is `"local"`.
 *
 * @param wgsl - The WGSL body.
 * @param glsl - The GLSL body.
 * @param cache - What the game declared.
+* @param backdrop - Whether the filter reads what was drawn under its view.
 * @returns The category.
 * @example
 * ```ts
-* cacheOf("let p = gfu.uOutputFrame.xy + uv * gfu.uInputSize.xy;", "", undefined); // "screen"
+* cacheOf("let p = gfu.uOutputFrame.xy + uv * gfu.uInputSize.xy;", "", undefined, false); // "screen"
 * ```
 */
-function cacheOf(wgsl, glsl, cache) {
-	if (cache === false) return "screen";
+function cacheOf(wgsl, glsl, cache, backdrop) {
+	if (cache === false || backdrop) return "screen";
 	if (cache === void 0 && (readsScreenIn(wgsl) || readsScreenIn(glsl))) return "screen";
 	if (cache === "placed" || callsCanvasPixel(wgsl, glsl)) return "placed";
 	return "local";
@@ -38013,6 +38830,61 @@ function readArea(id, area) {
 	return area;
 }
 /**
+* Reads the declared resolution: texels per CSS px, or 0 for the canvas's. A JavaScript caller may pass anything.
+*
+* @param id - The filter id.
+* @param resolution - What the game declared.
+* @returns The resolution; 0 when it was left out.
+* @throws {Error} When it is given and is not a number from 0 to `MAX_RESOLUTION`.
+*/
+function readResolution(id, resolution) {
+	if (resolution === void 0) return 0;
+	if (typeof resolution === "number" && resolution >= 0 && resolution <= 4) return resolution;
+	throw new Error(`[game] Filter "${id}": resolution must be from 0 to 4, 0 for the resolution of the canvas.\n  Got ${String(resolution)}.`);
+}
+/**
+* Reads the declared backdrop switch: `true`, `false` or left out. A JavaScript caller may pass anything.
+*
+* @param id - The filter id.
+* @param backdrop - What the game declared.
+* @returns True for a backdrop.
+* @throws {Error} When it is given and is not a boolean.
+*/
+function readBackdrop(id, backdrop) {
+	if (backdrop === void 0 || typeof backdrop === "boolean") return backdrop === true;
+	throw new Error(`[game] Filter "${id}": backdrop must be true or false.\n  Got ${JSON.stringify(backdrop)}.`);
+}
+/**
+* Refuses what a backdrop cannot have: a padding (Pixi copies the canvas under the padded box, and a copy past the
+* canvas edge fails on the GPU) and a cache that keeps it (what is under it changes without it).
+*
+* @param id - The filter id.
+* @param padding - The padding as declared, `0` when left out.
+* @param cache - The cache as declared.
+* @throws {Error} When the padding is not 0 or the cache keeps it.
+*/
+function checkBackdrop(id, padding, cache) {
+	if (padding !== 0) throw new Error(`[game] Filter "${id}" is a backdrop: its padding must be 0.\n  Pixi copies the canvas under the padded box, and a copy past the canvas edge fails: leave padding out.`);
+	if (cache === "local" || cache === "placed") throw new Error(`[game] Filter "${id}" is a backdrop: it reads what is drawn under its view, so it is drawn live in every frame.\n  Leave cache out, or set it to false.`);
+}
+/**
+* Reads where an input's first step reads: the view's own input (the default) or, for a backdrop, what was drawn under
+* the view. A JavaScript caller may pass anything.
+*
+* @param id - The filter id.
+* @param name - The input name.
+* @param from - What the game declared.
+* @param backdrop - Whether the filter is a backdrop.
+* @returns `"input"` or `"back"`.
+* @throws {Error} When it is neither, or `"back"` on a filter that is no backdrop.
+*/
+function readFrom(id, name, from, backdrop) {
+	if (from === void 0 || from === "input") return "input";
+	if (from !== "back") throw new Error(`[game] Filter "${id}": input "${name}" starts from ${JSON.stringify(from)}.\n  Write from: "input" or from: "back".`);
+	if (!backdrop) throw new Error(`[game] Filter "${id}": input "${name}" starts from "back", which only a backdrop filter can read.\n  Give the filter backdrop: true.`);
+	return "back";
+}
+/**
 * Tells whether a value is a list of 2 to 4 finite numbers.
 *
 * @param value - A uniform declaration.
@@ -38193,21 +39065,23 @@ function readStages(id, name, stages) {
 	for (const [index, stage] of stages.entries()) {
 		if (!isDefinedFilter(stage)) throw new Error(`[game] Filter "${id}": stage ${index} of input "${name}" is not a filter made by defineFilter.\n  List what defineFilter returned; a built-in kind cannot be a stage.`);
 		if (!drawsAlone(stage.filter)) throw new Error(`[game] Filter "${id}": stage "${stage.filter.id}" of input "${name}" has inputs or a fallback of its own.\n  A stage draws alone: give it neither.`);
+		if (stage.filter.backdrop) throw new Error(`[game] Filter "${id}": stage "${stage.filter.id}" of input "${name}" is a backdrop.\n  A stage reads the step before it: give it no backdrop.`);
 		if (!read.includes(stage)) read.push(stage);
 	}
 	return Object.freeze(read);
 }
 /**
-* Reads the inputs of a definition: the names the engine declares for each, its two uniforms, its
-* stages and its chain.
+* Reads the inputs of a definition: the names the engine declares for each, where its first step reads, its two
+* uniforms, its stages and its chain.
 *
 * @param id - The filter id.
 * @param declared - What the game declared under `inputs`.
 * @param uniforms - The read uniforms.
+* @param backdrop - Whether the filter is a backdrop: only then may an input start from back.
 * @returns The inputs in declaration order, frozen; empty without `inputs`.
 * @throws {Error} When `inputs` is not an object, has more than four entries, or an input breaks one of its rules.
 */
-function readInputs(id, declared, uniforms) {
+function readInputs(id, declared, uniforms, backdrop) {
 	if (declared === void 0) return Object.freeze([]);
 	if (typeof declared !== "object" || declared === null || Array.isArray(declared)) throw new Error(`[game] Filter "${id}": inputs must be an object of named inputs.\n  Write inputs: { blur: { stages: [...], chain } }.`);
 	const entries = Object.entries(declared);
@@ -38215,10 +39089,12 @@ function readInputs(id, declared, uniforms) {
 	const taken = /* @__PURE__ */ new Set();
 	return Object.freeze(entries.map(([name, input]) => {
 		const names = checkInputNames(id, name, uniforms, taken);
+		const from = readFrom(id, name, input.from, backdrop);
 		const stages = readStages(id, name, input.stages);
 		if (typeof input.chain !== "function") throw new TypeError(`[game] Filter "${id}": input "${name}" needs a chain.\n  Write chain: (value, { resolution }) => [{ stage, scale }].`);
 		return Object.freeze({
 			name,
+			from,
 			texture: names.texture,
 			sampler: names.sampler,
 			scale: Object.freeze({
@@ -38241,21 +39117,23 @@ function readInputs(id, declared, uniforms) {
 }
 /**
 * Reads the fallback of a definition: another filter of ours, drawing alone, over a subset of its
-* uniforms with the same types.
+* uniforms with the same types; a backdrop only for a backdrop, which it draws in place of on the same view.
 *
 * @param id - The filter id.
 * @param fallback - What the game declared under `fallback`.
 * @param uniforms - The read uniforms.
+* @param backdrop - Whether the filter is a backdrop.
 * @returns The fallback's definition, or `undefined` without one.
-* @throws {Error} When it is no filter of ours, has the same id, has inputs or a fallback, or a uniform of it is not
-*   one of this filter's with the same type.
+* @throws {Error} When it is no filter of ours, has the same id, has inputs or a fallback, a uniform of it is not
+*   one of this filter's with the same type, or it is a backdrop and the filter is not.
 */
-function readFallback(id, fallback, uniforms) {
+function readFallback(id, fallback, uniforms, backdrop) {
 	if (fallback === void 0) return void 0;
 	if (!isDefinedFilter(fallback)) throw new Error(`[game] Filter "${id}": fallback is not a filter made by defineFilter.\n  Pass what defineFilter returned.`);
 	const definition = fallback.filter;
 	if (definition.id === id) throw new Error(`[game] Filter "${id}": its fallback has the same id.\n  Give the fallback an id of its own.`);
 	if (!drawsAlone(definition)) throw new Error(`[game] Filter "${id}": its fallback "${definition.id}" has inputs or a fallback of its own.\n  A fallback draws alone and simply: give it neither.`);
+	if (definition.backdrop && !backdrop) throw new Error(`[game] Filter "${id}": its fallback "${definition.id}" is a backdrop, and "${id}" is not.\n  A fallback draws in its place on the same view: give it no backdrop, or make "${id}" a backdrop too.`);
 	for (const uniform of definition.uniforms) {
 		const own = uniforms.find((candidate) => candidate.name === uniform.name);
 		if (!(own?.type === uniform.type && own.form === uniform.form)) throw new Error(`[game] Filter "${id}": its fallback "${definition.id}" declares "${uniform.name}", which "${id}" ${own === void 0 ? "does not declare" : "declares as another type"}.\n  A fallback draws with the value of ${id}: use a subset of its uniforms.`);
@@ -38303,18 +39181,22 @@ function cacheWithInputs(cache, inputs) {
 * `enabled: true` and `order: 0`. An input `blur` gives the body `sampleBlur(uv)`: the last texture
 * of its chain, read at the body's `uv`. A `fallback` draws instead when the filter is broken.
 * An `area` answers, from the value, the rectangle in the entity's own units outside of which the
-* filter draws nothing: Pixi then renders and fills only that box, not the view's bounds.
-* Register it through the `filters` key of a feature. The README shows a filter with a blur input
-* and one with an `area`.
+* filter draws nothing: Pixi then renders and fills only that box, not the view's bounds. A
+* `resolution` draws the view and its filters at that many texels per CSS px instead of the
+* canvas's. A `backdrop` reads what was drawn under its view inside that box: the body calls
+* `sampleBack(uv)`, and an input may start `from: "back"`; it is drawn live in every frame.
+* Register it through the `filters` key of a feature. The README shows a filter with a blur input,
+* one with an `area` and a backdrop.
 *
 * @param id - The filter id, also the component name; unique, and not one of the built-ins.
 * @param spec - Both bodies, the uniforms, the passes one apply costs, the padding, the inputs, the fallback, the
-*   cache category and the area.
+*   cache category, the area, the resolution and the backdrop switch.
 * @returns The component type, with the frozen `filter` definition attached.
 * @throws {Error} When the id is empty, the WGSL has no `mainFragment`, the GLSL no `void main(`,
 *   a uniform is reserved, badly named or of no known form, the passes or the padding break
 *   their rules, an input or the fallback breaks one of its rules, `passes` is given with inputs,
-*   or `area` is not a function.
+*   `area` is not a function, `resolution` is not a number from 0 to 4, `backdrop` is not a
+*   boolean, or a backdrop has a padding or a cache that keeps it.
 * @example
 * ```ts
 * // features/board/effects.ts: a gold tint a motion hook tweens on a merge, on WebGPU and WebGL.
@@ -38328,20 +39210,23 @@ function defineFilter(id, spec) {
 	readSpec(id, spec);
 	const read = Object.entries(spec.uniforms ?? {}).map(([name, declaration]) => readUniform(id, name, declaration));
 	const uniforms = Object.freeze(read.map((entry) => entry.spec));
-	const inputs = readInputs(id, spec.inputs, uniforms);
+	const backdrop = readBackdrop(id, spec.backdrop);
+	const inputs = readInputs(id, spec.inputs, uniforms, backdrop);
 	if (spec.inputs !== void 0 && spec.passes !== void 0) throw new Error(`[game] Filter "${id}": passes is counted by the engine for a filter with inputs.\n  Leave passes out.`);
-	const fallback = readFallback(id, spec.fallback, uniforms);
+	const fallback = readFallback(id, spec.fallback, uniforms, backdrop);
 	const passes = spec.passes ?? 1;
 	const padding = spec.padding ?? 0;
 	checkCost(id, passes, padding, uniforms);
 	checkCache(id, spec.cache);
+	if (backdrop) checkBackdrop(id, padding, spec.cache);
 	const area = readArea(id, spec.area);
+	const resolution = readResolution(id, spec.resolution);
 	const origin = callsCanvasPixel(spec.wgsl, spec.glsl) ? KEPT_ORIGIN : void 0;
-	const cache = cacheWithInputs(cacheOf(spec.wgsl, spec.glsl, spec.cache), inputs);
+	const cache = cacheWithInputs(cacheOf(spec.wgsl, spec.glsl, spec.cache, backdrop), inputs);
 	const filter = Object.freeze({
 		id,
-		source: assemble(uniforms, inputs, spec.wgsl, origin),
-		glsl: assembleGlsl(uniforms, inputs, spec.glsl, origin),
+		source: assemble(uniforms, inputs, spec.wgsl, origin, backdrop),
+		glsl: assembleGlsl(uniforms, inputs, spec.glsl, origin, backdrop),
 		uniforms,
 		passes,
 		padding,
@@ -38349,9 +39234,11 @@ function defineFilter(id, spec) {
 		fallback,
 		cache,
 		origin,
+		resolution,
+		backdrop,
 		...area === void 0 ? {} : { area }
 	});
-	if (spec.cache !== false && (readsScreenIn(spec.wgsl) || readsScreenIn(spec.glsl))) screenReaders.add(filter);
+	if (!backdrop && spec.cache !== false && (readsScreenIn(spec.wgsl) || readsScreenIn(spec.glsl))) screenReaders.add(filter);
 	const defaults = Object.fromEntries([
 		...read.map((entry) => [entry.spec.name, entry.value]),
 		["enabled", true],
@@ -38569,6 +39456,7 @@ const displacementDefaults = {
 };
 const alphaDefaults = {
 	alpha: 1,
+	resolution: 0,
 	enabled: true,
 	order: 0
 };
@@ -38665,11 +39553,16 @@ const Noise = /*#__PURE__*/ component("effects.noise", noiseDefaults);
 const Displacement = /*#__PURE__*/ component("effects.displacement", displacementDefaults);
 /**
 * Pixi's alpha over a view and its subtree as one layer, so overlapping children do not show
-* through each other.
+* through each other. `resolution: 0` draws at the resolution of the canvas; a number draws the
+* subtree at that many texels per CSS px, at most 4, and every other filter of the view with it
+* (Pixi's smallest resolution wins). At `alpha: 1` and `resolution: 0` the filter is switched off
+* after 8 frames there: it would copy the subtree unchanged through a pass of its own, and a
+* keyframe that only touches 1 switches nothing. One render pass per apply.
 *
 * @example
 * ```ts
-* Alpha({ alpha: 0.5 }).value; // { alpha: 0.5, enabled: true, order: 0 }
+* // The fog of a memory screen, drawn at half a texel per CSS px through one pass.
+* Alpha({ resolution: 0.5 }).value; // { alpha: 1, resolution: 0.5, enabled: true, order: 0 }
 * ```
 */
 const Alpha = /*#__PURE__*/ component("effects.alpha", alphaDefaults);
@@ -38794,6 +39687,22 @@ function brokenMark() {
 //#endregion
 //#region src/plugins/effects/filters/instance.ts
 /**
+* @file effects/filters — the only file that builds, writes and destroys Pixi filters. Ours: a
+* `Filter` over a `GpuProgram` of the assembled WGSL and a `GlProgram` of the assembled GLSL, with
+* one `UniformGroup` both read. The Pixi-core kinds: their own class, written through their setters
+* when a field differs from what they were last given. Every kind but `Blur` renders at
+* `resolution: "inherit"`, the resolution of the canvas, so a filtered view stays sharp on DPR 2-3
+* (decision 32), unless its value (`Alpha`) or its definition (`defineFilter`) gives a resolution of
+* its own. An `Alpha` at 1 drawn at the canvas's is switched off once it rested there: it would copy
+* the view unchanged through a pass. Every write compares first: a value the filter holds already writes nothing and
+* asks the renderer for no frame. A destroy frees the uniform buffers first: `Filter.destroy()`
+* leaves them to a GC that runs after a minute (P10). A filter with inputs draws each place of its
+* chains through Pixi's public `applyFilter` from inside its own `apply`, into pooled textures given
+* back in a `finally`; a stand-in draws in place of a broken kind or instance. A backdrop is built
+* with Pixi's `blendRequired`: Pixi copies the canvas under the view before it draws, and the apply
+* places `sampleBack` on that copy (`activeBackTexture`) and starts the chains `from: "back"` there.
+*/
+/**
 * The resolution of every filter but `Blur`: the render target's, so a filter draws at the
 * resolution of the canvas. Pixi's default of 1 would draw it at half the pixels on DPR 2.
 */
@@ -38808,6 +39717,20 @@ const PROBE_VALUE = Object.freeze({
 /** The numbers of a vector field that holds none. */
 const NO_NUMBERS = Object.freeze([]);
 /**
+* The resolution Pixi is given for a resolution of a value or a definition: the number, at most `MAX_RESOLUTION`, or
+* the canvas's for 0 (or less, or not a number).
+*
+* @param resolution - Texels per CSS px; 0 for the canvas's.
+* @returns What a filter's `resolution` takes.
+* @example
+* ```ts
+* resolutionOf(50); // 4
+* ```
+*/
+function resolutionOf(resolution) {
+	return resolution > 0 ? Math.min(resolution, 4) : CANVAS_RESOLUTION;
+}
+/**
 * Tells whether two numbers are the same value for the GPU: equal, or both NaN.
 *
 * @param a - One number.
@@ -38950,11 +39873,21 @@ function createOurs(pixi, definition, value) {
 			type: input.clamp.type
 		};
 	}
+	if (definition.backdrop) {
+		structures[BACK_SCALE.name] = {
+			value: new Float32Array(BACK_SCALE.size),
+			type: BACK_SCALE.type
+		};
+		structures[BACK_CLAMP.name] = {
+			value: new Float32Array(BACK_CLAMP.size),
+			type: BACK_CLAMP.type
+		};
+	}
 	if (definition.origin !== void 0) structures[definition.origin.name] = {
 		value: new Float32Array(definition.origin.size),
 		type: definition.origin.type
 	};
-	const group = definition.uniforms.length > 0 || definition.inputs.length > 0 || definition.origin !== void 0 ? new pixi.UniformGroup(structures) : void 0;
+	const group = definition.uniforms.length > 0 || definition.inputs.length > 0 || definition.backdrop || definition.origin !== void 0 ? new pixi.UniformGroup(structures) : void 0;
 	const resources = group === void 0 ? {} : { fu: group };
 	const empty = pixi.Texture.EMPTY.source;
 	for (const input of definition.inputs) {
@@ -38968,7 +39901,8 @@ function createOurs(pixi, definition, value) {
 			glProgram,
 			resources,
 			padding: paddingOf$1(definition, value),
-			resolution: CANVAS_RESOLUTION
+			resolution: resolutionOf(definition.resolution),
+			blendRequired: definition.backdrop
 		}),
 		group,
 		definition,
@@ -39010,6 +39944,43 @@ function blurResolution(ectx, value) {
 	return ectx.state.phone ? ectx.config.blur.phoneResolution : 1;
 }
 /**
+* Tells whether an `Alpha` value draws its view unchanged: switched on, at alpha 1, at the canvas's resolution. Its
+* filter would copy the view through a pass of its own. The fields are read by name: a fade reads them every frame.
+*
+* @param value - The stored `Alpha` value.
+* @returns True when the filter may be switched off.
+* @example
+* ```ts
+* drawsUnchanged({ enabled: true, order: 0, alpha: 1, resolution: 0 }); // true
+* ```
+*/
+function drawsUnchanged(value) {
+	const { alpha, resolution } = value;
+	return value.enabled && alpha === 1 && !(typeof resolution === "number" && resolution > 0);
+}
+/**
+* The `enabled` switch of an instance for the stored value of this sync: the value's own, at once, but an `Alpha` that
+* draws its view unchanged is switched off only at its `CALM_AFTER`-th sync in a row so while its filter is on, counted
+* in `calm`: keyframes that touch 1 keep the pass and switch nothing, a fade that ends at 1 lets it go. The filter
+* sync syncs the view again while `calm` counts.
+*
+* @param instance - The instance.
+* @param value - The stored filter value.
+* @returns True when Pixi is to draw the filter.
+*/
+function switchOf(instance, value) {
+	if (instance.kind !== "alpha") return value.enabled;
+	if (!drawsUnchanged(value)) {
+		instance.calm = 0;
+		return value.enabled;
+	}
+	if (!instance.filter.enabled) return false;
+	instance.calm += 1;
+	if (instance.calm < 8) return true;
+	instance.calm = 0;
+	return false;
+}
+/**
 * Composes a colour matrix from the identity: brightness, saturation, contrast, hue, and the
 * grayscale as a negative saturation. `ColorMatrixFilter` multiplies, so it starts from `reset()`.
 *
@@ -39151,10 +40122,11 @@ function createCore(ectx, pixi, core, value, probeMap) {
 			kind: "alpha",
 			filter: new pixi.AlphaFilter({
 				alpha: numberOf$1(value, "alpha"),
-				resolution: CANVAS_RESOLUTION
+				resolution: resolutionOf(numberOf$1(value, "resolution"))
 			}),
 			...appliedOf(value),
-			passes: 1
+			passes: 1,
+			calm: 0
 		};
 	}
 }
@@ -39176,7 +40148,7 @@ function createCore(ectx, pixi, core, value, probeMap) {
 function createFilter(ectx, pixi, kind, value, probeMap) {
 	const body = kind.source === "wgsl" ? createOurs(pixi, kind.definition, value) : createCore(ectx, pixi, kind.core, value, probeMap);
 	if (body === void 0) return void 0;
-	body.filter.enabled = value.enabled;
+	body.filter.enabled = value.enabled && !(body.kind === "alpha" && drawsUnchanged(value));
 	if (body.kind === "wgsl") body.areaStale = body.definition.area !== void 0;
 	const instance = Object.assign(body, {
 		order: value.order,
@@ -39189,10 +40161,85 @@ function createFilter(ectx, pixi, kind, value, probeMap) {
 		entity: 0
 	});
 	if (instance.kind === "wgsl" && instance.definition.inputs.length > 0) wireInputs(ectx, pixi, instance);
+	else if (instance.kind === "wgsl" && instance.definition.backdrop) wireBack(pixi, instance);
 	guardApply(ectx, instance, kind);
 	return instance;
 }
 /**
+* What was drawn under the view of the running apply: the texture Pixi's filter system copied the canvas under the
+* view's box into, or its empty texture outside a backdrop's pop.
+*
+* @param pixi - The module the renderer loaded.
+* @param manager - Pixi's filter system, inside an apply.
+* @returns The back texture.
+*/
+function backOf(pixi, manager) {
+	return manager.activeBackTexture ?? pixi.Texture.EMPTY;
+}
+/**
+* Writes the scale and the clamp that place a sample of the body's uv on a texture: one over the size of its backing,
+* and half a texel inside the part of it its frame covers, rounded to float32. Written only where a value differs, so
+* Pixi's bind group stays cached; no array is allocated.
+*
+* @param uniforms - The values of the uniform group.
+* @param scaleName - The `vec2` scale uniform.
+* @param clampName - The `vec4` clamp uniform.
+* @param texture - The texture the body samples through them.
+*/
+function writePlacement(uniforms, scaleName, clampName, texture) {
+	const { source } = texture;
+	const scale = uniforms[scaleName];
+	const clamp = uniforms[clampName];
+	const halfX = .5 / source.pixelWidth;
+	const halfY = .5 / source.pixelHeight;
+	if (scale instanceof Float32Array) {
+		writeAt(scale, 0, 1 / source.width, true);
+		writeAt(scale, 1, 1 / source.height, true);
+	}
+	if (clamp instanceof Float32Array) {
+		writeAt(clamp, 0, halfX, true);
+		writeAt(clamp, 1, halfY, true);
+		writeAt(clamp, 2, texture.frame.width / source.width - halfX, true);
+		writeAt(clamp, 3, texture.frame.height / source.height - halfY, true);
+	}
+}
+/**
+* Places a backdrop's `sampleBack` on the back texture of this apply. Pixi binds the texture itself (group 0
+* binding 3); the engine fills the scale and the clamp, since the copy's backing is sized at the resolution of the
+* surface under the view, the input's at the view's.
+*
+* @param body - The backdrop body.
+* @param back - What was drawn under the view.
+*/
+function bindBack(body, back) {
+	const uniforms = body.group?.uniforms;
+	if (uniforms !== void 0) writePlacement(uniforms, BACK_SCALE.name, BACK_CLAMP.name, back);
+}
+/**
+* The apply of a backdrop without inputs, as Pixi calls it: `sampleBack` placed on the copy Pixi made, then the body
+* drawn from the view's input.
+*
+* @param pixi - The module the renderer loaded.
+* @param body - The backdrop body.
+* @param manager - Pixi's filter system.
+* @param input - The view's input texture.
+* @param output - The output.
+* @param clearMode - Whether the output is cleared.
+*/
+function applyBack(pixi, body, manager, input, output, clearMode) {
+	bindBack(body, backOf(pixi, manager));
+	manager.applyFilter(body.filter, input, output, clearMode);
+}
+/**
+* Gives a backdrop body without inputs its own `apply`, which places `sampleBack` before it draws.
+*
+* @param pixi - The module the renderer loaded.
+* @param body - The body, just built.
+*/
+function wireBack(pixi, body) {
+	body.filter.apply = (manager, input, output, clearMode) => applyBack(pixi, body, manager, input, output, clearMode);
+}
+/**
 * The share of the resolution the last place of one input draws at.
 *
 * @param inputs - The chains of the instance.
@@ -39218,8 +40265,12 @@ function stagesOf(inputs) {
 * @param inputs - The chains of the instance.
 */
 function giveBack(pixi, inputs) {
-	for (const target of inputs.taken) pixi.TexturePool.returnTexture(target);
-	inputs.taken.length = 0;
+	const { taken } = inputs;
+	for (let index = 0; index < taken.length; index += 1) {
+		const target = taken[index];
+		if (target !== void 0) pixi.TexturePool.returnTexture(target);
+	}
+	while (taken.length > 0) taken.pop();
 }
 /**
 * Draws the places of one input, each from the one before, the first from `from`, into a pooled
@@ -39229,7 +40280,7 @@ function giveBack(pixi, inputs) {
 * @param inputs - The chains of the instance.
 * @param index - The input.
 * @param manager - Pixi's filter system, inside an active filter pass.
-* @param from - The view's input, or a kept picture.
+* @param from - The view's input, the copy of what was drawn under the view, or a kept picture.
 * @param resolution - The resolution of `from`.
 * @param target - Where the last place draws, instead of a pooled texture.
 * @returns The texture the last place drew into; `from` for an empty chain.
@@ -39271,20 +40322,7 @@ function bindInput(instance, index, last) {
 	const { resources } = instance.filter;
 	if (resources[input.texture] !== source) resources[input.texture] = source;
 	if (resources[input.sampler] !== source.style) resources[input.sampler] = source.style;
-	const scale = uniforms[input.scale.name];
-	const clamp = uniforms[input.clamp.name];
-	const halfX = .5 / source.pixelWidth;
-	const halfY = .5 / source.pixelHeight;
-	if (scale instanceof Float32Array) {
-		writeAt(scale, 0, 1 / source.width, true);
-		writeAt(scale, 1, 1 / source.height, true);
-	}
-	if (clamp instanceof Float32Array) {
-		writeAt(clamp, 0, halfX, true);
-		writeAt(clamp, 1, halfY, true);
-		writeAt(clamp, 2, last.frame.width / source.width - halfX, true);
-		writeAt(clamp, 3, last.frame.height / source.height - halfY, true);
-	}
+	writePlacement(uniforms, input.scale.name, input.clamp.name, last);
 }
 /**
 * Points every input's texture and sampler back at Pixi's empty texture: a filter never holds a
@@ -39305,11 +40343,24 @@ function unbindInputs(pixi, instance) {
 	}
 }
 /**
+* Tells whether the chains of an instance must run again for the resolutions of this apply: the view's input's for a
+* chain that starts from it, what was drawn under the view's for one that starts from back.
+*
+* @param inputs - The chains of the instance.
+* @param resolution - The resolution of the view's input.
+* @param backResolution - The resolution of the back; the input's for a filter that reads none.
+* @returns True when one the chains start from changed.
+*/
+function resolutionMoved(inputs, resolution, backResolution) {
+	return inputs.fromInput && resolution !== inputs.resolution || inputs.fromBack && backResolution !== inputs.backResolution;
+}
+/**
 * The apply of a filter with inputs, as Pixi calls it: a resolution change runs the chains once
-* at the new value, then every place draws, the last texture of each input is bound, and the main
-* body draws from the view's input. Held results are bound instead and no stage draws. The pooled
-* textures go back and the inputs are unbound in a `finally`, also when a place throws; a throw then
-* reaches the guard, which breaks the instance.
+* at the new value, then every place draws, each chain from the view's input or, `from: "back"`,
+* from the copy Pixi made of the canvas under the view, the last texture of each input is bound, a
+* backdrop's `sampleBack` is placed, and the main body draws from the view's input. Held results are
+* bound instead and no stage draws. The pooled textures go back and the inputs are unbound in a
+* `finally`, also when a place throws; a throw then reaches the guard, which breaks the instance.
 *
 * @param ectx - Domain context of the effects plugin.
 * @param pixi - The module the renderer loaded.
@@ -39322,16 +40373,23 @@ function unbindInputs(pixi, instance) {
 */
 function applyInputs(ectx, pixi, instance, inputs, manager, input, output, clearMode) {
 	const { resolution } = input.source;
-	if (inputs.held === void 0 && resolution !== inputs.resolution) evaluateInRender(ectx, pixi, instance, inputs, resolution);
+	const { definition } = instance;
+	const back = definition.backdrop ? backOf(pixi, manager) : input;
+	const backResolution = inputs.fromBack ? back.source.resolution : resolution;
+	if (inputs.held === void 0 && resolutionMoved(inputs, resolution, backResolution)) evaluateInRender(ectx, pixi, instance, inputs, resolution, backResolution);
 	if (instance.broken) {
 		drawBroken(instance, manager, input, output, clearMode);
 		return;
 	}
 	try {
 		for (let index = 0; index < inputs.places.length; index += 1) {
-			const last = inputs.held === void 0 ? drawChain(pixi, inputs, index, manager, input, resolution) : inputs.held[index] ?? input;
+			const fromBack = definition.inputs[index]?.from === "back";
+			const start = fromBack ? back : input;
+			const startResolution = fromBack ? backResolution : resolution;
+			const last = inputs.held === void 0 ? drawChain(pixi, inputs, index, manager, start, startResolution) : inputs.held[index] ?? input;
 			bindInput(instance, index, last);
 		}
+		if (definition.backdrop) bindBack(instance, back);
 		manager.applyFilter(instance.filter, input, output, clearMode);
 	} finally {
 		giveBack(pixi, inputs);
@@ -39353,7 +40411,7 @@ function applyInputs(ectx, pixi, instance, inputs, manager, input, output, clear
 */
 function drawInto(ectx, pixi, instance, inputs, manager, picture, targets) {
 	const { resolution } = picture.source;
-	if (!instance.broken && resolution !== inputs.resolution) evaluateInRender(ectx, pixi, instance, inputs, resolution);
+	if (!instance.broken && resolution !== inputs.resolution) evaluateInRender(ectx, pixi, instance, inputs, resolution, resolution);
 	if (instance.broken) return;
 	try {
 		for (let index = 0; index < inputs.places.length; index += 1) {
@@ -39373,10 +40431,14 @@ function drawInto(ectx, pixi, instance, inputs, manager, picture, targets) {
 * @param instance - The instance, just built.
 */
 function wireInputs(ectx, pixi, instance) {
-	const count = instance.definition.inputs.length;
+	const declared = instance.definition.inputs;
+	const count = declared.length;
 	const inputs = {
 		stale: true,
 		resolution: 0,
+		backResolution: 0,
+		fromInput: declared.some((input) => input.from === "input"),
+		fromBack: declared.some((input) => input.from === "back"),
 		version: 0,
 		context: { resolution: 0 },
 		places: Array.from({ length: count }, () => []),
@@ -39401,7 +40463,10 @@ function wireInputs(ectx, pixi, instance) {
 	};
 	instance.inputs = inputs;
 	instance.filter.apply = (manager, input, output, clearMode) => applyInputs(ectx, pixi, instance, inputs, manager, input, output, clearMode);
-	evaluate(ectx, pixi, instance, inputs, ectx.deps.renderer.host.resolution());
+	const { resolution } = instance.definition;
+	const canvas = ectx.deps.renderer.host.resolution();
+	const own = resolution > 0 ? resolution : canvas;
+	evaluate(ectx, pixi, instance, inputs, own, inputs.fromBack ? canvas : own);
 }
 /**
 * Reads one property of a value a chain returned, whatever its type.
@@ -39595,9 +40660,10 @@ function placeSteps(pixi, inputs, index, steps) {
 	return changed || rebuilt;
 }
 /**
-* Runs the chain of every input for the instance's value at a resolution and places its steps.
+* Runs the chain of every input for the instance's value at a resolution and places its steps: a chain that starts
+* from the view's input at the input's resolution, one that starts from back at the back's.
 * A chain that throws or returns a step it may not draw breaks the instance (reason `"chain"`).
-* The version moves when a place, a scale, a stage uniform or the resolution changed; the passes
+* The version moves when a place, a scale, a stage uniform or a resolution changed; the passes
 * become the main body plus every place.
 *
 * @param ectx - Domain context of the effects plugin.
@@ -39605,14 +40671,15 @@ function placeSteps(pixi, inputs, index, steps) {
 * @param instance - The instance.
 * @param inputs - Its chains.
 * @param resolution - The resolution of the texture the view is drawn into.
+* @param backResolution - The resolution of what was drawn under the view; the input's for a filter that reads none.
 */
-function evaluate(ectx, pixi, instance, inputs, resolution) {
+function evaluate(ectx, pixi, instance, inputs, resolution, backResolution) {
 	const kind = ectx.state.kinds.get(instance.kindId);
-	let changed = resolution !== inputs.resolution;
+	let changed = resolution !== inputs.resolution || backResolution !== inputs.backResolution;
 	let passes = 1;
-	inputs.context.resolution = resolution;
 	for (const [index, input] of instance.definition.inputs.entries()) {
 		let steps;
+		inputs.context.resolution = input.from === "back" ? backResolution : resolution;
 		try {
 			steps = input.chain(instance.value, inputs.context);
 		} catch (error) {
@@ -39628,6 +40695,7 @@ function evaluate(ectx, pixi, instance, inputs, resolution) {
 		passes += steps.length;
 	}
 	inputs.resolution = resolution;
+	inputs.backResolution = backResolution;
 	inputs.stale = false;
 	instance.passes = passes;
 	if (changed) inputs.version += 1;
@@ -39642,9 +40710,10 @@ function evaluate(ectx, pixi, instance, inputs, resolution) {
 * @param instance - The instance.
 * @param inputs - Its chains.
 * @param resolution - The resolution of the texture the view is drawn into.
+* @param backResolution - The resolution of what was drawn under the view.
 */
-function evaluateInRender(ectx, pixi, instance, inputs, resolution) {
-	evaluate(ectx, pixi, instance, inputs, resolution);
+function evaluateInRender(ectx, pixi, instance, inputs, resolution, backResolution) {
+	evaluate(ectx, pixi, instance, inputs, resolution, backResolution);
 	ectx.state.filterSync.all = true;
 }
 /**
@@ -39666,12 +40735,13 @@ function refreshInputs(ectx, pixi, instance, off) {
 		inputs.retired.length = 0;
 	}
 	if (instance.broken || !instance.filter.enabled || off || !inputs.stale) return;
-	evaluate(ectx, pixi, instance, inputs, inputs.resolution);
+	evaluate(ectx, pixi, instance, inputs, inputs.resolution, inputs.backResolution);
 }
 /**
 * The body a stand-in of a dev build draws: the fallback with the striped mark over it, or the
 * mark alone. The pair draws the fallback into one pooled texture of the input's frame and
-* resolution, then the mark from it into the output, and gives the texture back in a `finally`.
+* resolution, then the mark from it into the output, and gives the texture back in a `finally`. A
+* backdrop fallback has its `sampleBack` placed first.
 *
 * @param pixi - The module the renderer loaded.
 * @param fallback - The checked fallback, or `undefined`.
@@ -39696,6 +40766,7 @@ function markedBody(pixi, fallback, value) {
 		request.height = input.frame.height;
 		request.resolution = input.source.resolution;
 		const pooled = pixi.TexturePool.getOptimalTexture(request);
+		if (body.definition.backdrop) bindBack(body, backOf(pixi, manager));
 		try {
 			manager.applyFilter(body.filter, input, pooled, true);
 			manager.applyFilter(mark.filter, pooled, output, clearMode);
@@ -39725,7 +40796,10 @@ function createStandIn(ectx, pixi, kind, value) {
 	const usable = status === "ok" ? fallback : void 0;
 	let body;
 	if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ === true) body = markedBody(pixi, usable, value);
-	else if (usable !== void 0) body = createOurs(pixi, usable, value);
+	else if (usable !== void 0) {
+		body = createOurs(pixi, usable, value);
+		if (usable.backdrop) wireBack(pixi, body);
+	}
 	if (body === void 0) return void 0;
 	body.filter.enabled = value.enabled;
 	body.areaStale = body.definition.area !== void 0;
@@ -39876,6 +40950,7 @@ function sameField(a, b) {
 */
 function coreDiffers(instance, value) {
 	const { fields, applied } = instance;
+	if (instance.kind === "alpha") return !sameField(applied.alpha, value.alpha) || !sameField(applied.resolution, value.resolution);
 	for (const field of fields) if (instance.kind === "displacement" && field === "map") {
 		if (mapOf(value) !== instance.map) return true;
 	} else if (!sameField(applied[field], value[field])) return true;
@@ -39905,6 +40980,12 @@ function mapOf(value) {
 function writeCore(ectx, instance, value) {
 	setCore(ectx, instance, value);
 	const { fields, applied } = instance;
+	if (instance.kind === "alpha") {
+		const { alpha, resolution } = value;
+		if (alpha !== void 0) applied.alpha = alpha;
+		if (resolution !== void 0 && resolution !== applied.resolution) applied.resolution = resolution;
+		return;
+	}
 	for (const field of fields) {
 		const next = value[field];
 		if (next !== void 0) applied[field] = next;
@@ -39946,7 +41027,11 @@ function setCore(ectx, instance, value) {
 			instance.map = map;
 			return;
 		}
-		default: instance.filter.alpha = numberOf$1(value, "alpha");
+		default: {
+			const { alpha, resolution } = value;
+			instance.filter.alpha = typeof alpha === "number" ? alpha : 0;
+			if (resolution !== instance.applied.resolution) instance.filter.resolution = resolutionOf(typeof resolution === "number" ? resolution : 0);
+		}
 	}
 }
 /**
@@ -39972,8 +41057,9 @@ function switchOffBroken(instance, before) {
 }
 /**
 * Brings one instance up to the stored value for a frame, comparing before anything is written.
-* A broken instance stays off whatever its component says. Switching on or off is a visible
-* change; so is a new value of a filter that is on. A filter that is off and stays off still gets
+* A broken instance stays off whatever its component says, and an `Alpha` at 1 drawn at the
+* canvas's resolution is switched off at its `CALM_AFTER`-th sync there. Switching on or off is a
+* visible change; so is a new value of a filter that is on. A filter that is off and stays off still gets
 * its new values written, so it is current when it comes back on, but asks for nothing: an off
 * filter draws no pixel. Ours compare on every sync of their view (a view syncs when something of it changed); a core
 * kind only when its component changed.
@@ -39990,13 +41076,14 @@ function writeFilter(ectx, instance, value, changed, before) {
 		switchOffBroken(instance, before);
 		return false;
 	}
-	const toggled = instance.filter.enabled !== value.enabled;
+	const on = switchOf(instance, value);
+	const toggled = instance.filter.enabled !== on;
 	const differs = instance.kind === "wgsl" ? oursDiffer(instance, instance.definition, value) : changed && coreDiffers(instance, value);
 	if (!toggled && !differs) return false;
 	staleArea(instance);
-	const visible = toggled || value.enabled;
+	const visible = toggled || on;
 	if (visible) before();
-	if (toggled) instance.filter.enabled = value.enabled;
+	if (toggled) instance.filter.enabled = on;
 	if (differs) {
 		if (instance.kind === "wgsl") {
 			writeOurs(instance, instance.definition, value);
@@ -40741,8 +41828,10 @@ function judgeArea(ectx, instance) {
 }
 /**
 * The union of the areas of a view's enabled filters, into the scratch box: none while no filter is enabled, and none
-* when an enabled filter has no area (every built-in kind, or a definition that answered `undefined`) — it draws over
-* the view's bounds. A disabled filter, and a kind a debug switch turned off (it is not placed), do not count.
+* when an enabled filter has no area (every other built-in kind, or a definition that answered `undefined`) — it draws
+* over the view's bounds. An `Alpha` does not count: it only scales the pixels the others draw, and makes none where
+* they draw nothing; alone it leaves the view without an area. A disabled filter, and a kind a debug switch turned off
+* (it is not placed), do not count either.
 *
 * @param view - The view's record, its instances placed.
 */
@@ -40753,7 +41842,7 @@ function unionOf(view) {
 	let bottom = Number.NEGATIVE_INFINITY;
 	union.some = false;
 	for (const instance of view.placed) {
-		if (!instance.filter.enabled) continue;
+		if (!instance.filter.enabled || instance.kind === "alpha") continue;
 		if (instance.kind !== "wgsl" || !instance.area.some) {
 			union.some = false;
 			return;
@@ -40765,6 +41854,7 @@ function unionOf(view) {
 		right = Math.max(right, area.x + area.width);
 		bottom = Math.max(bottom, area.y + area.height);
 	}
+	if (!union.some) return;
 	union.x = left;
 	union.y = top;
 	union.width = right - left;
@@ -40895,14 +41985,27 @@ function cacheOfInstance(instance) {
 	return instance.kind === "wgsl" ? instance.definition.cache : CORE_CACHE[instance.kind];
 }
 /**
+* Tells whether one of the inputs of a definition starts from the view's own input: its chain draws a copy of the
+* view's subtree. A chain from back draws what was drawn under the view instead.
+*
+* @param definition - The definition.
+* @returns True when one does.
+*/
+function readsOwnInput(definition) {
+	const { inputs } = definition;
+	for (let index = 0; index < inputs.length; index += 1) if (inputs[index]?.from === "input") return true;
+	return false;
+}
+/**
 * Whether an instance shows a blurred copy of what is under it (spec 23 P8.5): the built-in `Blur`, or one of ours
-* with inputs. The predicate an overlay's held loops read (spec 22).
+* with an input drawn from its own subtree. A backdrop whose chains start from back blurs the scene under the view,
+* not the view: an overlay holds no loops for it. The predicate an overlay's held loops read (spec 22).
 *
 * @param instance - The instance.
 * @returns True, or `undefined` for every other filter (the slot leaves the key out).
 */
 function blursOf(instance) {
-	return instance.kind === "blur" || instance.kind === "wgsl" && instance.definition.inputs.length > 0 ? true : void 0;
+	return instance.kind === "blur" || instance.kind === "wgsl" && readsOwnInput(instance.definition) ? true : void 0;
 }
 /**
 * Tells whether a debug switch turned a kind off (`effects.diagnostics.disable`). The guard is
@@ -40980,7 +42083,7 @@ function syncKind(ectx, pixi, entity, view, kind, changed, off) {
 		writeFilter(ectx, instance, value, changed, off ? NO_SIGNAL : view.signal);
 		instance.order = value.order;
 		refreshInputs(ectx, pixi, instance, off);
-		if (instance.kind === "wgsl" && (instance.inputs?.retired.length ?? 0) > 0) markDirty$1(ectx, view);
+		if (instance.kind === "wgsl" && (instance.inputs?.retired.length ?? 0) > 0 || instance.kind === "alpha" && instance.calm > 0) markDirty$1(ectx, view);
 		return installReplacement(view, kind, instance);
 	}
 	instance = firstInstance(ectx, pixi, kind, value);
@@ -41247,7 +42350,8 @@ function dropProbe(ectx, probe) {
 }
 /**
 * A probe of one Pixi-core kind at the frozen defaults of its component; a `Displacement` draws over Pixi's white
-* texture, since its program does not depend on the map. Its `apply` is guarded like any instance's.
+* texture, since its program does not depend on the map. A probe is switched on whatever its defaults: an `Alpha` at 1
+* would be off, and Pixi would warm nothing. Its `apply` is guarded like any instance's.
 *
 * @param ectx - Domain context of the effects plugin.
 * @param pixi - The module the renderer loaded.
@@ -41258,6 +42362,7 @@ function coreProbe(ectx, pixi, id) {
 	const kind = ectx.state.kinds.get(id);
 	const instance = kind === void 0 ? void 0 : createFilter(ectx, pixi, kind, kind.component.defaults, pixi.Texture.WHITE);
 	if (instance === void 0) return void 0;
+	instance.filter.enabled = true;
 	return {
 		filter: instance.filter,
 		destroy: () => destroyFilter(instance)
@@ -59043,6 +60148,7 @@ function cubicBezier(x1, y1, x2, y2) {
 * | renderer | preference | "webgpu", WebGL is Pixi's fallback |
 * | renderer | aspect | { min: 4/3, max: 21/9 }; shallow merge: a game that sets `aspect` gives both fields |
 * | renderer | poolLimit | 256 |
+* | renderer | adaptiveScale | { floor: 0.75, devices: "phone" }, the render scale of the adaptive frame rate on a GPU-bound phone; false keeps the resolution; shallow merge: a game that sets it gives both fields |
 * | renderer | unsupportedMessage | "This device cannot run the game." |
 * | renderer | loadPixi | () => import("pixi.js") |
 * | renderer | debug | { nineSlice: false, verifyFrames: false, kept: true, overdraw: false }; shallow merge: a game that sets `debug` replaces the whole object, and a switch it leaves out is off, except `kept`, which stays on unless set to false; `verifyFrames` and `overdraw` work in dev and debug builds only |