@moku-labs/game 0.14.13 → 0.15.1

package/dist/{src-BEbJ_sSx.mjs → src-CwVzErzN.mjs}

@@ -3,7 +3,7 @@ import { r as systemSource, t as memory } from "./memory-CWlqhS7l.mjs";
 import { a as finishDrafts, i as enableDraftPatches, n as deepFreeze$1, o as openDrafts, r as dropDrafts } from "./drafts-BawpSaVp.mjs";
 import { d as graphHash, f as isRestCheckpoint, h as pushEntry, i as servePaused, l as findNode, m as compact, n as captureFrame, o as collectFlows, p as slotNames, r as serveCaptures, s as describeGraph, t as cancelCaptures, u as framePath } from "./capture-D7XvoHdH.mjs";
 import { A as Order, C as Sprite, D as Exiting, F as system, I as systemsFor, L as tag, M as component, O as Layer, P as resource, S as Shape, T as componentsFor, _ as HudPart, b as OverlayLevel, c as Countdown, d as builtInStyles, g as Display, h as textFor, i as samePose, j as Tree, k as Now, l as Text, m as readStyle, n as drawnRect, o as visualOf$1, r as fitScaleOf, s as visualRectOf, t as CONTENT$1, v as NineSlice, w as Transform, x as Parent, y as Overlay } from "./visual-2m4wJL_z.mjs";
-import { a as isDev } from "./dev-DbHgx-R-.mjs";
+import { a as isDev } from "./dev-BNndV-hU.mjs";
 import { i as isComponentDefinition, n as flatten, r as defineComponent } from "./flatten-BkXuscAV.mjs";
 import { envPlugin, logPlugin } from "@moku-labs/common/browser";
 import { createCoreConfig } from "@moku-labs/core";
@@ -124,7 +124,9 @@ function createClockApi(ctx) {
 		poke: () => {
 			deliverElapsed(ctx.state);
 		},
-		dueAt: () => ctx.state.dueAt
+		dueAt: () => ctx.state.dueAt,
+		pending: () => ctx.state.dueAt === void 0 ? 0 : 1,
+		listeners: () => ctx.state.listeners.length
 	};
 }
 //#endregion
@@ -684,6 +686,25 @@ function capSlackMs(displayHz, frameMs) {
 	return whole >= 1 && Math.abs(periods - whole) <= .05 ? 500 / displayHz : 1;
 }
 /**
+* The rate the loop really runs at under a cap: the cap skips every tick that comes more than `capSlackMs` early, so
+* a frame runs on the first vsync at or after one frame of the cap minus the slack, never faster than the display. The
+* cap itself while the display is unknown. Called when the snapshot is rebuilt, never per frame.
+*
+* @param fps - The cap: the loop's rate, the idle cap left out.
+* @param displayHz - The display's refresh rate, or `null` while unknown.
+* @returns Frames per second the loop runs at.
+* @example
+* ```ts
+* loopRateOf(60, 144); // 48: every third tick of a 144 Hz panel
+* ```
+*/
+function loopRateOf(fps, displayHz) {
+	if (displayHz === null) return fps;
+	const frameMs = 1e3 / fps;
+	const ticks = Math.ceil((frameMs - capSlackMs(displayHz, frameMs)) * displayHz / 1e3);
+	return displayHz / Math.max(1, ticks);
+}
+/**
 * Normalizes a thermal status of the shell: a status name, or Android's whole number 0–6 mapped in order.
 *
 * @param value - The raw status.
@@ -856,20 +877,36 @@ function createGovernor(floor) {
 	};
 }
 /**
-* The frozen object `rate()` answers, built from the rate now.
+* The rate the loop is told to hold: the cap in mode `"fixed"` (`maxFps`) and `"forced"` (the `setRate` value, never
+* above `maxFps`); `null` in mode `"auto"`, where the adaptive rule decides. Outside `"auto"` the cap is always one of
+* the fixed choices, so the guard only narrows its type.
+*
+* @param rate - The rate and its mode.
+* @returns The asked rate, or `null`.
+*/
+function askedOf(rate) {
+	return rate.mode !== "auto" && isChoice(rate.fps) ? rate.fps : null;
+}
+/**
+* The frozen object `rate()` answers, built from the rate now: `fps` is what the loop really runs at under the cap on
+* the known display, and `heldBy` is `"panel"` when the asked rate is above the display's.
 *
 * @param rate - The rate, its mode, its reason, the display and the governor.
 * @returns A fresh frozen snapshot.
 */
 function snapshotOf(rate) {
 	const { governor } = rate;
+	const { hz } = rate.display;
+	const asked = askedOf(rate);
 	return Object.freeze({
-		fps: rate.fps,
+		fps: loopRateOf(rate.fps, hz),
 		mode: rate.mode,
 		reason: rate.reason,
-		displayHz: rate.display.hz,
+		displayHz: hz,
 		ladder: governor?.ladder ?? NO_STEPS,
-		thermal: governor?.thermal ?? null
+		thermal: governor?.thermal ?? null,
+		asked,
+		heldBy: asked !== null && hz !== null && asked > hz ? "panel" : null
 	});
 }
 /**
@@ -1597,7 +1634,7 @@ function noteCap(ctx, frameMs) {
 * skipped, is a sample of the display rate. The first frame, and the first frame after a
 * `resume`, counts as one capped frame instead of the gap to a stale timestamp. A frame that
 * arrives more than the cap's slack before the current cap allows it is skipped — the cap is
-* `idleFps` while the screen is idle and the loop's rate (`rate().fps`) otherwise, the slack half
+* `idleFps` while the screen is idle and the loop's rate otherwise (`rate().asked`, or the adaptive rule's), the slack half
 * a display period (`capSlackMs`) — and a long gap is clamped at `maxDeltaMs` so a backgrounded
 * tab does not produce a giant step. The idle timer moves by the raw gap, at most `idleAfterMs`,
 * so a throttled page goes idle in `idleAfterMs`. The interval that ends at a run frame is judged
@@ -1645,6 +1682,17 @@ function addFrameCallback(ctx, phase, callback) {
 	};
 }
 /**
+* Counts the registered frame callbacks of the six phases, named one by one as `capturePhases` does: no loop, no
+* iterator, no allocation.
+*
+* @param ctx - Domain context of the time plugin.
+* @returns The count.
+*/
+function countFrameListeners(ctx) {
+	const { input, animate, layout, sync, signals, render } = ctx.state.callbacks;
+	return input.length + animate.length + layout.length + sync.length + signals.length + render.length;
+}
+/**
 * 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`
 * for tests and tools.
@@ -1679,6 +1727,7 @@ function createTimeApi(ctx) {
 		isRunning: () => ctx.state.running,
 		wake: () => wakeClock(ctx),
 		wakes: () => ctx.state.wakes,
+		frameListeners: () => countFrameListeners(ctx),
 		measure: (listener) => {
 			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) {
 				const { measure } = ctx.state;
@@ -8045,8 +8094,9 @@ const WORLD_PHASES = [
 ];
 /**
 * Gives a timed system its row: the row of an earlier system of the same name, else the next one.
-* `ms` grows (a new array, the old values copied) only when the row is past its end: at
-* registration, never per frame.
+* A new row replaces `names` with a new array, so a reader that kept the old one sees the growth
+* by identity, and the old array stays as it was. `ms` grows (a new array, the old values copied)
+* only when the row is past its end. Both happen at registration, never per frame.
 *
 * @param state - The ecs branch of the plugin state.
 * @param timing - The timing table.
@@ -8055,7 +8105,7 @@ const WORLD_PHASES = [
 function giveRow(state, timing, name) {
 	if (state.timingSlots.has(name)) return;
 	const row = timing.names.length;
-	timing.names.push(name);
+	timing.names = [...timing.names, name];
 	state.timingSlots.set(name, row);
 	if (row < timing.ms.length) return;
 	const grown = new Float64Array(timing.ms.length * 2);
@@ -8341,6 +8391,7 @@ function createEcsApi(ctx) {
 		diff: (from, to) => diffHistory(state.history, from, to),
 		schema: () => schemaOf(state.types.values()),
 		ownerOf: (entity) => state.owners.get(entity),
+		count: () => state.owners.size,
 		onOwnerLeft: (fn) => {
 			state.ownerLeft.push(fn);
 			return () => {
@@ -10612,6 +10663,7 @@ function exposeEcs(ecs, projection) {
 		changed: ecs.changed,
 		typeOf: ecs.typeOf,
 		ownerOf: ecs.ownerOf,
+		count: ecs.count,
 		mode: ecs.mode,
 		setMode: (mode) => {
 			ecs.setMode(mode);
@@ -11298,18 +11350,27 @@ function someOf(entities, test) {
 	return false;
 }
 /**
+* Empties a set when it holds something. V8 gives an empty set a new table at every `clear()`, so clearing the empty
+* sets of a still screen every frame allocated about 18 MB in 20 000 frames.
+*
+* @param set - The set.
+*/
+function emptyOut(set) {
+	if (set.size > 0) set.clear();
+}
+/**
 * Empties the marks of a decision.
 *
 * @param state - The demand state.
 */
 function clearMarks(state) {
-	state.marked.clear();
-	state.pending.clear();
-	state.loose.clear();
-	state.visual.clear();
-	state.moved.clear();
-	state.published.clear();
-	state.wholes.clear();
+	emptyOut(state.marked);
+	emptyOut(state.pending);
+	emptyOut(state.loose);
+	emptyOut(state.visual);
+	emptyOut(state.moved);
+	emptyOut(state.published);
+	emptyOut(state.wholes);
 	state.counted = false;
 }
 /**
@@ -11426,7 +11487,7 @@ function createDemandApi(ctx, deps) {
 		if (drawn) {
 			state.drawnOnce = true;
 			state.requests = 0;
-			state.sinceDraw.clear();
+			emptyOut(state.sinceDraw);
 		}
 		return drawn;
 	};
@@ -11443,7 +11504,7 @@ function createDemandApi(ctx, deps) {
 		}
 		if ((typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) && state.verify.on) {
 			verifyFrame(ctx, state, host, state.frame);
-			if (state.frame.reason === "verify") state.sinceDraw.clear();
+			if (state.frame.reason === "verify") emptyOut(state.sinceDraw);
 		}
 	};
 	/**
@@ -12363,7 +12424,12 @@ function stopHost(state) {
 //#endregion
 //#region src/plugins/renderer/monitor/units.ts
 /**
-* @file renderer/monitor — the byte and rounding helpers the counters and the performance log share (LEAD-FIXES-3 O24).
+* @file renderer/monitor — the byte and rounding helpers the counters and the performance log share (LEAD-FIXES-3
+* O24), and the column readers: one per typed-array kind, never one shared. V8 keeps one load feedback per function,
+* inlined copies included: a reader that saw more than four array kinds goes generic, and every double it reads on the
+* per-frame path comes back boxed, a heap number a read. A reader that sees one kind stays monomorphic and reads the
+* double unboxed. The parameter type holds the rule: `cellF32` takes a `Float32Array` and nothing else. One read out of
+* bounds (slot -1) boxes a reader's doubles the same way, for every caller: a slot that may not exist is checked first.
 */
 /** Bytes of one MiB. */
 const BYTES_PER_MB$1 = 1048576;
@@ -12383,18 +12449,87 @@ function roundTo(value, decimals) {
 	return Math.round(value * factor) / factor;
 }
 /**
-* Reads one value of a column; a slot past the end reads NaN, "not measured". The one place a typed-array read meets
-* `noUncheckedIndexedAccess`.
+* Reads one value of a `Float64Array` column; a slot past the end reads NaN, "not measured".
+*
+* @param column - The column.
+* @param index - The slot.
+* @returns The value.
+* @example
+* ```ts
+* cellF64(Float64Array.of(2.5), 0); // 2.5
+* ```
+*/
+function cellF64(column, index) {
+	return column[index] ?? NaN;
+}
+/**
+* Reads one value of a `Float32Array` column; a slot past the end reads NaN, "not measured".
+*
+* @param column - The column.
+* @param index - The slot.
+* @returns The value.
+* @example
+* ```ts
+* cellF32(Float32Array.of(2.5), 1); // NaN
+* ```
+*/
+function cellF32(column, index) {
+	return column[index] ?? NaN;
+}
+/**
+* Reads one value of a `Uint32Array` column; a slot past the end reads NaN.
+*
+* @param column - The column.
+* @param index - The slot.
+* @returns The value.
+* @example
+* ```ts
+* cellU32(Uint32Array.of(4812), 0); // 4812
+* ```
+*/
+function cellU32(column, index) {
+	return column[index] ?? NaN;
+}
+/**
+* Reads one value of an `Int32Array` column; a slot past the end reads NaN.
+*
+* @param column - The column.
+* @param index - The slot.
+* @returns The value.
+* @example
+* ```ts
+* cellI32(Int32Array.of(-1), 0); // -1
+* ```
+*/
+function cellI32(column, index) {
+	return column[index] ?? NaN;
+}
+/**
+* Reads one value of a `Uint16Array` column; a slot past the end reads NaN.
 *
-* @param column - A typed array or any list of numbers.
+* @param column - The column.
 * @param index - The slot.
 * @returns The value.
 * @example
 * ```ts
-* cell(Float32Array.of(2.5), 0); // 2.5
+* cellU16(Uint16Array.of(0xff_ff), 0); // 65535
 * ```
 */
-function cell(column, index) {
+function cellU16(column, index) {
+	return column[index] ?? NaN;
+}
+/**
+* Reads one value of a `Uint8Array` column; a slot past the end reads NaN.
+*
+* @param column - The column.
+* @param index - The slot.
+* @returns The value.
+* @example
+* ```ts
+* cellU8(Uint8Array.of(1), 0); // 1
+* ```
+*/
+function cellU8(column, index) {
 	return column[index] ?? NaN;
 }
 //#endregion
@@ -12438,7 +12573,7 @@ function sourceBytes(source) {
 * isTarget({ uploadMethodId: "unknown", resource: null }); // true
 * ```
 */
-function isTarget(source) {
+function isTarget$1(source) {
 	return source.uploadMethodId === "unknown" && (source.resource === null || source.resource === void 0);
 }
 /**
@@ -12473,7 +12608,7 @@ function textureUsage(app, kept) {
 		usage.count += 1;
 		usage.bytes += bytes;
 		if (kept.has(source)) usage.kept += bytes;
-		else if (isTarget(source)) usage.targets += bytes;
+		else if (isTarget$1(source)) usage.targets += bytes;
 		else usage.art += bytes;
 	}
 	return usage;
@@ -14141,6 +14276,7 @@ function createRecord$1(kctx, pixi, entity, view, slots, category) {
 		still: 0,
 		churn: 0,
 		calm: false,
+		quiet: 0,
 		lastDrawn: kctx.state.frame,
 		depth: 0,
 		bytes: 0,
@@ -14708,6 +14844,7 @@ function stepRecord(kctx, pixi, matrices, record, view) {
 	if (eligible(kctx, record, view, NOW)) stepEligible(kctx, pixi, matrices, record, view);
 	else stepIneligible(kctx, record, view);
 	if (drawingChanged(kctx, record, BEFORE)) dirtyAbove(kctx, record);
+	record.quiet = record.dirtyS1 ? 0 : record.quiet + 1;
 	record.dirtyS1 = false;
 	record.dirtyS2 = false;
 	record.dirtyS3 = false;
@@ -14872,21 +15009,21 @@ function shownRecords(kctx) {
 	return kctx.state.records.filter((record) => record.mode === "kept" && record.quad?.visible === true);
 }
 /**
-* Reads the stage once more with every picture drawn live: the kept records bypassed, the entries of every range
-* lifted and its sprite hidden. The records draw their pictures again after the read.
+* Runs a draw with every picture drawn live: the kept records bypassed, the entries of every range with a sprite lifted
+* and its sprite hidden. The records draw their pictures again after it, the ranges show their sprites again.
 *
 * @param kctx - The kept context.
-* @param ranges - The ranges whose sprite stood in the frame.
 * @param bypass - Draws every kept record live (true) or as its picture again (false).
-* @param resolution - The resolution of the read, the renderer's.
-* @returns The pixels drawn live, or `undefined` when Pixi could not read them.
+* @param draw - The render or the read.
+* @returns What `draw` returned.
 */
-function renderLive(kctx, ranges, bypass, resolution) {
+function drawLive(kctx, bypass, draw) {
+	const ranges = [...kctx.state.ranges.values()].filter((range) => range.sprite !== void 0);
 	const lift = ranges.flatMap((range) => range.entries);
 	const hide = ranges.flatMap((range) => range.sprite === void 0 ? [] : [range.sprite]);
 	bypass(true);
 	try {
-		return kctx.sync.liftFor(kctx.hidden, lift, hide, "freeze", () => kctx.host.pixels(resolution));
+		return kctx.sync.liftFor(kctx.hidden, lift, hide, "freeze", draw);
 	} finally {
 		bypass(false);
 	}
@@ -14926,7 +15063,7 @@ function verifyPictures(kctx, bypass, recover) {
 	const resolution = host.resolution();
 	const drawn = host.pixels(resolution);
 	if (drawn === void 0) return;
-	const live = renderLive(kctx, ranges, bypass, resolution);
+	const live = drawLive(kctx, bypass, () => host.pixels(resolution));
 	if (live === void 0 || live.length !== drawn.length) return;
 	const screen = host.screen();
 	const width = screen === void 0 ? 0 : Math.round(screen.width * resolution);
@@ -15150,7 +15287,7 @@ function createKeptApi(ctx, deps) {
 			flushRanges(kctx);
 		},
 		after: () => {
-			if ((typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) && deps.demand.verifying()) verifyPictures(kctx, bypass, () => {
+			if ((typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) && deps.demand.verifying() && !ctx.state.sync.debug.overdraw) verifyPictures(kctx, bypass, () => {
 				for (const record of state.records) if (record.mode === "kept") live(record);
 			});
 		},
@@ -15182,6 +15319,10 @@ function createKeptApi(ctx, deps) {
 			return refreshes;
 		},
 		bypass,
+		live: (draw) => {
+			if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) return drawLive(kctx, bypass, draw);
+			return draw();
+		},
 		enabled: (on) => {
 			const next = on && state.allowed;
 			if (next === state.on) return;
@@ -15541,9 +15682,9 @@ function overlapsLongFrame(ring, start, end) {
 */
 function annotateLongFrame(perf, slot) {
 	const c = perf.ring.columns;
-	const t = cell(c.t, slot);
-	const gap = cell(c.gapMs, slot);
-	return overlapsLongFrame(perf.longFrames, Number.isNaN(gap) ? t : t - gap, t + cell(c.workMs, slot));
+	const t = cellF64(c.t, slot);
+	const gap = cellF32(c.gapMs, slot);
+	return overlapsLongFrame(perf.longFrames, Number.isNaN(gap) ? t : t - gap, t + cellF32(c.workMs, slot));
 }
 /**
 * The heap the page uses, in bytes: Chromium's `performance.memory.usedJSHeapSize`, read through a type guard.
@@ -15563,6 +15704,348 @@ function heapMb() {
 	return Number.isNaN(bytes) ? null : roundTo(bytes / BYTES_PER_MB$1, 2);
 }
 //#endregion
+//#region src/plugins/renderer/monitor/types.ts
+/**
+* Indices of the per-frame counters in `MonitorSinks.counts`. Not public.
+*/
+const COUNT = {
+	passes: 0,
+	stencilPasses: 1,
+	filterApplies: 2,
+	filterPixels: 3,
+	uploads: 4,
+	uploadBytes: 5,
+	compiles: 6,
+	marks: 7,
+	rebuilds: 8,
+	targetsCreated: 9,
+	targetsDestroyed: 10
+};
+/**
+* What this application measures, as bits of `PerfState.measuring`. Not public.
+*/
+const MEASURE = {
+	passes: 1,
+	stencilPasses: 2,
+	draws: 4,
+	counted: 8,
+	compiles: 16,
+	gpu: 32,
+	targets: 64
+};
+//#endregion
+//#region src/plugins/renderer/monitor/problems.ts
+/** Pixels per megapixel. */
+const PIXELS_PER_MPX$1 = 1e6;
+/** The window of the `retakes` rule, in seconds: two flushes. */
+const RETAKES_SECONDS = 2;
+/**
+* Adds one frame to the accumulators of the rules: for a drawn frame, each owner's run of drawn frames its filter
+* applied in (a drawn frame without an apply ends the run), its applies and pixels of the second; for every frame, the
+* render targets it made and dropped, a create in an idle frame and a create soon after a pool trim. Indexed stores
+* into the typed arrays of the perf state.
+*
+* @param pc - The perf context.
+* @param measure - What `time` measured of the frame.
+*/
+function accumulateProblems(pc, measure) {
+	if (pc.perf.drawn) accumulateOwners(pc, measure);
+	accumulateTargets(pc, measure);
+}
+/**
+* Adds a drawn frame to each owner's run: a frame its filter applied in grows the run and the second's applies and
+* pixels, a frame without an apply ends the run.
+*
+* @param pc - The perf context.
+* @param measure - What `time` measured of the frame.
+*/
+function accumulateOwners(pc, measure) {
+	const { problems } = pc.perf;
+	const { owners } = pc.sinks;
+	for (let slot = 0; slot < 32; slot += 1) {
+		if (cellF64(owners.ids, slot) === 0) continue;
+		if (cellF64(owners.applies, slot) === 0) {
+			problems.run[slot] = 0;
+			continue;
+		}
+		if (cellF64(problems.run, slot) === 0) problems.runSince[slot] = measure.frame;
+		problems.run[slot] = cellF64(problems.run, slot) + 1;
+		problems.secFrames[slot] = cellF64(problems.secFrames, slot) + 1;
+		problems.secPixels[slot] = cellF64(problems.secPixels, slot) + cellF64(owners.pixels, slot);
+	}
+}
+/**
+* Adds a frame's render targets to the second: the made and dropped ones, a create in an idle frame, a create within
+* `churnAfterTrimMs` after a pool trim.
+*
+* @param pc - The perf context.
+* @param measure - What `time` measured of the frame.
+*/
+function accumulateTargets(pc, measure) {
+	const { problems } = pc.perf;
+	const { counts } = pc.sinks;
+	const created = cellF64(counts, COUNT.targetsCreated);
+	problems.secTargets += created + cellF64(counts, COUNT.targetsDestroyed);
+	if (created === 0) return;
+	if (measure.idle && !problems.idleCreate) {
+		problems.idleCreate = true;
+		problems.createFrame = measure.frame;
+	}
+	if (!problems.trimCreate && measure.at > problems.trimAt && measure.at - problems.trimAt <= problems.thresholds.churnAfterTrimMs) {
+		problems.trimCreate = true;
+		problems.createFrame = measure.frame;
+	}
+}
+/**
+* The label of an entity's view now.
+*
+* @param pc - The perf context.
+* @param entity - The entity.
+* @returns The label of its view's display object, or `null` once the view left.
+*/
+function viewLabel(pc, entity) {
+	return pc.ctx.state.sync.views.get(entity)?.object.label ?? null;
+}
+/**
+* Tells whether a filtered view stands still unkept: its record is live while kept pictures are on, its subtree did
+* not change and its filter applied in the last `stillFrames` drawn frames, over `stillMpx` megapixels a frame.
+*
+* @param pc - The perf context.
+* @param slot - The owner's slot.
+* @param record - The owner's kept record, or `undefined` without one.
+* @returns True when the rule holds.
+*/
+function standsStill$1(pc, slot, record) {
+	const { problems } = pc.perf;
+	const { stillFrames, stillMpx } = problems.thresholds;
+	const kept = pc.ctx.state.kept;
+	const frames = cellF64(problems.secFrames, slot);
+	if (!(record !== void 0 && record.mode === "live" && kept.on && !kept.bypassed)) return false;
+	if (!(frames > 0 && record.quiet >= stillFrames && cellF64(problems.run, slot) >= stillFrames)) return false;
+	return cellF64(problems.secPixels, slot) / frames / PIXELS_PER_MPX$1 >= stillMpx;
+}
+/**
+* Judges `filter-still` for one owner: a crossing opens the problem with its reason, a stop clears it.
+*
+* @param pc - The perf context.
+* @param slot - The owner's slot.
+* @param owner - The owner.
+* @param out - The details written now.
+*/
+function judgeStillOwner(pc, slot, owner, out) {
+	const { problems } = pc.perf;
+	const { owners, kindNames } = pc.sinks;
+	const record = pc.ctx.state.kept.byEntity.get(owner);
+	const still = standsStill$1(pc, slot, record);
+	const open = cellU8(problems.stillOpen, slot) === 1;
+	if (still && !open && record !== void 0) {
+		const kind = cellU8(owners.kinds, slot);
+		const frames = cellF64(problems.run, slot);
+		problems.stillOpen[slot] = 1;
+		out.push({
+			rule: "filter-still",
+			severity: "warn",
+			owner,
+			view: viewLabel(pc, owner),
+			filter: kind === 0 ? null : kindNames[kind - 1] ?? "other",
+			value: Math.min(frames, record.quiet),
+			threshold: problems.thresholds.stillFrames,
+			since: cellF64(problems.runSince, slot),
+			frames,
+			reason: record.refused > 0 ? "budget" : "not-eligible"
+		});
+	} else if (!still && open) {
+		problems.stillOpen[slot] = 0;
+		out.push({
+			rule: "filter-still",
+			cleared: true,
+			owner,
+			view: viewLabel(pc, owner)
+		});
+	}
+}
+/**
+* Judges `filter-still` for every owner of the table: a crossing opens the problem with its reason (`"budget"` when
+* the kept budget refused the picture, `"not-eligible"` otherwise), a stop clears it; an owner whose filter applied in
+* no frame of the second leaves its slot.
+*
+* @param pc - The perf context.
+* @param out - The details written now.
+*/
+function judgeStill(pc, out) {
+	const { problems } = pc.perf;
+	const { owners } = pc.sinks;
+	for (let slot = 0; slot < 32; slot += 1) {
+		const owner = cellF64(owners.ids, slot);
+		if (owner === 0) continue;
+		judgeStillOwner(pc, slot, owner, out);
+		if (cellF64(problems.secFrames, slot) === 0) {
+			owners.ids[slot] = 0;
+			problems.run[slot] = 0;
+		}
+		problems.secFrames[slot] = 0;
+		problems.secPixels[slot] = 0;
+	}
+}
+/**
+* Why `target-churn` opens: a create soon after a pool trim wins over a create in an idle frame, and both over the
+* rate.
+*
+* @param problems - The problem state.
+* @returns The reason of the problem line.
+*/
+function churnReason(problems) {
+	if (problems.trimCreate) return "after-trim";
+	if (problems.idleCreate) return "idle";
+	return "rate";
+}
+/**
+* Judges `target-churn`: `churnPerSecond` targets made and dropped in each of `churnSeconds` seconds in a row, a
+* create in an idle frame, or a create within `churnAfterTrimMs` after a pool trim. One problem for the whole canvas.
+*
+* @param pc - The perf context.
+* @param out - The details written now.
+*/
+function judgeChurn(pc, out) {
+	const { problems } = pc.perf;
+	const { churnPerSecond, churnSeconds } = problems.thresholds;
+	const busy = problems.secTargets >= churnPerSecond;
+	if (busy && problems.churnRun === 0) problems.churnSince = pc.perf.frame;
+	problems.churnRun = busy ? problems.churnRun + 1 : 0;
+	const steady = problems.churnRun >= churnSeconds;
+	const churns = steady || problems.idleCreate || problems.trimCreate;
+	if (churns && !problems.churnOpen) {
+		const since = steady ? problems.churnSince : problems.createFrame;
+		problems.churnOpen = true;
+		out.push({
+			rule: "target-churn",
+			severity: "warn",
+			owner: null,
+			view: null,
+			filter: null,
+			value: problems.secTargets,
+			threshold: churnPerSecond,
+			since,
+			frames: Math.max(1, pc.perf.frame - since),
+			reason: churnReason(problems)
+		});
+	} else if (!churns && problems.churnOpen) {
+		problems.churnOpen = false;
+		out.push({
+			rule: "target-churn",
+			cleared: true,
+			owner: null,
+			view: null
+		});
+	}
+	problems.secTargets = 0;
+	problems.idleCreate = false;
+	problems.trimCreate = false;
+}
+/**
+* The stage-1 takes of a kept record in the last two seconds, its first take left out: the takes now less the ones of
+* two flushes back (one back for a record that came since, none for a record of this second).
+*
+* @param state - The problem state.
+* @param record - The record.
+* @returns Its retakes in the window.
+*/
+function retakesOf(state, record) {
+	const before = state.takes[1].get(record.entity) ?? state.takes[0].get(record.entity) ?? 1;
+	return Math.max(0, record.s1Version - Math.max(1, before));
+}
+/**
+* Judges `retakes`: a kept view taken again `RETAKES_LIMIT` times or more in two seconds. Its `value` is the takes per
+* second. A record that left clears its problem. The takes of every record are kept for the next two judgments.
+*
+* @param pc - The perf context.
+* @param out - The details written now.
+*/
+function judgeRetakes(pc, out) {
+	const { problems } = pc.perf;
+	const { records } = pc.ctx.state.kept;
+	const now = /* @__PURE__ */ new Map();
+	const since = problems.takesFrame[1];
+	for (const record of records) {
+		const { entity } = record;
+		const count = retakesOf(problems, record);
+		const open = problems.retakesOpen.has(entity);
+		now.set(entity, record.s1Version);
+		if (count >= 3 && !open) {
+			problems.retakesOpen.add(entity);
+			out.push({
+				rule: "retakes",
+				severity: "info",
+				owner: entity,
+				view: viewLabel(pc, entity),
+				filter: record.slots[0]?.kind ?? null,
+				value: roundTo(count / RETAKES_SECONDS, 2),
+				threshold: 3 / RETAKES_SECONDS,
+				since,
+				frames: Math.max(1, pc.perf.frame - since)
+			});
+		} else if (count < 3 && open) {
+			problems.retakesOpen.delete(entity);
+			out.push({
+				rule: "retakes",
+				cleared: true,
+				owner: entity,
+				view: viewLabel(pc, entity)
+			});
+		}
+	}
+	for (const entity of problems.retakesOpen) {
+		if (now.has(entity)) continue;
+		problems.retakesOpen.delete(entity);
+		out.push({
+			rule: "retakes",
+			cleared: true,
+			owner: entity,
+			view: viewLabel(pc, entity)
+		});
+	}
+	problems.takes = [now, problems.takes[0]];
+	problems.takesFrame = [pc.perf.frame, problems.takesFrame[0]];
+}
+/**
+* The once-a-second judgment of the three rules, at the flush: the details of the problems that opened or cleared.
+* Allocates: the flush is allowed to.
+*
+* @param pc - The perf context.
+* @returns The details, in rule order.
+*/
+function judgeProblems(pc) {
+	const out = [];
+	judgeStill(pc, out);
+	judgeChurn(pc, out);
+	judgeRetakes(pc, out);
+	return out;
+}
+/**
+* Forgets every accumulator and every open problem: the renderer stopped.
+*
+* @param pc - The perf context's sinks and perf state.
+* @param pc.perf - The perf state.
+* @param pc.sinks - The sinks.
+*/
+function resetProblems(pc) {
+	const { problems } = pc.perf;
+	pc.sinks.owners.ids.fill(0);
+	problems.run.fill(0);
+	problems.secFrames.fill(0);
+	problems.secPixels.fill(0);
+	problems.stillOpen.fill(0);
+	problems.secTargets = 0;
+	problems.idleCreate = false;
+	problems.trimCreate = false;
+	problems.trimAt = NaN;
+	problems.churnRun = 0;
+	problems.churnOpen = false;
+	problems.takes = [/* @__PURE__ */ new Map(), /* @__PURE__ */ new Map()];
+	problems.takesFrame = [0, 0];
+	problems.retakesOpen.clear();
+}
+//#endregion
 //#region src/plugins/renderer/monitor/log-types.ts
 /**
 * The version every line carries as `v`.
@@ -15593,6 +16076,35 @@ const PERF_CAUSES = [
 	"longFrame",
 	"gc?"
 ];
+/**
+* What a `shader` event line reports, in its `what`: a render pipeline (WebGPU) or a program (WebGL) created, or a
+* WebGPU shader module compiled. New values are only ever appended.
+*
+* @example
+* ```ts
+* // The editor counts the pipelines of a recording without a switch over strings it does not know.
+* const pipelines = lines.filter(line => line.kind === "event" && line.name === "shader" && line.detail.what === SHADER_WHATS[0]).length; // 14
+* ```
+*/
+const SHADER_WHATS = ["compile", "module"];
+/**
+* The rules of the `problem` event lines, judged once a second: `filter-still` (a filtered view stood still and was
+* filtered again in every drawn frame), `target-churn` (render targets made and dropped all the time, or right after a
+* pool trim, or while idle), `retakes` (a kept view taken again and again). New rules are only ever appended.
+*
+* @example
+* ```ts
+* // The editor reads the rule of the first problem a recording opened: a fog blur filtered again on a still board.
+* const problems = lines.filter((line): line is PerfEventLine => line.kind === "event" && line.name === "problem");
+* const opened = problems.find(line => line.detail.cleared !== true);
+* PROBLEM_RULES.find(rule => rule === opened?.detail.rule); // "filter-still"
+* ```
+*/
+const PROBLEM_RULES = [
+	"filter-still",
+	"target-churn",
+	"retakes"
+];
 //#endregion
 //#region src/plugins/renderer/monitor/ring.ts
 /**
@@ -15637,12 +16149,26 @@ const CHANGE_NAMES = [
 	"bundle",
 	"restore"
 ];
-/** The pass kinds by their index in the pass ring. */
+/**
+* The pass kinds by their index in the pass ring's `kind` column: 0 the canvas, 1 a texture, 2 a filter. A root export,
+* so a reader of the ring names a pass's kind without building a record.
+*
+* @example
+* ```ts
+* // The editor's pass strip names the newest pass of a debug build from the ring.
+* const { passes } = app.renderer.monitor.frames();
+* PASS_KINDS[passes.kind[passes.newest] ?? 0]; // "filter"
+* ```
+*/
 const PASS_KINDS = [
 	"canvas",
 	"texture",
 	"filter"
 ];
+/** The prefix of the label of a pass that took or refreshed a kept picture (`kept:<view>#n`). */
+const KEPT_PREFIX = "kept:";
+/** The largest draw count the 16-bit `drawsAt` column holds. */
+const DRAWS_MAX = 65535;
 /**
 * Creates the ring of the changes with a subject: 64 slots, empty.
 *
@@ -15684,7 +16210,7 @@ function noteSubject(events, frame, change, what) {
 function subjectOf(events, frame, bit) {
 	for (let age = 0; age < events.size; age += 1) {
 		const slot = (events.next - 1 - age + 64) % 64;
-		if (cell(events.frames, slot) === frame && cell(events.kinds, slot) === bit) return events.whats[slot] ?? null;
+		if (cellU32(events.frames, slot) === frame && cellU8(events.kinds, slot) === bit) return events.whats[slot] ?? null;
 	}
 	return null;
 }
@@ -15732,7 +16258,9 @@ function createColumns(capacity) {
 		fltApplies: new Uint16Array(capacity * 4),
 		fltMpx: new Float32Array(capacity * 4),
 		kept: new Float32Array(capacity).fill(NaN),
-		retakes: new Float32Array(capacity).fill(NaN)
+		retakes: new Float32Array(capacity).fill(NaN),
+		targetsCreated: new Float32Array(capacity).fill(NaN),
+		targetsDestroyed: new Float32Array(capacity).fill(NaN)
 	};
 }
 /**
@@ -15754,11 +16282,86 @@ function createPasses(capacity) {
 		width: new Uint16Array(capacity),
 		height: new Uint16Array(capacity),
 		gpuMs: new Float32Array(capacity),
-		label: Array.from({ length: capacity }).fill(null)
+		label: Array.from({ length: capacity }).fill(null),
+		owner: new Uint32Array(capacity),
+		kind2: new Uint8Array(capacity),
+		drawsAt: new Uint16Array(capacity),
+		format: Array.from({ length: capacity }).fill(null),
+		resolution: new Float32Array(capacity).fill(NaN)
 	};
 }
 /**
-* Copies one column of `count` frames, oldest first, into the caller's array, an indexed loop over the ring.
+* Copies one `Float32Array` column of `count` frames, oldest first, into the caller's array, an indexed loop over the
+* ring. One copy per array kind, as one column reader per kind: its loads and stores see one kind of array, and a
+* double is copied unboxed.
+*
+* @param target - The caller's array; nothing is copied without one.
+* @param source - The ring's column.
+* @param stride - Values per frame.
+* @param ring - The ring.
+* @param oldest - Slot of the oldest frame to copy.
+* @param count - Frames to copy.
+*/
+function copyF32(target, source, stride, ring, oldest, count) {
+	if (target === void 0) return;
+	for (let index = 0; index < count; index += 1) {
+		const slot = (oldest + index) % ring.capacity;
+		for (let value = 0; value < stride; value += 1) target[index * stride + value] = cellF32(source, slot * stride + value);
+	}
+}
+/**
+* Copies one `Float64Array` column of `count` frames, oldest first, into the caller's array: `copyF32` for its kind.
+*
+* @param target - The caller's array; nothing is copied without one.
+* @param source - The ring's column.
+* @param stride - Values per frame.
+* @param ring - The ring.
+* @param oldest - Slot of the oldest frame to copy.
+* @param count - Frames to copy.
+*/
+function copyF64(target, source, stride, ring, oldest, count) {
+	if (target === void 0) return;
+	for (let index = 0; index < count; index += 1) {
+		const slot = (oldest + index) % ring.capacity;
+		for (let value = 0; value < stride; value += 1) target[index * stride + value] = cellF64(source, slot * stride + value);
+	}
+}
+/**
+* Copies one `Uint32Array` column of `count` frames, oldest first, into the caller's array: `copyF32` for its kind.
+*
+* @param target - The caller's array; nothing is copied without one.
+* @param source - The ring's column.
+* @param stride - Values per frame.
+* @param ring - The ring.
+* @param oldest - Slot of the oldest frame to copy.
+* @param count - Frames to copy.
+*/
+function copyU32(target, source, stride, ring, oldest, count) {
+	if (target === void 0) return;
+	for (let index = 0; index < count; index += 1) {
+		const slot = (oldest + index) % ring.capacity;
+		for (let value = 0; value < stride; value += 1) target[index * stride + value] = cellU32(source, slot * stride + value);
+	}
+}
+/**
+* Copies one `Uint16Array` column of `count` frames, oldest first, into the caller's array: `copyF32` for its kind.
+*
+* @param target - The caller's array; nothing is copied without one.
+* @param source - The ring's column.
+* @param stride - Values per frame.
+* @param ring - The ring.
+* @param oldest - Slot of the oldest frame to copy.
+* @param count - Frames to copy.
+*/
+function copyU16(target, source, stride, ring, oldest, count) {
+	if (target === void 0) return;
+	for (let index = 0; index < count; index += 1) {
+		const slot = (oldest + index) % ring.capacity;
+		for (let value = 0; value < stride; value += 1) target[index * stride + value] = cellU16(source, slot * stride + value);
+	}
+}
+/**
+* Copies one `Uint8Array` column of `count` frames, oldest first, into the caller's array: `copyF32` for its kind.
 *
 * @param target - The caller's array; nothing is copied without one.
 * @param source - The ring's column.
@@ -15767,11 +16370,11 @@ function createPasses(capacity) {
 * @param oldest - Slot of the oldest frame to copy.
 * @param count - Frames to copy.
 */
-function copyColumn(target, source, stride, ring, oldest, count) {
+function copyU8(target, source, stride, ring, oldest, count) {
 	if (target === void 0) return;
 	for (let index = 0; index < count; index += 1) {
 		const slot = (oldest + index) % ring.capacity;
-		for (let value = 0; value < stride; value += 1) target[index * stride + value] = cell(source, slot * stride + value);
+		for (let value = 0; value < stride; value += 1) target[index * stride + value] = cellU8(source, slot * stride + value);
 	}
 }
 /**
@@ -15791,43 +16394,45 @@ function readRing(ring, into, since) {
 	result.lost = available - count;
 	if (count === 0) return result;
 	const oldest = (ring.newest - count + 1 + ring.capacity) % ring.capacity;
-	copyColumn(into.frame, columns.frame, 1, ring, oldest, count);
-	copyColumn(into.t, columns.t, 1, ring, oldest, count);
-	copyColumn(into.gapMs, columns.gapMs, 1, ring, oldest, count);
-	copyColumn(into.capMs, columns.capMs, 1, ring, oldest, count);
-	copyColumn(into.skipped, columns.skipped, 1, ring, oldest, count);
-	copyColumn(into.startMs, columns.startMs, 1, ring, oldest, count);
-	copyColumn(into.rateMs, columns.rateMs, 1, ring, oldest, count);
-	copyColumn(into.budgetMs, columns.budgetMs, 1, ring, oldest, count);
-	copyColumn(into.phaseMs, columns.phaseMs, 6, ring, oldest, count);
-	copyColumn(into.agentMs, columns.agentMs, 1, ring, oldest, count);
-	copyColumn(into.workMs, columns.workMs, 1, ring, oldest, count);
-	copyColumn(into.drawn, columns.drawn, 1, ring, oldest, count);
-	copyColumn(into.idle, columns.idle, 1, ring, oldest, count);
-	copyColumn(into.stepped, columns.stepped, 1, ring, oldest, count);
-	copyColumn(into.passes, columns.passes, 1, ring, oldest, count);
-	copyColumn(into.stencilPasses, columns.stencilPasses, 1, ring, oldest, count);
-	copyColumn(into.draws, columns.draws, 1, ring, oldest, count);
-	copyColumn(into.filterApplies, columns.filterApplies, 1, ring, oldest, count);
-	copyColumn(into.filterMpx, columns.filterMpx, 1, ring, oldest, count);
-	copyColumn(into.uploads, columns.uploads, 1, ring, oldest, count);
-	copyColumn(into.uploadMb, columns.uploadMb, 1, ring, oldest, count);
-	copyColumn(into.compiles, columns.compiles, 1, ring, oldest, count);
-	copyColumn(into.marks, columns.marks, 1, ring, oldest, count);
-	copyColumn(into.rebuilds, columns.rebuilds, 1, ring, oldest, count);
-	copyColumn(into.gpuMs, columns.gpuMs, 1, ring, oldest, count);
-	copyColumn(into.gpuPartial, columns.gpuPartial, 1, ring, oldest, count);
-	copyColumn(into.path, columns.path, 1, ring, oldest, count);
-	copyColumn(into.changed, columns.changed, 1, ring, oldest, count);
-	copyColumn(into.causes, columns.causes, 1, ring, oldest, count);
-	copyColumn(into.reason, columns.reason, 1, ring, oldest, count);
-	copyColumn(into.sysIdx, columns.sysIdx, 5, ring, oldest, count);
-	copyColumn(into.sysMs, columns.sysMs, 5, ring, oldest, count);
-	copyColumn(into.fltKind, columns.fltKind, 4, ring, oldest, count);
-	copyColumn(into.fltApplies, columns.fltApplies, 4, ring, oldest, count);
-	copyColumn(into.fltMpx, columns.fltMpx, 4, ring, oldest, count);
-	copyColumn(into.kept, columns.kept, 1, ring, oldest, count);
-	copyColumn(into.retakes, columns.retakes, 1, ring, oldest, count);
+	copyU32(into.frame, columns.frame, 1, ring, oldest, count);
+	copyF64(into.t, columns.t, 1, ring, oldest, count);
+	copyF32(into.gapMs, columns.gapMs, 1, ring, oldest, count);
+	copyF32(into.capMs, columns.capMs, 1, ring, oldest, count);
+	copyU8(into.skipped, columns.skipped, 1, ring, oldest, count);
+	copyF32(into.startMs, columns.startMs, 1, ring, oldest, count);
+	copyF32(into.rateMs, columns.rateMs, 1, ring, oldest, count);
+	copyF32(into.budgetMs, columns.budgetMs, 1, ring, oldest, count);
+	copyF32(into.phaseMs, columns.phaseMs, 6, ring, oldest, count);
+	copyF32(into.agentMs, columns.agentMs, 1, ring, oldest, count);
+	copyF32(into.workMs, columns.workMs, 1, ring, oldest, count);
+	copyU8(into.drawn, columns.drawn, 1, ring, oldest, count);
+	copyU8(into.idle, columns.idle, 1, ring, oldest, count);
+	copyU8(into.stepped, columns.stepped, 1, ring, oldest, count);
+	copyF32(into.passes, columns.passes, 1, ring, oldest, count);
+	copyF32(into.stencilPasses, columns.stencilPasses, 1, ring, oldest, count);
+	copyF32(into.draws, columns.draws, 1, ring, oldest, count);
+	copyF32(into.filterApplies, columns.filterApplies, 1, ring, oldest, count);
+	copyF32(into.filterMpx, columns.filterMpx, 1, ring, oldest, count);
+	copyF32(into.uploads, columns.uploads, 1, ring, oldest, count);
+	copyF32(into.uploadMb, columns.uploadMb, 1, ring, oldest, count);
+	copyF32(into.compiles, columns.compiles, 1, ring, oldest, count);
+	copyF32(into.marks, columns.marks, 1, ring, oldest, count);
+	copyF32(into.rebuilds, columns.rebuilds, 1, ring, oldest, count);
+	copyF32(into.gpuMs, columns.gpuMs, 1, ring, oldest, count);
+	copyU8(into.gpuPartial, columns.gpuPartial, 1, ring, oldest, count);
+	copyU16(into.path, columns.path, 1, ring, oldest, count);
+	copyU8(into.changed, columns.changed, 1, ring, oldest, count);
+	copyU8(into.causes, columns.causes, 1, ring, oldest, count);
+	copyU8(into.reason, columns.reason, 1, ring, oldest, count);
+	copyU16(into.sysIdx, columns.sysIdx, 5, ring, oldest, count);
+	copyF32(into.sysMs, columns.sysMs, 5, ring, oldest, count);
+	copyU8(into.fltKind, columns.fltKind, 4, ring, oldest, count);
+	copyU16(into.fltApplies, columns.fltApplies, 4, ring, oldest, count);
+	copyF32(into.fltMpx, columns.fltMpx, 4, ring, oldest, count);
+	copyF32(into.kept, columns.kept, 1, ring, oldest, count);
+	copyF32(into.retakes, columns.retakes, 1, ring, oldest, count);
+	copyF32(into.targetsCreated, columns.targetsCreated, 1, ring, oldest, count);
+	copyF32(into.targetsDestroyed, columns.targetsDestroyed, 1, ring, oldest, count);
 	return result;
 }
 /**
@@ -15864,7 +16469,8 @@ function createFrameRing(capacity, events = createEventRing(), kindNames = []) {
 */
 const EMPTY_RING = /*#__PURE__*/ createFrameRing(0);
 /**
-* Records one render pass in the pass ring, the label by reference.
+* Records one render pass in the pass ring, the label by reference. The detail of the pass (its owner, filter kind,
+* draw count, format and resolution) goes into the same slot with `writePassDetail`, right after.
 *
 * @param passes - The pass ring.
 * @param frame - The frame number.
@@ -15887,12 +16493,36 @@ function writePass(passes, frame, index, kind, stencil, width, height, label) {
 	passes.height[slot] = height;
 	passes.gpuMs[slot] = NaN;
 	passes.label[slot] = label;
+	passes.owner[slot] = 0;
+	passes.kind2[slot] = 0;
+	passes.drawsAt[slot] = 0;
+	passes.format[slot] = null;
+	passes.resolution[slot] = NaN;
 	passes.newest = slot;
 	passes.size = Math.min(passes.size + 1, passes.capacity);
 	passes.written = sequence + 1;
 	return sequence;
 }
 /**
+* Writes the detail of the newest pass: the entity whose filter drew it, the filter kind (1-based, 0 none), the draw
+* count of the frame when it began, and its target's format (by reference) and resolution, read from the target's
+* source here so no double is handed over. Indexed stores only.
+*
+* @param passes - The pass ring, its newest slot the pass `writePass` just wrote.
+* @param owner - The entity, 0 for none.
+* @param kind2 - The interned filter kind plus one, 0 for none.
+* @param drawsAt - The frame's draws so far.
+* @param source - The source of the target's color texture, or `undefined`.
+*/
+function writePassDetail(passes, owner, kind2, drawsAt, source) {
+	const slot = passes.newest;
+	passes.owner[slot] = owner;
+	passes.kind2[slot] = kind2;
+	passes.drawsAt[slot] = Math.min(drawsAt, DRAWS_MAX);
+	passes.format[slot] = source?.format ?? null;
+	passes.resolution[slot] = source?.resolution ?? NaN;
+}
+/**
 * The commit number of the frame in a slot: `written − 1` for the newest.
 *
 * @param ring - The ring.
@@ -15959,13 +16589,13 @@ function spikeCauses(frame, agentMs, budget, previousCapMs) {
 	return causes;
 }
 /**
-* Tells whether a ring is the monitor's own: the one that knows the names its columns index.
+* Tells whether a ring is the monitor's own: the one that keeps the subjects of its changes.
 *
 * @param ring - A ring.
 * @returns True for a ring of `monitor.frames()`.
 */
 function isPerfRing(ring) {
-	return "events" in ring && "kindNames" in ring && "systemNames" in ring;
+	return "events" in ring;
 }
 /**
 * Milliseconds or megabytes of a column as a record carries them: 2 decimals, so a `Float32Array`
@@ -16012,17 +16642,17 @@ function namesOf$3(bits, names) {
 * @returns Kind, applies and megapixels, the most pixels first.
 */
 function filterKindsAt(ring, slot) {
-	const names = isPerfRing(ring) ? ring.kindNames : [];
+	const names = ring.kindNames;
 	const { columns } = ring;
 	const kinds = [];
 	for (let place = 0; place < 4; place += 1) {
 		const at = slot * 4 + place;
-		const kind = cell(columns.fltKind, at);
+		const kind = cellU8(columns.fltKind, at);
 		if (kind === 0) continue;
 		kinds.push({
 			kind: names[kind - 1] ?? "other",
-			applies: cell(columns.fltApplies, at),
-			mpx: two(cell(columns.fltMpx, at))
+			applies: cellU16(columns.fltApplies, at),
+			mpx: two(cellF32(columns.fltMpx, at))
 		});
 	}
 	return kinds;
@@ -16036,16 +16666,16 @@ function filterKindsAt(ring, slot) {
 */
 function systemsAt(ring, slot) {
 	const { columns } = ring;
-	if (Number.isNaN(cell(columns.sysMs, slot * 5))) return null;
-	const names = isPerfRing(ring) ? ring.systemNames : [];
+	if (Number.isNaN(cellF32(columns.sysMs, slot * 5))) return null;
+	const names = ring.systemNames;
 	const systems = [];
 	for (let place = 0; place < 5; place += 1) {
 		const at = slot * 5 + place;
-		const index = cell(columns.sysIdx, at);
+		const index = cellU16(columns.sysIdx, at);
 		if (index === 65535) continue;
 		systems.push({
 			name: names[index] ?? String(index),
-			ms: two(cell(columns.sysMs, at))
+			ms: two(cellF32(columns.sysMs, at))
 		});
 	}
 	return systems;
@@ -16058,39 +16688,73 @@ function systemsAt(ring, slot) {
 * @returns One entry per change, in bit order.
 */
 function changesAt(ring, slot) {
-	const bits = cell(ring.columns.changed, slot);
-	const frame = cell(ring.columns.frame, slot);
+	const bits = cellU8(ring.columns.changed, slot);
+	const frame = cellU32(ring.columns.frame, slot);
 	return namesOf$3(bits, CHANGE_NAMES).map((kind) => ({
 		kind,
 		what: isPerfRing(ring) ? subjectOf(ring.events, frame, CHANGED[kind]) : null
 	}));
 }
 /**
-* The render passes of a frame still in the pass ring, in their order.
+* The draws of each pass of a frame from the snapshots its passes took when they began: up to the next pass's
+* snapshot, the last up to the frame's total. Pure: rewrites `draws` in place.
+*
+* @param found - The passes of the frame, in order, with `draws` holding their snapshot.
+* @param total - The frame's draws; NaN where draws are not counted, which makes every `draws` `null`.
+* @example
+* ```ts
+* splitDraws([{ draws: 0 }, { draws: 5 }], 7); // the passes now say 5 and 2
+* ```
+*/
+function splitDraws(found, total) {
+	for (let index = 0; index < found.length; index += 1) {
+		const pass = found[index];
+		if (pass === void 0) continue;
+		const next = found[index + 1]?.draws ?? total;
+		pass.draws = Number.isNaN(total) ? null : Math.max(0, next - (pass.draws ?? 0));
+	}
+}
+/**
+* The render passes of a frame still in the pass ring, in their order, with their detail: the entity whose filter drew
+* each and its view's label, the filter kind, the draws, the target's format and resolution, whether it was a kept
+* picture's.
 *
 * @param ring - The ring.
 * @param frame - The frame number.
+* @param total - The frame's draws (its `draws` column); NaN where draws are not counted.
+* @param viewOf - The label of an entity's view now, or `null` once it left.
 * @returns The passes; empty when none was recorded or they were overwritten.
 */
-function passesOf$1(ring, frame) {
+function passesOf$1(ring, frame, total = NaN, viewOf = () => null) {
 	const { passes } = ring;
 	const found = [];
 	for (let age = 0; age < passes.size; age += 1) {
 		const slot = (passes.newest - age + passes.capacity) % passes.capacity;
-		const owner = cell(passes.frame, slot);
-		if (owner < frame) break;
-		if (owner !== frame) continue;
-		const stencil = cell(passes.stencil, slot);
+		const at = cellU32(passes.frame, slot);
+		if (at < frame) break;
+		if (at !== frame) continue;
+		const stencil = cellU8(passes.stencil, slot);
+		const label = passes.label[slot] ?? null;
+		const owner = cellU32(passes.owner, slot);
+		const kind2 = cellU8(passes.kind2, slot);
 		found.unshift({
-			index: cell(passes.index, slot),
-			kind: PASS_KINDS[cell(passes.kind, slot)] ?? "texture",
-			label: passes.label[slot] ?? null,
+			index: cellU8(passes.index, slot),
+			kind: PASS_KINDS[cellU8(passes.kind, slot)] ?? "texture",
+			label,
 			stencil: stencil === 255 ? null : stencil === 1,
-			w: cell(passes.width, slot),
-			h: cell(passes.height, slot),
-			gpuMs: measured(cell(passes.gpuMs, slot))
+			w: cellU16(passes.width, slot),
+			h: cellU16(passes.height, slot),
+			gpuMs: measured(cellF32(passes.gpuMs, slot)),
+			owner: owner === 0 ? null : owner,
+			view: owner === 0 ? null : viewOf(owner),
+			filter: kind2 === 0 ? null : ring.kindNames[kind2 - 1] ?? "other",
+			draws: cellU16(passes.drawsAt, slot),
+			format: passes.format[slot] ?? null,
+			resolution: measured(cellF32(passes.resolution, slot)),
+			kept: label?.startsWith(KEPT_PREFIX) === true
 		});
 	}
+	splitDraws(found, total);
 	return found;
 }
 /**
@@ -16103,56 +16767,56 @@ function passesOf$1(ring, frame) {
 function recordAt(ring, slot) {
 	const c = ring.columns;
 	const phase = slot * 6;
-	const applies = measured(cell(c.filterApplies, slot));
-	const uploads = measured(cell(c.uploads, slot));
-	const kept = measured(cell(c.kept, slot));
-	return {
-		frame: cell(c.frame, slot),
-		t: two(cell(c.t, slot)),
-		gapMs: measured(cell(c.gapMs, slot)),
-		capMs: two(cell(c.capMs, slot)),
-		rateMs: two(cell(c.rateMs, slot)),
-		budgetMs: two(cell(c.budgetMs, slot)),
-		skipped: cell(c.skipped, slot),
-		startMs: two(cell(c.startMs, slot)),
+	const applies = measured(cellF32(c.filterApplies, slot));
+	const uploads = measured(cellF32(c.uploads, slot));
+	const kept = measured(cellF32(c.kept, slot));
+	return {
+		frame: cellU32(c.frame, slot),
+		t: two(cellF64(c.t, slot)),
+		gapMs: measured(cellF32(c.gapMs, slot)),
+		capMs: two(cellF32(c.capMs, slot)),
+		rateMs: two(cellF32(c.rateMs, slot)),
+		budgetMs: two(cellF32(c.budgetMs, slot)),
+		skipped: cellU8(c.skipped, slot),
+		startMs: two(cellF32(c.startMs, slot)),
 		phases: {
-			input: two(cell(c.phaseMs, phase)),
-			animate: two(cell(c.phaseMs, phase + 1)),
-			layout: two(cell(c.phaseMs, phase + 2)),
-			sync: two(cell(c.phaseMs, phase + 3)),
-			signals: two(cell(c.phaseMs, phase + 4)),
-			render: two(cell(c.phaseMs, phase + 5)),
-			agent: two(cell(c.agentMs, slot))
-		},
-		workMs: two(cell(c.workMs, slot)),
-		drawn: cell(c.drawn, slot) === 1,
-		idle: cell(c.idle, slot) === 1,
-		stepped: cell(c.stepped, slot) === 1,
-		reason: DEMAND_REASONS[cell(c.reason, slot)] ?? null,
-		passes: measured(cell(c.passes, slot)),
-		stencilPasses: measured(cell(c.stencilPasses, slot)),
-		draws: measured(cell(c.draws, slot)),
+			input: two(cellF32(c.phaseMs, phase)),
+			animate: two(cellF32(c.phaseMs, phase + 1)),
+			layout: two(cellF32(c.phaseMs, phase + 2)),
+			sync: two(cellF32(c.phaseMs, phase + 3)),
+			signals: two(cellF32(c.phaseMs, phase + 4)),
+			render: two(cellF32(c.phaseMs, phase + 5)),
+			agent: two(cellF32(c.agentMs, slot))
+		},
+		workMs: two(cellF32(c.workMs, slot)),
+		drawn: cellU8(c.drawn, slot) === 1,
+		idle: cellU8(c.idle, slot) === 1,
+		stepped: cellU8(c.stepped, slot) === 1,
+		reason: DEMAND_REASONS[cellU8(c.reason, slot)] ?? null,
+		passes: measured(cellF32(c.passes, slot)),
+		stencilPasses: measured(cellF32(c.stencilPasses, slot)),
+		draws: measured(cellF32(c.draws, slot)),
 		filters: applies === null ? null : {
 			applies,
-			mpx: two(cell(c.filterMpx, slot)),
+			mpx: two(cellF32(c.filterMpx, slot)),
 			kinds: filterKindsAt(ring, slot)
 		},
 		uploads: uploads === null ? null : {
 			count: uploads,
-			mb: two(cell(c.uploadMb, slot))
+			mb: two(cellF32(c.uploadMb, slot))
 		},
-		compiles: measured(cell(c.compiles, slot)),
-		marks: measured(cell(c.marks, slot)),
-		rebuilds: measured(cell(c.rebuilds, slot)),
+		compiles: measured(cellF32(c.compiles, slot)),
+		marks: measured(cellF32(c.marks, slot)),
+		rebuilds: measured(cellF32(c.rebuilds, slot)),
 		systems: systemsAt(ring, slot),
-		gpuMs: measured(cell(c.gpuMs, slot)),
-		gpuPartial: cell(c.gpuPartial, slot) === 1,
-		path: ring.paths[cell(c.path, slot)] ?? "…",
+		gpuMs: measured(cellF32(c.gpuMs, slot)),
+		gpuPartial: cellU8(c.gpuPartial, slot) === 1,
+		path: ring.paths[cellU16(c.path, slot)] ?? "…",
 		changed: changesAt(ring, slot),
-		causes: namesOf$3(cell(c.causes, slot), PERF_CAUSES),
+		causes: namesOf$3(cellU8(c.causes, slot), PERF_CAUSES),
 		kept: kept === null ? null : {
 			pictures: kept,
-			retakes: cell(c.retakes, slot)
+			retakes: cellF32(c.retakes, slot)
 		}
 	};
 }
@@ -16175,63 +16839,68 @@ function frameAt(ring, age) {
 	return recordAt(ring, (ring.newest - age + ring.capacity) % ring.capacity);
 }
 //#endregion
-//#region src/plugins/renderer/monitor/types.ts
-/**
-* Indices of the per-frame counters in `MonitorSinks.counts`. Not public.
-*/
-const COUNT = {
-	passes: 0,
-	stencilPasses: 1,
-	filterApplies: 2,
-	filterPixels: 3,
-	uploads: 4,
-	uploadBytes: 5,
-	compiles: 6,
-	marks: 7,
-	rebuilds: 8
-};
-/**
-* What this application measures, as bits of `PerfState.measuring`. Not public.
-*/
-const MEASURE = {
-	passes: 1,
-	stencilPasses: 2,
-	draws: 4,
-	counted: 8,
-	compiles: 16,
-	gpu: 32
-};
-//#endregion
 //#region src/plugins/renderer/monitor/compiles.ts
 /**
 * @file renderer/monitor — pipeline compiles of an agent build (R5). Pixi creates its WebGPU pipelines in a private
 * method, so no subclass sees a creation; the count is taken one level lower, on GPU objects that belong to this
 * application, never on a prototype and never on a Pixi object (OQ4): own properties on the engine's own device, and
 * `linkProgram` on this application's WebGL context. The remover deletes the own property, so the prototype's method
-* shows through again. A restore attaches to the new device or context.
+* shows through again. A restore attaches to the new device or context. Each record also notes where it happened:
+* the pass of the frame, and the filter kind and its owner while a filter applies; a compile of a plain batch has
+* none. The flush turns the records into `shader` events.
 */
 /**
-* Counts one compile of the frame and keeps it in the next of the 64 pre-made records: its frame, its label by
-* reference and the CPU time of the creation call, the part a frame waits for.
+* Keeps one compile or shader module in the next of the 64 pre-made records: its frame, its label by reference, the
+* CPU time of the creation call, the part a frame waits for, and the pass, filter kind and owner of the moment.
 *
 * @param sinks - The sinks.
 * @param frame - The frame running now.
-* @param label - The pipeline's label, or `null`.
+* @param label - The pipeline's or module's label, or `null`.
 * @param ms - The time of the call.
+* @param module - True for a WebGPU shader module.
 */
-function recordCompile(sinks, frame, label, ms) {
+function writeRecord(sinks, frame, label, ms, module) {
 	const ring = sinks.compiles;
 	const record = ring.records[ring.next];
-	sinks.counts[COUNT.compiles] = cell(sinks.counts, COUNT.compiles) + 1;
+	const applying = sinks.filterDepth > 0;
 	ring.next = (ring.next + 1) % ring.records.length;
 	ring.size = Math.min(ring.size + 1, ring.records.length);
+	ring.written += 1;
 	if (record === void 0) return;
 	record.frame = frame;
 	record.label = label;
 	record.ms = ms;
+	record.module = module;
+	record.pass = sinks.inFrame ? cellF64(sinks.counts, COUNT.passes) - 1 : -1;
+	record.kind = applying ? sinks.filterKind + 1 : 0;
+	record.owner = applying ? sinks.filterOwner : 0;
 }
 /**
-* The compiles of one frame still in the ring, oldest first.
+* Counts one compile of the frame and keeps its record.
+*
+* @param sinks - The sinks.
+* @param frame - The frame running now.
+* @param label - The pipeline's label, or `null`.
+* @param ms - The time of the call.
+*/
+function recordCompile(sinks, frame, label, ms) {
+	sinks.counts[COUNT.compiles] = cellF64(sinks.counts, COUNT.compiles) + 1;
+	writeRecord(sinks, frame, label, ms, false);
+}
+/**
+* Keeps the record of one shader module: not a compile of the frame's count, a `shader` event of its own.
+*
+* @param sinks - The sinks.
+* @param frame - The frame running now.
+* @param label - The module's label, or `null`.
+* @param ms - The time of the call.
+*/
+function recordModule(sinks, frame, label, ms) {
+	sinks.compiles.shaderModules += 1;
+	writeRecord(sinks, frame, label, ms, true);
+}
+/**
+* The compiles of one frame still in the ring, oldest first; shader modules left out.
 *
 * @param sinks - The sinks.
 * @param frame - The frame number.
@@ -16242,7 +16911,7 @@ function compilesOf(sinks, frame) {
 	const found = [];
 	for (let age = ring.size - 1; age >= 0; age -= 1) {
 		const record = ring.records[(ring.next - 1 - age + ring.records.length) % ring.records.length];
-		if (record?.frame === frame) found.push({
+		if (record?.frame === frame && !record.module) found.push({
 			label: record.label,
 			ms: record.ms
 		});
@@ -16250,6 +16919,40 @@ function compilesOf(sinks, frame) {
 	return found;
 }
 /**
+* The details of the `shader` events not sent yet, oldest first, from the records still in the ring (the 64 newest);
+* marks them sent. Built at the flush: it allocates.
+*
+* @param pc - The perf context.
+* @param viewOf - The label of an entity's view now, or `null`.
+* @returns One detail per compile or module.
+*/
+function takeShaderEvents(pc, viewOf) {
+	const ring = pc.sinks.compiles;
+	const { kindNames } = pc.sinks;
+	const first = Math.max(ring.sent, ring.written - ring.records.length);
+	const boot = pc.perf.firstDrawnFrame;
+	const details = [];
+	for (let sequence = first; sequence < ring.written; sequence += 1) {
+		const record = ring.records[sequence % ring.records.length];
+		if (record === void 0) continue;
+		details.push({
+			what: record.module ? SHADER_WHATS[1] : SHADER_WHATS[0],
+			label: record.label,
+			ms: roundTo(record.ms, 2),
+			frame: record.frame,
+			boot: Number.isNaN(boot) || record.frame <= boot,
+			during: {
+				pass: record.pass < 0 ? null : record.pass,
+				filter: record.kind === 0 ? null : kindNames[record.kind - 1] ?? "other",
+				owner: record.owner === 0 ? null : record.owner,
+				view: record.owner === 0 ? null : viewOf(record.owner)
+			}
+		});
+	}
+	ring.sent = ring.written;
+	return details;
+}
+/**
 * Counts the render pipelines and the shader modules the engine's own device creates.
 *
 * @param pc - The perf context.
@@ -16280,14 +16983,17 @@ function wrapDevice(pc, device) {
 		configurable: true,
 		writable: true,
 		/**
-		* Creates the shader module and counts it for the header, not per frame.
+		* Creates the shader module and keeps its record: counted for the header and sent as a `shader` event, not a
+		* compile of the frame.
 		*
 		* @param descriptor - The module descriptor.
 		* @returns The module.
 		*/
 		value: function countedModule(descriptor) {
-			sinks.compiles.shaderModules += 1;
-			return createShaderModule.call(this, descriptor);
+			const started = pageNow();
+			const made = createShaderModule.call(this, descriptor);
+			recordModule(sinks, pc.perf.frame, descriptor.label ?? null, pageNow() - started);
+			return made;
 		}
 	});
 	return () => {
@@ -16334,6 +17040,414 @@ function wrapGl(pc, gl) {
 function attachCompileCounting(pc, target) {
 	return "createRenderPipeline" in target ? wrapDevice(pc, target) : wrapGl(pc, target);
 }
+/**
+* Creates the estimate: no interval yet, no period.
+*
+* @returns The estimate.
+*/
+function createTickEstimate() {
+	return {
+		samples: /* @__PURE__ */ new Float32Array(9),
+		sorted: /* @__PURE__ */ new Float32Array(9),
+		size: 0,
+		next: 0,
+		periodMs: Float64Array.of(NaN)
+	};
+}
+/**
+* Forgets every interval: the next frames start a new estimate.
+*
+* @param ticks - The estimate.
+*/
+function resetTicks(ticks) {
+	ticks.size = 0;
+	ticks.next = 0;
+	ticks.periodMs[0] = NaN;
+}
+/**
+* Adds the tick interval of a frame and snaps the median of the last nine to a display rate: `periodMs[0]` becomes
+* that rate's period, or NaN while the median matches none. A stepped frame, a frame without a gap and a gap over
+* 50 ms (a hitch, a page away) add nothing. The median is taken by an insertion sort into `sorted`: nine numbers.
+*
+* @param ticks - The estimate.
+* @param measure - What `time` measured of the frame; read, never kept.
+*/
+function noteTicks(ticks, measure) {
+	if (measure.stepped || Number.isNaN(measure.gapMs) || measure.gapMs > 50) return;
+	const { samples, sorted } = ticks;
+	samples[ticks.next] = measure.gapMs / (measure.skipped + 1);
+	ticks.next = (ticks.next + 1) % 9;
+	ticks.size = Math.min(ticks.size + 1, 9);
+	for (let index = 0; index < ticks.size; index += 1) {
+		const value = cellF32(samples, index);
+		let place = index;
+		while (place > 0 && cellF32(sorted, place - 1) > value) {
+			sorted[place] = cellF32(sorted, place - 1);
+			place -= 1;
+		}
+		sorted[place] = value;
+	}
+	const rate = displayIndexOf(cellF32(sorted, ticks.size >> 1));
+	const hz = rate === -1 ? void 0 : DISPLAY_RATES[rate];
+	ticks.periodMs[0] = hz === void 0 ? NaN : 1e3 / hz;
+}
+//#endregion
+//#region src/plugins/renderer/monitor/state.ts
+/** Compiles the compile ring keeps. */
+const COMPILE_SLOTS = 64;
+/** Long frames the long-frame ring keeps. */
+const LONG_FRAME_SLOTS = 64;
+/** Top scripts a long frame keeps. */
+const SCRIPT_SLOTS = 3;
+/** Rows the per-second system accumulators hold before they first grow. */
+const SYSTEM_ROWS = 16;
+/** Drawn frames a filtered view stands still, filtered in every one, before `filter-still` (U5). */
+const STILL_FRAMES = 60;
+/** Megapixels a still filtered view filters a frame before `filter-still`. */
+const STILL_MPX = .25;
+/** Render targets made and dropped a second that count as churn. */
+const CHURN_PER_SECOND = 4;
+/** Seconds in a row of churn before `target-churn`. */
+const CHURN_SECONDS = 3;
+/** A target made this soon after a pool trim is churn, ms. */
+const CHURN_AFTER_TRIM_MS = 1e3;
+/**
+* Creates an empty map. It lives in its own non-exported function because lint rule L5 refuses
+* a collection built inside an exported declaration.
+*
+* @returns An empty map.
+*/
+function emptyMap$7() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Creates an empty weak set. Same reason as `emptyMap`.
+*
+* @returns An empty weak set.
+*/
+function emptyWeakSet$1() {
+	return /* @__PURE__ */ new WeakSet();
+}
+/**
+* Creates an empty set. Same reason as `emptyMap`.
+*
+* @returns An empty set.
+*/
+function emptySet$6() {
+	return /* @__PURE__ */ new Set();
+}
+/**
+* Creates the compile ring: 64 pre-made records.
+*
+* @returns The ring, empty.
+*/
+function createCompileRing() {
+	return {
+		records: Array.from({ length: COMPILE_SLOTS }, () => ({
+			frame: 0,
+			label: null,
+			ms: 0,
+			module: false,
+			pass: -1,
+			kind: 0,
+			owner: 0
+		})),
+		next: 0,
+		size: 0,
+		shaderModules: 0,
+		written: 0,
+		sent: 0
+	};
+}
+/**
+* Creates the owner table of the filter applies: `OWNER_SLOTS` empty slots.
+*
+* @returns The table.
+*/
+function createOwnerTable() {
+	return {
+		ids: /* @__PURE__ */ new Float64Array(32),
+		applies: /* @__PURE__ */ new Float64Array(32),
+		pixels: /* @__PURE__ */ new Float64Array(32),
+		kinds: /* @__PURE__ */ new Uint8Array(32)
+	};
+}
+/**
+* Creates the count table: room for `COUNT_SLOTS` counts, none registered.
+*
+* @returns The table.
+*/
+function createCountTable() {
+	return {
+		names: [],
+		reads: [],
+		failed: emptySet$6()
+	};
+}
+/**
+* Creates the problem accumulators with the thresholds of `renderer.monitor`, a key left out at its default: a game
+* that sets `monitor` replaces the whole object (shallow merge).
+*
+* @param config - `renderer.monitor`.
+* @returns The accumulators, no problem open.
+*/
+function createProblemState(config) {
+	return {
+		thresholds: {
+			stillFrames: config.stillFrames ?? STILL_FRAMES,
+			stillMpx: config.stillMpx ?? STILL_MPX,
+			churnPerSecond: config.churnPerSecond ?? CHURN_PER_SECOND,
+			churnSeconds: config.churnSeconds ?? CHURN_SECONDS,
+			churnAfterTrimMs: config.churnAfterTrimMs ?? CHURN_AFTER_TRIM_MS
+		},
+		run: /* @__PURE__ */ new Float64Array(32),
+		runSince: /* @__PURE__ */ new Float64Array(32),
+		secFrames: /* @__PURE__ */ new Float64Array(32),
+		secPixels: /* @__PURE__ */ new Float64Array(32),
+		stillOpen: /* @__PURE__ */ new Uint8Array(32),
+		secTargets: 0,
+		idleCreate: false,
+		trimCreate: false,
+		createFrame: 0,
+		trimAt: NaN,
+		churnRun: 0,
+		churnSince: 0,
+		churnOpen: false,
+		takes: [emptyMap$7(), emptyMap$7()],
+		takesFrame: [0, 0],
+		retakesOpen: emptySet$6()
+	};
+}
+/**
+* Creates the long-frame ring: 64 pre-made records with three pre-made scripts each.
+*
+* @returns The ring, empty, observing nothing.
+*/
+function createLongFrameRing() {
+	return {
+		records: Array.from({ length: LONG_FRAME_SLOTS }, () => ({
+			startMs: 0,
+			durationMs: 0,
+			blockingMs: NaN,
+			renderStartMs: NaN,
+			styleLayoutMs: NaN,
+			scripts: Array.from({ length: SCRIPT_SLOTS }, () => ({
+				invoker: "",
+				type: "",
+				source: "",
+				fn: "",
+				ms: 0,
+				forcedLayoutMs: 0
+			})),
+			scriptCount: 0
+		})),
+		next: 0,
+		size: 0,
+		type: void 0,
+		disconnect: void 0
+	};
+}
+/**
+* Creates the sinks the counting classes write into. Its identity never changes; in a production
+* build it stays at zero.
+*
+* @param draws - The draw counter of the monitor state; a fresh one when left out.
+* @returns The sinks.
+*/
+function createSinks(draws) {
+	return {
+		draws: draws ?? {
+			frame: 0,
+			last: 0
+		},
+		counts: new Float64Array(Object.keys(COUNT).length),
+		inFrame: false,
+		filterDepth: 0,
+		filterKind: 0,
+		kindNames: ["other"],
+		kindApplies: /* @__PURE__ */ new Float64Array(32),
+		kindPixels: /* @__PURE__ */ new Float64Array(32),
+		filterKinds: void 0,
+		filterOwners: void 0,
+		filterOwner: 0,
+		owners: createOwnerTable(),
+		compiles: createCompileRing(),
+		passes: void 0,
+		measuring: false,
+		rebuildsWindow: 0
+	};
+}
+/**
+* Creates the performance monitor of an agent build. Nothing large is allocated here: the ring
+* gets its capacity at the first attach, once per renderer state.
+*
+* @param config - `renderer.monitor`.
+* @param sinks - The sinks of the monitor state.
+* @returns The perf state.
+*/
+function createPerfState(config, sinks) {
+	const events = createEventRing();
+	return {
+		budget: config.budgetMs,
+		frames: config.frames,
+		ring: createFrameRing(0, events, sinks.kindNames),
+		scratch: /* @__PURE__ */ new Float32Array(0),
+		staged: /* @__PURE__ */ new Float64Array(2),
+		ticks: createTickEstimate(),
+		rate: void 0,
+		drawn: false,
+		flags: 0,
+		pathIds: emptyMap$7(),
+		pathId: 0,
+		restPath: void 0,
+		produced: 0,
+		measuring: 0,
+		lastHeap: NaN,
+		secSum: new Float64Array(SYSTEM_ROWS),
+		secMax: new Float32Array(SYSTEM_ROWS),
+		gapHist: /* @__PURE__ */ new Uint16Array(81),
+		listenersSum: 0,
+		events,
+		display: void 0,
+		pending: /* @__PURE__ */ new Float64Array(64),
+		pendingCount: 0,
+		lastFlushAt: NaN,
+		agentMs: 0,
+		agentStart: NaN,
+		frame: 0,
+		listeners: [],
+		waiting: [],
+		failed: emptyWeakSet$1(),
+		shell: "unknown",
+		startup: void 0,
+		firstDrawnAt: NaN,
+		firstDrawnFrame: NaN,
+		counts: createCountTable(),
+		problems: createProblemState(config),
+		timer: void 0,
+		longFrames: createLongFrameRing(),
+		detach: [],
+		attached: false
+	};
+}
+/**
+* Creates the initial monitor state: no frame seen, an empty window, no capture waiting, no draw
+* counted, zeroed sinks, and in an agent build the performance monitor.
+*
+* @param config - `renderer.monitor`.
+* @returns The monitor branch of the plugin state.
+*/
+function createMonitorState(config) {
+	const draws = {
+		frame: 0,
+		last: 0
+	};
+	const sinks = createSinks(draws);
+	return {
+		frameStart: void 0,
+		lastStart: void 0,
+		windowMs: 0,
+		intervals: 0,
+		workMs: 0,
+		frames: 0,
+		fps: 0,
+		drawnIntervals: 0,
+		drawnFps: 0,
+		lastDrawn: false,
+		frameMs: 0,
+		redrawsOpen: 0,
+		rebuildsOpen: 0,
+		redraws: 0,
+		rebuilds: 0,
+		captures: [],
+		draws,
+		sinks,
+		perf: typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ ? createPerfState(config, sinks) : void 0,
+		passes: {
+			last: 0,
+			open: 0,
+			max: 0
+		},
+		passDetach: []
+	};
+}
+//#endregion
+//#region src/plugins/renderer/monitor/counts.ts
+/**
+* The error of a register when the table is full.
+*
+* @returns The error.
+*/
+function fullTable() {
+	return /* @__PURE__ */ new Error(`[game] Monitor count table is full (16).\n  Remove a registered count or raise the table size.`);
+}
+/**
+* Registers a count, or gives a registered name its new reader.
+*
+* @param table - The count table.
+* @param name - The count's name.
+* @param read - Answers the count now.
+* @returns The remover; a second call, or a call after the name got another reader, does nothing.
+* @throws {Error} When the table holds `COUNT_SLOTS` other counts.
+*/
+function registerCount(table, name, read) {
+	const at = table.names.indexOf(name);
+	if (at !== -1) table.reads[at] = read;
+	else if (table.names.length >= 16) throw fullTable();
+	else {
+		table.names.push(name);
+		table.reads.push(read);
+	}
+	return () => {
+		const index = table.names.indexOf(name);
+		if (index === -1 || table.reads[index] !== read) return;
+		table.names.splice(index, 1);
+		table.reads.splice(index, 1);
+	};
+}
+/**
+* Forgets every registered count: the renderer stopped.
+*
+* @param table - The count table.
+*/
+function clearCounts(table) {
+	table.names.length = 0;
+	table.reads.length = 0;
+	table.failed.clear();
+}
+/**
+* The live object counts now: the five the renderer reads itself, then each registered count by its name. A reader
+* that throws is left out and warned about once.
+*
+* @param pc - The perf context.
+* @returns A fresh object.
+*/
+function readCounts(pc) {
+	const { world, clock, time } = pc.ctx.deps;
+	const table = pc.perf.counts;
+	const counts = {
+		entities: world.ecs.count(),
+		views: pc.ctx.state.sync.views.size,
+		timers: clock.pending(),
+		frameListeners: time.frameListeners(),
+		clockListeners: clock.listeners()
+	};
+	for (let index = 0; index < table.names.length; index += 1) {
+		const name = table.names[index] ?? "";
+		try {
+			counts[name] = table.reads[index]?.() ?? 0;
+		} catch (error) {
+			if (!table.failed.has(name)) {
+				table.failed.add(name);
+				pc.ctx.log.warn("renderer: a monitor count failed", {
+					name,
+					error
+				});
+			}
+		}
+	}
+	return counts;
+}
 //#endregion
 //#region src/plugins/renderer/monitor/log.ts
 /** What follows the Android model in a user agent: `…; SM-A266B Build/…`. */
@@ -16345,7 +17459,7 @@ const UA_WEBVIEW = /; wv\)/;
 /** Bytes of one KiB. */
 const BYTES_PER_KB = 1024;
 /**
-* Spec 10's build id of the page: `"debug-20261014T153012Z"`, `"debug-full-…"` or `"dev"`; never a version string.
+* Spec 10's build id of the page: `"debug-20261014T153012Z"` or `"dev"`; never a version string.
 *
 * @returns The id, or `null` on a page without one.
 */
@@ -16353,6 +17467,15 @@ function buildId() {
 	return typeof __MOKU_GAME_BUILD__ === "string" ? __MOKU_GAME_BUILD__ : null;
 }
 /**
+* The bundle identifier the build wrote into the page (`__MOKU_GAME_APP__`), the `.debug` suffix of a native debug
+* build included.
+*
+* @returns The id, or `null` on a page without one.
+*/
+function appId() {
+	return typeof __MOKU_GAME_APP__ === "string" ? __MOKU_GAME_APP__ : null;
+}
+/**
 * Freezes a line and every object and array in it, so a listener may keep it after it returns.
 *
 * @param value - The line, or a part of it.
@@ -16486,6 +17609,7 @@ function measuredOf(pc) {
 	if (heapMb() !== null) list.push("heap");
 	if (pc.ctx.deps.world.systemTimes() !== void 0) list.push("systems");
 	list.push("kept");
+	if ((bits & MEASURE.targets) !== 0) list.push("targets");
 	return list;
 }
 /**
@@ -16500,14 +17624,14 @@ function capsOf(ring) {
 	let idleFps = 0;
 	for (let age = 0; age < ring.size && (maxFps === 0 || idleFps === 0); age += 1) {
 		const slot = (ring.newest - age + ring.capacity) % ring.capacity;
-		const fps = Math.round(1e3 / cell(c.capMs, slot));
-		if (cell(c.idle, slot) === 1) idleFps ||= fps;
+		const fps = Math.round(1e3 / cellF32(c.capMs, slot));
+		if (cellU8(c.idle, slot) === 1) idleFps ||= fps;
 		else maxFps ||= fps;
 	}
 	return {
 		maxFps,
 		idleFps,
-		budgetMs: ring.size === 0 ? 0 : cell(c.budgetMs, ring.newest)
+		budgetMs: ring.size === 0 ? 0 : cellF32(c.budgetMs, ring.newest)
 	};
 }
 /**
@@ -16584,7 +17708,9 @@ function headerLine(pc, thermal) {
 			budget,
 			frames: pc.perf.ring.capacity
 		},
-		measured: measuredOf(pc)
+		measured: measuredOf(pc),
+		app: { id: appId() },
+		debug: { overdraw: pc.ctx.state.sync.debug.overdraw }
 	};
 }
 /**
@@ -16611,7 +17737,7 @@ function meanMax(sum, count, max) {
 */
 function rank(sorted, count, quantile) {
 	if (count === 0) return 0;
-	return ms(cell(sorted, Math.min(count - 1, Math.max(0, Math.ceil(quantile * count) - 1))));
+	return ms(cellF32(sorted, Math.min(count - 1, Math.max(0, Math.ceil(quantile * count) - 1))));
 }
 /**
 * The slots of a window of the ring, newest first: the frames whose start lies in `[start, end)`.
@@ -16624,9 +17750,9 @@ function rank(sorted, count, quantile) {
 function windowOf$1(ring, start, end) {
 	const c = ring.columns;
 	let first = 0;
-	while (first < ring.size && cell(c.t, slotAt(ring, first)) >= end) first += 1;
+	while (first < ring.size && cellF64(c.t, slotAt(ring, first)) >= end) first += 1;
 	let count = 0;
-	while (first + count < ring.size && cell(c.t, slotAt(ring, first + count)) >= start) count += 1;
+	while (first + count < ring.size && cellF64(c.t, slotAt(ring, first + count)) >= start) count += 1;
 	return {
 		first,
 		count
@@ -16643,20 +17769,21 @@ function slotAt(ring, age) {
 	return (ring.newest - age + ring.capacity) % ring.capacity;
 }
 /**
-* Sorts the values a window gives into the scratch array and answers its spread.
+* Sorts the values of one column over a window into the scratch array and answers its spread. The column, not a
+* reader closure: a closure's double comes back boxed from its call, once for every frame of the window.
 *
 * @param pc - The perf context.
 * @param window - The window.
 * @param window.first - Its first age.
 * @param window.count - Its frames.
-* @param read - Reads a frame's value; NaN leaves the frame out.
+* @param column - A `Float32Array` column of the ring; NaN leaves the frame out.
 * @returns The values kept, and the scratch view sorted over them.
 */
-function sortedOf(pc, window, read) {
+function sortedOf(pc, window, column) {
 	const { ring, scratch } = pc.perf;
 	let count = 0;
 	for (let age = window.first; age < window.first + window.count; age += 1) {
-		const value = read(slotAt(ring, age));
+		const value = cellF32(column, slotAt(ring, age));
 		if (!Number.isNaN(value)) {
 			scratch[count] = value;
 			count += 1;
@@ -16675,8 +17802,8 @@ function sortedOf(pc, window, read) {
 * @param value - The phase's ms.
 */
 function addPhase(totals, index, value) {
-	totals.phaseSum[index] = cell(totals.phaseSum, index) + value;
-	totals.phaseMax[index] = Math.max(cell(totals.phaseMax, index), value);
+	totals.phaseSum[index] = cellF64(totals.phaseSum, index) + value;
+	totals.phaseMax[index] = Math.max(cellF64(totals.phaseMax, index), value);
 }
 /**
 * Adds one frame of a window: its phases, its counts, its gap. A missed gap is a frame with the `gap` cause: the
@@ -16687,22 +17814,24 @@ function addPhase(totals, index, value) {
 * @param slot - The frame's slot.
 */
 function addFrame(totals, c, slot) {
-	const agent = cell(c.agentMs, slot);
-	const missed = (cell(c.causes, slot) & CAUSE.gap) !== 0;
-	addPhase(totals, 0, cell(c.startMs, slot));
-	for (let index = 0; index < 6; index += 1) addPhase(totals, index + 1, cell(c.phaseMs, slot * 6 + index));
+	const agent = cellF32(c.agentMs, slot);
+	const missed = (cellU8(c.causes, slot) & CAUSE.gap) !== 0;
+	addPhase(totals, 0, cellF32(c.startMs, slot));
+	for (let index = 0; index < 6; index += 1) addPhase(totals, index + 1, cellF32(c.phaseMs, slot * 6 + index));
 	addPhase(totals, 7, agent);
-	totals.idle += cell(c.idle, slot);
-	totals.overBudget += cell(c.workMs, slot) - agent > cell(c.budgetMs, slot) ? 1 : 0;
-	totals.spikes += cell(c.causes, slot) === 0 ? 0 : 1;
+	totals.idle += cellU8(c.idle, slot);
+	totals.overBudget += cellF32(c.workMs, slot) - agent > cellF32(c.budgetMs, slot) ? 1 : 0;
+	totals.spikes += cellU8(c.causes, slot) === 0 ? 0 : 1;
 	totals.missed += missed ? 1 : 0;
-	totals.missedDrawn += missed && cell(c.drawn, slot) === 1 ? 1 : 0;
-	totals.skipped += cell(c.skipped, slot);
-	totals.uploads += cell(c.uploads, slot);
-	totals.uploadMb += cell(c.uploadMb, slot);
-	totals.compiles += cell(c.compiles, slot);
-	totals.rebuilds += cell(c.rebuilds, slot);
-	totals.retakes += cell(c.retakes, slot);
+	totals.missedDrawn += missed && cellU8(c.drawn, slot) === 1 ? 1 : 0;
+	totals.skipped += cellU8(c.skipped, slot);
+	totals.uploads += cellF32(c.uploads, slot);
+	totals.uploadMb += cellF32(c.uploadMb, slot);
+	totals.compiles += cellF32(c.compiles, slot);
+	totals.rebuilds += cellF32(c.rebuilds, slot);
+	totals.retakes += cellF32(c.retakes, slot);
+	totals.targetsCreated += cellF32(c.targetsCreated, slot);
+	totals.targetsDestroyed += cellF32(c.targetsDestroyed, slot);
 }
 /**
 * Adds what only a drawn frame has: its passes, draws and filters.
@@ -16713,15 +17842,15 @@ function addFrame(totals, c, slot) {
 */
 function addDrawn(totals, c, slot) {
 	totals.drawn += 1;
-	totals.passes += cell(c.passes, slot);
-	totals.passesMax = Math.max(totals.passesMax, cell(c.passes, slot));
-	totals.stencil += cell(c.stencilPasses, slot);
-	totals.draws += cell(c.draws, slot);
-	totals.drawsMax = Math.max(totals.drawsMax, cell(c.draws, slot));
-	totals.applies += cell(c.filterApplies, slot);
-	totals.appliesMax = Math.max(totals.appliesMax, cell(c.filterApplies, slot));
-	totals.mpx += cell(c.filterMpx, slot);
-	totals.keptMax = Math.max(totals.keptMax, cell(c.kept, slot));
+	totals.passes += cellF32(c.passes, slot);
+	totals.passesMax = Math.max(totals.passesMax, cellF32(c.passes, slot));
+	totals.stencil += cellF32(c.stencilPasses, slot);
+	totals.draws += cellF32(c.draws, slot);
+	totals.drawsMax = Math.max(totals.drawsMax, cellF32(c.draws, slot));
+	totals.applies += cellF32(c.filterApplies, slot);
+	totals.appliesMax = Math.max(totals.appliesMax, cellF32(c.filterApplies, slot));
+	totals.mpx += cellF32(c.filterMpx, slot);
+	totals.keptMax = Math.max(totals.keptMax, cellF32(c.kept, slot));
 }
 /**
 * Adds up the frames of a window.
@@ -16758,12 +17887,14 @@ function totalsOf(pc, window) {
 		compiles: 0,
 		rebuilds: 0,
 		keptMax: 0,
-		retakes: 0
+		retakes: 0,
+		targetsCreated: 0,
+		targetsDestroyed: 0
 	};
 	for (let age = window.first; age < window.first + window.count; age += 1) {
 		const slot = slotAt(ring, age);
 		addFrame(totals, c, slot);
-		if (cell(c.drawn, slot) === 1) addDrawn(totals, c, slot);
+		if (cellU8(c.drawn, slot) === 1) addDrawn(totals, c, slot);
 	}
 	return totals;
 }
@@ -16780,8 +17911,8 @@ function systemsOfSecond(pc, frames) {
 	const { secSum, secMax } = pc.perf;
 	return timing.names.slice(0, secSum.length).map((name, index) => ({
 		name,
-		mean: frames === 0 ? 0 : cell(secSum, index) / frames,
-		max: cell(secMax, index)
+		mean: frames === 0 ? 0 : cellF64(secSum, index) / frames,
+		max: cellF32(secMax, index)
 	})).filter((system) => system.mean > 0).toSorted((first, second) => second.mean - first.mean).slice(0, 5).map((system) => ({
 		name: system.name,
 		mean: ms(system.mean),
@@ -16837,7 +17968,7 @@ function perDrawn(sum, drawn) {
 */
 function gpuOfSecond(pc, window) {
 	const { columns } = pc.perf.ring;
-	const gpu = sortedOf(pc, window, (slot) => cell(columns.gpuMs, slot));
+	const gpu = sortedOf(pc, window, columns.gpuMs);
 	return {
 		p50: rank(gpu.sorted, gpu.count, .5),
 		p90: rank(gpu.sorted, gpu.count, .9),
@@ -16877,24 +18008,24 @@ function sampleLine(pc, start, end) {
 	const totals = totalsOf(pc, window);
 	const bits = perf.measuring;
 	const counted = (bits & MEASURE.counted) !== 0;
-	const work = sortedOf(pc, window, (slot) => cell(c.workMs, slot));
+	const work = sortedOf(pc, window, c.workMs);
 	const workP50 = rank(work.sorted, work.count, .5);
 	const workP90 = rank(work.sorted, work.count, .9);
 	const workMax = rank(work.sorted, work.count, 1);
-	const gaps = sortedOf(pc, window, (slot) => cell(c.gapMs, slot));
+	const gaps = sortedOf(pc, window, c.gapMs);
 	const gapP50 = rank(gaps.sorted, gaps.count, .5);
 	const gapP90 = rank(gaps.sorted, gaps.count, .9);
 	const gapP99 = rank(gaps.sorted, gaps.count, .99);
 	const usage = deps.host.textures();
 	const counts = deps.sync.counts();
 	const drawn = totals.drawn;
-	const phase = (index) => meanMax(cell(totals.phaseSum, index), frames, cell(totals.phaseMax, index));
+	const phase = (index) => meanMax(cellF64(totals.phaseSum, index), frames, cellF64(totals.phaseMax, index));
 	return {
 		v: 1,
 		kind: "sample",
 		t: epochOf(end),
 		build: buildId(),
-		frame: frames === 0 ? 0 : cell(c.frame, slotAt(ring, window.first)),
+		frame: frames === 0 ? 0 : cellU32(c.frame, slotAt(ring, window.first)),
 		windowMs: ms(end - start),
 		path: ring.paths[perf.pathId] ?? "…",
 		ticks: frames + totals.skipped,
@@ -16962,7 +18093,12 @@ function sampleLine(pc, start, end) {
 		pooled: counts.pooled,
 		resolution: deps.host.resolution(),
 		monitorMs: frames === 0 ? 0 : roundTo(perf.listenersSum / frames, 3),
-		spikes: totals.spikes
+		spikes: totals.spikes,
+		counts: readCounts(pc),
+		targets: (bits & MEASURE.targets) === 0 ? null : {
+			created: totals.targetsCreated,
+			destroyed: totals.targetsDestroyed
+		}
 	};
 }
 /**
@@ -16989,7 +18125,7 @@ function spikeLine(pc, slot) {
 			ms: ms(compile.ms)
 		})),
 		filters: record.filters?.kinds ?? [],
-		passes: passesOf$1(ring, record.frame),
+		passes: passesOf$1(ring, record.frame, cellF32(ring.columns.draws, slot), (entity) => viewLabel(pc, entity)),
 		longFrames: longFramesIn(longFrames, start, record.t + record.workMs).map((entry) => entryOf(entry))
 	};
 }
@@ -17066,10 +18202,10 @@ function framesOver(ring, record) {
 	let last = NaN;
 	for (let age = ring.size - 1; age >= 0; age -= 1) {
 		const slot = slotAt(ring, age);
-		const t = cell(c.t, slot);
-		if (t < end && t + cell(c.workMs, slot) > record.startMs) {
-			if (Number.isNaN(first)) first = cell(c.frame, slot);
-			last = cell(c.frame, slot);
+		const t = cellF64(c.t, slot);
+		if (t < end && t + cellF32(c.workMs, slot) > record.startMs) {
+			if (Number.isNaN(first)) first = cellU32(c.frame, slot);
+			last = cellU32(c.frame, slot);
 		}
 	}
 	return Number.isNaN(first) ? null : [first, last];
@@ -17200,248 +18336,6 @@ function buildStartup(pc) {
 		}
 	};
 }
-/**
-* Creates the estimate: no interval yet, no period.
-*
-* @returns The estimate.
-*/
-function createTickEstimate() {
-	return {
-		samples: /* @__PURE__ */ new Float32Array(9),
-		sorted: /* @__PURE__ */ new Float32Array(9),
-		size: 0,
-		next: 0,
-		periodMs: Float64Array.of(NaN)
-	};
-}
-/**
-* Forgets every interval: the next frames start a new estimate.
-*
-* @param ticks - The estimate.
-*/
-function resetTicks(ticks) {
-	ticks.size = 0;
-	ticks.next = 0;
-	ticks.periodMs[0] = NaN;
-}
-/**
-* Adds the tick interval of a frame and snaps the median of the last nine to a display rate: `periodMs[0]` becomes
-* that rate's period, or NaN while the median matches none. A stepped frame, a frame without a gap and a gap over
-* 50 ms (a hitch, a page away) add nothing. The median is taken by an insertion sort into `sorted`: nine numbers.
-*
-* @param ticks - The estimate.
-* @param measure - What `time` measured of the frame; read, never kept.
-*/
-function noteTicks(ticks, measure) {
-	if (measure.stepped || Number.isNaN(measure.gapMs) || measure.gapMs > 50) return;
-	const { samples, sorted } = ticks;
-	samples[ticks.next] = measure.gapMs / (measure.skipped + 1);
-	ticks.next = (ticks.next + 1) % 9;
-	ticks.size = Math.min(ticks.size + 1, 9);
-	for (let index = 0; index < ticks.size; index += 1) {
-		const value = cell(samples, index);
-		let place = index;
-		while (place > 0 && cell(sorted, place - 1) > value) {
-			sorted[place] = cell(sorted, place - 1);
-			place -= 1;
-		}
-		sorted[place] = value;
-	}
-	const rate = displayIndexOf(cell(sorted, ticks.size >> 1));
-	const hz = rate === -1 ? void 0 : DISPLAY_RATES[rate];
-	ticks.periodMs[0] = hz === void 0 ? NaN : 1e3 / hz;
-}
-//#endregion
-//#region src/plugins/renderer/monitor/state.ts
-/** Compiles the compile ring keeps. */
-const COMPILE_SLOTS = 64;
-/** Long frames the long-frame ring keeps. */
-const LONG_FRAME_SLOTS = 64;
-/** Top scripts a long frame keeps. */
-const SCRIPT_SLOTS = 3;
-/** Rows the per-second system accumulators hold before they first grow. */
-const SYSTEM_ROWS = 16;
-/**
-* Creates an empty map. It lives in its own non-exported function because lint rule L5 refuses
-* a collection built inside an exported declaration.
-*
-* @returns An empty map.
-*/
-function emptyMap$7() {
-	return /* @__PURE__ */ new Map();
-}
-/**
-* Creates an empty weak set. Same reason as `emptyMap`.
-*
-* @returns An empty weak set.
-*/
-function emptyWeakSet$1() {
-	return /* @__PURE__ */ new WeakSet();
-}
-/**
-* Creates the compile ring: 64 pre-made records.
-*
-* @returns The ring, empty.
-*/
-function createCompileRing() {
-	return {
-		records: Array.from({ length: COMPILE_SLOTS }, () => ({
-			frame: 0,
-			label: null,
-			ms: 0
-		})),
-		next: 0,
-		size: 0,
-		shaderModules: 0
-	};
-}
-/**
-* Creates the long-frame ring: 64 pre-made records with three pre-made scripts each.
-*
-* @returns The ring, empty, observing nothing.
-*/
-function createLongFrameRing() {
-	return {
-		records: Array.from({ length: LONG_FRAME_SLOTS }, () => ({
-			startMs: 0,
-			durationMs: 0,
-			blockingMs: NaN,
-			renderStartMs: NaN,
-			styleLayoutMs: NaN,
-			scripts: Array.from({ length: SCRIPT_SLOTS }, () => ({
-				invoker: "",
-				type: "",
-				source: "",
-				fn: "",
-				ms: 0,
-				forcedLayoutMs: 0
-			})),
-			scriptCount: 0
-		})),
-		next: 0,
-		size: 0,
-		type: void 0,
-		disconnect: void 0
-	};
-}
-/**
-* Creates the sinks the counting classes write into. Its identity never changes; in a production
-* build it stays at zero.
-*
-* @param draws - The draw counter of the monitor state; a fresh one when left out.
-* @returns The sinks.
-*/
-function createSinks(draws) {
-	return {
-		draws: draws ?? {
-			frame: 0,
-			last: 0
-		},
-		counts: new Float64Array(Object.keys(COUNT).length),
-		inFrame: false,
-		filterDepth: 0,
-		filterKind: 0,
-		kindNames: ["other"],
-		kindApplies: /* @__PURE__ */ new Float64Array(32),
-		kindPixels: /* @__PURE__ */ new Float64Array(32),
-		filterKinds: void 0,
-		compiles: createCompileRing(),
-		passes: void 0,
-		measuring: false,
-		rebuildsWindow: 0
-	};
-}
-/**
-* Creates the performance monitor of an agent build. Nothing large is allocated here: the ring
-* gets its capacity at the first attach, once per renderer state.
-*
-* @param config - `renderer.monitor`.
-* @param sinks - The sinks of the monitor state.
-* @returns The perf state.
-*/
-function createPerfState(config, sinks) {
-	const events = createEventRing();
-	return {
-		budget: config.budgetMs,
-		frames: config.frames,
-		ring: createFrameRing(0, events, sinks.kindNames),
-		scratch: /* @__PURE__ */ new Float32Array(0),
-		staged: /* @__PURE__ */ new Float64Array(2),
-		ticks: createTickEstimate(),
-		rate: void 0,
-		drawn: false,
-		flags: 0,
-		pathIds: emptyMap$7(),
-		pathId: 0,
-		restPath: void 0,
-		produced: 0,
-		measuring: 0,
-		lastHeap: NaN,
-		secSum: new Float64Array(SYSTEM_ROWS),
-		secMax: new Float32Array(SYSTEM_ROWS),
-		gapHist: /* @__PURE__ */ new Uint16Array(81),
-		listenersSum: 0,
-		events,
-		display: void 0,
-		pending: /* @__PURE__ */ new Float64Array(64),
-		pendingCount: 0,
-		lastFlushAt: NaN,
-		agentMs: 0,
-		agentStart: NaN,
-		frame: 0,
-		listeners: [],
-		waiting: [],
-		failed: emptyWeakSet$1(),
-		shell: "unknown",
-		startup: void 0,
-		firstDrawnAt: NaN,
-		timer: void 0,
-		longFrames: createLongFrameRing(),
-		detach: [],
-		attached: false
-	};
-}
-/**
-* Creates the initial monitor state: no frame seen, an empty window, no capture waiting, no draw
-* counted, zeroed sinks, and in an agent build the performance monitor.
-*
-* @param config - `renderer.monitor`.
-* @returns The monitor branch of the plugin state.
-*/
-function createMonitorState(config) {
-	const draws = {
-		frame: 0,
-		last: 0
-	};
-	const sinks = createSinks(draws);
-	return {
-		frameStart: void 0,
-		lastStart: void 0,
-		windowMs: 0,
-		intervals: 0,
-		workMs: 0,
-		frames: 0,
-		fps: 0,
-		drawnIntervals: 0,
-		drawnFps: 0,
-		lastDrawn: false,
-		frameMs: 0,
-		redrawsOpen: 0,
-		rebuildsOpen: 0,
-		redraws: 0,
-		rebuilds: 0,
-		captures: [],
-		draws,
-		sinks,
-		perf: typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ ? createPerfState(config, sinks) : void 0,
-		passes: {
-			last: 0,
-			open: 0,
-			max: 0
-		},
-		passDetach: []
-	};
-}
 /** A gap spike is annotated `compile` for a compile in one of this many frames before it: the stall comes later. */
 const COMPILE_LOOKBACK = 4;
 /** What a refused promise of the shell leads to: nothing, the log goes on. */
@@ -17555,7 +18449,7 @@ function addPending(perf, sequence) {
 */
 function compiledBefore(ring, slot) {
 	const age = (ring.newest - slot + ring.capacity) % ring.capacity;
-	for (let back = 1; back <= COMPILE_LOOKBACK && age + back < ring.size; back += 1) if (cell(ring.columns.compiles, (slot - back + ring.capacity) % ring.capacity) > 0) return true;
+	for (let back = 1; back <= COMPILE_LOOKBACK && age + back < ring.size; back += 1) if (cellF32(ring.columns.compiles, (slot - back + ring.capacity) % ring.capacity) > 0) return true;
 	return false;
 }
 /**
@@ -17570,10 +18464,10 @@ function compiledBefore(ring, slot) {
 function annotate(pc, slot) {
 	const { ring } = pc.perf;
 	const c = ring.columns;
-	const late = (cell(c.causes, slot) & CAUSE.gap) !== 0;
+	const late = (cellU8(c.causes, slot) & CAUSE.gap) !== 0;
 	let bits = 0;
-	if (cell(c.compiles, slot) > 0 || late && compiledBefore(ring, slot)) bits |= CAUSE.compile;
-	if (cell(c.uploadMb, slot) >= 1) bits |= CAUSE.upload;
+	if (cellF32(c.compiles, slot) > 0 || late && compiledBefore(ring, slot)) bits |= CAUSE.compile;
+	if (cellF32(c.uploadMb, slot) >= 1) bits |= CAUSE.upload;
 	if (annotateLongFrame(pc.perf, slot)) bits |= CAUSE.longFrame;
 	return bits;
 }
@@ -17590,11 +18484,11 @@ function flushSpikes(pc, windowStart) {
 	const c = ring.columns;
 	let kept = 0;
 	for (let index = 0; index < perf.pendingCount; index += 1) {
-		const sequence = cell(perf.pending, index);
+		const sequence = cellF64(perf.pending, index);
 		const slot = slotOfSequence(ring, sequence);
 		if (slot === -1) continue;
-		if (cell(c.gpuPartial, slot) === 0 || cell(c.t, slot) < windowStart) {
-			c.causes[slot] = cell(c.causes, slot) | annotate(pc, slot);
+		if (cellU8(c.gpuPartial, slot) === 0 || cellF64(c.t, slot) < windowStart) {
+			c.causes[slot] = cellU8(c.causes, slot) | annotate(pc, slot);
 			deliver(pc, spikeLine(pc, slot));
 		} else {
 			perf.pending[kept] = sequence;
@@ -17616,10 +18510,10 @@ function flushLoads(pc, start, end) {
 	const window = windowOf$1(ring, start, end);
 	for (let age = window.first + window.count - 1; age >= window.first; age -= 1) {
 		const slot = slotAt(ring, age);
-		const frame = cell(c.frame, slot);
-		if (Number.isNaN(firstDrawnAt) || cell(c.t, slot) <= firstDrawnAt) continue;
-		const compiles = cell(c.compiles, slot);
-		const mb = cell(c.uploadMb, slot);
+		const frame = cellU32(c.frame, slot);
+		if (Number.isNaN(firstDrawnAt) || cellF64(c.t, slot) <= firstDrawnAt) continue;
+		const compiles = cellF32(c.compiles, slot);
+		const mb = cellF32(c.uploadMb, slot);
 		if (compiles > 0) deliver(pc, eventLine("compile", {
 			frame,
 			count: compiles
@@ -17631,6 +18525,26 @@ function flushLoads(pc, start, end) {
 	}
 }
 /**
+* Writes a `shader` event for every compile and shader module not sent yet that the ring still holds, boot compiles
+* included: a listener that came after the boot still gets them at its first flush.
+*
+* @param pc - The perf context.
+*/
+function flushShaders(pc) {
+	for (const detail of takeShaderEvents(pc, (entity) => viewLabel(pc, entity))) deliver(pc, eventLine("shader", detail, detail.frame));
+}
+/**
+* Judges the problem rules of the second and writes a `problem` event for each that opened or cleared; without a
+* listener the rules are judged all the same, so their accumulators stay per second.
+*
+* @param pc - The perf context.
+*/
+function flushProblems(pc) {
+	const details = judgeProblems(pc);
+	if (pc.perf.listeners.length === 0) return;
+	for (const detail of details) deliver(pc, eventLine("problem", detail, pc.perf.frame));
+}
+/**
 * Starts a new second: the histogram, the system sums and maxima and the monitor's own cost go back to 0, the system
 * accumulators grown when the world registered more systems than they hold.
 *
@@ -17647,7 +18561,7 @@ function nextSecond(pc) {
 	perf.secSum.fill(0);
 	perf.secMax.fill(0);
 	perf.listenersSum = 0;
-	perf.lastFlushAt = cell(perf.staged, 1);
+	perf.lastFlushAt = cellF64(perf.staged, 1);
 }
 /**
 * The flush, once a second of page clock and on a pause: the GPU batch closes, the startup line is built once after
@@ -17660,7 +18574,7 @@ function nextSecond(pc) {
 function flushPerf(pc) {
 	const { perf } = pc;
 	const start = perf.lastFlushAt;
-	const windowEnd = cell(perf.staged, 1);
+	const windowEnd = cellF64(perf.staged, 1);
 	perf.timer?.close();
 	if (perf.startup === void 0 && !Number.isNaN(perf.firstDrawnAt)) {
 		const startup = deepFreeze(buildStartup(pc));
@@ -17671,7 +18585,9 @@ function flushPerf(pc) {
 		deliver(pc, sampleLine(pc, start, windowEnd));
 		flushSpikes(pc, start);
 		flushLoads(pc, start, windowEnd);
+		flushShaders(pc);
 	} else perf.pendingCount = 0;
+	flushProblems(pc);
 	nextSecond(pc);
 }
 /**
@@ -17727,6 +18643,8 @@ function openFrame(sinks) {
 	sinks.counts.fill(0);
 	sinks.kindApplies.fill(0);
 	sinks.kindPixels.fill(0);
+	sinks.owners.applies.fill(0);
+	sinks.owners.pixels.fill(0);
 	sinks.inFrame = true;
 }
 /**
@@ -17742,21 +18660,24 @@ function writeCounters(pc, slot) {
 	const { counts } = sinks;
 	const bits = perf.measuring;
 	const counted = (bits & MEASURE.counted) !== 0;
-	c.passes[slot] = (bits & MEASURE.passes) === 0 ? NaN : cell(counts, COUNT.passes);
-	c.stencilPasses[slot] = (bits & MEASURE.stencilPasses) === 0 ? NaN : cell(counts, COUNT.stencilPasses);
+	c.passes[slot] = (bits & MEASURE.passes) === 0 ? NaN : cellF64(counts, COUNT.passes);
+	c.stencilPasses[slot] = (bits & MEASURE.stencilPasses) === 0 ? NaN : cellF64(counts, COUNT.stencilPasses);
 	c.draws[slot] = (bits & MEASURE.draws) === 0 ? NaN : sinks.draws.last;
-	c.filterApplies[slot] = counted ? cell(counts, COUNT.filterApplies) : NaN;
-	c.filterMpx[slot] = counted ? cell(counts, COUNT.filterPixels) / PIXELS_PER_MPX : NaN;
-	c.uploads[slot] = counted ? cell(counts, COUNT.uploads) : NaN;
-	c.uploadMb[slot] = counted ? cell(counts, COUNT.uploadBytes) / BYTES_PER_MB$1 : NaN;
-	c.compiles[slot] = (bits & MEASURE.compiles) === 0 ? NaN : cell(counts, COUNT.compiles);
+	c.filterApplies[slot] = counted ? cellF64(counts, COUNT.filterApplies) : NaN;
+	c.filterMpx[slot] = counted ? cellF64(counts, COUNT.filterPixels) / PIXELS_PER_MPX : NaN;
+	c.uploads[slot] = counted ? cellF64(counts, COUNT.uploads) : NaN;
+	c.uploadMb[slot] = counted ? cellF64(counts, COUNT.uploadBytes) / BYTES_PER_MB$1 : NaN;
+	c.compiles[slot] = (bits & MEASURE.compiles) === 0 ? NaN : cellF64(counts, COUNT.compiles);
 	const decided = pc.deps.demand.frame();
 	c.marks[slot] = decided.marks;
 	c.reason[slot] = reasonIndex(decided.reason);
-	c.rebuilds[slot] = perf.produced === 0 ? NaN : cell(counts, COUNT.rebuilds);
+	c.rebuilds[slot] = perf.produced === 0 ? NaN : cellF64(counts, COUNT.rebuilds);
 	const kept = pc.ctx.state.kept;
 	c.kept[slot] = perf.drawn ? kept.drawnPictures : 0;
 	c.retakes[slot] = kept.frameTakes;
+	const targets = (bits & MEASURE.targets) !== 0;
+	c.targetsCreated[slot] = targets ? cellF64(counts, COUNT.targetsCreated) : NaN;
+	c.targetsDestroyed[slot] = targets ? cellF64(counts, COUNT.targetsDestroyed) : NaN;
 }
 /**
 * The index of a draw reason in ring order, `NO_REASON` for a name the order does not know.
@@ -17785,11 +18706,11 @@ function reasonIndex(reason) {
 */
 function insertTop(indices, values, base, stride, index, value) {
 	let place = stride;
-	while (place > 0 && value > cell(values, base + place - 1)) place -= 1;
+	while (place > 0 && value > cellF32(values, base + place - 1)) place -= 1;
 	if (place === stride) return;
 	for (let move = stride - 1; move > place; move -= 1) {
-		indices[base + move] = cell(indices, base + move - 1);
-		values[base + move] = cell(values, base + move - 1);
+		indices[base + move] = indices[base + move - 1] ?? 0;
+		values[base + move] = cellF32(values, base + move - 1);
 	}
 	indices[base + place] = index;
 	values[base + place] = value;
@@ -17815,7 +18736,7 @@ function writeSystems(pc, slot, timing) {
 	ring.systemNames = timing.names;
 	const count = Math.min(timing.names.length, timing.ms.length);
 	for (let index = 0; index < count; index += 1) {
-		const ms = cell(timing.ms, index);
+		const ms = cellF64(timing.ms, index);
 		if (ms > 0) insertTop(c.sysIdx, c.sysMs, base, 5, index, ms);
 	}
 }
@@ -17835,12 +18756,12 @@ function writeKinds(pc, slot) {
 	c.fltApplies.fill(0, base, base + 4);
 	const kinds = sinks.kindPixels.length;
 	for (let kind = 0; kind < kinds; kind += 1) {
-		const pixels = cell(sinks.kindPixels, kind);
+		const pixels = cellF64(sinks.kindPixels, kind);
 		if (pixels > 0) insertTop(c.fltKind, c.fltMpx, base, 4, kind + 1, pixels / PIXELS_PER_MPX);
 	}
 	for (let place = 0; place < 4; place += 1) {
-		const kind = cell(c.fltKind, base + place);
-		if (kind !== 0) c.fltApplies[base + place] = cell(sinks.kindApplies, kind - 1);
+		const kind = cellU8(c.fltKind, base + place);
+		if (kind !== 0) c.fltApplies[base + place] = cellF64(sinks.kindApplies, kind - 1);
 	}
 }
 /**
@@ -17854,15 +18775,15 @@ function writeKinds(pc, slot) {
 function accumulate(perf, measure, timing) {
 	if (!Number.isNaN(measure.gapMs)) {
 		const bucket = bucketOf(measure.gapMs);
-		perf.gapHist[bucket] = cell(perf.gapHist, bucket) + 1;
+		perf.gapHist[bucket] = cellU16(perf.gapHist, bucket) + 1;
 	}
 	perf.listenersSum += measure.listenersMs;
 	if (timing === void 0) return;
 	const count = Math.min(timing.names.length, timing.ms.length, perf.secSum.length);
 	for (let index = 0; index < count; index += 1) {
-		const ms = cell(timing.ms, index);
-		perf.secSum[index] = cell(perf.secSum, index) + ms;
-		if (ms > cell(perf.secMax, index)) perf.secMax[index] = ms;
+		const ms = cellF64(timing.ms, index);
+		perf.secSum[index] = cellF64(perf.secSum, index) + ms;
+		if (ms > cellF32(perf.secMax, index)) perf.secMax[index] = ms;
 	}
 }
 /**
@@ -17888,10 +18809,10 @@ function turned(pc) {
 * @param measure - What `time` measured of the frame.
 */
 function stageBudget(perf, measure) {
-	const ticksSlower = Number.isNaN(measure.displayMs) && cell(perf.ticks.periodMs, 0) > measure.rateMs;
+	const ticksSlower = Number.isNaN(measure.displayMs) && cellF64(perf.ticks.periodMs, 0) > measure.rateMs;
 	perf.staged[0] = measure.rateMs;
 	if (measure.displayMs > measure.rateMs) perf.staged[0] = measure.displayMs;
-	else if (ticksSlower) perf.staged[0] = cell(perf.ticks.periodMs, 0);
+	else if (ticksSlower) perf.staged[0] = cellF64(perf.ticks.periodMs, 0);
 	if (perf.budget !== "rate") perf.staged[0] = perf.budget;
 }
 /**
@@ -17931,7 +18852,7 @@ function gapJudged(pc, measure, previous, littleWork) {
 	if (pageHidden()) return false;
 	if (previous === -1) return true;
 	const c = pc.perf.ring.columns;
-	return !(littleWork && measure.gapMs > AWAY_GAP_MS && cell(c.gapMs, previous) > AWAY_GAP_MS) && (pc.perf.drawn || cell(c.drawn, previous) === 1);
+	return !(littleWork && measure.gapMs > AWAY_GAP_MS && cellF32(c.gapMs, previous) > AWAY_GAP_MS) && (pc.perf.drawn || cellU8(c.drawn, previous) === 1);
 }
 /**
 * Writes what `time` measured of the frame into its slot: the clock numbers, the phases, the work, the flags of the
@@ -17952,8 +18873,8 @@ function writeMeasure(pc, slot, measure) {
 	c.skipped[slot] = Math.min(SKIPPED_MAX, measure.skipped);
 	c.startMs[slot] = measure.startMs;
 	c.rateMs[slot] = measure.rateMs;
-	c.budgetMs[slot] = cell(perf.staged, 0);
-	for (let index = 0; index < 6; index += 1) c.phaseMs[phase + index] = cell(measure.phaseMs, index);
+	c.budgetMs[slot] = cellF64(perf.staged, 0);
+	for (let index = 0; index < 6; index += 1) c.phaseMs[phase + index] = cellF32(measure.phaseMs, index);
 	c.agentMs[slot] = perf.agentMs;
 	c.workMs[slot] = measure.workMs;
 	c.drawn[slot] = perf.drawn ? 1 : 0;
@@ -17978,7 +18899,7 @@ function commitFrame(pc, measure) {
 	const slot = ring.written % ring.capacity;
 	const previous = ring.size === 0 ? -1 : ring.newest;
 	stageBudget(perf, measure);
-	const budget = cell(perf.staged, 0);
+	const budget = cellF64(perf.staged, 0);
 	const { agentMs } = perf;
 	const timing = pc.ctx.deps.world.systemTimes();
 	writeMeasure(pc, slot, measure);
@@ -17987,7 +18908,7 @@ function commitFrame(pc, measure) {
 	writeKinds(pc, slot);
 	const heap = usedHeapBytes();
 	const heapDrop = perf.lastHeap - heap;
-	let causes = spikeCauses(measure, agentMs, budget, cell(c.capMs, previous));
+	let causes = spikeCauses(measure, agentMs, budget, previous === -1 ? NaN : cellF32(c.capMs, previous));
 	const littleWork = measure.workMs - agentMs < budget * GC_WORK_SHARE;
 	if ((causes & CAUSE.gap) !== 0 && !gapJudged(pc, measure, previous, littleWork)) causes &= ~CAUSE.gap;
 	const cameLate = (causes & CAUSE.gap) !== 0;
@@ -18009,8 +18930,12 @@ function commitFrame(pc, measure) {
 		flushPerf(pc);
 	}
 	accumulate(perf, measure, timing);
+	accumulateProblems(pc, measure);
 	if (causes !== 0) addPending(perf, sequenceOf(ring, slot));
-	if (perf.drawn && Number.isNaN(perf.firstDrawnAt)) perf.firstDrawnAt = measure.at + measure.workMs;
+	if (perf.drawn && Number.isNaN(perf.firstDrawnAt)) {
+		perf.firstDrawnAt = measure.at + measure.workMs;
+		perf.firstDrawnFrame = measure.frame;
+	}
 	if ((perf.flags & (CHANGED.resize | CHANGED.restore)) !== 0 || turned(pc) || retuned(pc)) writeDisplay(pc);
 	perf.flags = 0;
 	perf.drawn = false;
@@ -18052,6 +18977,19 @@ function labelOf$2(pc, target, kind) {
 	return kind === KIND.filter ? pc.sinks.kindNames[pc.sinks.filterKind] ?? null : null;
 }
 /**
+* Writes the detail of the pass just recorded: for a filter pass the owner and the 1-based kind of the apply running
+* now, the frame's draws so far, the target's format and resolution.
+*
+* @param pc - The perf context.
+* @param target - The target.
+* @param kind - The pass kind.
+*/
+function writeDetail(pc, target, kind) {
+	const { sinks } = pc;
+	const filter = kind === KIND.filter;
+	writePassDetail(pc.perf.ring.passes, filter ? sinks.filterOwner : 0, filter ? sinks.filterKind + 1 : 0, sinks.draws.frame, target.colorTexture?.source);
+}
+/**
 * Creates the WebGPU pass sink the counting encoder calls: each pass of a frame goes into the pass ring, with the
 * frame number and its index in the frame, and gets the timer's timestamp writes when there is a timer.
 *
@@ -18064,7 +19002,8 @@ function createPassSink(pc, timer, canvas) {
 	return {
 		begin: (descriptor, target) => {
 			const kind = kindOf$3(pc, target === canvas);
-			const sequence = writePass(pc.perf.ring.passes, pc.perf.frame, cell(pc.sinks.counts, COUNT.passes) - 1, kind, descriptor.depthStencilAttachment === void 0 ? 0 : 1, target.pixelWidth, target.pixelHeight, labelOf$2(pc, target, kind));
+			const sequence = writePass(pc.perf.ring.passes, pc.perf.frame, cellF64(pc.sinks.counts, COUNT.passes) - 1, kind, descriptor.depthStencilAttachment === void 0 ? 0 : 1, target.pixelWidth, target.pixelHeight, labelOf$2(pc, target, kind));
+			writeDetail(pc, target, kind);
 			timer?.timePass(descriptor, sequence);
 		},
 		resolve: (commandEncoder) => timer?.resolve(commandEncoder)
@@ -18090,7 +19029,7 @@ function countGlPasses(renderer, sinks, record) {
 	*/
 	const count = (target) => {
 		const { counts } = sinks;
-		const index = cell(counts, COUNT.passes);
+		const index = cellF64(counts, COUNT.passes);
 		counts[COUNT.passes] = index + 1;
 		record?.(target, index);
 	};
@@ -18136,6 +19075,7 @@ function attachGlPasses(renderer, pc) {
 	return countGlPasses(renderer, pc.sinks, (target, index) => {
 		const kind = kindOf$3(pc, target.isRoot);
 		writePass(pc.perf.ring.passes, pc.perf.frame, index, kind, 255, target.pixelWidth, target.pixelHeight, labelOf$2(pc, target, kind));
+		writeDetail(pc, target, kind);
 	});
 }
 /** Queries of one frame slot: two per pass. */
@@ -18179,10 +19119,10 @@ function createBatch() {
 function noteGpuTime(pc, slot) {
 	const { ring } = pc.perf;
 	const c = ring.columns;
-	const before = cell(c.causes, slot);
-	const gpuMs = cell(c.gpuMs, slot);
-	if (cell(c.stepped, slot) === 1 || (before & CAUSE.gpu) !== 0) return;
-	if (Number.isNaN(gpuMs) || gpuMs <= cell(c.budgetMs, slot)) return;
+	const before = cellU8(c.causes, slot);
+	const gpuMs = cellF32(c.gpuMs, slot);
+	if (cellU8(c.stepped, slot) === 1 || (before & CAUSE.gpu) !== 0) return;
+	if (Number.isNaN(gpuMs) || gpuMs <= cellF32(c.budgetMs, slot)) return;
 	c.causes[slot] = before | CAUSE.gpu | (before === 0 ? annotate(pc, slot) : 0);
 	if (before === 0) addPending(pc.perf, sequenceOf(ring, slot));
 }
@@ -18194,7 +19134,7 @@ function noteGpuTime(pc, slot) {
 * @returns Nanoseconds.
 */
 function stampAt(view, query) {
-	return cell(view, 2 * query + 1) * HIGH_WORD + cell(view, 2 * query);
+	return cellU32(view, 2 * query + 1) * HIGH_WORD + cellU32(view, 2 * query);
 }
 /**
 * Writes what the readback says of one frame slot: the time of each pass into its pass-ring entry
@@ -18208,21 +19148,21 @@ function stampAt(view, query) {
 */
 function readFrame(timer, batch, view, frame) {
 	const { columns, passes } = timer.pc.perf.ring;
-	const count = cell(batch.timed, frame);
+	const count = cellU8(batch.timed, frame);
 	let sum = 0;
-	let whole = cell(batch.partial, frame) === 0;
+	let whole = cellU8(batch.partial, frame) === 0;
 	for (let pass = 0; pass < count; pass += 1) {
 		const start = stampAt(view, frame * QUERIES_PER_FRAME + 2 * pass);
 		const end = stampAt(view, frame * QUERIES_PER_FRAME + 2 * pass + 1);
-		const sequence = cell(batch.passes, frame * 32 + pass);
+		const sequence = cellF64(batch.passes, frame * 32 + pass);
 		if (start > 0 && end > start) {
 			const ms = (end - start) / NS_PER_MS$1;
 			sum += ms;
 			if (passes.written - sequence <= passes.capacity) passes.gpuMs[sequence % passes.capacity] = ms;
 		} else whole = false;
 	}
-	const slot = cell(batch.slots, frame);
-	if (count === 0 || slot < 0 || cell(columns.frame, slot) !== cell(batch.frames, frame)) return;
+	const slot = cellI32(batch.slots, frame);
+	if (count === 0 || slot < 0 || cellU32(columns.frame, slot) !== cellF64(batch.frames, frame)) return;
 	columns.gpuMs[slot] = sum;
 	if (whole) columns.gpuPartial[slot] = 0;
 	noteGpuTime(timer.pc, slot);
@@ -18299,7 +19239,7 @@ function timePass(timer, descriptor, sequence) {
 	if (timer.frameSlot === -1) reserveFrame(timer);
 	if (timer.buffer === -1) return;
 	const { open } = timer;
-	const pass = cell(open.timed, timer.frameSlot);
+	const pass = cellU8(open.timed, timer.frameSlot);
 	const write = timer.writes[timer.frameSlot * 32 + pass];
 	if (pass >= 32 || write === void 0) {
 		open.partial[timer.frameSlot] = 1;
@@ -18320,7 +19260,7 @@ function timePass(timer, descriptor, sequence) {
 function resolveFrame(timer, commandEncoder) {
 	if (timer.frameSlot === -1) return;
 	const target = timer.buffers[timer.buffer];
-	const count = cell(timer.open.timed, timer.frameSlot);
+	const count = cellU8(timer.open.timed, timer.frameSlot);
 	const offset = timer.frameSlot * REGION_BYTES;
 	if (target === void 0 || count === 0) return;
 	commandEncoder.resolveQuerySet(timer.querySet, timer.frameSlot * QUERIES_PER_FRAME, 2 * count, timer.resolveBuffer, offset);
@@ -18467,7 +19407,7 @@ prerender: () => {
 		state.tried = true;
 		if (state.free === 0) return;
 		state.free -= 1;
-		state.active = cell(free, state.free);
+		state.active = cellI32(free, state.free);
 		const query = pool[state.active];
 		if (query !== void 0) gl.beginQuery(extension.TIME_ELAPSED_EXT, query);
 	} };
@@ -18487,7 +19427,7 @@ postrender: () => {
 	* Takes the query at the head of the queue back into the pool.
 	*/
 	const dequeue = () => {
-		free[state.free] = cell(queue, state.head);
+		free[state.free] = cellI32(queue, state.head);
 		state.free += 1;
 		state.head = (state.head + 1) % POOL_SIZE;
 		state.pending -= 1;
@@ -18503,16 +19443,16 @@ postrender: () => {
 			return;
 		}
 		while (state.pending > 0) {
-			const query = pool[cell(queue, state.head)];
+			const query = pool[cellI32(queue, state.head)];
 			if (query === void 0 || !gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE)) return;
 			const ms = Number(gl.getQueryParameter(query, gl.QUERY_RESULT)) / NS_PER_MS;
-			const slot = cell(queueSlots, state.head);
-			const frame = cell(queueFrames, state.head);
+			const slot = cellI32(queueSlots, state.head);
+			const frame = cellF64(queueFrames, state.head);
 			dequeue();
-			if (slot < 0 || cell(columns.frame, slot) !== frame) continue;
-			const before = cell(columns.gpuMs, slot);
+			if (slot < 0 || cellU32(columns.frame, slot) !== frame) continue;
+			const before = cellF32(columns.gpuMs, slot);
 			columns.gpuMs[slot] = Number.isNaN(before) ? ms : before + ms;
-			if (state.pending === 0 || cell(queueFrames, state.head) !== frame) columns.gpuPartial[slot] = 0;
+			if (state.pending === 0 || cellF64(queueFrames, state.head) !== frame) columns.gpuPartial[slot] = 0;
 			noteGpuTime(pc, slot);
 		}
 	};
@@ -18523,7 +19463,7 @@ postrender: () => {
 		commit: (slot, frame) => {
 			for (let index = 0; index < state.pending; index += 1) {
 				const at = (state.head + index) % POOL_SIZE;
-				if (cell(queueFrames, at) === frame) queueSlots[at] = slot;
+				if (cellF64(queueFrames, at) === frame) queueSlots[at] = slot;
 			}
 			if (state.tried) pc.perf.ring.columns.gpuPartial[slot] = 1;
 			state.tried = false;
@@ -18670,11 +19610,15 @@ function attachFirst(pc) {
 		perf.flags |= CHANGED.restore;
 		writeEvent(pc, "device-restored", { kind: host.kind() });
 	});
-	host.onTrim((reason, freedMb) => writeEvent(pc, "pool-trim", {
-		reason,
-		freedMb
-	}));
+	host.onTrim((reason, freedMb) => {
+		perf.problems.trimAt = pageNow();
+		writeEvent(pc, "pool-trim", {
+			reason,
+			freedMb
+		});
+	});
 	deps.sync.onWarm((draws) => writeEvent(pc, "warm", { draws }));
+	deps.sync.onOverdraw((on) => writeEvent(pc, "debug", { overdraw: on }));
 	notePath(pc, ctx.deps.flow.state().path, false);
 	perf.display = displayOf(pc);
 }
@@ -18740,17 +19684,19 @@ function attachPerf(pc) {
 	perf.timer = void 0;
 	sinks.passes = void 0;
 	sinks.filterKinds = ctx.state.sync.filterKinds;
+	sinks.filterOwners = ctx.state.sync.filterOwners;
 	const counted = ctx.state.host.uninstallCounting !== void 0;
 	const kind = pc.deps.host.kind();
 	let bits = counted ? MEASURE.counted : 0;
+	if (counted && kind === "webgpu") bits |= MEASURE.targets;
 	if (kind === "webgpu") bits |= attachGpu(pc, counted);
 	else if (kind === "webgl") bits |= attachGl(pc);
 	perf.measuring = bits;
 }
 /**
 * Stops the monitor of an agent build: the per-application removers run, the timer stops, the observer disconnects,
-* the listeners, the pending spikes, the paths and the display's ticks go. The ring keeps its arrays (a restart of the same app reuses
-* them), empty.
+* the listeners, the pending spikes, the paths, the display's ticks, the registered counts and the problem
+* accumulators go. The ring keeps its arrays (a restart of the same app reuses them), empty.
 *
 * @param perf - The perf state.
 * @param sinks - The sinks.
@@ -18783,7 +19729,14 @@ function stopPerf(perf, sinks) {
 	resetTicks(perf.ticks);
 	sinks.passes = void 0;
 	sinks.filterKinds = void 0;
+	sinks.filterOwners = void 0;
+	sinks.filterOwner = 0;
 	sinks.inFrame = false;
+	clearCounts(perf.counts);
+	resetProblems({
+		perf,
+		sinks
+	});
 }
 //#endregion
 //#region src/plugins/renderer/monitor/window.ts
@@ -18887,6 +19840,10 @@ function resetWindow(state) {
 */
 const noStream = () => {};
 /**
+* The remover `counts.register` answers in a build without the agent flag: it does nothing.
+*/
+const noCount = () => {};
+/**
 * The detail of an event written without one.
 */
 const NO_DETAIL = Object.freeze({});
@@ -18954,7 +19911,7 @@ function createMonitorApi(ctx, deps) {
 	* @param drawn - True when the render phase drew the frame.
 	*/
 	const notePasses = (drawn) => {
-		const count = cell(sinks.counts, COUNT.passes);
+		const count = cellF64(sinks.counts, COUNT.passes);
 		if (drawn && count > 0) {
 			passes.last = count;
 			passes.open = Math.max(passes.open, count);
@@ -18984,12 +19941,17 @@ function createMonitorApi(ctx, deps) {
 				kept: deps.kept.stats()
 			};
 			if ((typeof __MOKU_GAME_DEV__ === "undefined" || !__MOKU_GAME_DEV__) && (typeof __MOKU_GAME_AGENT__ === "undefined" || !__MOKU_GAME_AGENT__)) return stats;
-			return {
+			const dev = {
 				...stats,
 				drawCalls: state.draws.last,
 				redraws: roundTo(state.redraws, 1),
 				rebuilds: roundTo(state.rebuilds, 1)
 			};
+			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) return {
+				...dev,
+				counts: readCounts(pc)
+			};
+			return dev;
 		},
 		capture: async (options = {}) => {
 			if ((typeof __MOKU_GAME_DEV__ === "undefined" || !__MOKU_GAME_DEV__) && (typeof __MOKU_GAME_AGENT__ === "undefined" || !__MOKU_GAME_AGENT__)) return;
@@ -19015,6 +19977,10 @@ function createMonitorApi(ctx, deps) {
 		endAgent: () => {
 			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) endAgent(pc);
 		},
+		counts: { register: (name, read) => {
+			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) return registerCount(pc.perf.counts, name, read);
+			return noCount;
+		} },
 		setResolution: (resolution) => {
 			if (!takesResolution(resolution)) throw new RangeError(resolutionMessage(resolution));
 			return deps.host.overrideResolution(resolution);
@@ -19062,7 +20028,7 @@ function createMonitorApi(ctx, deps) {
 		count: (_counter, amount) => {
 			if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && pc !== void 0) {
 				pc.perf.produced |= 1;
-				pc.sinks.counts[COUNT.rebuilds] = cell(pc.sinks.counts, COUNT.rebuilds) + amount;
+				pc.sinks.counts[COUNT.rebuilds] = cellF64(pc.sinks.counts, COUNT.rebuilds) + amount;
 			}
 		},
 		path: (path, rest) => {
@@ -19509,21 +20475,33 @@ function filtersOf(state, entity) {
 	return state.filters.get(entity) ?? [];
 }
 /**
-* Notes the kind of a slot's filter for the performance log: the filter itself, the stage filters
-* of its inputs and, for a blur, the two pass filters Pixi applies in its place. A slot without a
-* kind is left out: it counts as "other".
+* The Pixi filters a slot draws through: the filter itself, the stage filters of its inputs and, for a blur, the two
+* pass filters Pixi applies in its place.
+*
+* @param slot - The slot.
+* @returns The filters.
+*/
+function filtersIn(slot) {
+	const { filter } = slot;
+	const found = [filter, ...slot.inputs?.stages ?? []];
+	if ("blurXFilter" in filter && isFilterObject(filter.blurXFilter)) found.push(filter.blurXFilter);
+	if ("blurYFilter" in filter && isFilterObject(filter.blurYFilter)) found.push(filter.blurYFilter);
+	return found;
+}
+/**
+* Notes the kind and the owner of a slot's filters for the performance log: every filter it draws through. A slot
+* without a kind counts as "other".
 *
 * @param state - The sync branch of the plugin state.
+* @param entity - The entity the slot hangs on.
 * @param slot - The slot.
 */
-function nameKind(state, slot) {
-	const { filter, kind } = slot;
-	if (kind === void 0) return;
-	state.filterKinds.set(filter, kind);
-	const stages = slot.inputs?.stages;
-	if (stages !== void 0) for (const stage of stages) state.filterKinds.set(stage, kind);
-	if ("blurXFilter" in filter && isFilterObject(filter.blurXFilter)) state.filterKinds.set(filter.blurXFilter, kind);
-	if ("blurYFilter" in filter && isFilterObject(filter.blurYFilter)) state.filterKinds.set(filter.blurYFilter, kind);
+function nameFilters(state, entity, slot) {
+	const { kind } = slot;
+	for (const filter of filtersIn(slot)) {
+		state.filterOwners.set(filter, entity);
+		if (kind !== void 0) state.filterKinds.set(filter, kind);
+	}
 }
 /**
 * Tells whether a property a filter may carry holds an object: the pass filter Pixi's blur keeps under it. Pure.
@@ -19552,7 +20530,7 @@ function isFilterObject(value) {
 function setFilters(state, entity, slots, mark, kept) {
 	if (slots.length === 0) state.filters.delete(entity);
 	else state.filters.set(entity, [...slots]);
-	if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) for (const slot of slots) nameKind(state, slot);
+	if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) for (const slot of slots) nameFilters(state, entity, slot);
 	const view = state.views.get(entity);
 	if (view !== void 0) applyFilters(view, slots, () => mark(entity), kept.filterTarget(view));
 	else if (slots.length > 0) state.viewlessEntries = true;
@@ -23488,6 +24466,7 @@ function stopSync(state) {
 	stopWarm(state);
 	state.held.clear();
 	state.redraws = 0;
+	state.overdraw.listeners.length = 0;
 	clearLayers(state);
 	destroyPools(state);
 	state.root?.destroy({ children: true });
@@ -23633,7 +24612,8 @@ function withDeps$8(ctx) {
 * oracle; `demand` settles the
 * frame (the dev check, the pixel oracle), and `monitor` closes it and hands a drawn one to a
 * waiting capture; last, `host` trims Pixi's texture pool when a rest or a scene change is due. The display objects
-* are written by the `sync` system.
+* are written by the `sync` system. While the overdraw heat map of a dev or debug build is on, every frame asks to be
+* drawn and its stage pass is drawn as the map (`sync.drawOverdraw`).
 *
 * With `onDemand`, a frame in which nothing visible changed is not drawn: the canvas keeps the
 * last picture (WebGPU presents a canvas texture only when one is rendered; a WebGL canvas keeps
@@ -23655,11 +24635,13 @@ function renderFrame(ctx, modules) {
 	modules.sync.stepOverlays();
 	modules.sync.drainOverlayEvents(modules.monitor);
 	modules.kept.collect();
+	const overdraw = modules.sync.overdrawing();
+	if (overdraw) modules.demand.request();
 	const drawn = modules.demand.decide(modules.monitor.waiting());
 	if (drawn) {
 		const probed = modules.sync.warmStep();
 		modules.kept.flush();
-		if (modules.host.render()) {
+		if (overdraw ? modules.sync.drawOverdraw(modules.host.render) : modules.host.render()) {
 			ctx.deps.time.frameDrawn();
 			if (probed) ctx.deps.time.frameProbed();
 		}
@@ -23753,6 +24735,61 @@ function internKind(sinks, kind) {
 	return sinks.kindNames.length - 1;
 }
 /**
+* The slot of an owner in the owner table of the frame: its own slot, else the first free one, which it takes. An
+* indexed search over at most 32 slots: no allocation. A full table tracks no more owners.
+*
+* @param owners - The owner table.
+* @param owner - The entity, not 0.
+* @returns The slot, or -1 when the table is full.
+*/
+function ownerSlot(owners, owner) {
+	let free = -1;
+	for (let slot = 0; slot < 32; slot += 1) {
+		const id = cellF64(owners.ids, slot);
+		if (id === owner) return slot;
+		if (id === 0 && free === -1) free = slot;
+	}
+	if (free !== -1) owners.ids[free] = owner;
+	return free;
+}
+/**
+* Counts one filter apply of a frame: its pixels (width times height times resolution squared), its interned kind and
+* its owner, into the frame's counters, the kinds' and the owner table, and notes the kind and the owner being applied
+* so a pass begun inside is named by them. A plain function apart from the class: indexed stores only.
+*
+* @param sinks - The sinks.
+* @param filter - The filter applied.
+* @param input - Its input texture.
+*/
+function countApply(sinks, filter, input) {
+	const { counts, owners } = sinks;
+	const resolution = input.source.resolution;
+	const pixels = input.frame.width * input.frame.height * resolution * resolution;
+	const kind = internKind(sinks, sinks.filterKinds?.get(filter));
+	const owner = sinks.filterOwners?.get(filter) ?? 0;
+	const slot = owner === 0 ? -1 : ownerSlot(owners, owner);
+	counts[COUNT.filterApplies] = cellF64(counts, COUNT.filterApplies) + 1;
+	counts[COUNT.filterPixels] = cellF64(counts, COUNT.filterPixels) + pixels;
+	sinks.kindApplies[kind] = cellF64(sinks.kindApplies, kind) + 1;
+	sinks.kindPixels[kind] = cellF64(sinks.kindPixels, kind) + pixels;
+	sinks.filterKind = kind;
+	sinks.filterOwner = owner;
+	if (slot !== -1) {
+		owners.applies[slot] = cellF64(owners.applies, slot) + 1;
+		owners.pixels[slot] = cellF64(owners.pixels, slot) + pixels;
+		owners.kinds[slot] = kind + 1;
+	}
+}
+/**
+* Tells whether a source is a render target: it has no upload method, as `countUpload` tells them apart.
+*
+* @param source - The source.
+* @returns True for a render target.
+*/
+function isTarget(source) {
+	return source.uploadMethodId === "unknown";
+}
+/**
 * The bytes one upload of a source sends: 4 a pixel, or for a compressed source the sum of its
 * levels' `byteLength`.
 *
@@ -23778,8 +24815,8 @@ function countUpload(sinks, source) {
 	if (source.uploadMethodId === "unknown") return;
 	if (source.resource === null || source.resource === void 0) return;
 	const { counts } = sinks;
-	counts[COUNT.uploads] = cell(counts, COUNT.uploads) + 1;
-	counts[COUNT.uploadBytes] = cell(counts, COUNT.uploadBytes) + uploadBytes(source);
+	counts[COUNT.uploads] = cellF64(counts, COUNT.uploads) + 1;
+	counts[COUNT.uploadBytes] = cellF64(counts, COUNT.uploadBytes) + uploadBytes(source);
 }
 /**
 * Builds the seven counting subclasses from the module object. They are made at call time,
@@ -23804,7 +24841,7 @@ function createCountingClasses(pixi, sinks) {
 		* @param instructionSet - The instruction set being rebuilt.
 		*/
 		buildStart(instructionSet) {
-			if (sinks.inFrame) sinks.counts[COUNT.rebuilds] = cell(sinks.counts, COUNT.rebuilds) + 1;
+			if (sinks.inFrame) sinks.counts[COUNT.rebuilds] = cellF64(sinks.counts, COUNT.rebuilds) + 1;
 			sinks.rebuildsWindow += 1;
 			super.buildStart(instructionSet);
 		}
@@ -23885,8 +24922,8 @@ function createCountingClasses(pixi, sinks) {
 			if (sinks.inFrame) {
 				const { counts } = sinks;
 				const { descriptor } = gpuRenderTarget;
-				counts[COUNT.passes] = cell(counts, COUNT.passes) + 1;
-				if (descriptor.depthStencilAttachment !== void 0) counts[COUNT.stencilPasses] = cell(counts, COUNT.stencilPasses) + 1;
+				counts[COUNT.passes] = cellF64(counts, COUNT.passes) + 1;
+				if (descriptor.depthStencilAttachment !== void 0) counts[COUNT.stencilPasses] = cellF64(counts, COUNT.stencilPasses) + 1;
 				sinks.passes?.begin(descriptor, this.owner.renderTarget.renderTarget);
 			}
 			return super.beginRenderPass(gpuRenderTarget);
@@ -23905,34 +24942,50 @@ function createCountingClasses(pixi, sinks) {
 	class CountingFilterSystem extends pixi.FilterSystem {
 		static extension = pixi.FilterSystem.extension;
 		/**
-		* Counts the apply and its area inside a frame, notes the kind being applied so a pass begun
-		* inside is a filter pass named by it, then applies.
+		* Counts the apply and its area inside a frame, notes the kind and the owner being applied so a pass begun
+		* inside is a filter pass named by them, then applies. Its four arguments are named, not spread: a rest array
+		* would be made at every apply.
 		*
-		* @param args - The filter, its input, the output and the clear.
+		* @param filter - The filter.
+		* @param input - Its input texture.
+		* @param output - Where it draws.
+		* @param clear - Whether the output is cleared first.
 		*/
-		applyFilter(...args) {
-			const [filter, input] = args;
-			if (sinks.inFrame) {
-				const { counts } = sinks;
-				const pixels = input.frame.width * input.frame.height * input.source.resolution ** 2;
-				const kind = internKind(sinks, sinks.filterKinds?.get(filter));
-				counts[COUNT.filterApplies] = cell(counts, COUNT.filterApplies) + 1;
-				counts[COUNT.filterPixels] = cell(counts, COUNT.filterPixels) + pixels;
-				sinks.kindApplies[kind] = cell(sinks.kindApplies, kind) + 1;
-				sinks.kindPixels[kind] = cell(sinks.kindPixels, kind) + pixels;
-				sinks.filterKind = kind;
-			}
+		applyFilter(filter, input, output, clear) {
+			if (sinks.inFrame) countApply(sinks, filter, input);
 			sinks.filterDepth += 1;
 			try {
-				super.applyFilter(...args);
+				super.applyFilter(filter, input, output, clear);
 			} finally {
 				sinks.filterDepth -= 1;
 			}
 		}
 	}
-	/** Counts every upload of the WebGPU texture system. */
+	/**
+	* Counts every upload of the WebGPU texture system, and every render target it creates and drops: a target's
+	* source is created once in `initSource` and dropped once in `onSourceUnload` (a destroy, a pool trim, a lost
+	* device). Pixi calls `initSource` again for a source it already made (it answers the same texture then): the set of
+	* the targets made tells a new one.
+	*/
 	class CountingGpuTextureSystem extends pixi.GpuTextureSystem {
 		static extension = pixi.GpuTextureSystem.extension;
+		/** The render-target sources this system made and has not dropped. */
+		targets = /* @__PURE__ */ new WeakSet();
+		/**
+		* Makes the GPU texture of a source, and counts a render target made for the first time.
+		*
+		* @param source - The source.
+		* @returns The GPU texture.
+		*/
+		initSource(source) {
+			const made = isTarget(source) && !this.targets.has(source);
+			const texture = super.initSource(source);
+			if (made) {
+				this.targets.add(source);
+				sinks.counts[COUNT.targetsCreated] = cellF64(sinks.counts, COUNT.targetsCreated) + 1;
+			}
+			return texture;
+		}
 		/**
 		* Uploads the source, then counts it; the first upload goes through here too.
 		*
@@ -23942,6 +24995,15 @@ function createCountingClasses(pixi, sinks) {
 			super.onSourceUpdate(source);
 			countUpload(sinks, source);
 		}
+		/**
+		* Drops the source's GPU texture, and counts a render target dropped.
+		*
+		* @param source - The source.
+		*/
+		onSourceUnload(source) {
+			if (this.targets.delete(source)) sinks.counts[COUNT.targetsDestroyed] = cellF64(sinks.counts, COUNT.targetsDestroyed) + 1;
+			super.onSourceUnload(source);
+		}
 	}
 	/** Counts every upload of the WebGL texture system. */
 	class CountingGlTextureSystem extends pixi.GlTextureSystem {
@@ -24034,7 +25096,7 @@ function installPassCounting(pixi, sinks) {
 		* @returns The pass encoder.
 		*/
 		beginRenderPass(gpuRenderTarget) {
-			if (sinks.inFrame) sinks.counts[COUNT.passes] = cell(sinks.counts, COUNT.passes) + 1;
+			if (sinks.inFrame) sinks.counts[COUNT.passes] = cellF64(sinks.counts, COUNT.passes) + 1;
 			return super.beginRenderPass(gpuRenderTarget);
 		}
 	}
@@ -24370,6 +25432,162 @@ function layerOf(sctx, entity) {
 	return ecs.get(top, Layer)?.name;
 }
 //#endregion
+//#region src/plugins/renderer/sync/overdraw.ts
+/** The alpha one layer adds: 16 layers make white. */
+const LAYER_ALPHA = 1 / 16;
+/** The blend mode whose alpha adds up: `src + dst`. */
+const ADDITIVE = "add-npm";
+/**
+* The colour matrix of the heat map: red, green and blue are the frame's alpha, the alpha is 1. Rows of five: the
+* weights of red, green, blue and alpha, and an offset.
+*
+* @returns A fresh matrix.
+*/
+function alphaToGrey() {
+	return [
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		1
+	];
+}
+/**
+* Creates the overdraw state: off, an empty restore table, no matrix yet.
+*
+* @returns The state.
+*/
+function createOverdrawState() {
+	return {
+		nodes: [],
+		alphas: [],
+		blends: [],
+		filters: [],
+		rootFilters: void 0,
+		matrix: void 0,
+		listeners: []
+	};
+}
+/**
+* The filters a node holds now: Pixi answers `undefined` before the first write and `null` after a clear.
+*
+* @param node - The node.
+* @returns The filters, or `undefined` when it holds none.
+*/
+function heldBy(node) {
+	const held = node.filters;
+	return held === null || held === void 0 || held.length === 0 ? void 0 : held;
+}
+/**
+* Notes a node's alpha, blend mode and filters in the restore table and gives it the overdraw state.
+*
+* @param state - The overdraw state.
+* @param node - The node.
+* @param alpha - Its overdraw alpha when it draws at all.
+*/
+function swapNode(state, node, alpha) {
+	const filters = heldBy(node);
+	state.nodes.push(node);
+	state.alphas.push(node.alpha);
+	state.blends.push(node.blendMode);
+	state.filters.push(filters);
+	if (node.alpha > 0) node.alpha = alpha;
+	node.blendMode = ADDITIVE;
+	if (filters !== void 0) node.filters = null;
+}
+/**
+* Gives a subtree the overdraw state, a node that is not drawn (invisible, or not renderable) left as it is with its
+* children.
+*
+* @param state - The overdraw state.
+* @param top - The subtree's top.
+* @param alpha - The top's overdraw alpha.
+*/
+function swapTree(state, top, alpha) {
+	const open = [top];
+	for (let node = open.pop(); node !== void 0; node = open.pop()) {
+		if (!node.visible || !node.renderable) continue;
+		swapNode(state, node, node === top ? alpha : 1);
+		for (const child of node.children) open.push(child);
+	}
+}
+/**
+* The colour matrix of the heat map, made once per Pixi module.
+*
+* @param state - The overdraw state.
+* @param pixi - The Pixi module.
+* @returns The filter.
+*/
+function matrixOf(state, pixi) {
+	if (state.matrix !== void 0) return state.matrix;
+	const matrix = new pixi.ColorMatrixFilter();
+	matrix.matrix = alphaToGrey();
+	state.matrix = matrix;
+	return matrix;
+}
+/**
+* Puts every node back as the restore table holds it, the root's filters last; the table is empty after.
+*
+* @param state - The overdraw state.
+* @param root - The root.
+*/
+function restoreAll(state, root) {
+	for (let index = state.nodes.length - 1; index >= 0; index -= 1) {
+		const node = state.nodes[index];
+		if (node === void 0) continue;
+		node.alpha = state.alphas[index] ?? 1;
+		node.blendMode = state.blends[index] ?? "inherit";
+		const filters = state.filters[index];
+		if (filters !== void 0) node.filters = [...filters];
+	}
+	root.filters = state.rootFilters === void 0 ? null : [...state.rootFilters];
+	state.nodes.length = 0;
+	state.alphas.length = 0;
+	state.blends.length = 0;
+	state.filters.length = 0;
+	state.rootFilters = void 0;
+}
+/**
+* Draws the stage pass as the overdraw heat map: every kept picture live, every layer and node in the overdraw state
+* and the matrix on the root for the one `render` call, and everything back right after it, also when it throws.
+* Without a root or a Pixi module it only renders.
+*
+* @param sctx - Domain context of the sync module.
+* @param render - The stage pass.
+* @returns What `render` answered.
+*/
+function drawOverdraw(sctx, render) {
+	const { root } = sctx.ctx.state.sync;
+	const pixi = sctx.deps.host.pixi();
+	if (root === void 0 || pixi === void 0) return render();
+	const state = sctx.ctx.state.sync.overdraw;
+	return sctx.deps.kept.live(() => {
+		try {
+			state.rootFilters = heldBy(root);
+			for (const layer of root.children) swapTree(state, layer, LAYER_ALPHA);
+			root.filters = [matrixOf(state, pixi)];
+			return render();
+		} finally {
+			restoreAll(state, root);
+		}
+	});
+}
+//#endregion
 //#region src/plugins/renderer/sync/overlay-look.ts
 /**
 * Makes the dim of one overlay: a sprite of Pixi's white texture, never a view.
@@ -24569,7 +25787,7 @@ function stepParts(sctx) {
 	if (overlay.parts.size === 0 && overlay.offTops.size === 0) return;
 	const hud = hudLayerOf(state);
 	const ecs = sctx.ctx.deps.world.ecs;
-	overlay.nextOff.clear();
+	if (overlay.nextOff.size > 0) overlay.nextOff.clear();
 	for (const entity of overlay.parts) {
 		const view = state.views.get(entity);
 		if (view === void 0) continue;
@@ -24942,7 +26160,7 @@ function stepOverlays(sctx) {
 	const overlay = state.overlay;
 	if (state.root === void 0 || overlaysIdle(overlay)) return;
 	const wholes = sctx.deps.demand.wholes();
-	overlay.flipped.clear();
+	if (overlay.flipped.size > 0) overlay.flipped.clear();
 	if (wholes.has("layers")) clearRange(sctx);
 	for (const record of overlay.records.values()) record.seen = false;
 	for (const entity of overlay.entities) seeOverlay(sctx, entity);
@@ -25445,7 +26663,7 @@ function createSyncApi(ctx, deps) {
 	* view. A still frame (nothing added, removed or left without a view) builds no set and walks no entry.
 	*/
 	const pass = () => {
-		state.held.clear();
+		if (state.held.size > 0) state.held.clear();
 		if (state.removed.size > 0) {
 			for (const entity of state.removed) {
 				guard(entity, () => dropView(sctx, entity));
@@ -25561,6 +26779,16 @@ function createSyncApi(ctx, deps) {
 			},
 			verifyFrames: (on) => deps.demand.verifyFrames(on),
 			kept: (on) => deps.kept.enabled(on),
+			overdraw: (on) => {
+				const next = on && (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__);
+				if (state.debug.overdraw === next) return;
+				state.debug.overdraw = next;
+				deps.demand.request();
+				if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) {
+					ctx.log.info("renderer:overdraw", { on: next });
+					for (const listener of state.overdraw.listeners) listener(next);
+				}
+			},
 			overlays: () => overlayReports(sctx),
 			state: () => ({
 				...state.debug,
@@ -25583,6 +26811,14 @@ function createSyncApi(ctx, deps) {
 		onWarm: (fn) => {
 			state.warm.listeners.push(fn);
 		},
+		overdrawing: () => state.debug.overdraw,
+		drawOverdraw: (render) => {
+			if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) return drawOverdraw(sctx, render);
+			return render();
+		},
+		onOverdraw: (fn) => {
+			state.overdraw.listeners.push(fn);
+		},
 		loopsHeld: (entity, reveals) => loopsHeld(sctx, entity) || unseenHolds(sctx, entity, reveals),
 		takeRedraws: () => {
 			const redraws = state.redraws;
@@ -26184,7 +27420,8 @@ function createRendererApi(ctx) {
 			event: monitor.event,
 			beginAgent: monitor.beginAgent,
 			endAgent: monitor.endAgent,
-			setResolution: monitor.setResolution
+			setResolution: monitor.setResolution,
+			counts: monitor.counts
 		},
 		invalidate: demand.invalidate,
 		stats: monitor.stats,
@@ -26268,6 +27505,9 @@ function createHandlers$5(ctx) {
 //#endregion
 //#region src/plugins/renderer/sync/state.ts
 /**
+* @file renderer/sync — state factory.
+*/
+/**
 * Creates an empty collection. It lives in its own non-exported function because lint rule L5
 * refuses a collection built inside an exported declaration.
 *
@@ -26354,6 +27594,7 @@ function createWarmState() {
 * @returns The sync branch of the plugin state.
 */
 function createSyncState(debug) {
+	const overdrawInDebugBuild = debug.overdraw === true && (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__);
 	return {
 		root: void 0,
 		layerList: void 0,
@@ -26376,13 +27617,18 @@ function createSyncState(debug) {
 		reparented: emptySet$4(),
 		orphans: emptySet$4(),
 		mismatched: emptySet$4(),
-		debug: { nineSlice: debug.nineSlice === true },
+		debug: {
+			nineSlice: debug.nineSlice === true,
+			overdraw: overdrawInDebugBuild
+		},
+		overdraw: createOverdrawState(),
 		outlinesStale: false,
 		filters: emptyMap$6(),
 		areas: emptyMap$6(),
 		viewlessEntries: false,
 		warm: createWarmState(),
 		filterKinds: emptyWeakMap$1(),
+		filterOwners: emptyWeakMap$1(),
 		objectHidden: emptyWeakMap$1(),
 		viewOfTop: emptyWeakMap$1(),
 		overlay: createOverlayState(),
@@ -26553,11 +27799,17 @@ const rendererPlugin = /*#__PURE__*/ createPlugin$1("renderer", {
 		debug: {
 			nineSlice: false,
 			verifyFrames: false,
-			kept: true
+			kept: true,
+			overdraw: false
 		},
 		monitor: {
 			budgetMs: "rate",
-			frames: 1024
+			frames: 1024,
+			stillFrames: 60,
+			stillMpx: .25,
+			churnPerSecond: 4,
+			churnSeconds: 3,
+			churnAfterTrimMs: 1e3
 		},
 		onDemand: false,
 		keptMb: 64,
@@ -41466,11 +42718,72 @@ function stepGestures(ctx, time) {
 	pointer.id = ctx.state.pointerId ?? -1;
 }
 //#endregion
+//#region src/plugins/input/state.ts
+/**
+* Creates the initial input state: an empty sample queue, no active pointer and no gesture. Every
+* duration starts at zero; the plugin never reads a device clock.
+*
+* @param _ctx - Minimal context.
+* @param _ctx.config - Resolved plugin config.
+* @returns A fresh state, owned by one app.
+*/
+function createInputState(_ctx) {
+	return {
+		samples: [],
+		phase: "idle",
+		pointerId: void 0,
+		moved: false,
+		entity: void 0,
+		key: void 0,
+		start: {
+			x: 0,
+			y: 0
+		},
+		grabOffset: {
+			x: 0,
+			y: 0
+		},
+		pressedMs: 0,
+		hovered: void 0,
+		pointerOver: void 0,
+		parent: void 0,
+		restScale: void 0,
+		heldPose: void 0,
+		unmute: void 0,
+		carried: [],
+		path: [],
+		traceIntent: void 0,
+		traceClosed: false,
+		lastPoint: void 0,
+		canvas: void 0,
+		offFrame: void 0,
+		detach: void 0,
+		tapListeners: [],
+		keyListeners: [],
+		pointerListeners: [],
+		detachKeys: void 0,
+		wake: void 0,
+		cursor: void 0,
+		controls: []
+	};
+}
+/**
+* Counts the listeners and controls other code registered: `onTap`, `onPointer`, `onKey` and
+* `controls.add`, four lengths, nothing allocated.
+*
+* @param state - The input state.
+* @returns The number of registrations whose remover has not run.
+*/
+function countListeners(state) {
+	return state.tapListeners.length + state.pointerListeners.length + state.keyListeners.length + state.controls.length;
+}
+//#endregion
 //#region src/plugins/input/lifecycle.ts
 /**
 * @file input plugin — lifecycle functions: dependency resolution, the frame step registered in
-* `onInit`, the pointer listeners opened in `onStart` and the teardown that closes exactly what
-* was opened.
+* `onInit`, the pointer listeners opened in `onStart` (and, in a debug build, the count of the
+* listeners other code registered, pushed into the renderer's monitor) and the teardown that
+* closes exactly what was opened.
 */
 /**
 * Resolves the dependency APIs `time`, `flow`, `world` and `renderer` with `ctx.require`.
@@ -41514,12 +42827,17 @@ function initInput(ctx) {
 /**
 * Opens the pointer listeners on the canvas the renderer created and the one `keydown` listener
 * on `window`. Without a DOM the renderer has no canvas: nothing is attached, the plugin is
-* inert, and `app.input.*` still answers the gate.
+* inert, and `app.input.*` still answers the gate. In an agent build the count of the listeners
+* and controls other code registered goes into the renderer monitor's leak counts as
+* `inputListeners`, pushed: the renderer cannot depend on input, which depends on it. The
+* renderer's `onStop` drops the registration.
 *
 * @param ctx - Kernel context of the input plugin.
 */
 function startInput(ctx) {
-	const canvas = ctx.require(rendererPlugin).host.canvas();
+	const renderer = ctx.require(rendererPlugin);
+	if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) renderer.monitor.counts.register("inputListeners", () => countListeners(ctx.state));
+	const canvas = renderer.host.canvas();
 	ctx.state.canvas = canvas;
 	if (canvas === void 0) return;
 	attach(canvas, ctx);
@@ -41677,7 +42995,7 @@ function answerTrace(ctx, path) {
 }
 /**
 * Creates the input API: `app.input.tap`, `.press`, `.drag`, `.swipe`, `.trace`, `.onTap`,
-* `.onPointer`, `.onKey`, `.pressKey`, `.cursor` and `.controls`.
+* `.onPointer`, `.onKey`, `.pressKey`, `.cursor`, `.listeners` and `.controls`.
 *
 * @param ctx - Kernel context of the input plugin.
 * @returns The plugin API.
@@ -41698,59 +43016,10 @@ function createInputApi(ctx) {
 			shift: options?.shift ?? false
 		}),
 		cursor: () => inputCtx.state.cursor ?? inputCtx.config.cursor.idle,
+		listeners: () => countListeners(inputCtx.state),
 		controls: { add: (component) => addControl(inputCtx.state, component) }
 	};
 }
-//#endregion
-//#region src/plugins/input/state.ts
-/**
-* Creates the initial input state: an empty sample queue, no active pointer and no gesture. Every
-* duration starts at zero; the plugin never reads a device clock.
-*
-* @param _ctx - Minimal context.
-* @param _ctx.config - Resolved plugin config.
-* @returns A fresh state, owned by one app.
-*/
-function createInputState(_ctx) {
-	return {
-		samples: [],
-		phase: "idle",
-		pointerId: void 0,
-		moved: false,
-		entity: void 0,
-		key: void 0,
-		start: {
-			x: 0,
-			y: 0
-		},
-		grabOffset: {
-			x: 0,
-			y: 0
-		},
-		pressedMs: 0,
-		hovered: void 0,
-		pointerOver: void 0,
-		parent: void 0,
-		restScale: void 0,
-		heldPose: void 0,
-		unmute: void 0,
-		carried: [],
-		path: [],
-		traceIntent: void 0,
-		traceClosed: false,
-		lastPoint: void 0,
-		canvas: void 0,
-		offFrame: void 0,
-		detach: void 0,
-		tapListeners: [],
-		keyListeners: [],
-		pointerListeners: [],
-		detachKeys: void 0,
-		wake: void 0,
-		cursor: void 0,
-		controls: []
-	};
-}
 /**
 * Input plugin: `app.input.tap(target)`, `app.input.drag(from, to)`.
 *
@@ -54381,9 +55650,9 @@ function defineEffect(kind, options = {}) {
 * | renderer | poolLimit | 256 |
 * | renderer | unsupportedMessage | "This device cannot run the game." |
 * | renderer | loadPixi | () => import("pixi.js") |
-* | renderer | debug | { nineSlice: false, verifyFrames: false, kept: true }; 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 |
+* | 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 |
 * | renderer | onDemand | false, every frame is drawn; true draws only a frame in which something changed |
-* | renderer | monitor | { budgetMs: "rate", frames: 1024 }, the performance log of an agent build; shallow merge: a game that sets `monitor` gives both fields |
+* | renderer | monitor | { budgetMs: "rate", frames: 1024, stillFrames: 60, stillMpx: 0.25, churnPerSecond: 4, churnSeconds: 3, churnAfterTrimMs: 1000 }, the performance log of an agent build and the thresholds of its `problem` rules; shallow merge: a game that sets `monitor` gives `budgetMs` and `frames`, a threshold it leaves out keeps its default |
 * | renderer | keptMb | 64, MiB the kept pictures may hold: a filtered view that did not change is drawn from its picture, the least recently drawn goes first; 0 keeps none |
 * | renderer | warm | 1, probe draws a drawn frame that create the GPU pipelines while the game loads; 0 creates each in the first frame that needs it |
 * | input | tapSlopPx | 12 |
@@ -54543,4 +55812,4 @@ const screen = [
 	uiPlugin
 ];
 //#endregion
-export { parallel as $, refuseStart as $t, types_exports$12 as A, Blur as At, DebugTrigger as B, assetsPlugin as Bt, types_exports$5 as C, Traced as Ct, types_exports$9 as D, effectsPlugin as Dt, types_exports$8 as E, messageDuration as Et, types_exports$17 as F, Outline as Ft, textPlugin as G, rendererPlugin as Gt, popup as H, AnimPlayer as Ht, uiPlugin as I, defineFilter as It, defineAnimation as J, PERF_GAP_BUCKETS as Jt, platformPlugin as K, frameAt as Kt, resolve as L, debugPlugin as Lt, types_exports$14 as M, Displacement as Mt, types_exports$15 as N, Glow as Nt, types_exports$10 as O, Emitter as Ot, types_exports$16 as P, Noise as Pt, mark as Q, flowPlugin as Qt, defineMotion as R, audioPlugin as Rt, types_exports$4 as S, Traceable as St, types_exports$7 as T, messageArgument as Tt, defineTokens as U, Animation as Ut, LocalWrite as V, animPlugin as Vt, defineStyle as W, Frames as Wt, frames as X, DEMAND_REASONS as Xt, external as Y, PERF_LOG_VERSION as Yt, haptic as Z, worldPlugin as Zt, load as _, Pressable as _t, defineEffect as a, SaveUnreadableError as an, spawned as at, types_exports$2 as b, Tappable as bt, schedule as c, clockPlugin as cn, use as ct, tr as d, Draggable as dt, exit as en, play$1 as et, defineFeature as f, DropTarget as ft, defineBundles as g, PointerOver as gt, music as h, Pointer as ht, screen as i, modelPlugin as in, spawn as it, types_exports$13 as j, ColorMatrix as jt, types_exports$11 as k, Alpha as kt, projection as l, wait as lt, defineEmitter as m, Hovered as mt, createPlugin as n, to as nn, set as nt, guide as o, lifecyclePlugin as on, stagger as ot, flattenFeatures as p, Held as pt, HAPTIC_KINDS as q, PERF_CAUSES as qt, defineGame as r, type as rn, sfx as rt, hint as s, timePlugin as sn, tween as st, createApp as t, slot as tn, sequence as tt, defineScene as u, inputPlugin as ut, types_exports as v, Pressed as vt, types_exports$6 as w, i18nPlugin as wt, types_exports$3 as x, Touchable as xt, types_exports$1 as y, Swipeable as yt, Box as z, scenesPlugin as zt };
+export { parallel as $, DEMAND_REASONS as $t, types_exports$12 as A, Blur as At, DebugTrigger as B, assetsPlugin as Bt, types_exports$5 as C, Traced as Ct, types_exports$9 as D, effectsPlugin as Dt, types_exports$8 as E, messageDuration as Et, types_exports$17 as F, Outline as Ft, textPlugin as G, rendererPlugin as Gt, popup as H, AnimPlayer as Ht, uiPlugin as I, defineFilter as It, defineAnimation as J, PERF_CAUSES as Jt, platformPlugin as K, PASS_KINDS as Kt, resolve as L, debugPlugin as Lt, types_exports$14 as M, Displacement as Mt, types_exports$15 as N, Glow as Nt, types_exports$10 as O, Emitter as Ot, types_exports$16 as P, Noise as Pt, mark as Q, SHADER_WHATS as Qt, defineMotion as R, audioPlugin as Rt, types_exports$4 as S, Traceable as St, types_exports$7 as T, messageArgument as Tt, defineTokens as U, Animation as Ut, LocalWrite as V, animPlugin as Vt, defineStyle as W, Frames as Wt, frames as X, PERF_LOG_VERSION as Xt, external as Y, PERF_GAP_BUCKETS as Yt, haptic as Z, PROBLEM_RULES as Zt, load as _, Pressable as _t, defineEffect as a, to as an, spawned as at, types_exports$2 as b, Tappable as bt, schedule as c, SaveUnreadableError as cn, use as ct, tr as d, clockPlugin as dn, Draggable as dt, worldPlugin as en, play$1 as et, defineFeature as f, DropTarget as ft, defineBundles as g, PointerOver as gt, music as h, Pointer as ht, screen as i, slot as in, spawn as it, types_exports$13 as j, ColorMatrix as jt, types_exports$11 as k, Alpha as kt, projection as l, lifecyclePlugin as ln, wait as lt, defineEmitter as m, Hovered as mt, createPlugin as n, refuseStart as nn, set as nt, guide as o, type as on, stagger as ot, flattenFeatures as p, Held as pt, HAPTIC_KINDS as q, frameAt as qt, defineGame as r, exit as rn, sfx as rt, hint as s, modelPlugin as sn, tween as st, createApp as t, flowPlugin as tn, sequence as tt, defineScene as u, timePlugin as un, inputPlugin as ut, types_exports as v, Pressed as vt, types_exports$6 as w, i18nPlugin as wt, types_exports$3 as x, Touchable as xt, types_exports$1 as y, Swipeable as yt, Box as z, scenesPlugin as zt };