@moku-labs/game 0.15.8 → 0.15.10

package/dist/{src-DNVAJHwd.mjs → src-zXAFOqEc.mjs}

@@ -2,7 +2,7 @@ import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
 import { r as systemSource, t as memory } from "./memory-CWlqhS7l.mjs";
 import { a as finishDrafts, i as enableDraftPatches, n as deepFreeze$1, o as openDrafts, r as dropDrafts } from "./drafts-BawpSaVp.mjs";
 import { d as graphHash, f as isRestCheckpoint, h as pushEntry, i as servePaused, l as findNode, m as compact, n as captureFrame, o as collectFlows, p as slotNames, r as serveCaptures, s as describeGraph, t as cancelCaptures, u as framePath } from "./capture-D7XvoHdH.mjs";
-import { 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 Now, C as Sprite, E as componentsFor, F as resource, I as system, L as systemsFor, M as Tree, N as component, O as Exiting, R as tag, S as Shape, T as arcDefaults, _ as HudPart, b as OverlayLevel, c as Countdown, d as builtInStyles, g as Display, h as textFor, i as samePose, j as Order, k as Layer, 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-CIUx49C0.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";
@@ -16484,8 +16484,9 @@ function writeTakeKeys(record, now, box) {
 }
 /**
 * Takes or retakes the picture of a record: stages 1, 2 (when its first filter has inputs) and 3, at the phase of this
-* frame. Refused, and the view drawn live, for a `Display` in the subtree without `onDemand`, empty bounds, a picture
-* over 4096 device pixels, or a budget that has no room (P6.3, warned once).
+* frame. The bounds are cut to the filter area of the top when it holds one (F43). Refused, and the view drawn live,
+* for a `Display` in the subtree without `onDemand`, empty bounds, a picture over 4096 device pixels, or a budget that
+* has no room (P6.3, warned once).
 *
 * @param kctx - The kept context.
 * @param pixi - The module that draws.
@@ -16498,7 +16499,7 @@ function writeTakeKeys(record, now, box) {
 function takePicture(kctx, pixi, matrices, record, view, now) {
 	const { top } = record;
 	if (!kctx.ctx.config.onDemand && holdsDisplay(kctx, top)) return false;
-	const local = top.getLocalBounds();
+	const local = clippedToArea(top.getLocalBounds(), top.filterArea);
 	if (isEmptyBounds(local)) return false;
 	const box = linearBounds(now.a, now.b, now.c, now.d, local);
 	const x = gridSpan(now.tx + box.x0, now.tx + box.x1, now.rs);
@@ -16530,6 +16531,27 @@ function takePicture(kctx, pixi, matrices, record, view, now) {
 	return ok;
 }
 /**
+* The local bounds of a top cut to its filter area, both in the top's own units: its filters draw nothing outside
+* the area. With no area the bounds are returned as they are. Pure.
+*
+* @param bounds - The top's local bounds.
+* @param area - The filter area on the top, or none.
+* @returns The bounds the picture takes.
+* @example
+* ```ts
+* clippedToArea({ minX: 0, minY: 0, maxX: 400, maxY: 400 }, { x: 100, y: 100, width: 40, height: 40 }); // { minX: 100, minY: 100, maxX: 140, maxY: 140 }
+* ```
+*/
+function clippedToArea(bounds, area) {
+	if (area === null || area === void 0) return bounds;
+	return {
+		minX: Math.max(bounds.minX, area.x),
+		minY: Math.max(bounds.minY, area.y),
+		maxX: Math.min(bounds.maxX, area.x + area.width),
+		maxY: Math.min(bounds.maxY, area.y + area.height)
+	};
+}
+/**
 * Tells whether local bounds hold nothing to draw: no width or no height. Pure.
 *
 * @param bounds - The bounds of a subtree in its own space.
@@ -25527,10 +25549,22 @@ function stopOverlays(state) {
 }
 //#endregion
 //#region src/plugins/renderer/sync/shape-path.ts
+/**
+* @file renderer/sync — the path of a `Shape`: a rectangle, a rounded rectangle or a triangle,
+* its fill, and its stroke, solid or dashed, or an arc, a stroke alone. A dashed stroke walks the
+* outline (straight edges, and rounded corners sampled as arcs) and strokes one open line per dash.
+* An arc runs on the circle inscribed in its box, from 12 o'clock clockwise.
+*/
 /** Chords per rounded corner of a dashed outline: under 0.3 u off the arc at a 48 u radius. */
 const CORNER_SAMPLES = 8;
 /** The gap between two dashes, as a fraction of the dash length. */
 const GAP_RATIO = .5;
+/** Segments of a full ring: a ring of 28 u across strays under 0.03 u off its circle. */
+const RING_SEGMENTS = 48;
+/** The fewest segments of an arc that draws: a sliver still bends. */
+const ARC_MIN_SEGMENTS = 2;
+/** 12 o'clock, where an arc starts: Pixi's angles run clockwise from 3 o'clock. */
+const TWELVE = -Math.PI / 2;
 /**
 * The corner radius the rectangle is drawn with: Pixi clamps it to half the shorter side.
 *
@@ -25715,8 +25749,9 @@ function dashesOf(outline, dash) {
 }
 /**
 * Draws the path of a shape and fills it in a colour at the alpha given. At alpha 0 the path stays unfilled, so only
-* a stroke shows. A clip mask is drawn here too, never dashed. A fill-only shape is drawn white and coloured by the
-* object's tint, so a colour change draws no path (spec 26 R2.1).
+* a stroke shows. A clip mask is drawn here too, never dashed; the path of an arc here is its box, which is what it
+* clips its children to. A fill-only shape is drawn white and coloured by the object's tint, so a colour change draws
+* no path (spec 26 R2.1).
 *
 * @param object - The graphics to draw on.
 * @param value - The shape value.
@@ -25726,7 +25761,7 @@ function dashesOf(outline, dash) {
 function drawShapePath(object, value, fillAlpha, color = value.fill) {
 	object.clear();
 	if (value.kind === "triangle") object.moveTo(0, 0).lineTo(value.w, value.h / 2).lineTo(0, value.h).closePath();
-	else if (value.radius > 0) object.roundRect(0, 0, value.w, value.h, value.radius);
+	else if (value.kind === "rect" && value.radius > 0) object.roundRect(0, 0, value.w, value.h, value.radius);
 	else object.rect(0, 0, value.w, value.h);
 	if (fillAlpha <= 0) return;
 	object.fill(fillAlpha < 1 ? {
@@ -25759,6 +25794,102 @@ function strokeShape(object, value) {
 	}
 	object.stroke(style);
 }
+/**
+* The share of the circle an arc sweeps, clamped to 0..1: anything not above 0, `NaN` too, is 0; a whole ring when
+* the value leaves it out.
+*
+* @param value - The shape value.
+* @returns The share.
+* @example
+* ```ts
+* sweepOf({ ...Shape.defaults, kind: "arc", sweep: 1.4 }); // 1
+* ```
+*/
+function sweepOf(value) {
+	const sweep = value.sweep ?? arcDefaults.sweep;
+	if (Number.isNaN(sweep) || sweep <= 0) return 0;
+	return Math.min(sweep, 1);
+}
+/**
+* The radius of the circle an arc runs on: inscribed in the shorter side of its box, inside its stroke.
+*
+* @param value - The shape value.
+* @returns The radius in reference units; 0 or below when the stroke leaves no circle.
+* @example
+* ```ts
+* arcRadiusOf({ ...Shape.defaults, kind: "arc", w: 28, h: 40, strokeWidth: 2 }); // 13
+* ```
+*/
+function arcRadiusOf(value) {
+	return (Math.min(value.w, value.h) - value.strokeWidth) / 2;
+}
+/**
+* Tells whether an arc draws nothing: no stroke width, no sweep, or no circle inside its stroke.
+*
+* @param value - The shape value, an arc.
+* @returns True for an arc whose `Graphics` would hold no instruction.
+* @example
+* ```ts
+* isEmptyArc({ ...Shape.defaults, kind: "arc", w: 28, h: 28, strokeWidth: 2, sweep: 0 }); // true
+* ```
+*/
+function isEmptyArc(value) {
+	return value.strokeWidth <= 0 || sweepOf(value) <= 0 || arcRadiusOf(value) <= 0;
+}
+/**
+* Strokes an arc: from 12 o'clock clockwise over its share of the circle, in segments as many as its angle needs (48
+* for a ring, at least 2), ended by its `cap`. A full ring is closed and has no ends. Nothing for an empty arc. Drawn
+* only when the shape changed: never rebuilt per frame.
+*
+* @param object - The graphics, cleared.
+* @param value - The shape value, an arc.
+*/
+function strokeArc(object, value) {
+	if (isEmptyArc(value)) return;
+	const sweep = sweepOf(value);
+	const radius = arcRadiusOf(value);
+	const ring = sweep >= 1;
+	const segments = Math.max(ARC_MIN_SEGMENTS, Math.ceil(sweep * RING_SEGMENTS));
+	const step = sweep * 2 * Math.PI / segments;
+	const centreX = value.w / 2;
+	const centreY = value.h / 2;
+	const last = ring ? segments - 1 : segments;
+	object.moveTo(centreX, centreY - radius);
+	for (let index = 1; index <= last; index += 1) {
+		const angle = TWELVE + index * step;
+		object.lineTo(centreX + radius * Math.cos(angle), centreY + radius * Math.sin(angle));
+	}
+	if (ring) {
+		object.closePath();
+		object.stroke({
+			color: value.stroke,
+			width: value.strokeWidth
+		});
+		return;
+	}
+	object.stroke({
+		color: value.stroke,
+		width: value.strokeWidth,
+		cap: value.cap ?? arcDefaults.cap
+	});
+}
+/**
+* Paints a shape on its graphics: an arc as its stroke alone, every other kind as its path, its fill in a colour at its
+* own fill alpha, and its stroke. The one call that draws a shape's visual.
+*
+* @param object - The graphics.
+* @param value - The shape value.
+* @param color - The colour of the fill: white for a tinted shape, the value's own otherwise.
+*/
+function paintShape(object, value, color) {
+	if (value.kind === "arc") {
+		object.clear();
+		strokeArc(object, value);
+		return;
+	}
+	drawShapePath(object, value, value.fillAlpha, color);
+	strokeShape(object, value);
+}
 //#endregion
 //#region src/plugins/renderer/sync/sizing.ts
 /**
@@ -26738,8 +26869,20 @@ function copyClip(drawn, value) {
 	return drawn;
 }
 /**
+* Tells whether an arc was drawn with this value already: only what its stroke is built from, its
+* box, its stroke, its share and its ends. A new fill, fill alpha, radius or dash builds nothing.
+*
+* @param drawn - What the graphics was last drawn with, an arc too.
+* @param value - The arc now.
+* @returns True when nothing has to be drawn.
+*/
+function sameArc(drawn, value) {
+	return drawn.w === value.w && drawn.h === value.h && drawn.stroke === value.stroke && drawn.strokeWidth === value.strokeWidth && drawn.sweep === value.sweep && drawn.cap === value.cap;
+}
+/**
 * Tells whether a shape's graphics was drawn with this value already: the path, the fill and the
-* stroke. Its alpha, its clip and the fill of a tinted shape (its tint) are written apart.
+* stroke; for an arc only its stroke. Its alpha, its clip and the fill of a tinted shape (its tint)
+* are written apart.
 *
 * @param drawn - What the graphics was last drawn with.
 * @param value - The shape value now.
@@ -26747,7 +26890,9 @@ function copyClip(drawn, value) {
 * @returns True when nothing has to be drawn.
 */
 function sameShape$1(drawn, value, tinted) {
-	return drawn !== void 0 && drawn.tinted === tinted && (tinted || drawn.fill === value.fill) && drawn.kind === value.kind && drawn.w === value.w && drawn.h === value.h && drawn.fillAlpha === value.fillAlpha && drawn.radius === value.radius && drawn.stroke === value.stroke && drawn.strokeWidth === value.strokeWidth && drawn.dash === value.dash;
+	if (drawn === void 0 || drawn.tinted !== tinted || drawn.kind !== value.kind) return false;
+	if (value.kind === "arc") return sameArc(drawn, value);
+	return (tinted || drawn.fill === value.fill) && drawn.w === value.w && drawn.h === value.h && drawn.fillAlpha === value.fillAlpha && drawn.radius === value.radius && drawn.stroke === value.stroke && drawn.strokeWidth === value.strokeWidth && drawn.dash === value.dash && drawn.sweep === value.sweep && drawn.cap === value.cap;
 }
 /**
 * Keeps what a shape's graphics was drawn with, in the object it had, or in a new one the first
@@ -26760,7 +26905,7 @@ function sameShape$1(drawn, value, tinted) {
 */
 function copyShape(drawn, value, tinted) {
 	if (drawn === void 0) {
-		const { kind, w, h, fill, fillAlpha, radius, stroke, strokeWidth, dash } = value;
+		const { kind, w, h, fill, fillAlpha, radius, stroke, strokeWidth, dash, sweep, cap } = value;
 		return {
 			tinted,
 			kind,
@@ -26771,7 +26916,9 @@ function copyShape(drawn, value, tinted) {
 			radius,
 			stroke,
 			strokeWidth,
-			dash
+			dash,
+			sweep,
+			cap
 		};
 	}
 	const copy = drawn;
@@ -26785,10 +26932,13 @@ function copyShape(drawn, value, tinted) {
 	copy.stroke = value.stroke;
 	copy.strokeWidth = value.strokeWidth;
 	copy.dash = value.dash;
+	copy.sweep = value.sweep;
+	copy.cap = value.cap;
 	return copy;
 }
 /**
-* Tells whether a shape draws nothing: no stroke, and no fill alpha or no area. Pure.
+* Tells whether a shape draws nothing: no stroke, and no fill alpha or no area; an arc with no stroke, no sweep or no
+* circle inside its stroke. Pure.
 *
 * @param value - The shape value.
 * @returns True for a shape whose `Graphics` would hold no instruction.
@@ -26798,6 +26948,7 @@ function copyShape(drawn, value, tinted) {
 * ```
 */
 function isEmptyShape(value) {
+	if (value.kind === "arc") return isEmptyArc(value);
 	return value.strokeWidth <= 0 && (value.fillAlpha <= 0 || value.w <= 0 || value.h <= 0);
 }
 /**
@@ -26815,8 +26966,7 @@ function drawShape(sctx, entity, view, object, value) {
 	const tinted = value.strokeWidth <= 0;
 	if (!sameShape$1(view.drawn, value, tinted)) {
 		markView(sctx, entity);
-		drawShapePath(object, value, value.fillAlpha, tinted ? WHITE$1 : value.fill);
-		strokeShape(object, value);
+		paintShape(object, value, tinted ? WHITE$1 : value.fill);
 		sctx.ctx.state.sync.redraws += 1;
 		view.drawn = copyShape(view.drawn, value, tinted);
 	}
@@ -27201,7 +27351,9 @@ function displayObjectOf(sctx, entity) {
 }
 /**
 * Detaches the children of a parent that left, and names the ones that stay. A child that leaves in the same teardown
-* is no orphan: its view goes in this very pass (it waits in `removed`), or it plays its exit (`Exiting`).
+* is no orphan: its view goes in this very pass (it waits in `removed`), or it plays its exit (`Exiting`). Nor is a
+* child whose `Parent` names another entity, or none, by now: it moved in the same frame (a hosted view a restore
+* hung under the rebuilt host, F44), and the later steps of this pass hang it where it belongs.
 *
 * @param sctx - Domain context of the sync module.
 * @param entity - The parent entity.
@@ -27209,7 +27361,6 @@ function displayObjectOf(sctx, entity) {
 */
 function detachChildren(sctx, entity, host) {
 	const state = sctx.ctx.state.sync;
-	const ecs = sctx.ctx.deps.world.ecs;
 	const orphans = [];
 	for (const [child, childView] of state.views) {
 		if (child === entity) continue;
@@ -27218,7 +27369,7 @@ function detachChildren(sctx, entity, host) {
 		markView(sctx, child);
 		detach$1(object);
 		state.orphans.add(child);
-		if (!state.removed.has(child) && !isLeaving(ecs, child)) orphans.push(child);
+		if (isLostOrphan(sctx, child, entity)) orphans.push(child);
 	}
 	if (orphans.length > 0) sctx.ctx.log.warn("renderer: parent left before its children", {
 		parent: entity,
@@ -27226,6 +27377,19 @@ function detachChildren(sctx, entity, host) {
 	});
 }
 /**
+* Tells whether a child of a parent that left is an orphan worth a warning: it does not go in this pass, it plays no
+* exit, and its `Parent` still names the parent that left.
+*
+* @param sctx - Domain context of the sync module.
+* @param child - The child entity.
+* @param parent - The parent that left.
+* @returns True when the child stays behind with no parent.
+*/
+function isLostOrphan(sctx, child, parent) {
+	const ecs = sctx.ctx.deps.world.ecs;
+	return !sctx.ctx.state.sync.removed.has(child) && !isLeaving(ecs, child) && parentOf$1(ecs, child) === parent;
+}
+/**
 * Takes a view out of the tree and gives its object back to the pool.
 *
 * @param sctx - Domain context of the sync module.
@@ -32811,9 +32975,23 @@ function startTrack$1(actx, entity, component, to, options, muted, driven = fals
 	countPlaying(actx.deps.world.ecs, entity, 1);
 	actx.deps.time.wake();
 	warnIfCrowded(actx);
+	if (landsAtStart(track, options)) writeFields(actx, track, true);
 	return track;
 }
 /**
+* Tells whether a track writes its target as it starts: an absolute one of 0 ms with no delay,
+* no repeat and no keys, started so by its caller (not cut by reduced motion). A rest pose a
+* caller sets in phase `layout` so lands with the fields written beside it in that frame (F47);
+* the next frame step ends it, where its `Animation` count lands too.
+*
+* @param track - The track that starts.
+* @param options - What its caller asked for.
+* @returns True when it lands now.
+*/
+function landsAtStart(track, options) {
+	return options.ms === 0 && track.delayMs === 0 && !track.additive && !track.driven && track.repeatsLeft === 0 && track.segments === void 0;
+}
+/**
 * Tells whether a loop stands on its first key instead of walking: with reduced motion on, unless
 * the author kept it, or when it has no length to walk. It stays in the table either way, so it
 * never ends by itself.
@@ -42224,16 +42402,20 @@ function boxCovers(ectx, entity, width, height, size) {
 	return width * scale >= size.width && height * scale >= size.height;
 }
 /**
-* Tells whether a filtered view covers the whole viewport: the box its sprite, its nine-slice or
-* its shape declares, times its scale, covers the reference size on both axes. A sprite without a
-* size declares none. Read from components, never from Pixi bounds.
+* Tells whether a filtered view covers the whole viewport. A view whose enabled filters declare an
+* area draws only there: that area, times the view's scale, covers the reference size on both axes
+* (F43, a lens over a full-screen sprite is not full screen). Otherwise the box its sprite, its
+* nine-slice or its shape declares, times its scale, does. A sprite without a size declares none.
+* Read from components and the area handed over last, never from Pixi bounds.
 *
 * @param ectx - Domain context of the effects plugin.
-* @param entity - The entity.
+* @param view - The view's record.
 * @param size - The viewport size.
 * @returns True for a full-screen view.
 */
-function coversScreen(ectx, entity, size) {
+function coversScreen(ectx, view, size) {
+	const { entity, areaSent } = view;
+	if (areaSent.some) return boxCovers(ectx, entity, areaSent.width, areaSent.height, size);
 	const ecs = ectx.deps.world.ecs;
 	const sprite = ecs.get(entity, Sprite);
 	if (sprite !== void 0) {
@@ -42308,7 +42490,7 @@ function countFullScreen(ectx, size) {
 	let count = 0;
 	for (const view of ectx.state.viewList) {
 		if (view.gone) continue;
-		if (hasEnabledFilter(ectx, view) && coversScreen(ectx, view.entity, size)) count += 1;
+		if (hasEnabledFilter(ectx, view) && coversScreen(ectx, view, size)) count += 1;
 	}
 	return count;
 }
@@ -49225,24 +49407,37 @@ function createTextSystem(ctx, frame) {
 	});
 }
 /**
-* Resolves the labels whose `Text` came after the layout system ran. `ui` adds a label in its
-* solve, and the flush at the end of phase `layout` attaches it with the rest of its batch, a bound
-* component included; this runs right after that flush and before phase `sync`, so the renderer
-* builds the label with its string, and lists it, so the next system run writes its `Text` once
-* more for the remeasure of `ui`. A label whose content changed is not among them: it resolves in
-* the next layout phase, as before. While the world is not live its layout phase did not run: the
-* list is dropped, and the labels, marked, wait for the next live run, as every label does.
+* Resolves the labels whose `Text` came or changed after the layout system ran. `ui` adds a label in
+* its solve, and the flush at the end of phase `layout` attaches it with the rest of its batch, a
+* bound component included; this runs right after that flush and before phase `sync`, so the
+* renderer builds the label with its string, and lists it, so the next system run writes its `Text`
+* once more for the remeasure of `ui`. A label whose content or style `ui` changed in its reconcile
+* is resolved here too, in the frame of the change (F45): `ui` measured its content itself, so it is
+* not listed. While the world is not live its layout phase did not run: the list is dropped, and the
+* labels, marked, wait for the next live run, as every label does.
 *
 * @param ctx - Domain context of the text plugin.
 * @param frame - What the system's runs share.
 */
 function resolveAdded(ctx, frame) {
 	const added = ctx.state.added;
-	if (added.length === 0) return;
-	if (ctx.deps.world.ecs.mode() !== "live") {
-		added.length = 0;
-		return;
+	if (added.length > 0) {
+		if (ctx.deps.world.ecs.mode() !== "live") {
+			added.length = 0;
+			return;
+		}
+		resolveCame(ctx, frame, added);
 	}
+	resolveChanged(ctx, frame);
+}
+/**
+* Resolves the labels whose `Text` came with the layout flush, and lists them for the remeasure.
+*
+* @param ctx - Domain context of the text plugin.
+* @param frame - What the system's runs share.
+* @param added - The labels that came.
+*/
+function resolveCame(ctx, frame, added) {
 	frame.now = NaN;
 	frame.locale = ctx.deps.i18n.locale();
 	for (const entity of added) {
@@ -49254,6 +49449,25 @@ function resolveAdded(ctx, frame) {
 	forgetAdded(added);
 }
 /**
+* Resolves the labels of this frame's `changed(Text)` whose content or style moved since they were
+* resolved: `ui` writes `Text` after the layout system. The labels this frame resolved already
+* stand on what they show; a bound label shows its value, as in the system.
+*
+* @param ctx - Domain context of the text plugin.
+* @param frame - What the system's runs share; the locale of this frame is already in it.
+*/
+function resolveChanged(ctx, frame) {
+	const ecs = ctx.deps.world.ecs;
+	let live = false;
+	for (const entity of ecs.changed(Text)) {
+		const text = ecs.get(entity, Text);
+		if (text === void 0 || !isStale(ctx, entity, text, frame)) continue;
+		if (!live && ecs.mode() !== "live") return;
+		live = true;
+		stepText(ctx, entity, text, frame);
+	}
+}
+/**
 * Marks labels for the next layout phase: every one of them, or only the ones `keep` names. A
 * locale change names the labels whose content is a message; a dev hot swap names the labels
 * drawn with a replaced font or icon.
@@ -53845,7 +54059,10 @@ function recordRest(ctx, element, value) {
 * @param name - The component name of the extra.
 */
 function cancelExtra(element, name) {
-	element.extraHandles.get(name)?.cancel();
+	const last = element.extraHandles.get(name);
+	if (last === void 0) return;
+	last.cancel();
+	element.endless?.delete(last);
 	element.extraHandles.delete(name);
 }
 //#endregion
@@ -55559,10 +55776,11 @@ function createReconciler(ctx, modules, fields) {
 	*/
 	function subtreeSettled(element) {
 		if (!modules.layout.settled(element)) return false;
-		return element.children.every((child) => {
+		for (const child of element.children) {
 			const childElement = state.elements.get(child);
-			return childElement === void 0 || subtreeSettled(childElement);
-		});
+			if (childElement !== void 0 && !subtreeSettled(childElement)) return false;
+		}
+		return true;
 	}
 	/**
 	* Drops the identity, the key and the key registration of an element and of everything under
@@ -55617,6 +55835,24 @@ function createReconciler(ctx, modules, fields) {
 			if (!subtreeSettled(element)) continue;
 			despawnTree(element);
 		}
+		dropRemovedRoots();
+	}
+	/**
+	* Despawns every exiting element at once, finished or not, and drops the roots that were leaving:
+	* what a restore or a load does, as a page reload would (F42).
+	*/
+	function dropLeaving() {
+		for (const entity of state.exiting) {
+			const element = state.elements.get(entity);
+			if (element === void 0) state.exiting.delete(entity);
+			else despawnTree(element);
+		}
+		dropRemovedRoots();
+	}
+	/**
+	* Drops every removed root whose element tree is gone, and closes its popup.
+	*/
+	function dropRemovedRoots() {
 		for (const entity of state.removing) {
 			const root = state.roots.get(entity);
 			if (root === void 0) continue;
@@ -55951,11 +56187,12 @@ function createReconciler(ctx, modules, fields) {
 	* element stands exactly as if its root had just been mounted with the restored state: a new
 	* entity with the components of the description, then its `enter` hook, then its loop. What a
 	* mount does not bring is gone with the old tree: the local state of a component, a scroll
-	* offset, the keyboard focus, a text being edited, a hover. A root that is leaving keeps
-	* leaving.
+	* offset, the keyboard focus, a text being edited, a hover. An element or a root that is
+	* leaving is dropped at once, as a page reload drops it.
 	*/
 	function remountRoots() {
 		state.remount = false;
+		dropLeaving();
 		for (const root of state.roots.values()) {
 			if (state.removing.has(root.entity)) continue;
 			const element = root.element === void 0 ? void 0 : lookup(root.element);
@@ -56119,8 +56356,8 @@ function createReconciler(ctx, modules, fields) {
 	/**
 	* The second system of phase `layout`: every root takes its slot, then one solve per marked
 	* root, a root in a slot after the root of its slot and in its content box, then the rects, the
-	* rest poses and the hooks, the scrolls settled on what the solve and the render gave them, and
-	* the hosting of the hosts that came. The hints released since the last frame step are dropped
+	* rest poses and the hooks, the scrolls settled on what the solve and the render gave them, the
+	* hosting of the hosts that came, and a sweep of what left with nothing to wait for. The hints released since the last frame step are dropped
 	* at its end, so the `change.Box` and `change.Transform` hooks the solve plays get the hint the
 	* reconcile routed, and the next frame starts with none.
 	*
@@ -56140,6 +56377,7 @@ function createReconciler(ctx, modules, fields) {
 			hostViews(ctx, state, state.risen);
 			state.risen.clear();
 		}
+		if (state.exiting.size > 0 || state.removing.size > 0) sweep();
 		state.hints.length = 0;
 		writeCounters();
 	}
@@ -56722,14 +56960,15 @@ function noteTrack(span, options) {
 	span.reduced = options.reduced;
 }
 /**
-* The view handle of a hook whose tracks are measured: every call goes to the real handle, `tween` and `toRest` note
-* their track first.
+* The view handle of a watched hook: every call goes to the real handle; `tween` notes whether its track repeats
+* forever, and with a span `tween` and `toRest` note their track for the level of an overlay.
 *
 * @param handle - The real handle.
-* @param span - The span being measured.
-* @returns The measuring handle.
+* @param span - The span being measured, or nothing.
+* @param watch - Where a track that repeats forever is noted.
+* @returns The watching handle.
 */
-function spanned(handle, span) {
+function watched(handle, span, watch) {
 	return {
 		entity: handle.entity,
 		key: handle.key,
@@ -56737,11 +56976,12 @@ function spanned(handle, span) {
 		rest: (component) => handle.rest(component),
 		set: (component, patch) => handle.set(component, patch),
 		tween: (component, to, options) => {
-			noteTrack(span, options);
+			if (options.repeat === "forever") watch.forever = true;
+			if (span !== void 0) noteTrack(span, options);
 			return handle.tween(component, to, options);
 		},
 		toRest: (component, options) => {
-			noteTrack(span, options);
+			if (span !== void 0) noteTrack(span, options);
 			return handle.toRest(component, options);
 		},
 		all: (handles) => handle.all(handles),
@@ -56750,8 +56990,9 @@ function spanned(handle, span) {
 }
 /**
 * Runs one motion hook and keeps the handle it returned, so the exit sweep knows when the
-* element is still playing. Without a hook the value the solve wrote stands; a throwing hook is
-* logged and the same happens.
+* element is still playing. A motion whose hook started a track that repeats forever is also
+* noted as endless: the sweep never waits for it. Without a hook the value the solve wrote stands;
+* a throwing hook is logged and the same happens.
 *
 * @param ctx - Domain context of the ui plugin.
 * @param element - The element the hook belongs to.
@@ -56764,9 +57005,11 @@ function play(ctx, element, hook, span) {
 	const handle = handleOf(ctx, element);
 	if (handle === void 0) return void 0;
 	try {
-		const motion = hook(span === void 0 ? handle : spanned(handle, span));
+		const watch = { forever: false };
+		const motion = hook(watched(handle, span, watch));
 		if (motion === void 0) return void 0;
 		element.handles.push(motion);
+		if (watch.forever) noteEndless(element, motion);
 		return motion;
 	} catch (error) {
 		ctx.log.error("ui:motion-failed", {
@@ -56777,6 +57020,16 @@ function play(ctx, element, hook, span) {
 	}
 }
 /**
+* Notes a motion that never ends on its element, the set made with the first one.
+*
+* @param element - The element the motion plays on.
+* @param motion - The endless motion.
+*/
+function noteEndless(element, motion) {
+	element.endless ??= /* @__PURE__ */ new Set();
+	element.endless.add(motion);
+}
+/**
 * Plays the `change` hook of one extra component whose fields changed. The motion the last change
 * of that name started is cancelled first, so its value stays where it is and the new motion
 * starts from there; the new motion is kept with the element's handles, so an exit waits for it.
@@ -56791,8 +57044,12 @@ function play(ctx, element, hook, span) {
 * @returns True when the hook returned a motion: the caller writes nothing directly.
 */
 function playExtraChange(ctx, element, name, values, hint) {
-	element.extraHandles.get(name)?.cancel();
-	element.extraHandles.delete(name);
+	const last = element.extraHandles.get(name);
+	if (last !== void 0) {
+		last.cancel();
+		element.endless?.delete(last);
+		element.extraHandles.delete(name);
+	}
 	const hook = element.motion?.change?.[name];
 	if (hook === void 0) return false;
 	const motion = play(ctx, element, (view) => hook(view, values.previous, values.next, hint));
@@ -56828,19 +57085,23 @@ function startLoop(ctx, element) {
 }
 /**
 * Tells whether every motion of an element has finished, which is when an exiting element may
-* be despawned.
+* be despawned. A motion over a track that repeats forever never finishes, so it does not count:
+* waiting for it would keep the element for the life of the page (F42).
 *
 * @param element - The element to ask about.
-* @returns True when nothing is still playing.
+* @returns True when nothing that can end is still playing.
 */
 function still(element) {
-	return element.handles.every((handle) => !handle.active());
+	const { handles, endless } = element;
+	for (const handle of handles) if (handle.active() && endless?.has(handle) !== true) return false;
+	return true;
 }
 /**
 * Moves the rest `Transform` of an element to where its rect, style and fit put it now. A live
 * element plays its `change.Transform` motion when it has one, else takes the pose through a
-* 0 ms rest track, which lands on the next frame step and lets an additive loop re-base on the
-* new rest; an element that has not spawned yet only records it, and so does one whose
+* 0 ms rest track. That track writes the pose as it starts, so the pivot and the position land in
+* the same frame, and ends at the next frame step, where an additive loop re-bases on the new
+* rest. An element that has not spawned yet only records it, and so does one whose
 * `change.Box` motion already played. The content of a scroll keeps its `Transform` and records
 * no rest with the world: the scroll step owns it.
 *
@@ -56953,10 +57214,14 @@ function placeChildren(state, parent, children) {
 * @file ui/layout — exiting elements, policy "leave": the element leaves the flow in the same
 * reconcile, so its siblings reflow this frame while it plays its exit over them.
 */
+/** The dev warning of an element that left while a motion of it repeated forever. */
+const EXIT_WAITS_FOREVER = "ui:exit-waits-forever";
 /**
 * Starts the exit of one element: out of the Yoga tree at once, tagged `Exiting` so `input`
 * never hits it, then the hook plays over the siblings that already moved. A `change` motion of
 * an extra component that still runs, a counter's roll, is kept, so the sweep waits for it too.
+* One that repeats forever, a hot pulse, is cancelled where it stands: it would never end, and a
+* dev build names the element once (F42).
 *
 * @param ctx - Domain context of the ui plugin.
 * @param state - The layout state.
@@ -56970,11 +57235,45 @@ function beginExit(ctx, state, element, cause, span) {
 	element.dropKey = void 0;
 	if (!element.live) return;
 	ctx.deps.world.ecs.tag(element.entity, Exiting);
-	element.handles = [...element.extraHandles.values()].filter((handle) => handle.active());
+	element.handles = keptExtras(ctx, element);
 	const hook = element.motion?.exit;
 	play(ctx, element, hook === void 0 ? void 0 : (view) => hook(view, element.node, void 0, cause), span);
 }
 /**
+* The `change` motions of the extras an exit waits for: the ones still running that can end. One
+* that repeats forever is cancelled where it stands, and a dev build warns once per element.
+*
+* @param ctx - Domain context of the ui plugin.
+* @param element - The element that starts its exit.
+* @returns The motions the sweep waits for.
+*/
+function keptExtras(ctx, element) {
+	const kept = [];
+	for (const handle of element.extraHandles.values()) {
+		if (!handle.active()) continue;
+		if (element.endless?.has(handle) !== true) {
+			kept.push(handle);
+			continue;
+		}
+		handle.cancel();
+		warnEndless(ctx, element);
+	}
+	return kept;
+}
+/**
+* Names an element that left while a motion of it repeated forever, once per element, in a dev
+* build: the motion is cut where it stands, which the author may want to end in the exit instead.
+*
+* @param ctx - Domain context of the ui plugin.
+* @param element - The leaving element.
+*/
+function warnEndless(ctx, element) {
+	if (typeof __MOKU_GAME_DEV__ === "undefined" || !__MOKU_GAME_DEV__) return;
+	if (element.warned.has(EXIT_WAITS_FOREVER)) return;
+	element.warned.add(EXIT_WAITS_FOREVER);
+	ctx.log.warn(EXIT_WAITS_FOREVER, { key: element.key ?? element.identity });
+}
+/**
 * Tells whether an exiting element may be despawned: no hook, or every hook finished.
 *
 * @param element - The exiting element.