@pascal-app/viewer 1.0.3 → 1.0.5

package/dist/systems/construction-reveal/construction-reveal.js

@@ -0,0 +1,2383 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { criticallyDamped, emitter, getLevelElevations, isRestoringSceneHistory, nodeRegistry, sceneRegistry, subscribeSceneCommits, useScene, } from '@pascal-app/core';
+import { useFrame } from '@react-three/fiber';
+import { useCallback, useEffect, useRef, useState, useSyncExternalStore } from 'react';
+import { Box3, Vector3 } from 'three';
+import { DustPool, emitAlongBase, emitAroundFoot } from '../../lib/construction-dust';
+import { SCENE_LAYER } from '../../lib/layers';
+import { CONTAINERS, commitChangeCandidates, commitDeleteCandidates, commitEditCandidates, commitRevealCandidates, nodeRevealCandidates, PART_LEAD, } from '../../lib/reveal-candidates';
+import { clearGhost, setGhost } from '../../lib/reveal-ghost';
+import { isRevealWaiting, revealPending } from '../../lib/reveal-pending';
+import { clearRevealPose, hasRevealPose, REVEAL_ARRIVAL, retractPoseAt, revealHasLanded, revealLocalBounds, revealPivot, revealPoseAt, setGlidePose, setRevealPose, } from '../../lib/reveal-pose';
+import { coverRangeAt, LAZY_REVEAL_TIMING, lazyRetractTimingAt, lazyTimingAt, normalizeAnimationSpeed, planLazyRetract, planLazyReveal, planRetract, planReveal, retractTimingAt, revealGroupKey, revealTimingAt, styleMs, } from '../../lib/reveal-schedule';
+import { clearRiseTextureScale, setRiseTextureScale } from '../../lib/reveal-texture-scale';
+import { coverDurationMs, coverShareAt, coverSweepOf, setRevealWipe, } from '../../lib/reveal-wipe';
+import useViewer from '../../store/use-viewer';
+import { releaseLevel, setHeldLevelY } from '../level/level-hold';
+import { getLevelPresentationY } from '../level/level-utils';
+import { ConstructionDust } from './construction-dust';
+import { dressDeletionGhost } from './ghost-dress';
+export { isRevealWaiting };
+const coverBox = new Box3();
+/** The sweep over what is drawn under `root`, and the time it takes in `range`. */
+function planCover(root, range) {
+    root.updateWorldMatrix(true, true);
+    const sweep = coverSweepOf(coverBox.setFromObject(root));
+    return { sweep, durationMs: coverDurationMs(sweep, range) };
+}
+/**
+ * The world coordinate the covering has reached when `share` of its sweep is closed: a hair under
+ * the lowest edge at the start and over the highest at the end, so it is whole where it ends.
+ */
+const coverLevel = (sweep, share) => sweep.from - 0.01 + (sweep.to - sweep.from + 0.02) * share;
+/** Lays the covering `elapsedMs` into its time: it moves with every frame, easing in and out. */
+function layCover(root, cover, elapsedMs) {
+    const share = coverShareAt(elapsedMs, cover.durationMs);
+    setRevealWipe(root, cover.sweep, coverLevel(cover.sweep, share));
+}
+/** Lifts the covering off: the same sweep played from the highest edge to the lowest. */
+function liftCover(root, cover, progress) {
+    const left = (1 - Math.min(1, Math.max(0, progress))) * cover.durationMs;
+    setRevealWipe(root, cover.sweep, coverLevel(cover.sweep, coverShareAt(left, cover.durationMs)));
+}
+/** A started node waits this long for its renderer to register (its kind may never mount). */
+const MOUNT_TIMEOUT_MS = 2000;
+/**
+ * And this long for its first build (an item's model) before it animates anyway, counted from
+ * the last build that landed: a wall builds once mounted, a few a frame, so a big agent build
+ * queues for longer than this while every build lands in turn (Victor run 11: 1,545 walls).
+ */
+const BUILD_TIMEOUT_MS = 2500;
+/** The longest step the reveal clock takes: a stalled tab resumes the build, it does not start it all at once. */
+const MAX_STEP_MS = 50;
+const MIN_SCALE = 1e-3;
+/** A full-height drop (a column from 4 m) raises the most dust. */
+const FULL_DUST_DROP_M = 4;
+/** The last piece of a build lands this much heavier: a bigger squash, a bigger puff. */
+const FINALE_WEIGHT = 1.7;
+/** On the lazy schedule a drop lifts this share of its height before it falls (anticipation). */
+const LAZY_DROP_LEAD = 0.08;
+/** A lifted node rises over this many seconds, and comes back a little quicker. */
+const LIFT_RESPONSE_UP_S = 0.55;
+const LIFT_RESPONSE_DOWN_S = 0.45;
+/**
+ * It waits this long after the last piece of the phase has landed, in case more is coming: one
+ * furnishing is often several writes, a model's turn between them takes seconds, and a roof that
+ * bobs down and up between them is a distraction. A host that knows the turn is over brings it down
+ * at once (`seatLiftedNow`).
+ */
+const LIFT_HOLD_MS = 10_000;
+/** The beat the room is seen whole under the open sky before the roof comes down on a host's say. */
+const LIFT_BEAT_MS = 700;
+/** At the top it is this faint (a ghost), never gone: the walls under it keep their shape. */
+const LIFT_GHOST_MIN = 0.14;
+/**
+ * A ghost's first draw (the transparent variant of every roof material) costs its shaders: a lift warms
+ * with the roof at this opacity, indistinguishable from whole, before it begins to rise.
+ */
+const LIFT_WARM_OPACITY = 0.995;
+/** A lift stays put this many quiet frames after its first ghost draw. */
+const LIFT_WARM_TICKS = 3;
+/**
+ * A kind's first appearance costs its shaders and pipelines (a first wall, a roof, an item's model are
+ * 100 to 400 ms), and the frame that pays freezes the picture. So the first node of each kind not yet
+ * on screen mounts up front, hidden, and the plan waits for it to have drawn and for the frames to be
+ * quiet again: the stall lands while nothing moves.
+ */
+const WARM_QUIET_FRAMES = 2;
+const WARM_QUIET_FRAME_MS = 34;
+const WARM_MIN_TICKS = 2;
+const WARM_MAX_MS = 2500;
+/** A node whose renderer has not registered a root by then never will (a kind with no 3D renderer). */
+const WARM_MOUNT_MS = 600;
+const UNIT = new Vector3(1, 1, 1);
+const ORIGIN = new Vector3();
+const HIDDEN = new Vector3(MIN_SCALE, MIN_SCALE, MIN_SCALE);
+const sample = { lift: 0, scale: new Vector3() };
+const lineFrom = new Vector3();
+const lineTo = new Vector3();
+const foot = [new Vector3(), new Vector3(), new Vector3(), new Vector3()];
+const pending = revealPending;
+let queue = [];
+/** The plan's entries still to start, by id: when each moves in, and its preroll before. */
+const planned = new Map();
+/** How long a plugin plays before a node of the lazy schedule moves in (its preroll), if it plays any. */
+let prerollOf = null;
+let unplanned = false;
+/** The plan is to be made again, once what mounts up front has drawn. */
+let replanning = false;
+const warming = new Map();
+/** Roofs ghosted ahead of the furniture, with the frames they have drawn so. */
+const ghostWarming = new Map();
+let warmWaiting = false;
+let warmStartedMs = 0;
+let warmQuiet = 0;
+let dustWarmed = false;
+/** Whether the last frame took no longer than a steady one (unknown: it did not). */
+let frameQuiet = true;
+const active = new Map();
+const announced = new Set();
+/** An assembled node's parts still on their way, and each part's host. */
+const parts = new Map();
+const hostOf = new Map();
+let arrivals = 0;
+let lastStartMs = Number.NEGATIVE_INFINITY;
+let clockMs = 0;
+/** When a started node's first build last landed. */
+let buildLandedMs = Number.NEGATIVE_INFINITY;
+let tickedBusy = false;
+let revealLevel = () => 'full';
+/** The person's animation speed, asked when a plan is made (never mid-animation). */
+let revealSpeed = () => 1;
+/** The speed the plan in force was made at: what waits for its turn plays at it. */
+let planSpeed = 1;
+const currentSpeed = () => normalizeAnimationSpeed(revealSpeed());
+/** The animation speed the plan in force was made at, for a plugin that stages its own pieces. */
+export function getRevealPlanSpeed() {
+    return planSpeed;
+}
+let dust = null;
+/** The groups still open, each (phase, level) once; and the group each staged node counts in. */
+const groups = new Map();
+const groupOfNode = new Map();
+/** Moves waiting for the reveal to be quiet: they hold at their old place meanwhile. */
+let changeQueue = [];
+/** The ids waiting in `changeQueue`. */
+const queuedChanges = new Set();
+/** Pieces on their way (or waiting their turn to start). */
+const glides = new Map();
+const changeGroups = new Map();
+const changeGroupOf = new Map();
+/** The moves since the reveal was last quiet: what a change's `complete` reports. */
+let changeRun = null;
+let glideClockMs = Number.NEGATIVE_INFINITY;
+/** A move lifted the roof for the furniture: it is let go of at this time on the clock, a beat after the last. */
+let changeLiftReleaseAt = null;
+/** How long after the last move the roof is let go of (it then waits out `LIFT_HOLD_MS` for more). */
+const CHANGE_LIFT_BEAT_MS = 1200;
+/** A glide is a short spring: it is home about three quarters of a second after it starts. */
+const GLIDE_RESPONSE_S = 0.7;
+/** A piece is carried, not slid: it rises this far (metres) half way. */
+const GLIDE_HOP_M = 0.05;
+/** Pieces of a rearranged room start this far apart, up to a cap however many move. */
+const GLIDE_STAGGER_MS = 80;
+const GLIDE_STAGGER_CAP_MS = 1200;
+/** The build since the reveal was last idle: what `complete` reports. */
+let build = null;
+/** What is up, and what has asked to be but is still being built or revealed. */
+const lifts = new Map();
+const liftWanted = new Map();
+/** The build's finale, said when what was lifted seats again instead of at the last landing. */
+let deferredFinale = null;
+let liftClockMs = Number.NEGATIVE_INFINITY;
+const pendingListeners = new Map();
+const phaseListeners = new Set();
+const eventListeners = new Set();
+const assemblyListeners = new Map();
+const tickListeners = new Set();
+function notifyPending(id) {
+    const listeners = pendingListeners.get(id);
+    if (listeners)
+        for (const listener of [...listeners])
+            listener();
+}
+function notifyAssembly(hostId, assembling) {
+    const listeners = assemblyListeners.get(hostId);
+    if (listeners)
+        for (const listener of [...listeners])
+            listener(assembling);
+}
+function notifyTicks() {
+    for (const listener of [...tickListeners]) {
+        try {
+            listener();
+        }
+        catch (error) {
+            console.error('[viewer] reveal tick listener failed', error);
+        }
+    }
+}
+/**
+ * Whether the node waits for its turn (unmounted), is still moving in, is going out (a reverse play,
+ * and held gone until the host takes it out of the scene), or is being carried to a new place. A batch
+ * hands it back to itself and keeps it out.
+ */
+export function isNodeRevealing(id) {
+    return (pending.has(id) ||
+        active.has(id) ||
+        retracts.has(id) ||
+        held.has(id) ||
+        glides.has(id) ||
+        queuedChanges.has(id));
+}
+/**
+ * A `cut` node leaves its host: the host, built whole while it waited, rebuilds with the opening.
+ */
+function released(candidate) {
+    notifyPending(candidate.id);
+    if (candidate.style !== 'cut')
+        return;
+    const hostId = useScene.getState().nodes[candidate.id]?.parentId;
+    if (hostId)
+        useScene.getState().markDirty(hostId);
+}
+function subscribePending(id, listener) {
+    let listeners = pendingListeners.get(id);
+    if (!listeners) {
+        listeners = new Set();
+        pendingListeners.set(id, listeners);
+    }
+    const own = listeners;
+    own.add(listener);
+    return () => {
+        own.delete(listener);
+        if (own.size === 0 && pendingListeners.get(id) === own)
+            pendingListeners.delete(id);
+    };
+}
+/**
+ * True while the node waits for its turn: its renderer stays unmounted. A node that mounts up front,
+ * hidden, to draw its shaders before the build moves (see `chooseWarm`) is mounted: not pending.
+ */
+export function useRevealPending(id) {
+    const subscribe = useCallback((listener) => subscribePending(id, listener), [id]);
+    const read = useCallback(() => pending.has(id) && !warming.has(id), [id]);
+    return useSyncExternalStore(subscribe, read, read);
+}
+/**
+ * True while the plan has something to play for the node: it waits for its turn, moves in, goes (an
+ * undo's reverse play) or is held gone. A plan entry that draws the node itself subscribes to the
+ * reveal's ticks only while this is true.
+ */
+export function useRevealPlanActive(id) {
+    const subscribe = useCallback((listener) => subscribePending(id, listener), [id]);
+    const read = useCallback(() => pending.has(id) || active.has(id) || retracts.has(id) || held.has(id), [id]);
+    return useSyncExternalStore(subscribe, read, read);
+}
+/**
+ * True while the node has not had its turn, mounted up front or not: what a view that draws the node
+ * itself (the 2D plan) leaves out until it does.
+ */
+export function useRevealWaiting(id) {
+    const subscribe = useCallback((listener) => subscribePending(id, listener), [id]);
+    const read = useCallback(() => pending.has(id), [id]);
+    return useSyncExternalStore(subscribe, read, read);
+}
+/** True while an `assemble` node's parts are still on their way: its renderer draws them apart. */
+export function isRevealAssembling(id) {
+    return (parts.get(id)?.size ?? 0) > 0;
+}
+/**
+ * Calls `listener` each time `id` starts or stops assembling. It fires
+ * synchronously, even when a capture ends the reveal, so a renderer that
+ * swaps its parts for a merged shell can do so before the frame is cloned.
+ */
+export function subscribeRevealAssembling(id, listener) {
+    let listeners = assemblyListeners.get(id);
+    if (!listeners) {
+        listeners = new Set();
+        assemblyListeners.set(id, listeners);
+    }
+    const own = listeners;
+    own.add(listener);
+    return () => {
+        own.delete(listener);
+        if (own.size === 0 && assemblyListeners.get(id) === own)
+            assemblyListeners.delete(id);
+    };
+}
+/**
+ * The node's reveal for a plan view, on the reveal's own clock: `progress` is
+ * 0 while it waits and runs to 1 over its style's duration from its start
+ * (not from its first 3D build, which a paused canvas never runs). Null once
+ * it is done, or if it never revealed.
+ */
+export function getRevealPlanState(id) {
+    const waiting = pending.get(id);
+    if (waiting)
+        return { style: waiting.style, progress: 0 };
+    // The build played in reverse is the same state read backwards: whole until its turn, then going,
+    // then gone while it is held.
+    const retract = retracts.get(id);
+    if (retract) {
+        if (clockMs < retract.startMs)
+            return null;
+        const gone = (clockMs - retract.startMs) / Math.max(1, retract.durationMs);
+        return { style: retract.style, progress: Math.min(1, Math.max(0, 1 - gone)) };
+    }
+    const gone = held.get(id);
+    if (gone)
+        return { style: gone.style, progress: 0 };
+    const reveal = active.get(id);
+    if (!reveal)
+        return null;
+    const durationMs = reveal.style === 'assemble' ? reveal.assembleMs : reveal.durationMs;
+    const progress = (clockMs - reveal.startedAt) / Math.max(1, durationMs);
+    return { style: reveal.style, progress: Math.min(1, Math.max(0, progress)) };
+}
+/**
+ * When a waiting node of the plan moves in, on the reveal's clock (`revealClockMs`), and how long its
+ * preroll plays before: a plugin that stages its own pieces for it (a wall's frame and boards) plays
+ * them in `[startMs - prerollMs, startMs]`. Null once it has started, or when it is not planned.
+ */
+export function getRevealTurn(id) {
+    const entry = planned.get(id);
+    return entry ? { startMs: entry.startMs, prerollMs: entry.prerollMs ?? 0 } : null;
+}
+/** The reveal's own clock: what `getRevealTurn` counts in. */
+export function revealClockMs() {
+    return clockMs;
+}
+/**
+ * Lets a plugin ask for a preroll before nodes of the lazy schedule (the `framing` level) move in:
+ * the plan leaves `prerollOf(candidate)` ms before each, and the plugin plays its own pieces then.
+ * Asked once per node when the plan is made; 0 for none. Null takes it back.
+ */
+export function setRevealPreroll(next) {
+    prerollOf = next;
+}
+const puffFoot = [new Vector3(), new Vector3(), new Vector3(), new Vector3()];
+/**
+ * A puff of the reveal's dust around `centre` (world), `radius` metres out, `strength` in (0, 1]:
+ * for a plugin's own pieces landing. Nothing when no dust plays (the simple level, no reveal).
+ */
+export function emitRevealPuff(centre, radius, strength) {
+    if (!(dust && dustOn()))
+        return;
+    puffFoot[0].set(centre.x - radius, centre.y, centre.z - radius);
+    puffFoot[1].set(centre.x + radius, centre.y, centre.z - radius);
+    puffFoot[2].set(centre.x + radius, centre.y, centre.z + radius);
+    puffFoot[3].set(centre.x - radius, centre.y, centre.z + radius);
+    emitAroundFoot(dust, puffFoot, Math.min(1, Math.max(0.05, strength)), clockMs);
+}
+/** Calls `listener` after every reveal step while anything reveals, and once when it all ends. */
+export function subscribeRevealTicks(listener) {
+    tickListeners.add(listener);
+    return () => {
+        tickListeners.delete(listener);
+    };
+}
+/**
+ * Everything a reveal says, in order and on its clock: the phase groups starting, landing and
+ * settling, each node starting, and the build completing. The chat's step cards, the sounds and the
+ * camera that follows the build listen here, so they share one rhythm.
+ */
+export function subscribeRevealEvents(listener) {
+    eventListeners.add(listener);
+    return () => {
+        eventListeners.delete(listener);
+    };
+}
+function emit(event) {
+    for (const listener of [...eventListeners]) {
+        try {
+            listener(event);
+        }
+        catch (error) {
+            console.error('[viewer] reveal event listener failed', error);
+        }
+    }
+}
+function emitGroup(type, group, atMs) {
+    emit({
+        type,
+        phase: group.phase,
+        levelId: group.levelId,
+        nodeIds: [...group.ids],
+        source: group.source,
+        instant: !group.animated || group.forced,
+        atMs,
+    });
+}
+/** Counts each staged node in its (phase, level) group, and the build they belong to. */
+function registerCandidates(candidates, atMs) {
+    build ??= { startedAt: atMs, count: 0, source: null, animated: false };
+    for (const candidate of candidates) {
+        const key = revealGroupKey(candidate);
+        let group = groups.get(key);
+        if (!group) {
+            group = {
+                phase: candidate.phase,
+                levelId: candidate.levelId,
+                ids: new Set(),
+                remaining: 0,
+                started: false,
+                lifted: false,
+                landed: false,
+                animated: false,
+                forced: false,
+                source: candidate.source ?? null,
+            };
+            groups.set(key, group);
+        }
+        if (!group.ids.has(candidate.id))
+            group.remaining += 1;
+        group.ids.add(candidate.id);
+        groupOfNode.set(candidate.id, key);
+        build.count += 1;
+        build.source = candidate.source ?? build.source;
+    }
+}
+/**
+ * A node is let in to play. What lifts out of the way of its phase starts to, so the roof is on its way
+ * as the first piece of furniture begins; the group itself is not said to have started until a node moves.
+ */
+function groupReleased(candidate) {
+    const group = groups.get(revealGroupKey(candidate));
+    if (!group)
+        return;
+    group.animated = true;
+    if (build)
+        build.animated = true;
+    if (!group.lifted) {
+        group.lifted = true;
+        wantLifts(group.phase, group.levelId);
+    }
+}
+/**
+ * A node's first move: a group's first node begins to move. That is when a step card lands and the
+ * camera goes there, not when the node is let in (it may wait for a slow build, and nothing is seen).
+ */
+function groupStarted(candidate, atMs) {
+    const group = groups.get(revealGroupKey(candidate));
+    if (!group)
+        return;
+    if (!group.started) {
+        group.started = true;
+        emitGroup('start', group, atMs);
+    }
+    emit({
+        type: 'node-start',
+        id: candidate.id,
+        phase: candidate.phase,
+        levelId: candidate.levelId,
+        style: candidate.style,
+        source: candidate.source ?? null,
+        atMs,
+    });
+}
+/** A group's first node makes contact: the frame its sound belongs on. */
+function groupLanded(id, atMs) {
+    const group = groups.get(groupOfNode.get(id) ?? '');
+    if (!group || group.landed)
+        return;
+    if (!group.started) {
+        group.started = true;
+        emitGroup('start', group, atMs);
+    }
+    group.landed = true;
+    emitGroup('land', group, atMs);
+}
+/**
+ * `id` is at rest (or was never staged, or was cut short): when its group has no node left, the
+ * group settles, saying the start and the land first if it never had occasion to.
+ */
+function closeNode(id, atMs, forced) {
+    const key = groupOfNode.get(id);
+    if (key === undefined)
+        return;
+    groupOfNode.delete(id);
+    const group = groups.get(key);
+    if (!group)
+        return;
+    if (forced)
+        group.forced = true;
+    group.remaining -= 1;
+    if (group.remaining > 0)
+        return;
+    groups.delete(key);
+    if (!group.started) {
+        group.started = true;
+        emitGroup('start', group, atMs);
+    }
+    if (!group.landed) {
+        group.landed = true;
+        emitGroup('land', group, atMs);
+    }
+    emitGroup('settle', group, atMs);
+    releaseLifts(group.phase, atMs);
+}
+/** The build is over: nothing waits and nothing moves. */
+function completeBuild(atMs, forced) {
+    const finished = build;
+    build = null;
+    if (!finished)
+        return;
+    emit({
+        type: 'complete',
+        nodeCount: finished.count,
+        durationMs: Math.max(0, atMs - finished.startedAt),
+        source: finished.source,
+        instant: forced || !finished.animated,
+        atMs,
+    });
+}
+function emitChangeGroup(type, group, atMs) {
+    emit({
+        type,
+        phase: group.phase,
+        levelId: group.levelId,
+        nodeIds: [...group.ids],
+        source: group.source,
+        instant: !group.animated || group.forced,
+        atMs,
+        changed: true,
+    });
+}
+/** Counts each moved piece in its (phase, level) group, and the run they belong to. */
+function registerChanges(changes, atMs) {
+    changeRun ??= { startedAt: atMs, count: 0, source: null, animated: false };
+    for (const change of changes) {
+        const key = revealGroupKey(change);
+        let group = changeGroups.get(key);
+        if (!group) {
+            group = {
+                phase: change.phase,
+                levelId: change.levelId,
+                ids: new Set(),
+                remaining: 0,
+                started: false,
+                landed: false,
+                animated: false,
+                forced: false,
+                source: change.source ?? null,
+            };
+            changeGroups.set(key, group);
+        }
+        if (!group.ids.has(change.id))
+            group.remaining += 1;
+        group.ids.add(change.id);
+        changeGroupOf.set(change.id, key);
+        changeRun.count += 1;
+        changeRun.source = change.source ?? changeRun.source;
+    }
+}
+/** A piece's move begins: its group starts with its first, and the roof lifts out of the way as for furniture. */
+function beginChange(change, atMs) {
+    const group = changeGroups.get(changeGroupOf.get(change.id) ?? '');
+    if (!group)
+        return;
+    if (!group.started) {
+        group.started = true;
+        emitChangeGroup('start', group, atMs);
+    }
+    emit({
+        type: 'node-start',
+        id: change.id,
+        phase: change.phase,
+        levelId: change.levelId,
+        style: change.edited ? change.style : 'glide',
+        source: change.source ?? null,
+        atMs,
+        changed: true,
+    });
+    wantLifts(change.phase, change.levelId);
+    changeLiftReleaseAt = null;
+}
+/** A piece is home (or its move was cut short): its group settles with its last, and the run with its last group. */
+function endChange(id, atMs, forced) {
+    const key = changeGroupOf.get(id);
+    if (key === undefined)
+        return;
+    changeGroupOf.delete(id);
+    const group = changeGroups.get(key);
+    if (!group)
+        return;
+    if (forced)
+        group.forced = true;
+    if (!group.started) {
+        group.started = true;
+        emitChangeGroup('start', group, atMs);
+    }
+    if (!group.landed) {
+        group.landed = true;
+        emitChangeGroup('land', group, atMs);
+    }
+    group.remaining -= 1;
+    if (group.remaining > 0)
+        return;
+    changeGroups.delete(key);
+    emitChangeGroup('settle', group, atMs);
+    if (changeGroups.size > 0)
+        return;
+    const run = changeRun;
+    changeRun = null;
+    if (!run)
+        return;
+    emit({
+        type: 'complete',
+        nodeCount: run.count,
+        durationMs: Math.max(0, atMs - run.startedAt),
+        source: run.source,
+        instant: forced || !run.animated,
+        atMs,
+        changed: true,
+    });
+    changeLiftReleaseAt = atMs + CHANGE_LIFT_BEAT_MS;
+}
+const glideFrom = new Vector3();
+/** Shows `change` where it was, with `left` of the way still to go. */
+function poseGlide(change, root, left) {
+    const from = change.from;
+    if (!from)
+        return;
+    glideFrom.set(...from.position);
+    setGlidePose(root, glideFrom, from.yaw, left, GLIDE_HOP_M * 4 * left * (1 - left));
+}
+/** Whether a move glides now: it has somewhere to glide from, and the animation plays. */
+function glidePlays(change) {
+    return ((change.from !== null || change.edited === true) &&
+        !showsAtOnce() &&
+        !useViewer.getState().renderPaused);
+}
+/** The agent's moves wait for the reveal to be quiet; until then each piece holds at its old place. */
+function queueChanges(changes) {
+    for (const change of changes) {
+        if (queuedChanges.has(change.id) || glides.has(change.id))
+            continue;
+        queuedChanges.add(change.id);
+        changeQueue.push(change);
+        const root = sceneRegistry.nodes.get(change.id);
+        if (root && glidePlays(change))
+            poseGlide(change, root, 1);
+    }
+}
+/** Takes the glide pose off a piece that will not glide (it has gone, or the animation has been turned off). */
+function dropGlidePose(id) {
+    const root = sceneRegistry.nodes.get(id);
+    if (root && hasRevealPose(root))
+        clearRevealPose(root);
+}
+/** The reveal is quiet: the queued moves begin, a beat apart, or are said at once where they cannot glide. */
+function flushChanges(now) {
+    const nodes = useScene.getState().nodes;
+    const waiting = changeQueue.filter((change) => nodes[change.id]);
+    for (const change of changeQueue)
+        if (!nodes[change.id])
+            dropGlidePose(change.id);
+    changeQueue = [];
+    queuedChanges.clear();
+    if (waiting.length === 0)
+        return;
+    registerChanges(waiting, now);
+    const atOnce = [];
+    // However many move, they begin spread over the same time, never piled on the last frame.
+    const stagger = Math.min(GLIDE_STAGGER_MS, GLIDE_STAGGER_CAP_MS / waiting.length);
+    let delay = 0;
+    for (const change of waiting) {
+        const root = sceneRegistry.nodes.get(change.id);
+        if (root && glidePlays(change)) {
+            poseGlide(change, root, 1);
+            glides.set(change.id, {
+                change,
+                startAt: now + delay,
+                state: { x: 1, v: 0 },
+                began: false,
+            });
+            delay += stagger;
+            const group = changeGroups.get(changeGroupOf.get(change.id) ?? '');
+            if (group)
+                group.animated = true;
+            if (changeRun)
+                changeRun.animated = true;
+        }
+        else {
+            dropGlidePose(change.id);
+            atOnce.push(change);
+        }
+    }
+    for (const change of atOnce)
+        beginChange(change, now);
+    for (const change of atOnce)
+        endChange(change.id, now, false);
+}
+/** An edited node plays again in this share of the time its first appearance took. */
+const EDIT_SHARE = 0.55;
+/** An edited node begins its quick re-rise, at the person's animation speed. */
+function startEdit(change, now) {
+    beginChange(change, now);
+    const speed = currentSpeed();
+    const lazy = lazyOn();
+    const timing = lazy ? lazyTimingAt(speed) : revealTimingAt(speed);
+    active.set(change.id, {
+        id: change.id,
+        candidate: change,
+        style: change.style,
+        height: change.height,
+        levelId: change.levelId,
+        startedAt: now,
+        durationMs: styleMs(timing.durationMs, change.style) * EDIT_SHARE,
+        assembleMs: 0,
+        clockStart: null,
+        pivot: null,
+        base: null,
+        landed: false,
+        root: null,
+        lead: 0,
+        weight: 1,
+        overshoot: lazy && change.style in LAZY_REVEAL_TIMING.overshoot
+            ? LAZY_REVEAL_TIMING.overshoot[change.style]
+            : 0,
+        finale: false,
+        finaleSaid: false,
+        edit: true,
+    });
+}
+function stepGlides(now) {
+    const dt = Math.min(0.05, Math.max(0, (now - glideClockMs) / 1000));
+    glideClockMs = now;
+    const nodes = useScene.getState().nodes;
+    for (const glide of [...glides.values()]) {
+        const { change } = glide;
+        const root = sceneRegistry.nodes.get(change.id);
+        if (!nodes[change.id]) {
+            glides.delete(change.id);
+            endChange(change.id, now, true);
+            continue;
+        }
+        if (change.edited) {
+            if (now < glide.startAt)
+                continue;
+            glides.delete(change.id);
+            startEdit(change, now);
+            continue;
+        }
+        if (!glide.began) {
+            if (now < glide.startAt) {
+                if (root)
+                    poseGlide(change, root, 1);
+                continue;
+            }
+            glide.began = true;
+            beginChange(change, now);
+        }
+        criticallyDamped(glide.state, 0, GLIDE_RESPONSE_S, dt);
+        const left = Math.max(0, glide.state.x);
+        if (left < 0.003 && Math.abs(glide.state.v) < 0.05) {
+            glides.delete(change.id);
+            dropGlidePose(change.id);
+            endChange(change.id, now, false);
+            continue;
+        }
+        if (root)
+            poseGlide(change, root, left);
+    }
+}
+/** A glide is cut short (selected, retracted, the reveal stopped): the piece is home at once. */
+function finishGlide(id) {
+    if (queuedChanges.delete(id)) {
+        changeQueue = changeQueue.filter((change) => change.id !== id);
+        dropGlidePose(id);
+        return;
+    }
+    if (!glides.delete(id))
+        return;
+    dropGlidePose(id);
+    endChange(id, clockMs, true);
+}
+function finishChanges() {
+    for (const id of [...queuedChanges])
+        finishGlide(id);
+    for (const id of [...glides.keys()])
+        finishGlide(id);
+    changeLiftReleaseAt = null;
+}
+/** One event when each (phase, level) group of a reveal starts — at most one sound cue each. */
+export function subscribeRevealPhases(listener) {
+    phaseListeners.add(listener);
+    return () => {
+        phaseListeners.delete(listener);
+    };
+}
+function announce(candidate) {
+    const group = revealGroupKey(candidate);
+    if (announced.has(group))
+        return;
+    announced.add(group);
+    const event = { phase: candidate.phase, levelId: candidate.levelId };
+    for (const listener of [...phaseListeners]) {
+        try {
+            listener(event);
+        }
+        catch (error) {
+            console.error('[viewer] reveal phase listener failed', error);
+        }
+    }
+}
+/** What the commit stages, and the parts it adds to a node still assembling from an earlier one. */
+function revealCandidates(commit, at) {
+    const candidates = commitRevealCandidates(commit, at, arrivals);
+    arrivals += candidates.length;
+    // A kind that declares no reveal may have come in on its own (a default reveal): on a host still
+    // assembling, it is one of its parts instead; on a host still coming in, it comes in with it.
+    const staged = new Set(candidates.map((candidate) => candidate.id));
+    const replaced = new Set();
+    const { before, current } = commit;
+    for (const id in current.nodes) {
+        if (before.nodes[id])
+            continue;
+        const node = current.nodes[id];
+        if (!node || nodeRegistry.get(node.type)?.capabilities?.reveal)
+            continue;
+        const hostId = node.parentId;
+        const host = hostId ? (pending.get(hostId) ?? active.get(hostId)?.candidate) : undefined;
+        // Under a host still waiting or moving in, it is drawn inside it and comes in with it.
+        if (staged.has(id) && hostId && (pending.has(hostId) || active.has(hostId)))
+            replaced.add(id);
+        if (host?.style === 'assemble') {
+            candidates.push({
+                ...host,
+                id,
+                style: 'drop',
+                depth: host.depth + 1,
+                seq: arrivals++,
+                host: host.id,
+                lead: PART_LEAD,
+            });
+        }
+    }
+    if (replaced.size === 0)
+        return candidates;
+    return candidates.filter((candidate) => !(replaced.has(candidate.id) && candidate.host === undefined));
+}
+/** The author's own eye on a level (the sidebar's) is the one thing that keeps its work out of sight. */
+function levelHiddenByAuthor(levelId) {
+    if (!levelId)
+        return false;
+    const level = useScene.getState().nodes[levelId];
+    return level?.type === 'level' && level.visible === false;
+}
+/** The levels the reveal has work on: what waits, moves, goes out or is carried to a new place. */
+function levelsAtWork() {
+    const levels = new Set();
+    const add = (levelId) => {
+        if (levelId)
+            levels.add(levelId);
+    };
+    for (const candidate of pending.values())
+        add(candidate.levelId);
+    for (const reveal of active.values())
+        add(reveal.levelId);
+    for (const retract of retracts.values())
+        add(retract.group.levelId);
+    for (const glide of glides.values())
+        add(glide.change.levelId);
+    for (const change of changeQueue)
+        add(change.levelId);
+    for (const ghost of ghosts.values())
+        add(ghost.levelId);
+    for (const levelId of levelHolds.keys())
+        add(levelId);
+    return [...levels];
+}
+/**
+ * The nodes the agent changed that the reveal has not finished with: pieces moved or edited (not
+ * built, not going out), waiting for their turn, carried or replaying. What a commit that edits and
+ * moves is made of, read before its first piece plays.
+ */
+export function revealChangedNodeIds() {
+    const ids = new Set(queuedChanges);
+    for (const change of changeQueue)
+        ids.add(change.id);
+    for (const id of glides.keys())
+        ids.add(id);
+    for (const reveal of active.values())
+        if (reveal.edit)
+            ids.add(reveal.id);
+    return [...ids];
+}
+/**
+ * Tells the viewer which levels the reveal is working on, so each shows while its work plays: a build
+ * on the storey above the one the person has selected, or in the solo view of another, is seen, not
+ * played to nobody. The person's own choice of level is left as it is; the level steps aside again
+ * when its work is done.
+ */
+function publishLevelsAtWork() {
+    publishNodesAtPlay();
+    const next = levelsAtWork();
+    const current = useViewer.getState().levelsRevealing;
+    if (next.length === current.length && next.every((levelId) => current.includes(levelId)))
+        return;
+    useViewer.setState({ levelsRevealing: next });
+}
+/**
+ * The nodes playing now: moving in, going out, carried to a new place, or an edit waiting its turn
+ * with its new picture held. The cutaway leaves these, and what they host, in view
+ * (`nodesRevealing`); a node waiting for its turn is not drawn yet, so it is not among them. A
+ * deleted node's picture plays from a snapshot, out of the scene: what it leaves stands for it.
+ */
+function nodesAtPlay() {
+    const ids = new Set();
+    for (const id of active.keys())
+        ids.add(id);
+    for (const id of glides.keys())
+        ids.add(id);
+    for (const id of retracts.keys())
+        ids.add(id);
+    for (const id of queuedChanges)
+        ids.add(id);
+    for (const ghost of ghosts.values())
+        if (ghost.host)
+            ids.add(ghost.host);
+    return [...ids];
+}
+function publishNodesAtPlay() {
+    const next = nodesAtPlay();
+    const current = useViewer.getState().nodesRevealing;
+    if (next.length === current.length && next.every((id) => current.includes(id)))
+        return;
+    useViewer.setState({ nodesRevealing: next });
+}
+function endReveal(reveal, forced = false) {
+    if (reveal.root) {
+        clearRevealPose(reveal.root);
+        clearRiseTextureScale(reveal.root);
+    }
+    active.delete(reveal.id);
+    if (reveal.edit)
+        return endChange(reveal.id, clockMs, forced);
+    settle(reveal.id);
+    closeNode(reveal.id, clockMs, forced);
+}
+/** `id` no longer reveals: its host may now be whole, and done. */
+function settle(id) {
+    const hostId = hostOf.get(id);
+    if (hostId === undefined)
+        return;
+    hostOf.delete(id);
+    const own = parts.get(hostId);
+    if (!own?.delete(id) || own.size > 0)
+        return;
+    parts.delete(hostId);
+    const host = active.get(hostId);
+    if (host)
+        endReveal(host);
+    notifyAssembly(hostId, false);
+}
+function startReveal(candidate, now, animate) {
+    if (!pending.delete(candidate.id))
+        return;
+    planned.delete(candidate.id);
+    // A node shows only inside its host: a host still waiting starts with it.
+    const nodes = useScene.getState().nodes;
+    let parentId = nodes[candidate.id]?.parentId;
+    for (let guard = 0; parentId && guard < 32; guard += 1) {
+        const host = pending.get(parentId);
+        if (host)
+            startReveal(host, now, animate);
+        parentId = nodes[parentId]?.parentId;
+    }
+    released(candidate);
+    const wasWarm = restoreWarm(candidate.id);
+    if (wasWarm && !(animate && candidate.style !== 'assemble')) {
+        // Shown at once, or held still while its parts drop in: neither sets the pose the warm start left.
+        const root = sceneRegistry.nodes.get(candidate.id);
+        if (root)
+            clearRevealPose(root);
+    }
+    if (!animate) {
+        settle(candidate.id);
+        return closeNode(candidate.id, now, false);
+    }
+    lastStartMs = now;
+    announce(candidate);
+    groupReleased(candidate);
+    // The lazy schedule overdoes it a little: higher falls, an anticipation, an overshoot.
+    const lazy = lazyOn();
+    const timing = lazy ? lazyTimingAt(planSpeed) : revealTimingAt(planSpeed);
+    active.set(candidate.id, {
+        id: candidate.id,
+        candidate,
+        style: candidate.style,
+        height: lazy
+            ? Math.max(candidate.height, LAZY_REVEAL_TIMING.minHeightM[candidate.style] ?? 0)
+            : candidate.height,
+        levelId: candidate.levelId,
+        startedAt: now,
+        durationMs: styleMs(timing.durationMs, candidate.style),
+        assembleMs: revealTimingAt(planSpeed).durationMs.drop,
+        ...(candidate.style === 'cover' ? { coverRange: coverRangeAt(planSpeed) } : {}),
+        clockStart: null,
+        pivot: null,
+        base: null,
+        landed: false,
+        root: null,
+        lead: lazy && candidate.style === 'drop'
+            ? Math.max(candidate.lead ?? 0, LAZY_DROP_LEAD)
+            : (candidate.lead ?? 0),
+        overshoot: lazy && candidate.style in LAZY_REVEAL_TIMING.overshoot
+            ? LAZY_REVEAL_TIMING.overshoot[candidate.style]
+            : 0,
+        weight: 'finale' in candidate && candidate.finale ? FINALE_WEIGHT : 1,
+        finale: 'finale' in candidate && candidate.finale === true,
+        finaleSaid: false,
+    });
+}
+const dustOn = () => dust !== null && revealLevel() !== 'simple';
+/** A rising wall's puff, along the longer side of its base. */
+function puffAlongBase(reveal, root, now) {
+    const box = reveal.base;
+    if (!(dust && dustOn() && box) || box.isEmpty())
+        return;
+    const midX = (box.min.x + box.max.x) / 2;
+    const midZ = (box.min.z + box.max.z) / 2;
+    if (box.max.x - box.min.x >= box.max.z - box.min.z) {
+        lineFrom.set(box.min.x, box.min.y, midZ);
+        lineTo.set(box.max.x, box.min.y, midZ);
+    }
+    else {
+        lineFrom.set(midX, box.min.y, box.min.z);
+        lineTo.set(midX, box.min.y, box.max.z);
+    }
+    root.updateWorldMatrix(true, false);
+    emitAlongBase(dust, lineFrom.applyMatrix4(root.matrixWorld), lineTo.applyMatrix4(root.matrixWorld), now);
+}
+/** A landing's puff, around its foot. */
+function puffAroundFoot(reveal, root, now) {
+    const box = reveal.base;
+    if (!(dust && dustOn() && box) || box.isEmpty())
+        return;
+    root.updateWorldMatrix(true, false);
+    foot[0].set(box.min.x, box.min.y, box.min.z).applyMatrix4(root.matrixWorld);
+    foot[1].set(box.max.x, box.min.y, box.min.z).applyMatrix4(root.matrixWorld);
+    foot[2].set(box.max.x, box.min.y, box.max.z).applyMatrix4(root.matrixWorld);
+    foot[3].set(box.min.x, box.min.y, box.max.z).applyMatrix4(root.matrixWorld);
+    const strength = Math.min(1, Math.max(0.25, reveal.height / FULL_DUST_DROP_M)) * reveal.weight;
+    emitAroundFoot(dust, foot, strength, now);
+}
+function stepReveal(reveal, now) {
+    const { nodes, dirtyNodes } = useScene.getState();
+    if (!nodes[reveal.id] || levelHiddenByAuthor(reveal.levelId))
+        return endReveal(reveal);
+    const root = sceneRegistry.nodes.get(reveal.id);
+    if (!root) {
+        if (now - reveal.startedAt > MOUNT_TIMEOUT_MS)
+            endReveal(reveal);
+        return;
+    }
+    if (reveal.root !== root) {
+        if (reveal.root) {
+            clearRevealPose(reveal.root);
+            clearRiseTextureScale(reveal.root);
+        }
+        reveal.root = root;
+    }
+    // An assembled node holds still; it is done once its last part has landed.
+    if (reveal.style === 'assemble') {
+        if (!isRevealAssembling(reveal.id))
+            endReveal(reveal);
+        return;
+    }
+    if (reveal.clockStart === null) {
+        // Hidden until its first build lands, so it moves in from nothing rather
+        // than popping in at full size mid-animation.
+        if (dirtyNodes.has(reveal.id)) {
+            if (now - Math.max(reveal.startedAt, buildLandedMs) < BUILD_TIMEOUT_MS) {
+                setRevealPose(root, ORIGIN, HIDDEN);
+                return;
+            }
+        }
+        else
+            buildLandedMs = now;
+        reveal.clockStart = now;
+        reveal.base = revealLocalBounds(root);
+        reveal.pivot = revealPivot(reveal.base, reveal.style);
+        revealPoseAt(reveal.style, 0, reveal.height, sample, reveal);
+        setRevealPose(root, reveal.pivot, sample.scale, sample.lift);
+        if (reveal.style === 'cover') {
+            // The covering takes as long as what it covers is big, now that the roof is drawn.
+            reveal.cover = planCover(root, reveal.coverRange ?? coverRangeAt(planSpeed));
+            reveal.durationMs = reveal.cover.durationMs;
+            layCover(root, reveal.cover, 0);
+        }
+        if (!reveal.edit)
+            groupStarted(reveal.candidate, now);
+        if (reveal.style === 'rise')
+            puffAlongBase(reveal, root, now);
+    }
+    const t = (now - reveal.clockStart) / reveal.durationMs;
+    if (t < 1) {
+        revealPoseAt(reveal.style, t, reveal.height, sample, reveal);
+        setRevealPose(root, reveal.pivot ?? ORIGIN, sample.scale, sample.lift);
+        if (reveal.style === 'rise')
+            setRiseTextureScale(root, sample.scale.y, reveal.pivot?.y ?? 0);
+        if (reveal.cover)
+            layCover(root, reveal.cover, now - reveal.clockStart);
+    }
+    if (!reveal.landed && revealHasLanded(reveal.style, t)) {
+        reveal.landed = true;
+        if (!reveal.edit)
+            groupLanded(reveal.id, now);
+        if (reveal.finale && !reveal.finaleSaid && t >= REVEAL_ARRIVAL[reveal.style])
+            sayFinale(reveal, now);
+        if (reveal.style === 'drop')
+            puffAroundFoot(reveal, root, now);
+    }
+    if (reveal.finale && !reveal.finaleSaid && t >= REVEAL_ARRIVAL[reveal.style])
+        sayFinale(reveal, now);
+    if (t >= 1)
+        endReveal(reveal);
+}
+const climbToBuilding = (id) => {
+    const nodes = useScene.getState().nodes;
+    let node = nodes[id];
+    for (let guard = 0; node && guard < 32; guard += 1) {
+        if (node.type === 'building')
+            return node.id;
+        node = node.parentId ? nodes[node.parentId] : undefined;
+    }
+    return null;
+};
+/** Whether the plan is the lazy, nested one: the framing level. */
+const lazyOn = () => revealLevel() === 'framing';
+/** Whether lifts play at the person's level: the full construction only. */
+const liftsPlay = () => revealLevel() === 'full' || revealLevel() === 'framing';
+/**
+ * A phase starts: what declares it clears for it (a roof, for the furnishing) in the same building
+ * asks to lift. It lifts as soon as it is built and done revealing.
+ */
+function wantLifts(phase, levelId, skip) {
+    if (!liftsPlay())
+        return;
+    const nodes = useScene.getState().nodes;
+    const building = levelId ? climbToBuilding(levelId) : null;
+    for (const id in nodes) {
+        if (skip?.has(id))
+            continue;
+        const node = nodes[id];
+        const clears = node && nodeRegistry.get(node.type)?.capabilities?.reveal?.clears;
+        if (!clears || clears.for !== phase)
+            continue;
+        if (building && climbToBuilding(id) !== building)
+            continue;
+        const held = lifts.get(id);
+        if (held) {
+            // More of the phase is coming: it stays where it is.
+            held.releaseAt = null;
+            held.target = 1;
+            continue;
+        }
+        liftWanted.set(id, { phase, levelId, height: clears.height });
+    }
+}
+/**
+ * The last group of `phase` has settled (or been taken back): what was lifted for it comes back after
+ * `holdMs`, in case more of the phase is coming.
+ */
+function releaseLifts(phase, atMs, holdMs = LIFT_HOLD_MS) {
+    for (const group of groups.values())
+        if (group.phase === phase)
+            return;
+    for (const retract of retracts.values())
+        if (retract.group.phase === phase)
+            return;
+    for (const [id, want] of [...liftWanted])
+        if (want.phase === phase)
+            liftWanted.delete(id);
+    for (const lift of lifts.values()) {
+        if (lift.phase === phase && lift.releaseAt === null)
+            lift.releaseAt = atMs + holdMs;
+    }
+}
+/**
+ * The build is over (the agent's turn has ended): what lifted out of the way comes back down after
+ * a beat, without waiting out the hold. Nothing happens when nothing is up.
+ */
+export function seatLiftedNow() {
+    liftWanted.clear();
+    changeLiftReleaseAt = null;
+    for (const lift of lifts.values()) {
+        lift.releaseAt = Math.min(lift.releaseAt ?? Number.POSITIVE_INFINITY, liftClockMs + LIFT_BEAT_MS);
+    }
+}
+/** Seats `lift` exactly where it was, whole again. */
+function seatLift(lift, atMs, say) {
+    if (lift.root) {
+        clearRevealPose(lift.root);
+        clearGhost(lift.root);
+    }
+    lifts.delete(lift.id);
+    if (!(say && deferredFinale))
+        return;
+    const finale = deferredFinale;
+    deferredFinale = null;
+    emit({ ...finale, id: lift.id, atMs });
+}
+function stepLifts(now) {
+    const dt = Math.min(0.05, Math.max(0, (now - liftClockMs) / 1000));
+    liftClockMs = now;
+    if (changeLiftReleaseAt !== null && now >= changeLiftReleaseAt && glides.size === 0) {
+        changeLiftReleaseAt = null;
+        releaseLifts('furnishing', now);
+    }
+    const nodes = useScene.getState().nodes;
+    for (const [id, want] of [...liftWanted]) {
+        if (!nodes[id]) {
+            liftWanted.delete(id);
+            continue;
+        }
+        const root = sceneRegistry.nodes.get(id);
+        if (!root || isNodeRevealing(id))
+            continue;
+        liftWanted.delete(id);
+        lifts.set(id, {
+            id,
+            phase: want.phase,
+            levelId: want.levelId,
+            height: want.height,
+            state: { x: 0, v: 0 },
+            target: 1,
+            releaseAt: null,
+            root,
+            // Ghosted ahead of the furniture already: its shaders have drawn.
+            warm: ghostWarming.delete(id) ? 0 : LIFT_WARM_TICKS,
+        });
+    }
+    for (const lift of [...lifts.values()]) {
+        if (!nodes[lift.id]) {
+            lifts.delete(lift.id);
+            continue;
+        }
+        lift.root = sceneRegistry.nodes.get(lift.id) ?? lift.root;
+        if (lift.warm > 0 && lift.root) {
+            // The ghost's first draw pays for its shaders: it holds still until the frames are steady again.
+            setGhost(lift.root, LIFT_WARM_OPACITY);
+            if (frameQuiet)
+                lift.warm -= 1;
+            continue;
+        }
+        if (lift.releaseAt !== null && now >= lift.releaseAt)
+            lift.target = 0;
+        criticallyDamped(lift.state, lift.target, lift.target === 1 ? LIFT_RESPONSE_UP_S : LIFT_RESPONSE_DOWN_S, dt);
+        const root = lift.root;
+        if (!root)
+            continue;
+        if (lift.target === 0 && lift.state.x < 1e-3 && Math.abs(lift.state.v) < 1e-2) {
+            seatLift(lift, now, true);
+            continue;
+        }
+        const x = Math.max(0, lift.state.x);
+        setRevealPose(root, ORIGIN, UNIT, x * lift.height);
+        // Never quite whole while it is up: whole would give the ghost's materials back, and their shaders with them.
+        setGhost(root, Math.min(LIFT_WARM_OPACITY, 1 - (1 - LIFT_GHOST_MIN) * Math.min(1, x)));
+    }
+}
+/** Everything that is up comes down at once: a load, an undo, a capture. */
+function seatAllLifts() {
+    for (const lift of [...lifts.values()])
+        seatLift(lift, liftClockMs, false);
+    liftWanted.clear();
+    deferredFinale = null;
+}
+// ---------------------------------------------------------------------------------------------
+// The build in reverse. An undo of what an agent built plays the construction backwards: the host
+// asks `retractNodes` to take the nodes back, waits for it, and then removes them from the scene.
+// The nodes stay hidden (held) until they leave the scene, so no frame shows them whole between.
+// ---------------------------------------------------------------------------------------------
+/** A node that has gone and is not yet out of the scene is held gone this long, then comes back. */
+const RETRACT_HOLD_MS = 2000;
+/** A roof that lifts out of the way of the furniture going has this long to be most of the way up first. */
+const RETRACT_LIFT_LEAD_MS = 450;
+const retracts = new Map();
+const held = new Map();
+const retractSample = { lift: 0, scale: new Vector3(), opacity: 1 };
+/** Whether the host shows a build at once (animation off, reduced motion, the read-only viewer, an export). */
+let showsAtOnce = () => true;
+/** What lifts away as it goes fades with it; what shrinks does not. */
+const fadesAway = (style) => style === 'settle' || style === 'drop' || style === 'assemble';
+function emitRetract(type, group, atMs) {
+    emit({
+        type,
+        phase: group.phase,
+        levelId: group.levelId,
+        nodeIds: [...group.ids],
+        source: null,
+        atMs,
+    });
+}
+function dressHeld(hold, root) {
+    hold.root = root;
+    setRevealPose(root, hold.pivot, hold.scale, hold.lift);
+    if (hold.fades)
+        setGhost(root, 0);
+}
+function releaseHold(id, hold) {
+    held.delete(id);
+    notifyPending(id);
+    if (!hold.root)
+        return;
+    clearRevealPose(hold.root);
+    clearGhost(hold.root);
+}
+/** One piece has gone (or was cut short): its group ends with its last, and the run with its last group. */
+function retractedAway(retract, atMs) {
+    if (!retracts.delete(retract.id))
+        return;
+    const { group, run } = retract;
+    group.remaining -= 1;
+    if (group.remaining === 0) {
+        if (!group.started) {
+            group.started = true;
+            emitRetract('retract-start', group, atMs);
+        }
+        emitRetract('retract-end', group, atMs);
+        // What lifted out of the way of this phase comes back down after a beat: there is no more of it.
+        releaseLifts(group.phase, atMs, LIFT_BEAT_MS);
+    }
+    run.remaining -= 1;
+    if (run.remaining === 0)
+        run.resolve({ retracted: run.retracted, skipped: run.skipped, instant: false });
+}
+/** Holds `retract`'s node gone, at the pose it ends in, until the host takes it out of the scene. */
+function holdGone(retract, root, atMs) {
+    const pivot = retract.pivot ?? revealPivot(revealLocalBounds(root), retract.style);
+    const end = retractPoseAt(retract.style, 1, retract.height, retractSample);
+    const hold = {
+        root: null,
+        style: retract.style,
+        pivot,
+        scale: end.scale.clone(),
+        lift: retract.from.lift + end.lift,
+        fades: fadesAway(retract.style),
+        until: atMs + RETRACT_HOLD_MS,
+    };
+    held.set(retract.id, hold);
+    dressHeld(hold, root);
+    notifyPending(retract.id);
+}
+const ghosts = new Map();
+/**
+ * Where a deleted node's snapshot stands: its own parent's object while that node stays in the
+ * scene, else the nearest object above it that does (a deleted floor's pictures stand in their
+ * building), so they outlive the object that held them.
+ */
+function ghostStand(id, commit, own) {
+    const above = survivingAbove(id, commit);
+    return (above ? sceneRegistry.nodes.get(above) : undefined) ?? own;
+}
+/** The nearest node above a deleted one that the commit leaves in the scene. */
+function survivingAbove(id, commit) {
+    let above = commit.before.nodes[id]?.parentId;
+    for (let guard = 0; above && !commit.current.nodes[above] && guard < 32; guard += 1)
+        above = commit.before.nodes[above]?.parentId;
+    return above ?? null;
+}
+/** The node a departing one hung on, when it stays: a storey or a building is not a host. */
+function ghostHost(id, commit) {
+    const above = survivingAbove(id, commit);
+    const type = above && commit.current.nodes[above]?.type;
+    return above && type && !CONTAINERS.has(type) ? above : null;
+}
+/**
+ * When a node that is going out (undone, or deleted) plays, on the reveal clock: its own going
+ * starts at `startMs` and takes `durationMs`; a plugin that takes it apart plays `prerollMs` after.
+ * Null when the node is not going.
+ */
+export function getRetractTurn(id) {
+    const ghost = ghosts.get(id);
+    if (ghost) {
+        return { startMs: ghost.startMs, durationMs: ghost.durationMs, prerollMs: ghost.prerollMs ?? 0 };
+    }
+    const retract = retracts.get(id);
+    if (!retract)
+        return null;
+    return {
+        startMs: retract.startMs,
+        durationMs: retract.durationMs,
+        prerollMs: retract.prerollMs ?? 0,
+    };
+}
+/** Draws the clone as the scene pass does: a batched source keeps no layer of its own. */
+function drawnInScenePass(root) {
+    root.traverse((object) => {
+        object.layers.set(SCENE_LAYER);
+    });
+}
+/**
+ * The reverse plan of `candidates` from `at`: at the Framing level the build's own plan read from its
+ * end (the rooms come apart as they went up, a plugin's prerolls kept), else the Full rewind.
+ */
+function planBack(candidates, at, speed, nodes) {
+    if (!lazyOn())
+        return planRetract(candidates, at, retractTimingAt(speed), revealTimingAt(speed));
+    const asked = candidates.map((candidate) => {
+        let prerollMs = 0;
+        try {
+            prerollMs = prerollOf?.(candidate, nodes) ?? 0;
+        }
+        catch (error) {
+            console.error('[viewer] reveal preroll failed', error);
+        }
+        return prerollMs > 0 ? { ...candidate, prerollMs } : candidate;
+    });
+    return planLazyRetract(asked, at, lazyRetractTimingAt(speed), lazyTimingAt(speed));
+}
+/**
+ * A commit deleted nodes: each one that stages a reveal and is on screen leaves a ghost that plays the
+ * reveal backwards, staggered like a build in reverse. Nothing plays for an undo (it plays its own
+ * reverse), a load, the animation off, or a level the author hid.
+ */
+function playDeletions(commit) {
+    if (commit.origin !== 'local' || isRestoringSceneHistory() || showsAtOnce())
+        return;
+    if (useViewer.getState().renderPaused)
+        return;
+    const staged = commitDeleteCandidates(commit, revealLevel()).filter((candidate) => !(retracts.has(candidate.id) || held.has(candidate.id)) &&
+        !levelHiddenByAuthor(candidate.levelId) &&
+        sceneRegistry.nodes.get(candidate.id)?.parent);
+    if (staged.length === 0)
+        return;
+    const plan = planBack(staged, clockMs, currentSpeed(), commit.before.nodes);
+    const groupsByKey = new Map();
+    for (const entry of plan) {
+        const original = sceneRegistry.nodes.get(entry.id);
+        const own = original?.parent;
+        if (!(original && own))
+            continue;
+        const root = original.clone(true);
+        drawnInScenePass(root);
+        dressDeletionGhost(original, root);
+        const parent = ghostStand(entry.id, commit, own);
+        own.add(root);
+        // A deleted floor's pieces would go with their floor's object: they stand in the building.
+        if (parent !== own) {
+            own.updateWorldMatrix(true, false);
+            parent.attach(root);
+        }
+        const key = `${entry.phase}:${entry.levelId}`;
+        let group = groupsByKey.get(key);
+        if (!group) {
+            group = { phase: entry.phase, levelId: entry.levelId, ids: [], remaining: 0, started: false };
+            groupsByKey.set(key, group);
+        }
+        group.ids.push(entry.id);
+        group.remaining += 1;
+        const cover = entry.style === 'cover' ? planCover(root, coverRangeAt(currentSpeed(), true)) : undefined;
+        ghosts.set(entry.id, {
+            id: entry.id,
+            levelId: entry.levelId,
+            root,
+            parent,
+            host: ghostHost(entry.id, commit),
+            style: entry.style,
+            height: entry.height,
+            startMs: entry.startMs,
+            durationMs: cover?.durationMs ?? entry.durationMs,
+            ...(cover ? { cover } : {}),
+            group,
+            pivot: null,
+            ...(entry.prerollMs ? { prerollMs: entry.prerollMs } : {}),
+        });
+    }
+    holdLevelsAbove(commit, new Set(plan.map((entry) => entry.id).filter((id) => ghosts.has(id))));
+}
+/** A ghost has gone (or was cut short): its picture is taken away, and its group ends with its last. */
+function ghostGone(ghost, atMs) {
+    if (!ghosts.delete(ghost.id))
+        return;
+    clearRevealPose(ghost.root);
+    clearGhost(ghost.root);
+    ghost.parent.remove(ghost.root);
+    const { group } = ghost;
+    group.remaining -= 1;
+    if (group.remaining > 0)
+        return;
+    if (!group.started) {
+        group.started = true;
+        emitRetract('retract-start', group, atMs);
+    }
+    emitRetract('retract-end', group, atMs);
+}
+function stepGhosts(now) {
+    for (const ghost of [...ghosts.values()]) {
+        if (now < ghost.startMs)
+            continue;
+        if (!ghost.pivot) {
+            ghost.pivot = revealPivot(revealLocalBounds(ghost.root), ghost.style);
+            if (!ghost.group.started) {
+                ghost.group.started = true;
+                emitRetract('retract-start', ghost.group, now);
+            }
+        }
+        const t = (now - ghost.startMs) / ghost.durationMs;
+        const pose = retractPoseAt(ghost.style, t, ghost.height, retractSample);
+        setRevealPose(ghost.root, ghost.pivot, pose.scale, pose.lift);
+        if (ghost.cover)
+            liftCover(ghost.root, ghost.cover, t);
+        if (fadesAway(ghost.style))
+            setGhost(ghost.root, pose.opacity);
+        if (t >= 1)
+            ghostGone(ghost, now);
+    }
+}
+function finishGhosts() {
+    for (const ghost of [...ghosts.values()])
+        ghostGone(ghost, clockMs);
+}
+const levelHolds = new Map();
+const easeInOut = (t) => (t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2);
+/**
+ * A commit deleted levels whose pictures now play: each level that stood above them, in the same
+ * building, and whose height changes, keeps its place until they have gone. The stack's elevations
+ * in the store are not written; only what is presented waits.
+ */
+function holdLevelsAbove(commit, ghostIds) {
+    const before = commit.before.nodes;
+    const current = commit.current.nodes;
+    const stack = getLevelElevations(before);
+    const going = [...stack].filter(([id]) => !current[id]);
+    if (going.length === 0 || ghostIds.size === 0)
+        return;
+    const levelMode = useViewer.getState().levelMode;
+    const dropMs = (lazyOn() ? lazyRetractTimingAt(currentSpeed()) : retractTimingAt(currentSpeed()))
+        .durationMs.drop;
+    for (const [id, above] of stack) {
+        const node = current[id];
+        if (node?.type !== 'level' || node.visible === false)
+            continue;
+        if (!going.some(([, gone]) => gone.buildingId === above.buildingId && gone.ordinal < above.ordinal))
+            continue;
+        const object = sceneRegistry.nodes.get(id);
+        if (!object)
+            continue;
+        const standing = levelHolds.get(id);
+        const heldY = standing?.heldY ?? object.position.y;
+        if (Math.abs(heldY - getLevelPresentationY(id, current, levelMode)) < 0.01)
+            continue;
+        if (standing) {
+            for (const ghostId of ghostIds)
+                standing.ghostIds.add(ghostId);
+            standing.lowering = null;
+            continue;
+        }
+        levelHolds.set(id, { ghostIds: new Set(ghostIds), dropMs, heldY, lowering: null });
+        setHeldLevelY(id, heldY);
+    }
+}
+/** Holds each level at its place until its floor has gone, then eases it down to its elevation. */
+function stepLevelHolds(now) {
+    if (levelHolds.size === 0)
+        return;
+    const nodes = useScene.getState().nodes;
+    const levelMode = useViewer.getState().levelMode;
+    for (const [id, hold] of [...levelHolds]) {
+        if (!nodes[id]) {
+            levelHolds.delete(id);
+            releaseLevel(id);
+            continue;
+        }
+        if (!hold.lowering) {
+            if ([...hold.ghostIds].some((ghostId) => ghosts.has(ghostId)))
+                continue;
+            hold.lowering = { startMs: now, fromY: hold.heldY };
+        }
+        const t = Math.min(1, (now - hold.lowering.startMs) / Math.max(1, hold.dropMs));
+        if (t >= 1) {
+            levelHolds.delete(id);
+            releaseLevel(id);
+            continue;
+        }
+        const to = getLevelPresentationY(id, nodes, levelMode);
+        hold.heldY = hold.lowering.fromY + (to - hold.lowering.fromY) * easeInOut(t);
+        setHeldLevelY(id, hold.heldY);
+    }
+}
+/** Every level goes to its own height now (a load, an undo, a capture, the reveal stopping). */
+function releaseLevelHolds() {
+    for (const id of levelHolds.keys())
+        releaseLevel(id);
+    levelHolds.clear();
+}
+function stepRetracts(now) {
+    const nodes = useScene.getState().nodes;
+    for (const retract of [...retracts.values()]) {
+        if (!nodes[retract.id]) {
+            // Taken out of the scene under it: nothing left to show going.
+            if (retract.root) {
+                clearRevealPose(retract.root);
+                clearGhost(retract.root);
+            }
+            retractedAway(retract, now);
+            continue;
+        }
+        if (now < retract.startMs)
+            continue;
+        const root = sceneRegistry.nodes.get(retract.id);
+        if (!root) {
+            if (now - retract.startMs > MOUNT_TIMEOUT_MS)
+                retractedAway(retract, now);
+            continue;
+        }
+        if (retract.root !== root) {
+            if (retract.root) {
+                clearRevealPose(retract.root);
+                clearGhost(retract.root);
+            }
+            retract.root = root;
+        }
+        if (!retract.pivot) {
+            retract.pivot = revealPivot(revealLocalBounds(root), retract.style);
+            if (!retract.group.started) {
+                retract.group.started = true;
+                emitRetract('retract-start', retract.group, now);
+            }
+        }
+        const t = (now - retract.startMs) / retract.durationMs;
+        const pose = retractPoseAt(retract.style, t, retract.height, retractSample);
+        setRevealPose(root, retract.pivot, pose.scale, retract.from.lift + pose.lift);
+        if (retract.cover)
+            liftCover(root, retract.cover, t);
+        if (fadesAway(retract.style))
+            setGhost(root, retract.from.opacity * pose.opacity);
+        if (t >= 1) {
+            holdGone(retract, root, now);
+            retractedAway(retract, now);
+        }
+    }
+    for (const [id, hold] of [...held]) {
+        if (!nodes[id] || now >= hold.until) {
+            releaseHold(id, hold);
+            continue;
+        }
+        const root = sceneRegistry.nodes.get(id);
+        if (!root)
+            continue;
+        if (root === hold.root) {
+            // Its renderer may have dressed it in its own materials again.
+            if (hold.fades)
+                setGhost(root, 0);
+            continue;
+        }
+        if (hold.root) {
+            clearRevealPose(hold.root);
+            clearGhost(hold.root);
+        }
+        dressHeld(hold, root);
+    }
+}
+/**
+ * Ends every reverse play at once: what is going goes (and is held gone when the host is about to take
+ * it out, `keepHeld`), or comes back whole (a capture, a load), and what waits on it resolves.
+ */
+function finishRetracts(keepHeld) {
+    for (const retract of [...retracts.values()]) {
+        const root = retract.root ?? sceneRegistry.nodes.get(retract.id) ?? null;
+        if (root && keepHeld)
+            holdGone(retract, root, clockMs);
+        else if (root) {
+            clearRevealPose(root);
+            clearGhost(root);
+        }
+        retractedAway(retract, clockMs);
+    }
+    if (keepHeld)
+        return;
+    for (const [id, hold] of [...held])
+        releaseHold(id, hold);
+}
+/**
+ * Takes `ids` back, and what stands under them, by playing their construction in reverse: the last
+ * phase built goes first (the furniture lifts away, the roof, the openings close, the walls sink,
+ * the slab), the last piece to arrive first within a phase, quicker than the build. It is what an
+ * Undo of an agent's build shows before the host takes the nodes out of the scene: the promise
+ * resolves when all have gone, the nodes stay hidden until they leave the scene (or a couple of seconds
+ * pass, and they come back whole), and the host removes them then. `retract-start` and `retract-end`
+ * events say each phase's turn, on the reveal's clock, for step cards, sounds and the camera.
+ *
+ * Nothing animates (so `instant` is true and nothing is retracted) when no reveal runs, the animation is
+ * off, or motion is reduced: the host removes the nodes at once.
+ */
+export function retractNodes(ids) {
+    const asked = [...new Set(ids)];
+    if (currentDriver === null || showsAtOnce()) {
+        return Promise.resolve({ retracted: [], skipped: asked, instant: true });
+    }
+    const nodes = useScene.getState().nodes;
+    const staged = nodeRevealCandidates(asked, nodes, revealLevel()).filter((candidate) => sceneRegistry.nodes.has(candidate.id) &&
+        !pending.has(candidate.id) &&
+        !retracts.has(candidate.id) &&
+        !held.has(candidate.id) &&
+        !levelHiddenByAuthor(candidate.levelId));
+    const taken = new Set(staged.map((candidate) => candidate.id));
+    const skipped = asked.filter((id) => !taken.has(id));
+    if (staged.length === 0)
+        return Promise.resolve({ retracted: [], skipped, instant: false });
+    // What is up for the furniture carries on up from where it is; a build still playing is shown first.
+    const from = new Map();
+    for (const { id } of staged) {
+        const lifted = lifts.get(id);
+        if (lifted) {
+            const x = Math.max(0, lifted.state.x);
+            from.set(id, { lift: x * lifted.height, opacity: 1 - (1 - LIFT_GHOST_MIN) * Math.min(1, x) });
+            lifts.delete(id);
+        }
+        liftWanted.delete(id);
+        finishNode(id);
+    }
+    if (lifts.size === 0 && liftWanted.size === 0)
+        deferredFinale = null;
+    // The furniture goes in the open, as it came: the roof over it lifts out of the way first.
+    const lifting = liftWanted.size;
+    for (const entry of new Map(staged.map((c) => [`${c.phase}:${c.levelId}`, c])).values()) {
+        wantLifts(entry.phase, entry.levelId, taken);
+    }
+    // A roof that goes over the furniture that goes with it goes first: it is what lets the furniture be
+    // seen leaving, as it lifted for it to be seen arriving.
+    const stagedPhases = new Set(staged.map((candidate) => candidate.phase));
+    const clearing = staged.filter((candidate) => {
+        const node = nodes[candidate.id];
+        const clears = node && nodeRegistry.get(node.type)?.capabilities?.reveal?.clears;
+        return clears !== undefined && stagedPhases.has(clears.for);
+    });
+    const clearingIds = new Set(clearing.map((candidate) => candidate.id));
+    const roofFirst = clearing.some((candidate) => !from.has(candidate.id));
+    const lead = liftWanted.size > lifting || roofFirst ? RETRACT_LIFT_LEAD_MS : 0;
+    const speed = currentSpeed();
+    const plan = [
+        ...planBack(clearing, clockMs, speed),
+        ...planBack(staged.filter((candidate) => !clearingIds.has(candidate.id)), clockMs + lead, speed),
+    ].sort((left, right) => left.startMs - right.startMs);
+    const end = Math.max(...plan.map((entry) => entry.startMs + entry.durationMs));
+    // What was already up for a phase going has nothing left to make room for.
+    const phases = new Set(plan.map((entry) => entry.phase));
+    for (const lift of lifts.values()) {
+        if (phases.has(lift.phase)) {
+            lift.releaseAt = Math.min(lift.releaseAt ?? Number.POSITIVE_INFINITY, end + LIFT_BEAT_MS);
+        }
+    }
+    return new Promise((resolve) => {
+        const run = {
+            retracted: staged.map((candidate) => candidate.id),
+            skipped,
+            remaining: plan.length,
+            resolve,
+        };
+        const groups = new Map();
+        for (const entry of plan) {
+            let group = groups.get(entry.group);
+            if (!group) {
+                group = {
+                    phase: entry.phase,
+                    levelId: entry.levelId,
+                    ids: [],
+                    remaining: 0,
+                    started: false,
+                };
+                groups.set(entry.group, group);
+            }
+            group.ids.push(entry.id);
+            group.remaining += 1;
+            // A covering lifts off in a time that follows its size: known now, with the roof still drawn.
+            const mounted = entry.style === 'cover' ? sceneRegistry.nodes.get(entry.id) : undefined;
+            const cover = mounted ? planCover(mounted, coverRangeAt(speed, true)) : undefined;
+            retracts.set(entry.id, {
+                id: entry.id,
+                style: entry.style,
+                height: entry.height,
+                startMs: entry.startMs,
+                durationMs: cover?.durationMs ?? entry.durationMs,
+                ...(cover ? { cover } : {}),
+                from: from.get(entry.id) ?? { lift: 0, opacity: 1 },
+                group,
+                run,
+                root: null,
+                pivot: null,
+                ...(entry.prerollMs ? { prerollMs: entry.prerollMs } : {}),
+            });
+            // A plan entry that draws it hears that it is going.
+            notifyPending(entry.id);
+        }
+        publishLevelsAtWork();
+        // With a roof to lift first, the first group is said to start now: the camera and the card move
+        // with the roof, not a beat after it, and its pieces follow once the way is clear.
+        const first = groups.get(plan[0].group);
+        if (lead > 0 && first && !first.started) {
+            first.started = true;
+            emitRetract('retract-start', first, clockMs);
+        }
+    });
+}
+function sayFinale(reveal, atMs) {
+    reveal.finaleSaid = true;
+    // What is lifted seats last: that is the finish, not this piece's landing.
+    if (lifts.size > 0 || liftWanted.size > 0) {
+        deferredFinale = {
+            type: 'finale',
+            phase: reveal.candidate.phase,
+            levelId: reveal.levelId,
+            source: reveal.candidate.source ?? null,
+        };
+        return;
+    }
+    emit({
+        type: 'finale',
+        id: reveal.id,
+        phase: reveal.candidate.phase,
+        levelId: reveal.levelId,
+        source: reveal.candidate.source ?? null,
+        atMs,
+    });
+}
+/** Gives a warming node's meshes their culling back, and its place among the nodes that wait. */
+function restoreWarm(id) {
+    const warm = warming.get(id);
+    if (!warm)
+        return false;
+    for (const [object, culled] of warm.culled)
+        object.frustumCulled = culled;
+    warming.delete(id);
+    return true;
+}
+function hasWaitingAncestor(id, nodes) {
+    let parentId = nodes[id]?.parentId;
+    for (let guard = 0; parentId && guard < 32; guard += 1) {
+        if (pending.has(parentId) && !warming.has(parentId))
+            return true;
+        parentId = nodes[parentId]?.parentId;
+    }
+    return false;
+}
+/**
+ * A commit arrived: the first node of each kind not yet on screen mounts now, hidden, so its first draw
+ * (and with it a stall of a hundred milliseconds or more) comes while nothing moves. An opening is left
+ * for its turn, since mounting it cuts its wall; a part of an assembled node mounts with its host.
+ * The roofs that will lift for the furniture of this commit draw once as the ghost they will become.
+ */
+function chooseWarm(now) {
+    // Nothing draws when only the 2D plan shows: there are no shaders to build, and no frames to wait for.
+    if (revealLevel() === 'off' || useViewer.getState().renderPaused)
+        return;
+    const nodes = useScene.getState().nodes;
+    // What a node's first draw costs follows its shaders: its kind, and for a catalog item its model,
+    // whose materials are its own.
+    const shadersOf = (node) => `${node.type}:${node.asset?.id ?? ''}`;
+    const onScreen = new Set();
+    const kinds = new Set();
+    const phases = new Set();
+    let started = false;
+    let added = 0;
+    for (const candidate of pending.values()) {
+        phases.add(candidate.phase);
+        const candidateNode = nodes[candidate.id];
+        if (!candidateNode || warming.has(candidate.id) || candidate.style === 'cut')
+            continue;
+        const kind = shadersOf(candidateNode);
+        if (kinds.has(kind))
+            continue;
+        if (!onScreen.has(candidateNode.type)) {
+            onScreen.add(candidateNode.type);
+            for (const id of sceneRegistry.byType[candidateNode.type] ?? []) {
+                const mounted = nodes[id];
+                if (mounted && !pending.has(id))
+                    kinds.add(shadersOf(mounted));
+            }
+            if (kinds.has(kind))
+                continue;
+        }
+        if (levelHiddenByAuthor(candidate.levelId) || hasWaitingAncestor(candidate.id, nodes))
+            continue;
+        kinds.add(kind);
+        warming.set(candidate.id, { culled: new Map(), builtTicks: 0 });
+        notifyPending(candidate.id);
+        started = true;
+        added += 1;
+    }
+    if (liftsPlay()) {
+        for (const phase of phases) {
+            for (const id in nodes) {
+                const node = nodes[id];
+                const clears = node && nodeRegistry.get(node.type)?.capabilities?.reveal?.clears;
+                const root = sceneRegistry.nodes.get(id);
+                if (!(clears && clears.for === phase && root) || isNodeRevealing(id) || lifts.has(id))
+                    continue;
+                if (ghostWarming.has(id))
+                    continue;
+                ghostWarming.set(id, 0);
+                started = true;
+            }
+        }
+    }
+    if (dust && !dustWarmed && added > 0) {
+        dustWarmed = true;
+        dust.requestWarm();
+        started = true;
+    }
+    if (started) {
+        warmWaiting = true;
+        warmStartedMs = now;
+        warmQuiet = 0;
+    }
+}
+/**
+ * Keeps what mounted up front hidden, drawable (never culled), and counts the frames since it was
+ * built; says when the plan may begin: everything has drawn and the frames are steady again.
+ */
+function stepWarm(now) {
+    if (!warmWaiting && warming.size === 0 && ghostWarming.size === 0)
+        return;
+    warmQuiet = frameQuiet ? warmQuiet + 1 : 0;
+    const { nodes, dirtyNodes } = useScene.getState();
+    let ready = true;
+    for (const [id, warm] of [...warming]) {
+        if (!nodes[id]) {
+            restoreWarm(id);
+            continue;
+        }
+        const root = sceneRegistry.nodes.get(id);
+        if (!root) {
+            if (now - warmStartedMs < WARM_MOUNT_MS)
+                ready = false;
+            continue;
+        }
+        setRevealPose(root, ORIGIN, HIDDEN);
+        root.traverse((object) => {
+            if (warm.culled.has(object))
+                return;
+            warm.culled.set(object, object.frustumCulled);
+            object.frustumCulled = false;
+        });
+        if (dirtyNodes.has(id)) {
+            ready = false;
+            continue;
+        }
+        warm.builtTicks += 1;
+        if (warm.builtTicks < WARM_MIN_TICKS)
+            ready = false;
+    }
+    for (const [id, ticks] of [...ghostWarming]) {
+        const root = sceneRegistry.nodes.get(id);
+        if (!(nodes[id] && root)) {
+            ghostWarming.delete(id);
+            continue;
+        }
+        setGhost(root, LIFT_WARM_OPACITY);
+        ghostWarming.set(id, ticks + 1);
+        if (ticks + 1 < WARM_MIN_TICKS)
+            ready = false;
+    }
+    if (warmWaiting &&
+        ((ready && warmQuiet >= WARM_QUIET_FRAMES) || now - warmStartedMs >= WARM_MAX_MS))
+        warmWaiting = false;
+}
+/**
+ * The plan for what waits, from `now`. On the lazy schedule, a node whose preroll has begun keeps its
+ * turn (its plugin is playing it), and the rest are planned around it with their prerolls.
+ */
+function planPending(now) {
+    // The person's speed is read here, when the plan is made: what is already moving keeps its own
+    // durations, and what is planned now keeps this speed until it starts.
+    planSpeed = currentSpeed();
+    if (!lazyOn()) {
+        const timing = revealTimingAt(planSpeed);
+        return planReveal([...pending.values()], Math.max(now, lastStartMs + timing.nodeGapMs), timing);
+    }
+    const kept = [];
+    for (const entry of queue) {
+        if (pending.has(entry.id) && entry.prerollMs && entry.startMs - entry.prerollMs <= now)
+            kept.push(entry);
+    }
+    const keptIds = new Set(kept.map((entry) => entry.id));
+    const waiting = [];
+    for (const candidate of pending.values()) {
+        if (keptIds.has(candidate.id))
+            continue;
+        let prerollMs = 0;
+        try {
+            prerollMs = prerollOf?.(candidate) ?? 0;
+        }
+        catch (error) {
+            console.error('[viewer] reveal preroll failed', error);
+        }
+        waiting.push(prerollMs > 0 ? { ...candidate, prerollMs } : candidate);
+    }
+    // What comes next waits for the prerolls already playing: nothing of it can pull their node in early.
+    const from = Math.max(now, ...kept.map((entry) => entry.startMs));
+    return [...kept, ...planLazyReveal(waiting, from, lazyTimingAt(planSpeed))].sort((left, right) => left.startMs - right.startMs || left.seq - right.seq);
+}
+function tickReveals(now, frameMs) {
+    clockMs = now;
+    frameQuiet = frameMs === undefined || frameMs < WARM_QUIET_FRAME_MS;
+    if (revealLevel() === 'off' && (pending.size > 0 || active.size > 0 || retracts.size > 0))
+        finishReveals();
+    if (unplanned) {
+        unplanned = false;
+        for (const candidate of [...pending.values()]) {
+            if (levelHiddenByAuthor(candidate.levelId))
+                startReveal(candidate, now, false);
+        }
+        chooseWarm(now);
+        replanning = true;
+    }
+    stepWarm(now);
+    if (replanning && !warmWaiting) {
+        replanning = false;
+        queue = planPending(now);
+        planned.clear();
+        for (const entry of queue)
+            planned.set(entry.id, entry);
+    }
+    let due = 0;
+    while (due < queue.length && (queue[due]?.startMs ?? Number.POSITIVE_INFINITY) <= now) {
+        const entry = queue[due++];
+        planned.delete(entry.id);
+        if (pending.has(entry.id))
+            startReveal(entry, now, !levelHiddenByAuthor(entry.levelId));
+    }
+    if (due > 0)
+        queue = queue.slice(due);
+    for (const reveal of active.values())
+        stepReveal(reveal, now);
+    stepLifts(now);
+    stepRetracts(now);
+    stepGhosts(now);
+    stepLevelHolds(now);
+    stepGlides(now);
+    const building = pending.size > 0 || active.size > 0 || lifts.size > 0 || liftWanted.size > 0;
+    if (!building) {
+        announced.clear();
+        // A roof ghosted ahead of furniture that never came goes back to its own materials.
+        for (const id of ghostWarming.keys()) {
+            const root = sceneRegistry.nodes.get(id);
+            if (root && !lifts.has(id))
+                clearGhost(root);
+        }
+        ghostWarming.clear();
+        completeBuild(now, false);
+    }
+    // No group is open and nothing waits for its turn: what the agent moved can begin without
+    // closing a build's group early.
+    if (changeQueue.length > 0 && groups.size === 0 && pending.size === 0 && active.size === 0) {
+        flushChanges(now);
+    }
+    const busy = building ||
+        retracts.size > 0 ||
+        held.size > 0 ||
+        glides.size > 0 ||
+        ghosts.size > 0 ||
+        levelHolds.size > 0 ||
+        changeQueue.length > 0;
+    publishLevelsAtWork();
+    if (busy || tickedBusy)
+        notifyTicks();
+    tickedBusy = busy;
+}
+/**
+ * Ends every reveal at once: waiting nodes mount, moving ones snap to their final pose, dust clears.
+ * A reverse play ends too; its nodes stay gone when the host is about to remove them (`keepHeld`).
+ */
+function finishReveals(keepHeld = false) {
+    const waiting = [...pending.values()];
+    const busy = waiting.length > 0 || active.size > 0 || retracts.size > 0 || ghosts.size > 0;
+    pending.clear();
+    queue = [];
+    planned.clear();
+    unplanned = false;
+    replanning = false;
+    warmWaiting = false;
+    for (const id of [...warming.keys()]) {
+        restoreWarm(id);
+        const root = sceneRegistry.nodes.get(id);
+        if (root)
+            clearRevealPose(root);
+    }
+    for (const id of ghostWarming.keys()) {
+        const root = sceneRegistry.nodes.get(id);
+        if (root && !lifts.has(id))
+            clearGhost(root);
+    }
+    ghostWarming.clear();
+    for (const candidate of waiting) {
+        released(candidate);
+        settle(candidate.id);
+        closeNode(candidate.id, clockMs, true);
+    }
+    for (const reveal of [...active.values()])
+        endReveal(reveal, true);
+    announced.clear();
+    dust?.clear();
+    seatAllLifts();
+    finishRetracts(keepHeld);
+    finishGhosts();
+    releaseLevelHolds();
+    finishChanges();
+    completeBuild(clockMs, true);
+    publishLevelsAtWork();
+    if (busy)
+        notifyTicks();
+}
+/** Ends one node's reveal, and its parts' if it is assembled from them. */
+function finishNode(id) {
+    if (restoreWarm(id)) {
+        const root = sceneRegistry.nodes.get(id);
+        if (root)
+            clearRevealPose(root);
+    }
+    planned.delete(id);
+    const waiting = pending.get(id);
+    if (waiting && pending.delete(id)) {
+        released(waiting);
+        settle(id);
+        closeNode(id, clockMs, true);
+    }
+    const reveal = active.get(id);
+    if (reveal)
+        endReveal(reveal, true);
+    const lifted = lifts.get(id);
+    if (lifted)
+        seatLift(lifted, clockMs, false);
+    liftWanted.delete(id);
+    finishGlide(id);
+    const own = parts.get(id);
+    if (own)
+        for (const part of [...own])
+            finishNode(part);
+}
+/** Ends the reveal of `ids` and of their hosts. */
+function finishNodes(ids) {
+    const nodes = useScene.getState().nodes;
+    for (const id of ids) {
+        let node = nodes[id];
+        for (let guard = 0; node && guard < 32; guard += 1) {
+            finishNode(node.id);
+            node = node.parentId ? nodes[node.parentId] : undefined;
+        }
+    }
+}
+/** Whether a store change hid or showed a level that a waiting node stands on. */
+function pendingLevelVisibilityChanged(nodes, previous) {
+    const seen = new Set();
+    for (const candidate of pending.values()) {
+        const levelId = candidate.levelId;
+        if (!levelId || seen.has(levelId))
+            continue;
+        seen.add(levelId);
+        if (nodes[levelId]?.visible !== previous[levelId]?.visible)
+            return true;
+    }
+    return false;
+}
+function mediaPrefersReducedMotion() {
+    if (typeof window === 'undefined' || typeof window.matchMedia !== 'function')
+        return () => false;
+    const query = window.matchMedia('(prefers-reduced-motion: reduce)');
+    return () => query.matches;
+}
+/** The reduced-motion reading of the driver in force; the media query while none runs. */
+let motionReduced = mediaPrefersReducedMotion();
+/**
+ * Whether the person's animation setting asks for no motion: Off, or reduced motion. What eases
+ * for the eye outside a build (the dive under the ground) is instant then, as the builds are.
+ */
+export function revealMotionOff() {
+    return motionReduced() || revealLevel() === 'off';
+}
+let currentDriver = null;
+/**
+ * The reveal without a canvas: `<ConstructionReveal>` calls `tick` every
+ * frame. One driver runs at a time; a newer one takes over.
+ */
+export function startConstructionReveal(options) {
+    finishReveals();
+    const token = {};
+    currentDriver = token;
+    revealLevel = options.level ?? (() => 'full');
+    revealSpeed = options.speed ?? (() => 1);
+    planSpeed = 1;
+    dust = options.dust ?? null;
+    const reducedMotion = options.prefersReducedMotion ?? mediaPrefersReducedMotion();
+    motionReduced = reducedMotion;
+    const instant = () => {
+        const viewer = useViewer.getState();
+        return (reducedMotion() ||
+            revealLevel() === 'off' ||
+            viewer.renderContext === 'viewer' ||
+            viewer.isExporting);
+    };
+    showsAtOnce = instant;
+    const deletes = options.deletes ?? options.reveals;
+    const stops = [
+        subscribeSceneCommits((commit) => {
+            if (currentDriver !== token)
+                return;
+            if (commit.origin === 'load')
+                return finishReveals();
+            if (deletes(commit))
+                playDeletions(commit);
+            if (!options.reveals(commit))
+                return publishLevelsAtWork();
+            const candidates = revealCandidates(commit, revealLevel());
+            // Furniture the agent moved, that is shown and not still on its way in.
+            const moved = commitChangeCandidates(commit, revealLevel());
+            const movedIds = new Set(moved.map((change) => change.id));
+            const changes = [
+                ...moved,
+                ...commitEditCandidates(commit, revealLevel()).filter((edit) => !movedIds.has(edit.id)),
+            ].filter((change) => !(pending.has(change.id) || active.has(change.id) || isNodeRevealing(change.id)) &&
+                !levelHiddenByAuthor(change.levelId));
+            if (changes.length > 0)
+                queueChanges(changes);
+            publishLevelsAtWork();
+            if (candidates.length === 0)
+                return;
+            registerCandidates(candidates, clockMs);
+            if (instant()) {
+                for (const candidate of candidates)
+                    announce(candidate);
+                for (const candidate of candidates)
+                    closeNode(candidate.id, clockMs, false);
+                completeBuild(clockMs, false);
+                return;
+            }
+            const assembling = new Set();
+            for (const candidate of candidates) {
+                pending.set(candidate.id, candidate);
+                if (candidate.host !== undefined) {
+                    if (!isRevealAssembling(candidate.host))
+                        assembling.add(candidate.host);
+                    hostOf.set(candidate.id, candidate.host);
+                    const own = parts.get(candidate.host) ?? new Set();
+                    parts.set(candidate.host, own.add(candidate.id));
+                }
+                notifyPending(candidate.id);
+            }
+            for (const hostId of assembling)
+                notifyAssembly(hostId, true);
+            publishLevelsAtWork();
+            unplanned = true;
+        }),
+        useScene.subscribe((state, previous) => {
+            if (currentDriver !== token)
+                return;
+            if (isRestoringSceneHistory() || state.hydrationId !== previous.hydrationId) {
+                // An undo is about to take what a reverse play was taking back out of the scene: it stays gone.
+                return finishReveals(isRestoringSceneHistory());
+            }
+            // A waiting node on a level that just hid starts at once and holds no slot (failure mode 10).
+            if (pending.size > 0 &&
+                state.nodes !== previous.nodes &&
+                pendingLevelVisibilityChanged(state.nodes, previous.nodes)) {
+                unplanned = true;
+            }
+        }),
+        useViewer.subscribe((state, previous) => {
+            if (currentDriver !== token)
+                return;
+            if (state.isExporting && !previous.isExporting)
+                return finishReveals();
+            if (state.selection.selectedIds !== previous.selection.selectedIds ||
+                state.externalSelectedIds !== previous.externalSelectedIds ||
+                state.previewSelectedIds !== previous.previewSelectedIds) {
+                finishNodes([
+                    ...state.selection.selectedIds,
+                    ...state.externalSelectedIds,
+                    ...state.previewSelectedIds,
+                ]);
+            }
+        }),
+    ];
+    const onCapture = () => {
+        if (currentDriver === token)
+            finishReveals();
+    };
+    emitter.on('thumbnail:before-capture', onCapture);
+    return {
+        tick(nowMs, frameMs) {
+            if (currentDriver === token)
+                tickReveals(nowMs, frameMs);
+        },
+        stop() {
+            for (const stop of stops)
+                stop();
+            emitter.off('thumbnail:before-capture', onCapture);
+            if (currentDriver !== token)
+                return;
+            currentDriver = null;
+            finishReveals();
+            showsAtOnce = () => true;
+            dustWarmed = false;
+            changeQueue = [];
+            queuedChanges.clear();
+            changeGroups.clear();
+            changeGroupOf.clear();
+            changeRun = null;
+            changeLiftReleaseAt = null;
+            glideClockMs = Number.NEGATIVE_INFINITY;
+            frameQuiet = true;
+            revealLevel = () => 'full';
+            revealSpeed = () => 1;
+            motionReduced = mediaPrefersReducedMotion();
+            planSpeed = 1;
+            dust = null;
+            lastStartMs = Number.NEGATIVE_INFINITY;
+            buildLandedMs = Number.NEGATIVE_INFINITY;
+            liftClockMs = Number.NEGATIVE_INFINITY;
+            tickedBusy = false;
+        },
+    };
+}
+/**
+ * Mount inside `<Viewer>` to stage the commits `reveals` selects, at the
+ * host's `level`. Hosts that never mount it (the read-only viewer, the bake)
+ * show every write at once.
+ */
+export function ConstructionReveal({ reveals, deletes, level = 'full', speed = 1, }) {
+    const revealsRef = useRef(reveals);
+    const deletesRef = useRef(deletes);
+    const levelRef = useRef(level);
+    const speedRef = useRef(speed);
+    const driverRef = useRef(null);
+    const clockRef = useRef(0);
+    const [pool] = useState(() => new DustPool());
+    const renderPaused = useViewer((state) => state.renderPaused);
+    useEffect(() => {
+        revealsRef.current = reveals;
+    }, [reveals]);
+    useEffect(() => {
+        deletesRef.current = deletes;
+    }, [deletes]);
+    useEffect(() => {
+        levelRef.current = level;
+    }, [level]);
+    useEffect(() => {
+        speedRef.current = speed;
+    }, [speed]);
+    useEffect(() => {
+        const driver = startConstructionReveal({
+            reveals: (commit) => revealsRef.current(commit),
+            deletes: (commit) => (deletesRef.current ?? revealsRef.current)(commit),
+            level: () => levelRef.current,
+            speed: () => speedRef.current,
+            dust: pool,
+        });
+        driverRef.current = driver;
+        return () => {
+            driver.stop();
+            if (driverRef.current === driver)
+                driverRef.current = null;
+        };
+    }, [pool]);
+    // The canvas stops its frames when only the 2D plan shows; the plan still
+    // plays the reveal, so the reveal keeps its own clock meanwhile.
+    useEffect(() => {
+        if (!renderPaused)
+            return;
+        let request = 0;
+        let last = null;
+        const step = (time) => {
+            request = requestAnimationFrame(step);
+            const frameMs = last === null ? undefined : Math.max(0, time - last);
+            if (frameMs !== undefined)
+                clockRef.current += Math.min(MAX_STEP_MS, frameMs);
+            last = time;
+            driverRef.current?.tick(clockRef.current, frameMs);
+        };
+        request = requestAnimationFrame(step);
+        return () => cancelAnimationFrame(request);
+    }, [renderPaused]);
+    useFrame((_, delta) => {
+        clockRef.current += Math.min(MAX_STEP_MS, delta * 1000);
+        driverRef.current?.tick(clockRef.current, delta * 1000);
+    });
+    return _jsx(ConstructionDust, { clock: clockRef, pool: pool });
+}