@moku-labs/game 0.15.9 → 0.15.11

package/dist/{src-Cs1bP3v7.mjs → src-0m2mjRDI.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 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 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-Dwfy9wDb.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.
@@ -25455,9 +25477,9 @@ function holdsLoops(state, range) {
 }
 /**
 * Tells whether the endless loops of a view should write nothing (the overlay cases of `loopsHeld`, O9.2): its view
-* lies in a range an opaque overlay covers, or in a held picture of a blurred range, or in a blurred range the
-* fallback draws live; the last two touch the range, so the held loops write once at landing and at the first exit
-* frame.
+* lies in a range an opaque overlay covers, or in a held picture of a range that is blurred or whose owner has
+* `hold: true`, or in such a range the fallback draws live; all but the cover touch the range, so the held loops
+* write once at landing and at the first exit frame. Only the owner's `hold` counts: the range is the owner's.
 *
 * @param state - The sync state.
 * @param entity - The entity a loop is about to write.
@@ -25471,7 +25493,8 @@ function rangeHolds(state, entity) {
 	if (view === void 0 || root === void 0) return false;
 	if (!inRange(range.set, view.wrapper ?? view.object, root)) return false;
 	if (range.reason === "cover") return true;
-	if (!range.blurred) return false;
+	const ownerHolds = state.overlay.records.get(range.owner)?.value.hold === true;
+	if (!range.blurred && !ownerHolds) return false;
 	range.touched = true;
 	return true;
 }
@@ -27329,7 +27352,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.
@@ -27337,7 +27362,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;
@@ -27346,7 +27370,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,
@@ -27354,6 +27378,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.
@@ -28857,7 +28894,8 @@ function isKeyList(value) {
 }
 /**
 * Copies the marker into the record's own value, clamped (O1): `dim` into [0, 1], `fade` to 0 or more, an unknown
-* `cover` as `"none"`, a `hud` that is not `"all"`, `"none"` or a key list as `"all"`; one dev warning per field.
+* `cover` as `"none"`, a `hud` that is not `"all"`, `"none"` or a key list as `"all"`, a `hold` that is no boolean as
+* `false`; one dev warning per field.
 *
 * @param sctx - Domain context of the sync module.
 * @param entity - The marked entity.
@@ -28869,15 +28907,18 @@ function clampInto(sctx, entity, into, raw) {
 	const fade = Number.isFinite(raw.fade) ? Math.max(0, raw.fade) : 0;
 	const cover = raw.cover === "opaque" ? "opaque" : "none";
 	const hud = raw.hud === "all" || raw.hud === "none" || isKeyList(raw.hud) ? raw.hud : "all";
+	const hold = raw.hold === true;
 	if (dim !== raw.dim) warnOnce$4(sctx, "renderer:overlay-value", entity, { field: "dim" });
 	if (fade !== raw.fade) warnOnce$4(sctx, "renderer:overlay-value", entity, { field: "fade" });
 	if (cover !== raw.cover) warnOnce$4(sctx, "renderer:overlay-value", entity, { field: "cover" });
 	if (hud !== raw.hud) warnOnce$4(sctx, "renderer:overlay-value", entity, { field: "hud" });
+	if (hold !== raw.hold) warnOnce$4(sctx, "renderer:overlay-value", entity, { field: "hold" });
 	into.dim = dim;
 	into.dimColor = Number.isFinite(raw.dimColor) ? raw.dimColor : 0;
 	into.cover = cover;
 	into.hud = hud;
 	into.fade = fade;
+	into.hold = hold;
 }
 /**
 * The root of an entity's `Parent` chain, depth-bounded.
@@ -32939,9 +32980,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.
@@ -42352,16 +42407,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) {
@@ -42436,7 +42495,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;
 }
@@ -49353,24 +49412,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) {
@@ -49382,6 +49454,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.
@@ -53973,7 +54064,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
@@ -55687,10 +55781,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
@@ -55745,6 +55840,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;
@@ -56079,11 +56192,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);
@@ -56247,8 +56361,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.
 	*
@@ -56268,6 +56382,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();
 	}
@@ -56850,14 +56965,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,
@@ -56865,11 +56981,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),
@@ -56878,8 +56995,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.
@@ -56892,9 +57010,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", {
@@ -56905,6 +57025,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.
@@ -56919,8 +57049,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));
@@ -56956,19 +57090,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.
 *
@@ -57081,10 +57219,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.
@@ -57098,11 +57240,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.

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-import { Cr as Json, Yn as FeaturePlugin, Zn as AnyFlow, _r as FakeClock, dr as Hint, fr as NodeFx, hr as ClockSource, rr as NodeTable, sr as Descriptor } from "./types-i77Nrrv-.mjs";
-import { t as createApp } from "./index-DT9aYVGd.mjs";
-import { b as saveOf, v as WithGameState, y as memory } from "./types-DK-IYk-s.mjs";
-import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-CrxofjLt.mjs";
+import { Qn as AnyFlow, Xn as FeaturePlugin, cr as Descriptor, fr as Hint, gr as ClockSource, ir as NodeTable, pr as NodeFx, vr as FakeClock, wr as Json } from "./types-CuEK0Vam.mjs";
+import { t as createApp } from "./index-CsTMiO0x.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-CveBhKTs.mjs";
+import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-DHtavbqk.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/clock/fake.d.ts

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { an as refuseStart, ln as type, m as flattenFeatures, on as exit, t as createApp } from "./src-Cs1bP3v7.mjs";
+import { an as refuseStart, ln as type, m as flattenFeatures, on as exit, t as createApp } from "./src-0m2mjRDI.mjs";
 import { n as saveOf, t as memory } from "./memory-CWlqhS7l.mjs";
 import { t as fakeClock } from "./fake-6mazmHK3.mjs";
 import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-BA6ffzqD.mjs";

package/dist/{types-DDmfkONF.d.mts → types-CpBnGqDU.d.mts}

@@ -1,5 +1,5 @@
-import { $r as Require, A as PixiModule, An as TrackOptions, At as FilterSlotInputs, Cr as Json, E as Api$4, En as NumericFields, M as PixiTexture, Mt as Point, Nn as Api$2, Pt as FilterCache, Qr as Events$2, Qt as Api$3, Sn as Ease, Sr as Events$3, Tn as MotionHandle, Ur as Api$1, an as AnyComponentValue, br as Api$6, cn as ComponentType, j as PixiSprite, jn as TrackSegment, k as PixiFilter, kn as ReducedMotion, kt as FilterSlot, on as ComponentHandle, or as TypeTag, rn as AnyComponent, s as Events$1, sr as Descriptor, t as Api$5, un as Entity, v as Events$4, zr as Events$5 } from "./types-i77Nrrv-.mjs";
-import { C as TextApi, L as I18nApi, M as InputApi, Y as StylesState, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion } from "./types-D8roM1u3.mjs";
+import { $r as Events$2, $t as Api$3, An as ReducedMotion, Br as Events$5, Cn as Ease, Cr as Events$3, D as FilterSlotInputs, Dn as NumericFields, E as FilterSlot, En as MotionHandle, K as Api$4, Mn as TrackSegment, O as SyncApi, Pn as Api$2, Q as PixiTexture, Wr as Api$1, X as PixiModule, Y as PixiFilter, Z as PixiSprite, cr as Descriptor, dn as Entity, ei as Require, in as AnyComponent, jn as TrackOptions, ln as ComponentType, lt as FilterCache, on as AnyComponentValue, s as Events$1, sn as ComponentHandle, sr as TypeTag, st as Point, t as Api$5, v as Events$4, wr as Json, xr as Api$6 } from "./types-CuEK0Vam.mjs";
+import { C as TextApi, L as I18nApi, M as InputApi, Y as StylesState, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion } from "./types-D5Pmo8BD.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -1093,7 +1093,7 @@ type State$3 = {
    * nothing while its clock runs on (spec 22 O9), told what the loop reveals (spec 26 R1.7). `undefined` before the
    * start and after the stop: nothing is held.
    */
-  loopsHeld: ((entity: Entity, reveals?: "alpha" | "place" | "both") => boolean) | undefined;
+  loopsHeld: SyncApi["loopsHeld"] | undefined;
 };
 /**
  * anim plugin API, `app.anim`: play a choreography, end everything, count what runs and listen