@moku-labs/game 0.14.8 → 0.14.10

package/dist/{src-DiPISDVO.mjs → src-CzfMhkry.mjs}

@@ -387,7 +387,7 @@ function stopLoop(state) {
 *
 * @param ctx - Domain context of the time plugin.
 */
-function startLoop$1(ctx) {
+function startLoop$2(ctx) {
 	if (typeof globalThis.requestAnimationFrame !== "function") return;
 	ctx.state.running = true;
 	ctx.state.rafId = globalThis.requestAnimationFrame(createFrameFunction(ctx));
@@ -451,7 +451,7 @@ const timePlugin = /*#__PURE__*/ createPlugin$1("time", {
 	},
 	createState: createTimeState,
 	api: createTimeApi,
-	onStart: startLoop$1,
+	onStart: startLoop$2,
 	onStop: ({ state }) => stopLoop(state)
 });
 //#endregion
@@ -2941,7 +2941,7 @@ function continueSlot(frames, finished) {
 //#endregion
 //#region src/plugins/flow/runner/edge.ts
 /**
-* Turns whatever a node failed with into an error the log takes.
+* Turns whatever a node, or an effect it started, failed with into an error the log takes.
 *
 * @param value - The thrown value or the rejection reason.
 * @returns The value itself when it is an error, a new error with its text otherwise.
@@ -3340,14 +3340,16 @@ function refuseEffect(signal) {
 	return refused;
 }
 /**
-* Builds the `fx` of a node context: awaited effects by call, cosmetic hints by `emit`. A `guide`
-* narrows the gate while it runs; the runner lifts the narrow when the node is left. A body that
-* was aborted keeps running, since the loop only stops waiting for it, so its `fx` starts nothing
-* any more: the gate and the narrow belong to the node the loop entered after it. The `recover`
-* of a rest node gets the same `fx`, bound to the signal of its recovery.
+* Builds the `fx` of a node context: awaited effects by call, effects the body does not wait for
+* by `start`, cosmetic hints by `emit`. A `guide` narrows the gate while it runs; the runner lifts
+* the narrow when the node is left. A body that was aborted keeps running, since the loop only
+* stops waiting for it, so its `fx` starts nothing any more: the gate and the narrow belong to the
+* node the loop entered after it. The `recover` of a rest node gets the same `fx`, bound to the
+* signal of its recovery.
 *
 * @param modules - Injected sibling APIs.
-* @param step - The run in progress: its abort signal, and how it tells a walk that a gate opened.
+* @param step - The run in progress: its abort signal, how it tells a walk that a gate opened, and
+*   the path and the log a failed `start` is reported with.
 * @returns The effects gateway of one node run.
 */
 function nodeFx(modules, step) {
@@ -3367,15 +3369,39 @@ function nodeFx(modules, step) {
 		if (descriptor.answers !== void 0) step.gateOpened();
 		return value;
 	};
-	return Object.assign(run, { 
 	/**
-	* Buffers one cosmetic hint until the transaction of this node commits.
+	* Starts one effect and does not wait for it. It takes the path of an awaited effect, so the
+	* mode and the node's signal apply; only its end is nobody's wait. A failure is the handler's:
+	* it goes to the log and never to the node. A `cosmetic` descriptor does not get that far: the
+	* gateway swallows its failure. After the abort of the node nothing is started and nothing is
+	* thrown, not even for a descriptor refused otherwise. An effect that ends with a rejection
+	* after the abort did not fail: its handler was told to stop, so nothing is logged.
 	*
-	* @param item - The hint.
+	* @param descriptor - The descriptor the node starts.
+	* @throws {Error} When the descriptor has `answers` or is a `guide`.
 	*/
-emit: (item) => {
-		modules.fx.buffer(item);
-	} });
+	const start = (descriptor) => {
+		if (step.signal.aborted) return;
+		if (descriptor.answers !== void 0 || descriptor.kind === "guide") throw new Error(`[game] fx.start() got the effect "${descriptor.kind}" in the node "${step.path}", and its answer has to be awaited.\n  Write await fx(...) for a descriptor with answers and for a guide.`);
+		modules.fx.run(descriptor, step.signal).catch((error) => {
+			if (step.signal.aborted) return;
+			step.log.error("flow:fx-start-failed", {
+				path: step.path,
+				kind: descriptor.kind
+			}, asError$4(error));
+		});
+	};
+	return Object.assign(run, {
+		/**
+		* Buffers one cosmetic hint until the transaction of this node commits.
+		*
+		* @param item - The hint.
+		*/
+		emit: (item) => {
+			modules.fx.buffer(item);
+		},
+		start
+	});
 }
 /**
 * Builds the one object a node body receives.
@@ -3791,7 +3817,8 @@ async function recoverNode(ctx, modules, place, safe) {
 		*/
 		gateOpened: () => {
 			notifyGateOpen(state);
-		}
+		},
+		log: ctx.log
 	};
 	const outcome = await Promise.race([callRecover(modules, recovery), abortOutcome(abort.signal)]);
 	modules.gate.narrow(void 0);
@@ -3926,7 +3953,8 @@ async function runNode(ctx, modules, location, node, safe) {
 		*/
 		gateOpened: () => {
 			notifyGateOpen(state);
-		}
+		},
+		log: ctx.log
 	};
 	const outcome = await nodeOutcome(modules, step, { event: void 0 });
 	modules.gate.narrow(void 0);
@@ -6579,6 +6607,8 @@ function noFields$1() {
 function joinFields(driven, owned) {
 	return /* @__PURE__ */ new Set([...driven ?? [], ...owned]);
 }
+/** What a component no loop adds to answers: no offset on any field. */
+const NO_OFFSETS = Object.freeze({});
 /** A handle for a motion that is already done. */
 const INERT = {
 	finish: () => {},
@@ -6682,7 +6712,8 @@ function startTrack$2(pctx, entity, component, to, options) {
 	if (handle.active()) state.tracks.push({
 		entity,
 		component: component.componentName,
-		handle
+		handle,
+		additive: options.additive === true
 	});
 	return handle;
 }
@@ -6708,7 +6739,9 @@ function forgetEndedTracks(pctx) {
 	state.tracks = state.tracks.filter((track) => track.handle.active());
 }
 /**
-* The component names a running track drives on one entity.
+* The component names a running track drives on one entity. An additive track drives none: the
+* loop of a view adds an offset to the rest pose and owns no component, so a settle may bring
+* the component home under it.
 *
 * @param pctx - Domain context of the projection module.
 * @param entity - The entity to ask about.
@@ -6717,10 +6750,23 @@ function forgetEndedTracks(pctx) {
 function drivenComponents(pctx, entity) {
 	forgetEndedTracks(pctx);
 	const driven = noFields$1();
-	for (const track of pctx.ctx.state.projection.tracks) if (track.entity === entity) driven.add(track.component);
+	for (const track of pctx.ctx.state.projection.tracks) if (track.entity === entity && !track.additive) driven.add(track.component);
 	return driven;
 }
 /**
+* What the additive tracks of the installed driver add to one component of one entity right now:
+* the offset of a loop. A driver that does not report it, and a world without a driver, answer
+* no offset.
+*
+* @param pctx - Domain context of the projection module.
+* @param entity - The entity to ask about.
+* @param component - The component to ask about.
+* @returns Field name to what is added to it, empty for a component no loop adds to.
+*/
+function loopOffsets(pctx, entity, component) {
+	return pctx.ctx.state.projection.driver?.offsetsOf?.(entity, component) ?? NO_OFFSETS;
+}
+/**
 * The components a running track drives on one entity, in start order, each name once. It only
 * reads: an ended track is skipped, not forgotten.
 *
@@ -6916,6 +6962,7 @@ function createViewRecord(entity, projection, key, item, rest) {
 		handles: [],
 		lifted: false,
 		dropWhenStill: false,
+		loopOwed: false,
 		exiting: false
 	};
 }
@@ -7055,7 +7102,69 @@ function runHook(pctx, view, hook, run) {
 	}
 }
 /**
-* The rest components that are off their rest value and that no running track drives.
+* The peers of a call outside a reconcile, as `settle` and the loop the sweep starts make it:
+* both sides are the items of the last reconcile.
+*
+* @param mounted - The mounted projection.
+* @returns The peers, the same item table as new and as old.
+*/
+function restingPeers(mounted) {
+	return {
+		next: mounted.items,
+		previous: mounted.items
+	};
+}
+/**
+* Plays the `loop` hook of a view, when its projection has one. The motion is not kept with the
+* view's handles: a change cancels those, and the loop runs until the view dies or a flush ends
+* its tracks.
+*
+* @param pctx - Domain context of the projection module.
+* @param view - The view that loops.
+* @param spec - The projection spec.
+* @param peers - The new and the old items of the projection.
+*/
+function startLoop$1(pctx, view, spec, peers) {
+	const loop = spec.motion?.loop;
+	if (loop === void 0) return;
+	runHook(pctx, view, "loop", () => loop(createViewHandle(pctx, view, peers)));
+}
+/**
+* The stored value of one rest component as it stands under the loop of the view: what the
+* additive tracks of the driver add right now is taken off each numeric field. Where the result
+* is at rest within `REST_TOLERANCE`, the exact rest value stands in, so the float noise of the
+* subtraction is no difference. Without a loop on the component, and with a driver that reports
+* no offsets, it is the stored value itself.
+*
+* It is what every comparison with the rest pose reads: the loose components of a settle, the
+* question of a rollback and the convergence check. So a view that only sways or bobs is home,
+* and a view something moved is not, in whatever field.
+*
+* @param pctx - Domain context of the projection module.
+* @param view - The view to read.
+* @param value - The rest value of the component, which names its type.
+* @returns The value under the loop, or `undefined` for a tag and for a missing component.
+*/
+function valueUnderLoop(pctx, view, value) {
+	const stored = storedValue(pctx, view.entity, value.type);
+	if (stored === void 0 || value.value === true) return stored;
+	const rest = value.value;
+	const offsets = loopOffsets(pctx, view.entity, asComponent$1(value.type));
+	let under;
+	for (const [field, offset] of Object.entries(offsets)) {
+		const current = stored[field];
+		if (typeof current !== "number") continue;
+		const below = current - offset;
+		under ??= { ...stored };
+		under[field] = atRest(below, rest[field]) ? rest[field] : below;
+	}
+	return under ?? stored;
+}
+/**
+* The rest components that are off their rest value and that no running track drives. The loop
+* of a view counts for neither. It drives no component: it adds an offset to the rest pose and
+* owns nothing. And its offset is no distance from the rest pose: the value under the loop is
+* what is compared. So a looping view is loose exactly when a view without a loop would be.
 *
 * @param pctx - Domain context of the projection module.
 * @param view - The view to check.
@@ -7066,8 +7175,8 @@ function looseComponents(pctx, view) {
 	const loose = [];
 	for (const [name, value] of view.rest) {
 		if (driven.has(name) || value.value === true) continue;
-		const stored = storedValue(pctx, view.entity, value.type);
-		if (stored !== void 0 && !deepEquals(stored, value.value)) loose.push(name);
+		const under = valueUnderLoop(pctx, view, value);
+		if (under !== void 0 && !deepEquals(under, value.value)) loose.push(name);
 	}
 	return loose;
 }
@@ -7094,13 +7203,69 @@ function playSettle(pctx, view, spec, peers, components) {
 	}
 	const played = runHook(pctx, view, "settle", () => custom(handle, components));
 	if (played === void 0) {
-		writeRestNow(pctx, view, components);
+		writeRestUnderLoops(pctx, view, components);
 		return;
 	}
 	if (played.motion !== void 0) view.handles.push(played.motion);
 }
 /**
-* Writes the rest values of the named components at once, leaving out muted fields.
+* Writes fields of one rest component at once while a loop of the view may run. A field a loop
+* adds to is written with the offset on top, so the picture does not lose the offset for a
+* frame. Its new value is first handed to the driver: the driver keeps its own base for such a
+* field and would write the old one back with its next frame. A track of 0 ms to the rest value
+* does that, and it is finished at once. So the base is moved before this call returns, whatever
+* cancels the motions of the view next and also in a world that is not live, and no handle is
+* left with the view. The shown value is written last: a driver that adds no offset on `finish`
+* must not have the last word. A field no loop adds to is written as it is, and muted fields are
+* left out.
+*
+* @param pctx - Domain context of the projection module.
+* @param view - The view to write.
+* @param value - The rest value of the component, which names its type.
+* @param patch - The fields to write, with their rest values.
+*/
+function writeUnderLoop(pctx, view, value, patch) {
+	const offsets = loopOffsets(pctx, view.entity, asComponent$1(value.type));
+	const shown = {};
+	const based = {};
+	for (const [field, entry] of Object.entries(patch)) {
+		const offset = offsets[field];
+		if (offset === void 0 || typeof entry !== "number") {
+			shown[field] = entry;
+			continue;
+		}
+		shown[field] = entry + offset;
+		based[field] = entry;
+	}
+	if (Object.keys(based).length > 0) startTrack$2(pctx, view.entity, asComponent$1(value.type), based, {
+		ms: 0,
+		ease: "linear",
+		delayMs: 0,
+		additive: false
+	}).finish();
+	writeUnmuted(pctx, view.entity, value, shown);
+}
+/**
+* Writes the rest values of the named components at once where a loop of the view may still
+* run: in play mode, and when `settle(entity)` writes in a world that is not live. A value under
+* a loop keeps the offset on top and reaches the driver too, as `writeUnderLoop` says. A direct
+* reconcile needs none of this and uses `writeRestNow`: its flush ends every loop.
+*
+* @param pctx - Domain context of the projection module.
+* @param view - The view to correct.
+* @param components - The component names to write.
+*/
+function writeRestUnderLoops(pctx, view, components) {
+	for (const name of components) {
+		const value = view.rest.get(name);
+		if (value === void 0 || value.value === true) continue;
+		writeUnderLoop(pctx, view, value, value.value);
+	}
+}
+/**
+* Writes the rest values of the named components at once, leaving out muted fields. It is the
+* write of a direct reconcile, whose flush ends every loop of the view: a value written under a
+* loop that runs on goes through `writeRestUnderLoops`.
 *
 * @param pctx - Domain context of the projection module.
 * @param view - The view to correct.
@@ -7159,23 +7324,54 @@ function atRest(stored, rest) {
 	return deepEquals(stored, rest);
 }
 /**
-* The convergence check of the last motion: every rest component is compared with the stored
-* value, muted fields excluded, numbers within `REST_TOLERANCE`. A difference is written and
-* reported.
+* The fields of one rest component that are off their rest value: muted fields left out, numbers
+* within `REST_TOLERANCE`. The value under the loop of the view is what is compared, so the
+* offset of a loop is no miss, and a miss in a field a loop adds to is one. A tag and a component
+* the entity does not carry answer nothing.
+*
+* @param pctx - Domain context of the projection module.
+* @param view - The view to check.
+* @param name - Name of the rest component.
+* @param value - The rest value of that component.
+* @returns The fields to write to bring the component home, by field name, with their rest
+*   values.
+*/
+function offRestFields(pctx, view, name, value) {
+	const patch = {};
+	if (value.value === true) return patch;
+	const under = valueUnderLoop(pctx, view, value);
+	if (under === void 0) return patch;
+	const muted = mutedFields(pctx, view.entity, name);
+	for (const [field, entry] of Object.entries(value.value)) if (!muted.has(field) && !atRest(under[field], entry)) patch[field] = entry;
+	return patch;
+}
+/**
+* Tells whether a view carries a component off its rest value: a field another writer owns does
+* not count, a number counts as at rest within `REST_TOLERANCE`, and what a loop adds does not
+* count. A rollback asks it before it settles a view whose item did not change.
+*
+* @param pctx - Domain context of the projection module.
+* @param view - The view to check.
+* @returns True when at least one field of one rest component is off its rest value.
+*/
+function standsOffRest(pctx, view) {
+	for (const [name, value] of view.rest) if (Object.keys(offRestFields(pctx, view, name, value)).length > 0) return true;
+	return false;
+}
+/**
+* The convergence check of the last motion: every rest component is compared with the value
+* under the loop of the view, muted fields excluded, numbers within `REST_TOLERANCE`. A
+* difference is written and reported. A field a loop adds to is handed to the driver and written
+* with the offset on top, so the correction does not jump and is not undone by the loop.
 *
 * @param pctx - Domain context of the projection module.
 * @param view - The view that came to rest.
 */
 function checkConvergence(pctx, view) {
 	for (const [name, value] of view.rest) {
-		if (value.value === true) continue;
-		const stored = storedValue(pctx, view.entity, value.type);
-		if (stored === void 0) continue;
-		const muted = mutedFields(pctx, view.entity, name);
-		const patch = {};
-		for (const [field, entry] of Object.entries(value.value)) if (!muted.has(field) && !atRest(stored[field], entry)) patch[field] = entry;
+		const patch = offRestFields(pctx, view, name, value);
 		if (Object.keys(patch).length === 0) continue;
-		pctx.deps.ecs.set(view.entity, asComponent$1(value.type), patch);
+		writeUnderLoop(pctx, view, value, patch);
 		pctx.ctx.log.warn("world:view-corrected", {
 			projection: view.projection,
 			key: view.key,
@@ -7186,8 +7382,10 @@ function checkConvergence(pctx, view) {
 //#endregion
 //#region src/plugins/world/projection/queue.ts
 /**
-* @file world/projection — the despawn queue: an exited view stays drawn until its last motion
-* ends, and every flush empties it in the same call.
+* @file world/projection — the despawn queue and the frame sweep: an exited view stays drawn
+* until its last motion ends, and every flush empties the queue in the same call. The sweep and
+* the flush also apply a pending `lift(false)`, the sweep forgets what is kept of a dead element
+* and starts the loops the views owe.
 */
 /**
 * Creates the empty item table of a flushed projection. It lives in its own non-exported function
@@ -7249,6 +7447,32 @@ function dequeueRevive(pctx, mounted, view, spec) {
 	mounted.live.set(view.key, view);
 }
 /**
+* Applies a pending `lift(false)`: the view leaves the lift layer for the layer of its
+* projection. A view the finger still holds carries no pending drop and stays lifted.
+*
+* @param pctx - Domain context of the projection module.
+* @param view - The view whose last motion ended.
+*/
+function dropPending(pctx, view) {
+	if (!view.dropWhenStill) return;
+	const spec = pctx.ctx.state.projection.specs.get(view.projection);
+	if (spec === void 0) return;
+	view.dropWhenStill = false;
+	view.lifted = false;
+	writeLayer(pctx, view.entity, spec.layer);
+}
+/**
+* Applies the pending `lift(false)` of a view no motion moves any more. A play reconcile and
+* `settle(entity)` call it where they cancelled the motions of a view: with nothing loose no new
+* motion starts, the view holds no handle, and the sweep skips a view without handles.
+*
+* @param pctx - Domain context of the projection module.
+* @param view - The view whose motions were cancelled.
+*/
+function dropIfStill(pctx, view) {
+	if (!stillMoving(view)) dropPending(pctx, view);
+}
+/**
 * The sweep of phase `animate`: queued views whose motions ended are despawned, and a live view
 * that came to rest is checked against its rest pose and gets its pending `lift(false)`.
 *
@@ -7257,24 +7481,63 @@ function dequeueRevive(pctx, mounted, view, spec) {
 function sweepQueue(pctx) {
 	const state = pctx.ctx.state.projection;
 	forgetEndedTracks(pctx);
-	for (const [name, mounted] of state.mounted) {
-		const spec = state.specs.get(name);
+	for (const mounted of state.mounted.values()) {
 		for (const view of [...mounted.queue]) if (!stillMoving(view)) despawnView(pctx, mounted, view);
 		for (const view of [...mounted.live.values()]) {
 			if (view.handles.length === 0 || stillMoving(view)) continue;
 			view.handles = [];
 			checkConvergence(pctx, view);
-			if (view.dropWhenStill && spec !== void 0) {
-				view.dropWhenStill = false;
-				view.lifted = false;
-				writeLayer(pctx, view.entity, spec.layer);
-			}
+			dropPending(pctx, view);
+		}
+	}
+}
+/**
+* Drops what the projection keeps about an element whose entity is gone: the rest pose `setRest`
+* or `viewOf` recorded, and the key `registerKey` published. An owner that despawns its element
+* without calling the key remover leaves both, and `entityOf` would go on answering with an
+* entity that is gone. The sweep calls it once per frame, and the converge step before it
+* writes. A key a newer element took over stays, and the remover that comes late is still safe.
+*
+* @param pctx - Domain context of the projection module.
+*/
+function forgetDeadElements(pctx) {
+	const { ecs } = pctx.deps;
+	const state = pctx.ctx.state.projection;
+	for (const entity of state.rests.keys()) if (ecs.ownerOf(entity) === void 0) state.rests.delete(entity);
+	for (const [entity, { projection, key }] of state.keysByEntity) {
+		if (ecs.ownerOf(entity) !== void 0) continue;
+		state.keysByEntity.delete(entity);
+		const byKey = state.keys.get(projection);
+		if (byKey?.get(key) === entity) byKey.delete(key);
+	}
+}
+/**
+* Starts the loop of every live view that owes one and clears the flag: a view that entered in a
+* direct reconcile, and a view whose tracks a flush ended. The sweep calls it, so it runs only
+* while the world is live, which also covers a world that comes back from `paused` or `fast`
+* with no reconcile of its own. Without a tween driver nothing starts and the views keep owing:
+* the instant driver would write the end pose of the loop once. A view of a projection without
+* a `loop` hook only has its flag cleared.
+*
+* @param pctx - Domain context of the projection module.
+*/
+function startOwedLoops(pctx) {
+	const state = pctx.ctx.state.projection;
+	if (state.driver === void 0) return;
+	for (const [name, mounted] of state.mounted) {
+		const spec = state.specs.get(name);
+		for (const view of mounted.live.values()) {
+			if (!view.loopOwed) continue;
+			view.loopOwed = false;
+			if (spec !== void 0) startLoop$1(pctx, view, spec, restingPeers(mounted));
 		}
 	}
 }
 /**
 * Flushes one mounted projection: every motion is finished and the despawn queue is emptied in
-* the same call.
+* the same call. The flush leaves a live view without a handle, and the sweep skips such a view,
+* so a pending `lift(false)` is applied here. It also ends the loop of a live view with its
+* other tracks, so the view owes its loop from here on.
 *
 * @param pctx - Domain context of the projection module.
 * @param mounted - The mounted projection.
@@ -7283,6 +7546,8 @@ function flushMounted(pctx, mounted) {
 	for (const view of [...mounted.live.values()]) {
 		finishHandles(view);
 		cancelTracks(pctx, view.entity);
+		dropPending(pctx, view);
+		view.loopOwed = true;
 	}
 	for (const view of [...mounted.queue]) {
 		finishHandles(view);
@@ -7410,6 +7675,7 @@ function hintFor$1(pctx, projection, key, used) {
 * A key that is new: spawn the entity with the view components and the projection's layer, then
 * play the `enter` hook and the `loop` hook when the reconcile plays motions. The loop is not
 * kept with the view's handles: a change cancels those, and the loop runs until the view dies.
+* A direct reconcile plays neither hook. The view then owes its loop, which the sweep starts.
 *
 * @param pctx - Domain context of the projection module.
 * @param spec - The projection spec.
@@ -7432,7 +7698,11 @@ function enterEntry(pctx, spec, mounted, entry) {
 	pctx.ctx.state.projection.byEntity.set(entity, view);
 	const hook = spec.motion?.enter;
 	const loop = spec.motion?.loop;
-	if (entry.direct || hook === void 0 && loop === void 0) return;
+	if (entry.direct) {
+		view.loopOwed = true;
+		return;
+	}
+	if (hook === void 0 && loop === void 0) return;
 	const handle = createViewHandle(pctx, view, entry.peers);
 	if (hook !== void 0) {
 		const hint = hintFor$1(pctx, spec.name, entry.key, entry.used);
@@ -7443,22 +7713,37 @@ function enterEntry(pctx, spec, mounted, entry) {
 	playSettle(pctx, view, spec, entry.peers, looseComponents(pctx, view));
 }
 /**
-* A key whose item changed: structural changes are written, a changed component with a hook is
-* handed to it and one without is written directly, then the retarget settles what is loose.
+* A key whose item is another object than before: structural changes are written, a changed
+* component with a hook is handed to it and one without is written directly, then the retarget
+* settles what is loose. A view no motion moves after that gets its pending `lift(false)`.
+*
+* In play mode an item with the same content is no change: when the component diff is empty the
+* new item is stored and nothing else happens. No motion of the view is cancelled, no hook runs,
+* nothing is written, no loose component is settled and no hint is used. A `from` that builds a
+* new object on every commit so keeps the motions of its views. A direct reconcile, and a forced
+* one, project the item as before.
 *
 * @param pctx - Domain context of the projection module.
 * @param spec - The projection spec.
 * @param view - The live view.
-* @param entry - The item, the peers, the mode and the used hints.
+* @param entry - The item, the peers, the mode, the force flag, the used hints and the list a
+*   direct reconcile fills.
 * @param entry.item - The new model item.
 * @param entry.peers - The new and the old items.
 * @param entry.direct - Whether the reconcile writes without motions.
+* @param entry.force - Whether an unchanged item is projected again.
 * @param entry.used - The hints that reached an entry.
+* @param entry.rewritten - The views a direct reconcile wrote, written again after its flush.
+* @returns False when the item has the same content as before and was only stored.
 */
 function changeEntry(pctx, spec, view, entry) {
 	const next = collectView(pctx, spec, entry.item);
 	const { added, changed, removed } = diffComponents(view.rest, next, treeName(pctx));
 	const previous = view.item;
+	if (!entry.direct && !entry.force && added.length + changed.length + removed.length === 0) {
+		view.item = entry.item;
+		return false;
+	}
 	for (const value of valuesOf(next, added)) writeValue(pctx, view.entity, value);
 	for (const value of valuesOf(view.rest, removed)) pctx.deps.ecs.remove(view.entity, value.type);
 	view.rest = next;
@@ -7466,7 +7751,8 @@ function changeEntry(pctx, spec, view, entry) {
 	if (entry.direct) {
 		finishHandles(view);
 		writeRestNow(pctx, view, [...next.keys()]);
-		return;
+		entry.rewritten.push(view);
+		return true;
 	}
 	cancelHandles(view);
 	const handle = createViewHandle(pctx, view, entry.peers);
@@ -7482,21 +7768,25 @@ function changeEntry(pctx, spec, view, entry) {
 		if (played === void 0) written.push(name);
 		else if (played.motion !== void 0) view.handles.push(played.motion);
 	}
-	writeRestNow(pctx, view, written);
+	writeRestUnderLoops(pctx, view, written);
 	playSettle(pctx, view, spec, entry.peers, looseComponents(pctx, view));
+	dropIfStill(pctx, view);
+	return true;
 }
 /**
 * A key that came back while its exit still played: the SAME view is revived, no `enter` and no
-* `change` hook runs, and one settle over the loose components brings it home.
+* `change` hook runs, and one settle over the loose components brings it home. A view no motion
+* moves after that gets its pending `lift(false)`.
 *
 * @param pctx - Domain context of the projection module.
 * @param spec - The projection spec.
 * @param mounted - The mounted projection.
 * @param view - The queued view.
-* @param entry - The item, the peers and the mode.
+* @param entry - The item, the peers, the mode and the list a direct reconcile fills.
 * @param entry.item - The new model item.
 * @param entry.peers - The new and the old items.
 * @param entry.direct - Whether the reconcile writes without motions.
+* @param entry.rewritten - The views a direct reconcile wrote, written again after its flush.
 */
 function reviveEntry(pctx, spec, mounted, view, entry) {
 	cancelHandles(view);
@@ -7509,9 +7799,11 @@ function reviveEntry(pctx, spec, mounted, view, entry) {
 	view.item = entry.item;
 	if (entry.direct) {
 		writeRestNow(pctx, view, [...next.keys()]);
+		entry.rewritten.push(view);
 		return;
 	}
 	playSettle(pctx, view, spec, entry.peers, looseComponents(pctx, view));
+	dropIfStill(pctx, view);
 }
 /**
 * A live key that is gone: despawned at once without an `exit` hook, otherwise moved into the
@@ -7542,27 +7834,57 @@ function exitEntry(pctx, spec, mounted, view, entry) {
 	if (!stillMoving(view)) despawnView(pctx, mounted, view);
 }
 /**
+* A live key whose item did not change, on a rollback: the same object, or in play mode a new
+* one with the same content. The failed node committed nothing, so no entry brings back a view
+* it moved with a motion or a timeline. A view that stands off its rest pose is settled as
+* `projection.settle(entity)` does: its motions are cancelled and the settle is played for the
+* loose components. With nothing loose a pending `lift(false)` takes effect. A view that stands
+* on its rest pose is left alone, so its motions run on. That holds for a view that loops too:
+* the value under its loop is what is compared. A direct reconcile only remembers the view: its
+* rest pose is written after the flush, in `writeUnchanged`.
+*
+* @param pctx - Domain context of the projection module.
+* @param spec - The projection spec.
+* @param view - The live view whose item is the same as before.
+* @param entry - The peers, the mode and the list a direct reconcile fills.
+* @param entry.peers - The new and the old items.
+* @param entry.direct - Whether the reconcile writes without motions.
+* @param entry.unchanged - The unchanged views of a direct reconcile, written after its flush.
+*/
+function settleUnchanged(pctx, spec, view, entry) {
+	if (entry.direct) {
+		entry.unchanged.push(view);
+		return;
+	}
+	if (!standsOffRest(pctx, view)) return;
+	cancelHandles(view);
+	playSettle(pctx, view, spec, entry.peers, looseComponents(pctx, view));
+	dropIfStill(pctx, view);
+}
+/**
 * Routes one key of the new state to the entry it belongs to: a live view changes, a queued view
 * revives, an unknown key enters.
 *
 * @param pctx - Domain context of the projection module.
 * @param spec - The projection spec.
 * @param mounted - The mounted projection.
-* @param entry - The key, its item, the peers, the mode, the force flag and the used hints.
+* @param entry - The key, its item, the peers, the mode, the flags and the used hints.
 * @param entry.key - The model key.
 * @param entry.item - The model item.
 * @param entry.peers - The new and the old items.
 * @param entry.direct - Whether the reconcile writes without motions.
 * @param entry.force - Whether an unchanged item is projected again.
+* @param entry.settle - Whether an unchanged view that stands off its rest pose is settled.
 * @param entry.used - The hints that reached an entry.
+* @param entry.unchanged - The unchanged views of a direct reconcile that settles.
+* @param entry.rewritten - The views a direct reconcile wrote, written again after its flush.
 * @param counts - The counters of this reconcile.
 */
 function applyEntry(pctx, spec, mounted, entry, counts) {
 	const live = mounted.live.get(entry.key);
 	if (live !== void 0) {
-		if (!entry.force && live.item === entry.item) return;
-		changeEntry(pctx, spec, live, entry);
-		counts.changed += 1;
+		if (!(!entry.force && live.item === entry.item) && changeEntry(pctx, spec, live, entry)) counts.changed += 1;
+		else if (entry.settle) settleUnchanged(pctx, spec, live, entry);
 		return;
 	}
 	const queued = mounted.queue.find((view) => view.key === entry.key);
@@ -7645,20 +7967,47 @@ function convergeMounted(pctx, mounted) {
 	for (const view of mounted.live.values()) writeRestNow(pctx, view, [...view.rest.keys()]);
 }
 /**
+* The last step of a direct reconcile that does not converge: every view an entry wrote is
+* written to its rest pose once more. The flush cancels the loop of a view with its other
+* tracks, and the driver writes the base it kept for the fields the loop added to back: the old
+* rest value. So the write of the entry, which came before the flush, would be lost in those
+* fields. Muted fields are left out.
+*
+* @param pctx - Domain context of the projection module.
+* @param rewritten - The live views a changed or revived entry wrote in this reconcile.
+*/
+function writeAgain(pctx, rewritten) {
+	for (const view of rewritten) writeRestNow(pctx, view, [...view.rest.keys()]);
+}
+/**
+* The last step of a direct reconcile a rollback caused: an unchanged view that stands off its
+* rest pose is written to it. It runs after the flush, as `convergeMounted` does and for the same
+* reason: the flush finishes the motions of the view, and a cancelled additive track writes its
+* base back, so the rest write has to come last. Muted fields are left out.
+*
+* @param pctx - Domain context of the projection module.
+* @param unchanged - The live views whose item did not change in this reconcile.
+*/
+function writeUnchanged(pctx, unchanged) {
+	for (const view of unchanged) if (standsOffRest(pctx, view)) writeRestNow(pctx, view, [...view.rest.keys()]);
+}
+/**
 * The same last step for the elements another plugin owns, which no reconcile of a projection
 * meets: each is written to the rest pose its owner recorded with `setRest`. Every track on the
 * entity is ended first, so nothing writes after it. Only a component the entity still carries
 * is written and muted fields are left out. An element that is leaving has its tracks ended and
-* keeps its place, and the recorded pose of an entity that is gone is skipped. So is one recorded
-* for a projection view: its own rest pose wins, as in `restOf`, and it is already home.
+* keeps its place. The recorded pose and the registered key of an entity that is gone are
+* dropped before anything is written. A pose recorded for a projection view is skipped: its own
+* rest pose wins, as in `restOf`, and it is already home.
 *
 * @param pctx - Domain context of the projection module.
 */
 function convergeElements(pctx) {
 	const { ecs, components } = pctx.deps;
 	const state = pctx.ctx.state.projection;
+	forgetDeadElements(pctx);
 	for (const [entity, rest] of state.rests) {
-		if (ecs.ownerOf(entity) === void 0 || state.byEntity.has(entity)) continue;
+		if (state.byEntity.has(entity)) continue;
 		cancelTracks(pctx, entity);
 		if (ecs.has(entity, components.Exiting)) continue;
 		const carried = [];
@@ -7687,20 +8036,26 @@ function tellConverged(pctx) {
 * @param spec - The projection spec.
 * @param mounted - The mounted projection.
 * @param snapshot - The model snapshot of this reconcile.
-* @param options - Mode, force flag and converge flag of this reconcile.
+* @param options - Mode, force flag, converge flag and settle flag of this reconcile.
 * @param counts - The counters of this reconcile.
 * @param used - The hints that reached an entry.
 */
 function reconcileOne(pctx, spec, mounted, snapshot, options, counts, used) {
 	const next = keyedItems(pctx, spec, snapshot);
 	if (next === void 0) return;
+	const peers = {
+		next,
+		previous: mounted.items
+	};
+	const unchanged = [];
+	const rewritten = [];
 	const entry = {
-		peers: {
-			next,
-			previous: mounted.items
-		},
+		peers,
 		direct: options.direct,
-		used
+		settle: options.settle,
+		used,
+		unchanged,
+		rewritten
 	};
 	try {
 		for (const [key, item] of next) applyEntry(pctx, spec, mounted, {
@@ -7717,6 +8072,10 @@ function reconcileOne(pctx, spec, mounted, snapshot, options, counts, used) {
 	mounted.items = next;
 	if (options.direct) flushMounted(pctx, mounted);
 	if (options.converge) convergeMounted(pctx, mounted);
+	else {
+		writeAgain(pctx, rewritten);
+		writeUnchanged(pctx, unchanged);
+	}
 	counts.queued += mounted.queue.length;
 }
 /**
@@ -7724,8 +8083,9 @@ function reconcileOne(pctx, spec, mounted, snapshot, options, counts, used) {
 * one then brings the elements other plugins own home and tells their owners.
 *
 * @param pctx - Domain context of the projection module.
-* @param options - Which projections, play or direct, whether `view` is forced, and whether
-*   every live view and every element is brought to its rest pose at the end.
+* @param options - Which projections, play or direct, whether `view` is forced, whether every
+*   live view and every element is brought to its rest pose at the end, and whether an unchanged
+*   view that stands off its rest pose is settled.
 */
 function reconcile(pctx, options) {
 	const state = pctx.ctx.state.projection;
@@ -7750,18 +8110,6 @@ function reconcile(pctx, options) {
 		...counts
 	});
 }
-/**
-* Re-projects one view with the same item, used by `lift` and `settle` to reach the peers.
-*
-* @param mounted - The mounted projection.
-* @returns The peers of a call outside a reconcile: the items of the last one.
-*/
-function restingPeers(mounted) {
-	return {
-		next: mounted.items,
-		previous: mounted.items
-	};
-}
 //#endregion
 //#region src/plugins/world/projection/api.ts
 /**
@@ -7925,8 +8273,9 @@ function createProjectionApi(ctx, deps) {
 	};
 	const state = ctx.state.projection;
 	/**
-	* Reconciles what is dirty. The cause table decides play or direct, and whether every live view
-	* and every element with a recorded rest pose is brought to it: a restore and a load do that.
+	* Reconciles what is dirty. The cause table decides play or direct, whether every live view
+	* and every element with a recorded rest pose is brought to it (a restore and a load do that),
+	* and whether an unchanged view that stands off its rest pose is settled (a rollback does).
 	*/
 	const reconcileIfDirty = () => {
 		const dirty = state.dirty;
@@ -7934,10 +8283,12 @@ function createProjectionApi(ctx, deps) {
 		if (dirty !== void 0 && (dirty.roots.has("player") || dirty.roots.has("session"))) {
 			const direct = dirty.force || dirty.causes.some((cause) => isDirectCause(cause)) || deps.ecs.mode() !== "live";
 			const converge = dirty.causes.some((cause) => isConvergeCause(cause));
+			const settle = dirty.causes.includes("rollback");
 			reconcile(pctx, {
 				direct,
 				force: dirty.force,
-				converge
+				converge,
+				settle
 			});
 		}
 		state.hints.length = 0;
@@ -7963,6 +8314,7 @@ function createProjectionApi(ctx, deps) {
 		handles: [],
 		lifted: false,
 		dropWhenStill: false,
+		loopOwed: false,
 		exiting: false
 	});
 	return {
@@ -7998,7 +8350,8 @@ function createProjectionApi(ctx, deps) {
 				names: fresh.map((spec) => spec.name),
 				direct: true,
 				force: true,
-				converge: false
+				converge: false,
+				settle: false
 			});
 		},
 		unmount: (names) => {
@@ -8022,15 +8375,12 @@ function createProjectionApi(ctx, deps) {
 			cancelHandles(view);
 			forgetEndedTracks(pctx);
 			if (deps.ecs.mode() !== "live") {
-				writeRestNow(pctx, view, [...view.rest.keys()]);
-				if (view.dropWhenStill) {
-					view.dropWhenStill = false;
-					view.lifted = false;
-					writeLayer(pctx, entity, spec.layer);
-				}
+				writeRestUnderLoops(pctx, view, [...view.rest.keys()]);
+				dropPending(pctx, view);
 				return;
 			}
 			playSettle(pctx, view, spec, restingPeers(mounted), looseComponents(pctx, view));
+			dropIfStill(pctx, view);
 		},
 		mute: (entity, component, fields) => {
 			const byComponent = state.mutes.get(entity) ?? emptyMuteTable();
@@ -8137,6 +8487,8 @@ function createProjectionApi(ctx, deps) {
 		sweep: () => {
 			if (deps.ecs.mode() !== "live") return;
 			sweepQueue(pctx);
+			forgetDeadElements(pctx);
+			startOwedLoops(pctx);
 		},
 		flushAll: () => {
 			for (const view of state.byEntity.values()) {
@@ -14354,6 +14706,52 @@ function sumOffsets(actx, key) {
 	return sum;
 }
 /**
+* What the running additive tracks of one component of one entity add to each of its fields
+* right now: the offset of a loop. The `TweenDriver` seam hands it to `world`, which takes it off
+* the stored value before it compares a view with its rest pose. A field no additive track adds
+* to is left out.
+*
+* A field another writer owns keeps the offset of the last write of its track. That is what
+* stands in the field while the writer only holds it, and what the track adds again when the
+* field is given back. So a view the hand held still reads as home, and a view the hand put
+* somewhere reads as moved.
+*
+* @param actx - Domain context of the anim plugin.
+* @param entity - The entity to ask about.
+* @param component - The component to ask about.
+* @returns Field name to the sum of the offsets on it.
+*/
+function addedOffsets(actx, entity, component) {
+	const sums = {};
+	for (const track of actx.state.additive.get(entity) ?? []) {
+		if (track.component.componentName !== component.componentName) continue;
+		for (const field of Object.keys(track.to)) sums[field] = sumOffsets(actx, keyOf$1(track, field));
+	}
+	return sums;
+}
+/**
+* Files a new additive track under its entity, so `addedOffsets` finds it without a walk of the
+* whole track table.
+*
+* @param actx - Domain context of the anim plugin.
+* @param track - The additive track that starts.
+*/
+function fileAdditive(actx, track) {
+	const tracks = actx.state.additive.get(track.entity) ?? /* @__PURE__ */ new Set();
+	tracks.add(track);
+	actx.state.additive.set(track.entity, tracks);
+}
+/**
+* Takes an ended additive track out of the table of its entity, and the entity with its last one.
+*
+* @param actx - Domain context of the anim plugin.
+* @param track - The track that ended.
+*/
+function unfileAdditive(actx, track) {
+	const tracks = actx.state.additive.get(track.entity);
+	if (tracks?.delete(track) === true && tracks.size === 0) actx.state.additive.delete(track.entity);
+}
+/**
 * Reads the start values of a track, once, when its delay has ended. The base of a field another
 * track already drives is used, so an additive offset is never folded into a start value.
 *
@@ -14424,6 +14822,53 @@ function fieldValue$1(track, field, start, target, fraction) {
 	return walkValue(track.segments, track.ease, field, start, fraction);
 }
 /**
+* Tells whether another writer owns a field at this write, so the track leaves it alone. An
+* additive track remembers that it skipped the field: it has to find the value under it again
+* once the field is given back.
+*
+* @param track - The track that is about to write.
+* @param owned - The fields another writer owns now.
+* @param field - The field.
+* @returns True when the track must not write the field.
+*/
+function skipsOwned(track, owned, field) {
+	if (!owned.has(field)) return false;
+	if (track.additive) track.masked.add(field);
+	return true;
+}
+/**
+* How far a field may sit from the value the table last wrote into it and still count as
+* untouched by another writer. The same size as the rest tolerance of `world`.
+*/
+const UNTOUCHED = 1e-6;
+/**
+* Books what an additive track adds to one field in this frame. On its first write after another
+* writer gave the field back it also moves the base of the field, when that writer moved the
+* field. While the field was owned, the track did not write it and the other writer put it where
+* it wanted, so the base the table kept is stale: a hand dragged a bobbing view away. The value
+* that stands in the field becomes what the base and the offsets add up to. So this write leaves
+* the field where it is, the track runs on from there, and a track that starts now to bring the
+* field home reads that value as its start. Without it the field would jump back to the old base
+* in one frame.
+*
+* A writer that only held the field left in it what the table last wrote: the base plus the
+* offsets as they stood. Then nothing moved the value under the track, and the base stays.
+*
+* @param actx - Domain context of the anim plugin.
+* @param track - The additive track.
+* @param field - The field.
+* @param delta - What the track adds to the field now.
+* @param left - The value that stands in the field before this write.
+*/
+function addOffset(actx, track, field, delta, left) {
+	const key = keyOf$1(track, field);
+	const written = (actx.state.bases.get(key) ?? 0) + sumOffsets(actx, key);
+	offsetsOf(actx, key).set(track.id, delta);
+	if (!track.masked.delete(field) || typeof left !== "number") return;
+	if (Math.abs(left - written) <= UNTOUCHED) return;
+	actx.state.bases.set(key, left - sumOffsets(actx, key));
+}
+/**
 * Writes one frame of a track: the eased value for an absolute track, the contributed delta for
 * an additive one, and in both cases the base plus every offset of the field. A component the
 * entity no longer carries ends the track silently.
@@ -14432,6 +14877,9 @@ function fieldValue$1(track, field, start, target, fraction) {
 * delta it adds over the base, so a loop keeps its shape whatever pose it started on. A straight
 * additive track still adds the way from its start value to its target.
 *
+* A field another writer owns is left alone. An additive track remembers that it skipped the
+* field, and adds to the value it finds there once the field is given back.
+*
 * @param actx - Domain context of the anim plugin.
 * @param track - The track to write.
 * @param fraction - Normalised time of the track.
@@ -14449,12 +14897,12 @@ function writeFields(actx, track, fraction, final) {
 	const patch = {};
 	const walksOffsets = track.additive && track.segments !== void 0;
 	for (const [field, target] of Object.entries(track.to)) {
-		if (owned.has(field)) continue;
+		if (skipsOwned(track, owned, field)) continue;
 		const key = keyOf$1(track, field);
 		const start = from[field] ?? target;
 		const origin = walksOffsets ? 0 : start;
 		const value = final ? target : fieldValue$1(track, field, origin, target, fraction);
-		if (track.additive) offsetsOf(actx, key).set(track.id, value - origin);
+		if (track.additive) addOffset(actx, track, field, value - origin, stored[field]);
 		else actx.state.bases.set(key, value);
 		patch[field] = (actx.state.bases.get(key) ?? start) + sumOffsets(actx, key);
 	}
@@ -14496,6 +14944,7 @@ function endTrack(actx, track) {
 	if (track.ended) return;
 	track.ended = true;
 	actx.state.tracks.delete(track.id);
+	if (track.additive) unfileAdditive(actx, track);
 	const clean = releaseFields(actx, track);
 	const ecs = actx.deps.world.ecs;
 	if (Object.keys(clean).length > 0 && ecs.get(track.entity, track.component) !== void 0) ecs.set(track.entity, track.component, clean);
@@ -14563,6 +15012,15 @@ function beginFrame(actx) {
 	actx.state.frame += 1;
 }
 /**
+* The empty set of the fields a new track skipped. It lives in its own function because lint
+* rule L5 refuses a collection built inside an exported declaration.
+*
+* @returns An empty set of field names.
+*/
+function noMaskedFields() {
+	return /* @__PURE__ */ new Set();
+}
+/**
 * The target of a new track: the fields the caller passed, plus every field a keyframe segment
 * names at the last value a segment gives it, so `claimFields` books the whole walk at once.
 *
@@ -14630,11 +15088,13 @@ function startTrack$1(actx, entity, component, to, options, muted, driven = fals
 		ended: Object.keys(target).length === 0,
 		segments: options.segments,
 		repeatsLeft: instant ? 0 : repeats,
-		held: false
+		held: false,
+		masked: noMaskedFields()
 	};
 	actx.state.nextId += 1;
 	if (track.ended) return track;
-	if (!track.additive) claimFields(actx, track);
+	if (track.additive) fileAdditive(actx, track);
+	else claimFields(actx, track);
 	actx.state.tracks.set(track.id, track);
 	countPlaying(actx.deps.world.ecs, entity, 1);
 	actx.deps.time.wake();
@@ -14763,12 +15223,19 @@ function advanceTracks(actx, deltaMs) {
 	for (const track of open) if (!track.additive) advanceTrack(actx, track, deltaMs);
 }
 /**
-* Finishes every track of the table, in table order.
+* Finishes every track of the table, in table order. With `keepLoops` a loop is left alone: it
+* has no end to finish on, so it stays in the table and stands where it is. The frame step of a
+* fast world asks for that, because nothing would start the loop again: a fast walk of the flow
+* that commits nothing flushes no view, so no view would owe its loop.
 *
 * @param actx - Domain context of the anim plugin.
+* @param keepLoops - True to leave every track that repeats forever running.
 */
-function finishAllTracks(actx) {
-	for (const track of [...actx.state.tracks.values()]) finishTrack(actx, track);
+function finishAllTracks(actx, keepLoops = false) {
+	for (const track of [...actx.state.tracks.values()]) {
+		if (keepLoops && track.repeatsLeft === Number.POSITIVE_INFINITY) continue;
+		finishTrack(actx, track);
+	}
 }
 /**
 * Ends every track of one entity, absolute and additive, and removes its `Animation`.
@@ -14793,7 +15260,9 @@ function noFields() {
 }
 /**
 * Creates the tween engine `world` runs `ViewHandle.tween`, `toRest` and `all` on. Installed with
-* `world.projection.setDriver` in `onStart`; the remover puts the instant writes back.
+* `world.projection.setDriver` in `onStart`; the remover puts the instant writes back. It also
+* reports what its additive tracks add to a component right now, so `world` can compare the
+* value under a loop with the rest pose.
 *
 * @param actx - Domain context of the anim plugin.
 * @returns The driver.
@@ -14801,7 +15270,8 @@ function noFields() {
 function createDriver(actx) {
 	return {
 		track: (entity, component, to, options, muted) => handleOf$1(actx, startTrack$1(actx, entity, component, to, options, muted)),
-		cancelAll: (entity) => cancelTracksOf(actx, entity)
+		cancelAll: (entity) => cancelTracksOf(actx, entity),
+		offsetsOf: (entity, component) => addedOffsets(actx, entity, component)
 	};
 }
 /**
@@ -14927,7 +15397,9 @@ function createRuntime(actx) {
 }
 /**
 * Ends everything that moves: every timeline at its own end, then every track on its exact
-* target. The frame step calls it in fast mode, the API exposes it, the teardown runs it last.
+* target, a loop too. The API exposes it and the teardown runs it last. It owes no loop by
+* itself; the next flush of `world` (a load, a restore, a commit in a paused or fast world) owes
+* the loop of a view again.
 *
 * @param actx - Domain context of the anim plugin.
 * @param rt - The timeline runtime.
@@ -14939,8 +15411,10 @@ function finishAllAnim(actx, rt) {
 /**
 * The one frame step: the timelines consume the delta first, so a track a step just started is
 * advanced by the remainder at once, then every other track advances, then every `Frames` loop.
-* A paused world moves nothing; a fast world ends everything, and a loop, which has no end,
-* stands where it is.
+* A paused world moves nothing. A fast world ends every timeline and every track that has an
+* end; a loop, which has none, stays and stands where it is, so it runs on when the world is live
+* again. That matters for a fast walk of the flow that commits nothing: no view is flushed then,
+* so no view would get its loop back.
 *
 * @param actx - Domain context of the anim plugin.
 * @param rt - The timeline runtime.
@@ -14950,7 +15424,8 @@ function stepAnim(actx, rt, time) {
 	const mode = actx.deps.world.ecs.mode();
 	if (mode === "paused") return;
 	if (mode === "fast") {
-		finishAllAnim(actx, rt);
+		finishAllTimelines(actx, rt);
+		finishAllTracks(actx, true);
 		return;
 	}
 	beginFrame(actx);
@@ -15114,6 +15589,7 @@ function stopAnim(state) {
 	state.owner.clear();
 	state.offsets.clear();
 	state.bases.clear();
+	state.additive.clear();
 	state.timelines.clear();
 	state.registry.clear();
 	state.markListeners.clear();
@@ -15191,6 +15667,7 @@ function createAnimState(ctx) {
 		owner: emptyMap$5(),
 		offsets: emptyMap$5(),
 		bases: emptyMap$5(),
+		additive: emptyMap$5(),
 		timelines: emptyMap$5(),
 		registry: emptyMap$5(),
 		markListeners: emptySet$3(),
@@ -35779,9 +36256,9 @@ function changeHooks(names, transition) {
 * transition is resolved and every name is checked here, at definition time, so every track it
 * starts carries a concrete duration and a wrong name fails where it is written. A `loop` builds
 * the `loop` hook: `world` and `ui` play it wherever they play `enter`, so a projection view loops
-* once it entered with motion, never after a direct reconcile, and `ui` swaps it when the motion
-* prop of an element changes. One cycle of the loop is `loop.ms`, or `transition.ms` when it is
-* left out.
+* from its enter, or from the first live frame after a direct reconcile, and `ui` swaps it when
+* the motion prop of an element changes. One cycle of the loop is `loop.ms`, or `transition.ms`
+* when it is left out.
 *
 * @param spec - The named poses, the keyframe tracks, the transition, the loop and the hooks to
 *   build.