@moku-labs/game 0.15.27 → 0.15.29

package/dist/{src-DLs4b_Vs.mjs → src-wyJYr12n.mjs}

@@ -5872,7 +5872,7 @@ function restorePosition(ctx, _modules, bookmark) {
 * @param view - The last view.
 * @returns True while nothing the state shows moved.
 */
-function isCurrent$1(ctx, view) {
+function isCurrent$2(ctx, view) {
 	const runner = ctx.state.runner;
 	return view.running === (runner.running !== void 0) && view.depth === runner.stack.length && view.top === runner.stack.at(-1) && view.open === ctx.state.gate.open && view.mode === ctx.state.fx.mode && view.journalIndex === runner.journalIndex;
 }
@@ -5913,7 +5913,7 @@ function viewOf(ctx) {
 function readState(ctx) {
 	const runner = ctx.state.runner;
 	const view = runner.view;
-	if (view !== void 0 && isCurrent$1(ctx, view)) return view.state;
+	if (view !== void 0 && isCurrent$2(ctx, view)) return view.state;
 	const next = viewOf(ctx);
 	runner.view = next;
 	return next.state;
@@ -9467,7 +9467,8 @@ function registerFeatures(ctx, ecs, projection) {
 * callback records the frame history before it clears the change sets; in an agent build the
 * timing table starts with the page clock of `time` and the `input` callback zeroes it each
 * frame. The resource `Now` gets `clock.now()` once here and first thing in every `input`
-* callback, so every system of a frame reads one moment. `onStart` has no access to the
+* callback, so every system of a frame reads one moment; a running scene build counts its frame
+* budget from that moment too. `onStart` has no access to the
 * plugin's own API, so it builds its own module objects — they are views on `ctx.state`, which is
 * the one place the modules keep their data.
 *
@@ -9486,7 +9487,9 @@ function connectWorld(ctx) {
 	registerFeatures(worldCtx, ecs, projection);
 	ecs.resource(Now).now = clock.now();
 	worldCtx.state.ecs.offFrame.push(ecs.onOwnerLeft((owner) => projection.ownerLeft(owner)), time.onFrame("input", (frame) => {
-		ecs.resource(Now).now = clock.now();
+		const now = clock.now();
+		ecs.resource(Now).now = now;
+		projection.startFrame(now);
 		worldCtx.state.ecs.timing?.ms.fill(0);
 		projection.reconcileIfDirty();
 		ecs.runPhase("input", frame);
@@ -9501,8 +9504,8 @@ function connectWorld(ctx) {
 }
 /**
 * Empties the world in `onStop`: the frame callbacks and the hint listener are removed, then
-* every track, view, queued view, entity and resource is dropped, and the scenes and the frame
-* history are reset.
+* every track, view, queued view, entity and resource is dropped, a running scene build and the
+* `onBuild` checks with them, and the scenes and the frame history are reset.
 * No `onRemoved` fires, because `renderer` stopped earlier and destroyed its own objects.
 *
 * @param state - The plugin state, the only thing a teardown context carries.
@@ -9528,6 +9531,8 @@ function clearWorld(state) {
 	state.projection.membershipVersion += 1;
 	state.projection.moving = false;
 	state.projection.owedLoops = 0;
+	delete state.projection.building;
+	state.projection.buildChecks.length = 0;
 	state.ecs.generations.length = 0;
 	state.ecs.free.length = 0;
 	state.ecs.owners.clear();
@@ -9920,9 +9925,10 @@ function isNode(output) {
 /**
 * Runs `view(item)` and collects its output by component name. A view that describes a screen
 * returns one node, which becomes the `Tree` of the entity, and `ui` reconciles it from there;
-* the root draws at the `Order` of its place in the mounted list, written before `Tree` because the
-* ecs fires `onAdded` in list order and the `Tree` hook of `ui` reads it. `Order` is part of the
-* view's rest, so a new node compares it by value and writes nothing.
+* the root draws at the `Order` of its place in the mounted list (or the list of the running build,
+* which mounts it aside), written before `Tree` because the ecs fires `onAdded` in list order and the
+* `Tree` hook of `ui` reads it. `Order` is part of the view's rest, so a new node compares it by value
+* and writes nothing.
 * `Layer` is the projection's own component: a view that returns it is reported and ignored.
 *
 * @param pctx - Domain context of the projection module.
@@ -9935,7 +9941,8 @@ function collectView(pctx, spec, item) {
 	const layerName = pctx.deps.components.Layer.componentName;
 	const output = spec.view(item);
 	const { Order, Tree } = pctx.deps.components;
-	const order = pctx.ctx.state.projection.mounted.get(spec.name)?.order ?? 0;
+	const state = pctx.ctx.state.projection;
+	const order = (state.mounted.get(spec.name) ?? state.building?.mounted.get(spec.name))?.order ?? 0;
 	const produced = isNode(output) ? [Order({ value: order }), Tree({ node: output })] : output;
 	for (const value of produced) {
 		if (value.type.componentName === layerName) {
@@ -10862,6 +10869,8 @@ function hintFor$1(pctx, projection, key, used) {
 * play the `enter` hook and the `loop` hook when the reconcile plays motions. The loop is not
 * kept with the view's handles: a change cancels those, and the loop runs until the view dies.
 * A direct reconcile plays neither hook. The view then owes its loop, which the sweep starts.
+* A view of a projection the running build mounts is flagged building right after its spawn: the
+* spawn fires `onAdded` inside the call, so no flag can come before it.
 *
 * @param pctx - Domain context of the projection module.
 * @param spec - The projection spec.
@@ -10880,14 +10889,17 @@ function enterEntry(pctx, spec, mounted, entry) {
 		name: spec.name
 	}, [pctx.deps.components.Layer({ name: spec.layer }), ...values.values()]);
 	const view = createViewRecord(entity, spec.name, entry.key, entry.item, values, entry.direct ? "mount" : "change");
+	const state = pctx.ctx.state.projection;
+	const building = state.building;
 	mounted.live.set(entry.key, view);
-	pctx.ctx.state.projection.byEntity.set(entity, view);
-	pctx.ctx.state.projection.membershipVersion += 1;
+	state.byEntity.set(entity, view);
+	state.membershipVersion += 1;
+	if (building?.mounted.get(spec.name) === mounted) building.entities.add(entity);
 	const hook = spec.motion?.enter;
 	const loop = spec.motion?.loop;
 	if (entry.direct) {
 		view.loopOwed = true;
-		pctx.ctx.state.projection.owedLoops += 1;
+		state.owedLoops += 1;
 		return;
 	}
 	if (hook === void 0 && loop === void 0) return;
@@ -11258,10 +11270,12 @@ function reconcileOne(pctx, spec, mounted, snapshot, options, counts, used) {
 		}, counts);
 		exitGone(pctx, spec, mounted, next, entry, counts);
 	} catch (error) {
+		if (options.strict === true) throw error;
 		pctx.ctx.log.error("world:projection-failed", { projection: spec.name }, asError$2(error));
 		return;
 	}
 	mounted.items = next;
+	mounted.seen = snapshot;
 	if (options.direct) flushMounted(pctx, mounted);
 	if (options.converge) convergeMounted(pctx, mounted);
 	else {
@@ -11271,8 +11285,60 @@ function reconcileOne(pctx, spec, mounted, snapshot, options, counts, used) {
 	counts.queued += mounted.queue.length;
 }
 /**
-* Runs one reconcile over every mounted projection, or over the named ones only. A converging
-* one then brings the elements other plugins own home and tells their owners.
+* Tells whether a play reconcile would change nothing in a projection: its last reconcile read the same `player` and
+* `session` trees, and nothing forces, converges or settles it. A scene mounts its projections direct after the commit
+* of its node; the next frame's reconcile of that commit then skips them (≈2 ms a switch on a Galaxy A26, F61).
+*
+* @param mounted - The mounted projection.
+* @param snapshot - The state of this reconcile.
+* @param options - How this reconcile runs.
+* @returns True when the projection is passed over.
+*/
+function isCurrent$1(mounted, snapshot, options) {
+	const seen = mounted.seen;
+	return seen !== void 0 && !options.direct && !options.force && !options.converge && !options.settle && seen.player === snapshot.player && seen.session === snapshot.session;
+}
+/**
+* Reconciles the projections of one table against the snapshot: every one, or the named ones only.
+* A projection whose last reconcile read the same trees is passed over as `skipBy` decides; `runWith`
+* is how the others run.
+*
+* @param pctx - Domain context of the projection module.
+* @param table - The mounted projections, or the ones a build mounts aside.
+* @param snapshot - The model snapshot of this reconcile.
+* @param skipBy - The options of the reconcile that was asked for.
+* @param runWith - The options each projection of this table is reconciled with.
+* @param counts - The counters of this reconcile.
+* @param used - The hints that reached an entry.
+*/
+function reconcileTable(pctx, table, snapshot, skipBy, runWith, counts, used) {
+	const specs = pctx.ctx.state.projection.specs;
+	for (const [name, mounted] of table) {
+		if (skipBy.names !== void 0 && !skipBy.names.includes(name)) continue;
+		const spec = specs.get(name);
+		if (spec === void 0 || isCurrent$1(mounted, snapshot, skipBy)) continue;
+		counts.projections += 1;
+		reconcileOne(pctx, spec, mounted, snapshot, runWith, counts, used);
+	}
+}
+/**
+* Tells whether a mounted projection is not on a list: one a reconcile limited to the list passes over.
+*
+* @param mounted - The mounted projections.
+* @param names - The list, the coming scene's.
+* @returns True when one is left out.
+*/
+function passesOver(mounted, names) {
+	for (const name of mounted.keys()) if (!names.includes(name)) return true;
+	return false;
+}
+/**
+* Runs one reconcile over every mounted projection, or over the named ones only, or over the table
+* the options name. A reconcile of every mounted projection reaches the projections a running build
+* mounts aside too, direct, so a store change during the build reaches the coming scene and none of
+* its views plays a motion unseen; the mounted projections the coming scene drops are passed over
+* until the build ends. A converging one then brings the elements other plugins own home and tells
+* their owners.
 *
 * @param pctx - Domain context of the projection module.
 * @param options - Which projections, play or direct, whether `view` is forced, whether every
@@ -11284,12 +11350,20 @@ function reconcile(pctx, options) {
 	const snapshot = pctx.ctx.deps.model.store.snapshot();
 	const counts = emptyCounts();
 	const used = emptyHintSet();
-	for (const [name, mounted] of state.mounted) {
-		if (options.names !== void 0 && !options.names.includes(name)) continue;
-		const spec = state.specs.get(name);
-		if (spec === void 0) continue;
-		counts.projections += 1;
-		reconcileOne(pctx, spec, mounted, snapshot, options, counts, used);
+	const building = state.building;
+	const whole = options.table === void 0 && options.names === void 0;
+	const skipBy = whole && building !== void 0 ? {
+		...options,
+		names: building.names
+	} : options;
+	if (whole && building !== void 0 && passesOver(state.mounted, building.names)) building.held = options.force || building.held === "rerun" ? "rerun" : "change";
+	reconcileTable(pctx, options.table ?? state.mounted, snapshot, skipBy, options, counts, used);
+	if (whole && building !== void 0) {
+		const aside = {
+			...options,
+			direct: true
+		};
+		reconcileTable(pctx, building.mounted, snapshot, options, aside, counts, used);
 	}
 	if (options.converge) {
 		convergeElements(pctx);
@@ -11305,9 +11379,7 @@ function reconcile(pctx, options) {
 //#endregion
 //#region src/plugins/world/projection/mount.ts
 /**
-* Creates the empty view tables of a freshly mounted projection. These live in their own
-* non-exported functions because lint rule L5 refuses a collection built inside an exported
-* declaration.
+* Creates the empty view tables of a freshly mounted projection.
 *
 * @param owner - Who owns the entities of this projection.
 * @param order - The `Order` its screen roots draw at.
@@ -11325,14 +11397,29 @@ function emptyMounted(owner, order, layers) {
 	};
 }
 /**
-* Checks that every layer a projection names is declared by the scene.
+* The `Order` a screen root of a projection draws at: its place in the list of its scene minus the
+* length of the list, so the roots of one scene take −n … −1 (spec 16 U1.6).
+*
+* @param names - The projection list of the scene.
+* @param name - One projection of it.
+* @returns The order of its screen roots.
+* @example
+* ```ts
+* orderIn(["board.items", "hud"], "hud"); // -1
+* ```
+*/
+function orderIn(names, name) {
+	return names.indexOf(name) - names.length;
+}
+/**
+* Checks that every layer a projection names is declared by a layer list.
 *
-* @param pctx - Domain context of the projection module.
 * @param spec - The projection spec.
+* @param layers - The layer list of the scene: the current one, or the one a build comes with.
 * @throws {Error} When `layer` or `lift` is not in the layer list.
 */
-function checkLayers(pctx, spec) {
-	const declared = new Set(pctx.ctx.state.projection.layers.map((layer) => layer.name));
+function checkLayers(spec, layers) {
+	const declared = new Set(layers.map((layer) => layer.name));
 	for (const name of [spec.layer, spec.lift]) {
 		if (name === void 0 || declared.has(name)) continue;
 		throw new Error(`[game] Projection "${spec.name}" names layer "${name}", which the scene does not declare.\n  Add it to the layers of the scene.`);
@@ -11389,16 +11476,17 @@ function unmountNames(pctx, names) {
 	}
 }
 /**
-* The first pass of a mount, which touches nothing: every name is checked, a projection mounted
-* into this scene already is reported and passed over, and the rest is sorted into the ones that
-* come and the ones a scene before mounted that have to go and come back.
+* The first pass of a mount, which touches nothing: every name is checked against a layer list, a
+* projection mounted under that very list already is reported and passed over, and the rest is
+* sorted into the ones that come and the ones a scene before mounted that have to go and come back.
 *
 * @param pctx - Domain context of the projection module.
 * @param names - Names of the projections to mount.
+* @param layers - The layer list they are mounted under: the current one, or the one a build comes with.
 * @returns The specs to mount and reconcile, and the names to unmount first.
-* @throws {Error} For an unknown name, or a `layer` or `lift` the scene does not declare.
+* @throws {Error} For an unknown name, or a `layer` or `lift` the list does not declare.
 */
-function sortMount(pctx, names) {
+function sortMount(pctx, names, layers) {
 	const state = pctx.ctx.state.projection;
 	const fresh = [];
 	const again = [];
@@ -11406,12 +11494,12 @@ function sortMount(pctx, names) {
 		const spec = state.specs.get(name);
 		if (spec === void 0) throw new Error(`[game] Projection "${name}" is not registered.\n  Register it before a scene mounts it.`);
 		const mounted = state.mounted.get(name);
-		if (mounted?.layers === state.layers) {
+		if (mounted?.layers === layers) {
 			pctx.ctx.log.warn("world:already-mounted", { projection: name });
 			continue;
 		}
-		checkLayers(pctx, spec);
-		if (mounted !== void 0 && drawsAlike(mounted.layers, state.layers, spec)) continue;
+		checkLayers(spec, layers);
+		if (mounted !== void 0 && drawsAlike(mounted.layers, layers, spec)) continue;
 		if (mounted !== void 0) again.push(name);
 		fresh.push(spec);
 	}
@@ -11433,18 +11521,40 @@ function sortMount(pctx, names) {
 * @throws {Error} For an unknown name, or a `layer` or `lift` the scene does not declare.
 */
 function mountNames(pctx, names, owner) {
-	const state = pctx.ctx.state.projection;
-	const { fresh, again } = sortMount(pctx, names);
+	const { fresh, again } = sortMount(pctx, names, pctx.ctx.state.projection.layers);
 	unmountNames(pctx, again);
+	placeNames(pctx, names, owner);
+	reconcileFresh(pctx, fresh.map((spec) => spec.name));
+}
+/**
+* Gives every projection of a list its place under the current layer list: a missing one gets an
+* empty record at the `Order` of its place, a kept one mounted under another list takes its new
+* place (`placeMounted`). A screen root draws at its place in the list (spec 16 U1.6).
+*
+* @param pctx - Domain context of the projection module.
+* @param names - The projection list of the scene.
+* @param owner - Who owns the entities of a missing one.
+*/
+function placeNames(pctx, names, owner) {
+	const state = pctx.ctx.state.projection;
 	for (const name of names) {
-		const order = names.indexOf(name) - names.length;
+		const order = orderIn(names, name);
 		const mounted = state.mounted.get(name);
 		if (mounted === void 0) state.mounted.set(name, emptyMounted(owner, order, state.layers));
 		else if (mounted.layers !== state.layers) placeMounted(pctx, mounted, order);
 	}
-	if (fresh.length === 0) return;
+}
+/**
+* Reconciles freshly placed projections at once, direct, as a mount does. Nothing runs for an
+* empty list.
+*
+* @param pctx - Domain context of the projection module.
+* @param names - The projections that came.
+*/
+function reconcileFresh(pctx, names) {
+	if (names.length === 0) return;
 	reconcile(pctx, {
-		names: fresh.map((spec) => spec.name),
+		names,
 		direct: true,
 		force: true,
 		converge: false,
@@ -11452,6 +11562,148 @@ function mountNames(pctx, names, owner) {
 	});
 }
 //#endregion
+//#region src/plugins/world/projection/build.ts
+/**
+* Creates the empty table of a build: nothing mounted aside and nothing spawned yet.
+*
+* @param names - The projection list of the coming scene.
+* @param layers - The layer list of the coming scene.
+* @param owner - Who owns the entities of the projections it mounts.
+* @param timing - The frame budget and the moment the build starts.
+* @param timing.budgetMs - Milliseconds per frame the building work may take.
+* @param timing.now - The game clock at the build start.
+* @returns The table, its frame starting at the build start.
+*/
+function emptyBuilding(names, layers, owner, timing) {
+	return {
+		names: [...names],
+		layers,
+		owner,
+		mounted: /* @__PURE__ */ new Map(),
+		entities: /* @__PURE__ */ new Set(),
+		frameStart: timing.now,
+		budgetMs: timing.budgetMs
+	};
+}
+/**
+* Creates the empty set of dirty roots. It lives in its own non-exported function because lint
+* rule L5 refuses a collection built inside an exported declaration.
+*
+* @returns An empty set of roots.
+*/
+function emptyRoots() {
+	return /* @__PURE__ */ new Set();
+}
+/**
+* Marks the world dirty at the end of a build that passed mounted projections over (`held`), so the
+* next frame's reconcile reaches the ones still mounted: their last reconcile read an older state,
+* every other projection read this one and is passed over. A build that held a forced reconcile
+* forces the next one too. A build that held nothing marks nothing.
+*
+* @param pctx - Domain context of the projection module.
+* @param building - The build that ends.
+*/
+function handBack(pctx, building) {
+	const state = pctx.ctx.state.projection;
+	const held = building.held;
+	if (held === void 0) return;
+	const dirty = state.dirty ?? {
+		causes: [],
+		roots: emptyRoots(),
+		force: false
+	};
+	dirty.causes.push(held === "rerun" ? "rerun" : "edge");
+	dirty.roots.add("player");
+	dirty.roots.add("session");
+	dirty.force ||= held === "rerun";
+	state.dirty = dirty;
+}
+/**
+* Starts the build of a scene's list under its layer list. A projection mounted now under other
+* layer rules makes it answer false before anything is touched. The rest of the list is checked as
+* a mount checks it, against the coming layers; a projection the current scene mounts and the
+* coming one declares alike stays as it is, and every other one is mounted aside, direct. A view
+* that throws leaves nothing behind: what the build spawned is despawned and the throw goes on.
+*
+* @param pctx - Domain context of the projection module.
+* @param names - The projection list of the coming scene.
+* @param owner - Who owns the entities of the projections it mounts.
+* @param layers - The layer list of the coming scene.
+* @param budgetMs - Milliseconds per frame the building work may take.
+* @returns True when the build runs, false on a projection mounted under other layer rules.
+* @throws {Error} When a build already runs, for an unknown name, for a `layer` or `lift` the
+*   coming list does not declare, and whatever a `view` threw.
+*/
+function buildNames(pctx, names, owner, layers, budgetMs) {
+	const state = pctx.ctx.state.projection;
+	if (state.building !== void 0) throw new Error("[game] A scene is already being built.\n  Commit or discard the running build before the next one starts.");
+	const { fresh, again } = sortMount(pctx, names, layers);
+	if (again.length > 0) return false;
+	const building = emptyBuilding(names, layers, owner, {
+		budgetMs,
+		now: pctx.ctx.deps.clock.now()
+	});
+	for (const spec of fresh) building.mounted.set(spec.name, emptyMounted(owner, orderIn(names, spec.name), layers));
+	state.building = building;
+	if (fresh.length === 0) return true;
+	try {
+		reconcile(pctx, {
+			table: building.mounted,
+			direct: true,
+			force: true,
+			converge: false,
+			settle: false,
+			strict: true
+		});
+	} catch (error) {
+		discardBuild(pctx);
+		throw error;
+	}
+	return true;
+}
+/**
+* The swap of the running build. Its projections move into the mounted table, and the list is
+* placed as a mount places it: every moved and kept projection takes the layer list `setLayers`
+* stored just before (`placeMounted`), so the next scene compares it by identity as after a mount;
+* a kept one takes its new place, and one the build kept that left before the commit is mounted
+* now, direct. The views that moved owe their loop, also when nothing left with the commit, and the
+* hosts of `ui` look at the views again.
+*
+* @param pctx - Domain context of the projection module.
+*/
+function commitBuild(pctx) {
+	const state = pctx.ctx.state.projection;
+	const building = state.building;
+	if (building === void 0) return;
+	delete state.building;
+	for (const [name, mounted] of building.mounted) state.mounted.set(name, mounted);
+	const missing = building.names.filter((name) => !state.mounted.has(name));
+	placeNames(pctx, building.names, building.owner);
+	state.owedLoops += 1;
+	state.membershipVersion += 1;
+	reconcileFresh(pctx, missing);
+	handBack(pctx, building);
+}
+/**
+* Drops the running build: every view it spawned leaves with the cause `"discard"` and no motion,
+* then every entity `adopt` marked that is still there is despawned too, and the table goes. The
+* removal hooks still see the build while they run.
+*
+* @param pctx - Domain context of the projection module.
+*/
+function discardBuild(pctx) {
+	const state = pctx.ctx.state.projection;
+	const building = state.building;
+	if (building === void 0) return;
+	for (const mounted of building.mounted.values()) for (const view of [...mounted.live.values()]) {
+		view.cause = "discard";
+		despawnView(pctx, mounted, view);
+	}
+	for (const entity of building.entities) if (pctx.deps.ecs.ownerOf(entity) !== void 0) pctx.deps.ecs.despawn(entity);
+	delete state.building;
+	handBack(pctx, building);
+}
+//#endregion
 //#region src/plugins/world/projection/api.ts
 /**
 * Tells whether a cause sets the picture instead of playing it.
@@ -11626,7 +11878,7 @@ function createProjectionApi(ctx, deps) {
 		replace: (spec) => {
 			if (!state.specs.has(spec.name)) throw new Error(`[game] Projection "${spec.name}" is not registered.\n  Register it before replacing it.`);
 			const mounted = state.mounted.has(spec.name);
-			if (mounted) checkLayers(pctx, spec);
+			if (mounted) checkLayers(spec, state.layers);
 			state.specs.set(spec.name, spec);
 			if (mounted) forceRerun();
 		},
@@ -11701,7 +11953,7 @@ function createProjectionApi(ctx, deps) {
 		motionsOf: (entity) => runningComponents(state.tracks, entity),
 		entityOf: (projection, key) => state.mounted.get(projection)?.live.get(key)?.entity ?? state.keys.get(projection)?.get(key),
 		entitiesOf: (name) => {
-			const mounted = state.mounted.get(name);
+			const mounted = state.mounted.get(name) ?? state.building?.mounted.get(name);
 			return mounted === void 0 ? [] : liveEntities(mounted);
 		},
 		setDriver: (driver) => {
@@ -11747,6 +11999,38 @@ function createProjectionApi(ctx, deps) {
 			};
 		},
 		rerunAll: forceRerun,
+		build: (names, owner, layers, budgetMs) => buildNames(pctx, names, owner, layers, budgetMs),
+		built: () => {
+			if (state.building === void 0) return false;
+			for (const check of state.buildChecks) if (!check()) return false;
+			return true;
+		},
+		commit: () => {
+			commitBuild(pctx);
+		},
+		discard: () => {
+			discardBuild(pctx);
+		},
+		left: () => {
+			const building = state.building;
+			if (building === void 0) return Number.POSITIVE_INFINITY;
+			return building.budgetMs - (ctx.deps.clock.now() - building.frameStart);
+		},
+		isBuilding: (entity) => state.building?.entities.has(entity) === true,
+		onBuild: (check) => {
+			state.buildChecks.push(check);
+			return () => {
+				const at = state.buildChecks.indexOf(check);
+				if (at !== -1) state.buildChecks.splice(at, 1);
+			};
+		},
+		adopt: (entity) => {
+			state.building?.entities.add(entity);
+		},
+		startFrame: (now) => {
+			const building = state.building;
+			if (building !== void 0) building.frameStart = now;
+		},
 		markDirty: (roots, cause) => {
 			const dirty = state.dirty ?? emptyDirty();
 			dirty.causes.push(cause);
@@ -11785,6 +12069,7 @@ function createProjectionApi(ctx, deps) {
 			if (mounted !== void 0) clearMounted(pctx, mounted);
 		},
 		clear: () => {
+			discardBuild(pctx);
 			for (const mounted of [...state.mounted.values()]) clearMounted(pctx, mounted);
 			state.mounted.clear();
 			state.specs.clear();
@@ -11893,8 +12178,8 @@ function exposeEcs(ecs, projection) {
 	};
 }
 /**
-* Reduces the projection module to what `scenes`, `input`, `i18n` and the `/inspect` door call.
-* The frame methods and the dirty flag stay with the plugin root.
+* Reduces the projection module to what `scenes`, `input`, `i18n`, `ui`, `renderer` and the
+* `/inspect` door call. The frame methods and the dirty flag stay with the plugin root.
 *
 * @param projection - The full projection module.
 * @returns The public projection API.
@@ -11922,7 +12207,15 @@ function exposeProjection(projection) {
 		restOf: projection.restOf,
 		registerKey: projection.registerKey,
 		onConverged: projection.onConverged,
-		rerunAll: projection.rerunAll
+		rerunAll: projection.rerunAll,
+		build: projection.build,
+		built: projection.built,
+		commit: projection.commit,
+		discard: projection.discard,
+		left: projection.left,
+		isBuilding: projection.isBuilding,
+		onBuild: projection.onBuild,
+		adopt: projection.adopt
 	};
 }
 /**
@@ -12065,7 +12358,8 @@ function emptyWeakMap$2() {
 }
 /**
 * Creates the initial projection state: nothing registered, nothing mounted, no layer list, no
-* running track and no driver, so every motion is instant until `anim` installs one.
+* running track and no driver, so every motion is instant until `anim` installs one. No build
+* runs: `building` is absent.
 *
 * @returns The projection branch of the plugin state.
 */
@@ -12091,7 +12385,8 @@ function createProjectionState() {
 		membershipVersion: 0,
 		moving: false,
 		owedLoops: 0,
-		sweptDespawns: 0
+		sweptDespawns: 0,
+		buildChecks: []
 	};
 }
 //#endregion
@@ -23548,7 +23843,7 @@ function heldFilters(target) {
 * @param slots - The slots to compare with.
 * @returns True when nothing has to be written.
 */
-function holds(target, slots) {
+function holds$1(target, slots) {
 	const held = heldFilters(target);
 	let at = 0;
 	for (let index = 0; index < slots.length; index += 1) {
@@ -23605,7 +23900,7 @@ function clearFilters(target) {
 * @param target - Where the filters hang: the view's top unless the kept cache says otherwise.
 */
 function applyFilters(view, slots, before, target = view.wrapper ?? view.object) {
-	if (holds(target, slots)) return;
+	if (holds$1(target, slots)) return;
 	before();
 	writeFilters(target, slots);
 }
@@ -23717,7 +24012,7 @@ function applySwitchedOne(slots, entity) {
 	const view = sync?.views.get(entity);
 	if (view === void 0 || kept === void 0) return;
 	const target = kept.filterTarget(view);
-	if (holds(target, slots)) return;
+	if (holds$1(target, slots)) return;
 	writeFilters(target, slots);
 	switched.wrote = true;
 }
@@ -24628,6 +24923,348 @@ function clearFonts(state) {
 	state.fontCache = void 0;
 }
 //#endregion
+//#region src/plugins/renderer/sync/pools.ts
+/**
+* Tells whether a display object is a sprite. A `NineSliceSprite` carries the slice widths and
+* is recognised by them.
+*
+* @param object - The display object.
+* @returns True for a plain sprite.
+*/
+function isSprite(object) {
+	return "texture" in object && !("leftWidth" in object);
+}
+/**
+* Tells whether a display object draws paths, so a `Shape` can be written onto it.
+*
+* @param object - The display object.
+* @returns True for a graphics object.
+*/
+function isGraphics(object) {
+	return "roundRect" in object;
+}
+/**
+* Tells whether a display object draws a nine-slice: Pixi's `NineSliceSprite`, or the engine's rim-only mesh of a
+* `hollow` one. Both carry the slice widths.
+*
+* @param object - The display object.
+* @returns True for either nine-slice object.
+*/
+function isNineSlice(object) {
+	return "leftWidth" in object;
+}
+/**
+* Tells whether a display object is the engine's rim-only nine-slice (F59).
+*
+* @param object - The display object.
+* @returns True for the hollow mesh, false for Pixi's `NineSliceSprite` and every other object.
+*/
+function isHollow(object) {
+	return "hollow" in object;
+}
+/**
+* Takes a display object out of the Pixi tree. Pixi containers are not DOM nodes, so the DOM
+* helper the linter suggests does not exist on them.
+*
+* @param object - The display object.
+*/
+function detach$1(object) {
+	object.parent?.removeChild(object);
+}
+/**
+* Takes the masked container off a view: its children go back to the wrapper, unmasked and in
+* their order, and the container is freed.
+*
+* @param view - The view of a shape that clips, or of anything that does not.
+*/
+function dropClipped(view) {
+	const clipped = view.clipped;
+	if (clipped === void 0) return;
+	clipped.mask = null;
+	const wrapper = view.wrapper;
+	if (wrapper !== void 0) for (const child of clipped.children) wrapper.addChild(child);
+	detach$1(clipped);
+	clipped.destroy();
+	view.clipped = void 0;
+}
+/**
+* Takes the clip rectangle off a view: the children stop being masked and the graphics goes.
+*
+* @param view - The view of a shape that clips, or of anything that does not.
+*/
+function dropMask(view) {
+	dropClipped(view);
+	const mask = view.mask;
+	if (mask === void 0) return;
+	detach$1(mask);
+	mask.destroy();
+	view.mask = void 0;
+}
+/**
+* Takes the debug outline off a view: the graphics leaves the wrapper and is freed.
+*
+* @param view - The view of a nine-slice that was outlined, or of anything that was not.
+*/
+function dropOutline(view) {
+	const outline = view.outline;
+	if (outline === void 0) return;
+	detach$1(outline);
+	outline.destroy();
+	view.outline = void 0;
+}
+/**
+* The pool an object belongs to: its class and the texture it draws. A rim-only nine-slice has a pool of its own, so
+* a filled panel never gets a hollow object back, nor the other way round.
+*
+* @param kind - Which component gave the entity its display object.
+* @param textureKey - The asset key.
+* @param hollow - True for the rim-only object of a `NineSlice` with `hollow: true`.
+* @returns The pool key.
+* @example
+* ```ts
+* poolKeyOf("NineSlice", "glass.frost", true); // "NineSlice.hollow:glass.frost"
+* ```
+*/
+function poolKeyOf(kind, textureKey, hollow) {
+	return hollow ? `${kind}.hollow:${textureKey}` : `${kind}:${textureKey}`;
+}
+/**
+* Brings the object of a view that left back to the state a fresh one has: detached, drawn, opaque, unmoved, blending
+* normally, white.
+* Its hidden reasons go with `clearHidden`, so a pooled object never brings the reason of the view it belonged to; a
+* sprite and a graphics lose their tint (a fill-only shape is coloured by it, spec 26 R2.1).
+*
+* @param view - The view whose object goes back to its pool; its wrapper is gone already.
+*/
+function resetObject(view) {
+	detach$1(view.object);
+	clearHidden(view);
+	resetNode(view.object);
+}
+/**
+* Brings a detached object back to a fresh one's pose and look: drawn, opaque, unmoved, blending as its parent (no
+* glow of the view it drew for), white for a sprite and a graphics, and a graphics without a path.
+*
+* @param object - The object, out of the tree.
+*/
+function resetNode(object) {
+	object.visible = true;
+	object.alpha = 1;
+	object.blendMode = "inherit";
+	object.rotation = 0;
+	object.zIndex = 0;
+	object.position.set(0, 0);
+	object.pivot.set(0, 0);
+	object.scale.set(1);
+	if (isSprite(object)) object.tint = 16777215;
+	if (isGraphics(object)) {
+		object.tint = 16777215;
+		object.clear();
+	}
+}
+/**
+* Takes an object out of its pool, if one is waiting.
+*
+* @param state - The sync branch of the plugin state.
+* @param poolKey - Class and texture key.
+* @returns A reusable object, or `undefined`.
+*/
+function acquire(state, poolKey) {
+	const object = state.pools.get(poolKey)?.pop();
+	if (object !== void 0) state.pooled -= 1;
+	return object;
+}
+/**
+* Creates the array a pool keeps its objects in. Lint rule L5 refuses a collection built inside
+* an exported declaration, so it lives here.
+*
+* @returns An empty pool.
+*/
+function emptyPool() {
+	return [];
+}
+/**
+* The pool that holds the object that has waited longest.
+*
+* @param state - The sync branch of the plugin state.
+* @returns A non-empty pool, or `undefined` when every pool is empty.
+*/
+function oldestPool(state) {
+	for (const pool of state.pools.values()) if (pool.length > 0) return pool;
+}
+/**
+* Puts a view's object back into its pool and evicts the oldest one when the pool grew past the
+* configured limit. A `Display` object belongs to the game and is only detached. The filters and the
+* filter area the renderer hung on the object or its wrapper come off first, so a pooled object never
+* carries a filter into its next life; the filter instances themselves belong to `effects`.
+*
+* @param sctx - Domain context of the sync module.
+* @param view - The view that left.
+*/
+function release$1(sctx, view) {
+	dropMask(view);
+	dropOutline(view);
+	clearFilters(view.object);
+	clearArea(view.object);
+	if (view.wrapper !== void 0) {
+		clearFilters(view.wrapper);
+		clearArea(view.wrapper);
+		detach$1(view.wrapper);
+		view.wrapper.destroy({ children: false });
+		view.wrapper = void 0;
+	}
+	if (view.kind === "Display") {
+		detach$1(view.object);
+		clearHidden(view);
+		return;
+	}
+	if (view.kind === "adapter") {
+		detach$1(view.object);
+		clearHidden(view);
+		view.display?.adapter.destroy(view.object);
+		return;
+	}
+	dropGroup(sctx, view.object);
+	resetObject(view);
+	store$1(sctx, view.object, view.poolKey);
+}
+/**
+* Puts an object a view no longer draws with back into a pool, while the view goes on with another one: the
+* nine-slice whose `hollow` flipped (F59). Reset as `release` resets a view's object; its view keeps its hidden
+* reasons, which hang on the view's wrapper.
+*
+* @param sctx - Domain context of the sync module.
+* @param object - The object, still in the view's wrapper.
+* @param poolKey - The pool it belongs to.
+*/
+function releaseObject(sctx, object, poolKey) {
+	dropGroup(sctx, object);
+	detach$1(object);
+	resetNode(object);
+	store$1(sctx, object, poolKey);
+}
+/**
+* Takes away the render group the kept cache made of an object (spec 23 P9.3), before it is pooled.
+*
+* @param sctx - Domain context of the sync module.
+* @param object - The object.
+*/
+function dropGroup(sctx, object) {
+	const groups = sctx.ctx.state.kept.madeGroups;
+	if (!groups.has(object)) return;
+	object.disableRenderGroup();
+	groups.delete(object);
+}
+/**
+* Pushes a reset object into its pool and evicts the one that waited longest while the pools hold more than
+* `poolLimit`.
+*
+* @param sctx - Domain context of the sync module.
+* @param object - The reset object.
+* @param poolKey - Its pool.
+*/
+function store$1(sctx, object, poolKey) {
+	const state = sctx.ctx.state.sync;
+	const pool = state.pools.get(poolKey) ?? emptyPool();
+	pool.push(object);
+	state.pools.set(poolKey, pool);
+	state.pooled += 1;
+	while (state.pooled > sctx.ctx.config.poolLimit) {
+		const oldest = oldestPool(state);
+		if (oldest === void 0) return;
+		oldest.shift()?.destroy({ texture: false });
+		state.pooled -= 1;
+	}
+}
+/**
+* Destroys the pooled objects that draw one of these keys, so a bundle that left frees its GPU
+* memory instead of waiting for a reuse that resolves nothing: sprites, nine-slices and rim-only nine-slices.
+*
+* @param state - The sync branch of the plugin state.
+* @param keys - The asset keys that went stale.
+*/
+function dropPooled(state, keys) {
+	for (const key of keys) {
+		dropPool(state, poolKeyOf("Sprite", key, false));
+		dropPool(state, poolKeyOf("NineSlice", key, false));
+		dropPool(state, poolKeyOf("NineSlice", key, true));
+	}
+}
+/**
+* Destroys one pool and everything in it.
+*
+* @param state - The sync branch of the plugin state.
+* @param poolKey - The pool.
+*/
+function dropPool(state, poolKey) {
+	const pool = state.pools.get(poolKey);
+	if (pool === void 0) return;
+	for (const object of pool) object.destroy({ texture: false });
+	state.pooled -= pool.length;
+	state.pools.delete(poolKey);
+}
+/**
+* Destroys everything the pools hold. Works on the state alone, because `onStop` has no context.
+*
+* @param state - The sync branch of the plugin state.
+*/
+function destroyPools(state) {
+	for (const pool of state.pools.values()) for (const object of pool) object.destroy({ texture: false });
+	state.pools.clear();
+	state.pooled = 0;
+}
+//#endregion
+//#region src/plugins/renderer/sync/held.ts
+/**
+* Tells whether a view is held: its entity belongs to the running build, and it has no parent or its parent is live.
+* A building view under a building parent hangs in the parent's tree, which is held as a whole. One set lookup for a
+* live entity.
+*
+* @param sctx - Domain context of the sync module.
+* @param entity - The entity of the view.
+* @param parent - The entity its `Parent` names, 0 without one.
+* @returns True when the view must hang nowhere until the commit.
+*/
+function holds(sctx, entity, parent) {
+	const projection = sctx.ctx.deps.world.projection;
+	return projection.isBuilding(entity) && (parent === 0 || !projection.isBuilding(parent));
+}
+/**
+* Holds a view of the build: out of the tree, no orphan, listed once in `heldViews`. A top keeps the name of the layer
+* it will hang in, which the coming scene may declare only after the commit.
+*
+* @param sctx - Domain context of the sync module.
+* @param entity - The entity.
+* @param view - Its view.
+* @param layer - The layer it names; `""` for a view whose parent is live.
+*/
+function holdView(sctx, entity, view, layer) {
+	const state = sctx.ctx.state.sync;
+	const held = state.heldViews;
+	state.orphans.delete(entity);
+	view.layer = layer;
+	detach$1(view.wrapper ?? view.object);
+	if (view.held) return;
+	view.held = true;
+	held.entities[held.count] = entity;
+	held.count += 1;
+}
+/**
+* Forgets the queues of a scene build with the tree, on a device loss, a rebuild or a stop: the views they name are
+* gone, and a rebuild holds every building view again. Works on the state alone.
+*
+* @param state - The sync branch of the plugin state.
+*/
+function forgetBuild(state) {
+	const { aside, heldViews } = state;
+	aside.count = 0;
+	aside.head = 0;
+	aside.made = 0;
+	aside.waiting.clear();
+	heldViews.count = 0;
+	heldViews.reported = false;
+}
+//#endregion
 //#region src/plugins/renderer/sync/outline.ts
 /** Above every child of the wrapper, whatever `Order` a child carries. */
 const OUTLINE_Z = Number.MAX_SAFE_INTEGER;
@@ -25056,293 +25693,6 @@ function labelOf$1(sctx, name, entity) {
 	return key === void 0 ? base : `${base} ${key.projection}:${key.key}`;
 }
 //#endregion
-//#region src/plugins/renderer/sync/pools.ts
-/**
-* Tells whether a display object is a sprite. A `NineSliceSprite` carries the slice widths and
-* is recognised by them.
-*
-* @param object - The display object.
-* @returns True for a plain sprite.
-*/
-function isSprite(object) {
-	return "texture" in object && !("leftWidth" in object);
-}
-/**
-* Tells whether a display object draws paths, so a `Shape` can be written onto it.
-*
-* @param object - The display object.
-* @returns True for a graphics object.
-*/
-function isGraphics(object) {
-	return "roundRect" in object;
-}
-/**
-* Tells whether a display object draws a nine-slice: Pixi's `NineSliceSprite`, or the engine's rim-only mesh of a
-* `hollow` one. Both carry the slice widths.
-*
-* @param object - The display object.
-* @returns True for either nine-slice object.
-*/
-function isNineSlice(object) {
-	return "leftWidth" in object;
-}
-/**
-* Tells whether a display object is the engine's rim-only nine-slice (F59).
-*
-* @param object - The display object.
-* @returns True for the hollow mesh, false for Pixi's `NineSliceSprite` and every other object.
-*/
-function isHollow(object) {
-	return "hollow" in object;
-}
-/**
-* Takes a display object out of the Pixi tree. Pixi containers are not DOM nodes, so the DOM
-* helper the linter suggests does not exist on them.
-*
-* @param object - The display object.
-*/
-function detach$1(object) {
-	object.parent?.removeChild(object);
-}
-/**
-* Takes the masked container off a view: its children go back to the wrapper, unmasked and in
-* their order, and the container is freed.
-*
-* @param view - The view of a shape that clips, or of anything that does not.
-*/
-function dropClipped(view) {
-	const clipped = view.clipped;
-	if (clipped === void 0) return;
-	clipped.mask = null;
-	const wrapper = view.wrapper;
-	if (wrapper !== void 0) for (const child of clipped.children) wrapper.addChild(child);
-	detach$1(clipped);
-	clipped.destroy();
-	view.clipped = void 0;
-}
-/**
-* Takes the clip rectangle off a view: the children stop being masked and the graphics goes.
-*
-* @param view - The view of a shape that clips, or of anything that does not.
-*/
-function dropMask(view) {
-	dropClipped(view);
-	const mask = view.mask;
-	if (mask === void 0) return;
-	detach$1(mask);
-	mask.destroy();
-	view.mask = void 0;
-}
-/**
-* Takes the debug outline off a view: the graphics leaves the wrapper and is freed.
-*
-* @param view - The view of a nine-slice that was outlined, or of anything that was not.
-*/
-function dropOutline(view) {
-	const outline = view.outline;
-	if (outline === void 0) return;
-	detach$1(outline);
-	outline.destroy();
-	view.outline = void 0;
-}
-/**
-* The pool an object belongs to: its class and the texture it draws. A rim-only nine-slice has a pool of its own, so
-* a filled panel never gets a hollow object back, nor the other way round.
-*
-* @param kind - Which component gave the entity its display object.
-* @param textureKey - The asset key.
-* @param hollow - True for the rim-only object of a `NineSlice` with `hollow: true`.
-* @returns The pool key.
-* @example
-* ```ts
-* poolKeyOf("NineSlice", "glass.frost", true); // "NineSlice.hollow:glass.frost"
-* ```
-*/
-function poolKeyOf(kind, textureKey, hollow) {
-	return hollow ? `${kind}.hollow:${textureKey}` : `${kind}:${textureKey}`;
-}
-/**
-* Brings the object of a view that left back to the state a fresh one has: detached, drawn, opaque, unmoved, blending
-* normally, white.
-* Its hidden reasons go with `clearHidden`, so a pooled object never brings the reason of the view it belonged to; a
-* sprite and a graphics lose their tint (a fill-only shape is coloured by it, spec 26 R2.1).
-*
-* @param view - The view whose object goes back to its pool; its wrapper is gone already.
-*/
-function resetObject(view) {
-	detach$1(view.object);
-	clearHidden(view);
-	resetNode(view.object);
-}
-/**
-* Brings a detached object back to a fresh one's pose and look: drawn, opaque, unmoved, blending as its parent (no
-* glow of the view it drew for), white for a sprite and a graphics.
-*
-* @param object - The object, out of the tree.
-*/
-function resetNode(object) {
-	object.visible = true;
-	object.alpha = 1;
-	object.blendMode = "inherit";
-	object.rotation = 0;
-	object.zIndex = 0;
-	object.position.set(0, 0);
-	object.pivot.set(0, 0);
-	object.scale.set(1);
-	if (isSprite(object) || isGraphics(object)) object.tint = 16777215;
-}
-/**
-* Takes an object out of its pool, if one is waiting.
-*
-* @param state - The sync branch of the plugin state.
-* @param poolKey - Class and texture key.
-* @returns A reusable object, or `undefined`.
-*/
-function acquire(state, poolKey) {
-	const object = state.pools.get(poolKey)?.pop();
-	if (object !== void 0) state.pooled -= 1;
-	return object;
-}
-/**
-* Creates the array a pool keeps its objects in. Lint rule L5 refuses a collection built inside
-* an exported declaration, so it lives here.
-*
-* @returns An empty pool.
-*/
-function emptyPool() {
-	return [];
-}
-/**
-* The pool that holds the object that has waited longest.
-*
-* @param state - The sync branch of the plugin state.
-* @returns A non-empty pool, or `undefined` when every pool is empty.
-*/
-function oldestPool(state) {
-	for (const pool of state.pools.values()) if (pool.length > 0) return pool;
-}
-/**
-* Puts a view's object back into its pool and evicts the oldest one when the pool grew past the
-* configured limit. A `Display` object belongs to the game and is only detached. The filters and the
-* filter area the renderer hung on the object or its wrapper come off first, so a pooled object never
-* carries a filter into its next life; the filter instances themselves belong to `effects`.
-*
-* @param sctx - Domain context of the sync module.
-* @param view - The view that left.
-*/
-function release$1(sctx, view) {
-	dropMask(view);
-	dropOutline(view);
-	clearFilters(view.object);
-	clearArea(view.object);
-	if (view.wrapper !== void 0) {
-		clearFilters(view.wrapper);
-		clearArea(view.wrapper);
-		detach$1(view.wrapper);
-		view.wrapper.destroy({ children: false });
-		view.wrapper = void 0;
-	}
-	if (view.kind === "Display") {
-		detach$1(view.object);
-		clearHidden(view);
-		return;
-	}
-	if (view.kind === "adapter") {
-		detach$1(view.object);
-		clearHidden(view);
-		view.display?.adapter.destroy(view.object);
-		return;
-	}
-	dropGroup(sctx, view.object);
-	resetObject(view);
-	store$1(sctx, view.object, view.poolKey);
-}
-/**
-* Puts an object a view no longer draws with back into a pool, while the view goes on with another one: the
-* nine-slice whose `hollow` flipped (F59). Reset as `release` resets a view's object; its view keeps its hidden
-* reasons, which hang on the view's wrapper.
-*
-* @param sctx - Domain context of the sync module.
-* @param object - The object, still in the view's wrapper.
-* @param poolKey - The pool it belongs to.
-*/
-function releaseObject(sctx, object, poolKey) {
-	dropGroup(sctx, object);
-	detach$1(object);
-	resetNode(object);
-	store$1(sctx, object, poolKey);
-}
-/**
-* Takes away the render group the kept cache made of an object (spec 23 P9.3), before it is pooled.
-*
-* @param sctx - Domain context of the sync module.
-* @param object - The object.
-*/
-function dropGroup(sctx, object) {
-	const groups = sctx.ctx.state.kept.madeGroups;
-	if (!groups.has(object)) return;
-	object.disableRenderGroup();
-	groups.delete(object);
-}
-/**
-* Pushes a reset object into its pool and evicts the one that waited longest while the pools hold more than
-* `poolLimit`.
-*
-* @param sctx - Domain context of the sync module.
-* @param object - The reset object.
-* @param poolKey - Its pool.
-*/
-function store$1(sctx, object, poolKey) {
-	const state = sctx.ctx.state.sync;
-	const pool = state.pools.get(poolKey) ?? emptyPool();
-	pool.push(object);
-	state.pools.set(poolKey, pool);
-	state.pooled += 1;
-	while (state.pooled > sctx.ctx.config.poolLimit) {
-		const oldest = oldestPool(state);
-		if (oldest === void 0) return;
-		oldest.shift()?.destroy({ texture: false });
-		state.pooled -= 1;
-	}
-}
-/**
-* Destroys the pooled objects that draw one of these keys, so a bundle that left frees its GPU
-* memory instead of waiting for a reuse that resolves nothing: sprites, nine-slices and rim-only nine-slices.
-*
-* @param state - The sync branch of the plugin state.
-* @param keys - The asset keys that went stale.
-*/
-function dropPooled(state, keys) {
-	for (const key of keys) {
-		dropPool(state, poolKeyOf("Sprite", key, false));
-		dropPool(state, poolKeyOf("NineSlice", key, false));
-		dropPool(state, poolKeyOf("NineSlice", key, true));
-	}
-}
-/**
-* Destroys one pool and everything in it.
-*
-* @param state - The sync branch of the plugin state.
-* @param poolKey - The pool.
-*/
-function dropPool(state, poolKey) {
-	const pool = state.pools.get(poolKey);
-	if (pool === void 0) return;
-	for (const object of pool) object.destroy({ texture: false });
-	state.pooled -= pool.length;
-	state.pools.delete(poolKey);
-}
-/**
-* Destroys everything the pools hold. Works on the state alone, because `onStop` has no context.
-*
-* @param state - The sync branch of the plugin state.
-*/
-function destroyPools(state) {
-	for (const pool of state.pools.values()) for (const object of pool) object.destroy({ texture: false });
-	state.pools.clear();
-	state.pooled = 0;
-}
-//#endregion
 //#region src/plugins/renderer/sync/layers.ts
 /**
 * @file renderer/sync — the layers. `scenes` declares them through `world.projection.setLayers`;
@@ -28047,7 +28397,9 @@ function keepOrphan(sctx, entity, view, parentEntity) {
 /**
 * Hangs a view where it belongs: under its parent, or in the container of the layer it names.
 * An entity with no layer and no parent is not drawn. A view whose parent has no view yet waits
-* as an orphan, detached, so it is never drawn in a layer while its parent waits.
+* as an orphan, detached, so it is never drawn in a layer while its parent waits. A view of a scene
+* build with no parent, or with a live parent, is held: it hangs nowhere until the commit (spec 31),
+* and no wrapper is made on the live parent before it.
 *
 * @param sctx - Domain context of the sync module.
 * @param entity - The entity.
@@ -28058,6 +28410,11 @@ function attach$1(sctx, entity, view) {
 	const parentEntity = parentOf$1(sctx.ctx.deps.world.ecs, entity);
 	markView(sctx, entity);
 	noteLeaving(state, view);
+	if (holds(sctx, entity, parentEntity)) {
+		holdView(sctx, entity, view, parentEntity === 0 ? layerNameOf(sctx, entity) : "");
+		return;
+	}
+	if (view.held) view.held = false;
 	if (parentEntity !== 0) {
 		const host = childHostOf(sctx, parentEntity);
 		view.layer = "";
@@ -28185,7 +28542,8 @@ function createView(sctx, entity) {
 		clipDrawn: void 0,
 		hiddenSelf: 0,
 		hiddenTop: 0,
-		hud: 1
+		hud: 1,
+		held: false
 	};
 	object.label = labelOf$1(sctx, nameOf$1(visual), entity);
 	state.views.set(entity, view);
@@ -28286,10 +28644,10 @@ function dropView(sctx, entity) {
 }
 /**
 * Drops every view, every layer, every pool, every filter slot and filter area, the warm-up (its waiting promises
-* answer false, its probe tree is destroyed) and the upload queue (its waiting calls answer false). Works on the state
-* alone,
-* because `onStop` has no context. A `Display` object belongs to the game: it is detached, never
-* destroyed, and leaves without the filters, the filter area and the hidden reasons the renderer gave it.
+* answer false, its probe tree is destroyed), the upload queue (its waiting calls answer false) and the queues of a
+* scene build. Works on the state alone, because `onStop` has no context. A `Display` object belongs to the game: it
+* is detached, never destroyed, and leaves without the filters, the filter area and the hidden reasons the renderer
+* gave it.
 *
 * @param state - The sync branch of the plugin state.
 */
@@ -28335,6 +28693,7 @@ function stopSync(state) {
 	stopWarm(state);
 	stopUploads(state);
 	state.held.clear();
+	forgetBuild(state);
 	state.redraws = 0;
 	state.overdraw.listeners.length = 0;
 	clearLayers(state);
@@ -28478,8 +28837,7 @@ function withDeps$8(ctx) {
 * overlay step (spec 22), then `kept` reads the marks before `demand` decides whether the frame is
 * drawn and clears them; a drawn frame draws the probes of the warm-up onto the canvas first (F4: the
 * stage pass clears them, in the same task, so they never show), then uploads the queued texture sources (F60), then
-* the kept pictures
-* (`kept.flush`, so the canvas stays one pass, E7), then the stage, then the pixel leg of the kept
+* the kept pictures (`kept.flush`, so the canvas stays one pass, E7), then the stage, then the pixel leg of the kept
 * oracle; `demand` settles the
 * frame (the dev check, the pixel oracle), and `monitor` closes it and hands a drawn one to a
 * waiting capture; last, `host` trims Pixi's texture pool when a rest or a scene change is due. The display objects
@@ -28490,7 +28848,8 @@ function withDeps$8(ctx) {
 * last picture (WebGPU presents a canvas texture only when one is rendered; a WebGL canvas keeps
 * what it composited until the next draw). A drawn frame is reported to `time` for the adaptive
 * frame rate, and only when Pixi drew it: an inert or lost host reports none. A frame that also drew
-* probes is reported as probed: it created pipelines, so it is never a sample of the rate.
+* probes, uploaded sources or made views of the next scene aside is reported as probed: it did load work, so it is
+* never a sample of the rate.
 *
 * @param ctx - Domain context of the renderer plugin.
 * @param modules - The six modules.
@@ -28514,10 +28873,11 @@ function renderFrame(ctx, modules) {
 	if (drawn) {
 		const probed = modules.sync.warmStep();
 		const uploaded = modules.sync.uploadStep();
+		const built = modules.sync.takeBuildWork();
 		modules.kept.flush();
 		if (overdraw ? modules.sync.drawOverdraw(modules.host.render) : modules.host.render()) {
 			ctx.deps.time.frameDrawn();
-			if (probed || uploaded) ctx.deps.time.frameProbed();
+			if (probed || uploaded || built) ctx.deps.time.frameProbed();
 		}
 		modules.kept.after();
 	}
@@ -29320,6 +29680,233 @@ function layerOf(sctx, entity) {
 	return ecs.get(top, Layer)?.name;
 }
 //#endregion
+//#region src/plugins/renderer/sync/build.ts
+/** Views made between two reads of the clock: a read costs more than a small view. */
+const CLOCK_EVERY = 8;
+/**
+* Tells whether a scene is being built: `left()` answers a finite number only while a build runs.
+*
+* @param sctx - Domain context of the sync module.
+* @returns True while a build runs.
+*/
+function buildRuns(sctx) {
+	return sctx.ctx.deps.world.projection.left() !== Number.POSITIVE_INFINITY;
+}
+/**
+* Queues one building entity for its view, once.
+*
+* @param aside - The aside queue.
+* @param entity - The entity.
+*/
+function pushAside(aside, entity) {
+	if (aside.waiting.has(entity)) return;
+	aside.waiting.add(entity);
+	aside.entities[aside.count] = entity;
+	aside.count += 1;
+}
+/**
+* Moves the building entities of the pass's added set into the aside queue, in their order: the live pass builds the
+* rest. One set lookup per added entity; called only while a build runs.
+*
+* @param sctx - Domain context of the sync module.
+* @param taken - The entities the pass took out of `added`; the building ones leave it.
+*/
+function sortAside(sctx, taken) {
+	const projection = sctx.ctx.deps.world.projection;
+	const aside = sctx.ctx.state.sync.aside;
+	for (const entity of taken) {
+		if (!projection.isBuilding(entity)) continue;
+		taken.delete(entity);
+		pushAside(aside, entity);
+	}
+}
+/**
+* Forgets a queued entity that left before its view was made: the queue passes over it.
+*
+* @param state - The sync branch of the plugin state.
+* @param entity - The entity that left.
+*/
+function dropAside(state, entity) {
+	if (state.aside.count > 0) state.aside.waiting.delete(entity);
+}
+/**
+* Makes the view of one queued entity, its queued parent first (spec 16 U2.3: a child made before its parent finds no
+* parent view and is detached for good). The entity leaves the waiting set before its parent is made, so a cycle of
+* parents ends. A throw costs that entity.
+*
+* @param sctx - Domain context of the sync module.
+* @param entity - The entity.
+* @param report - Logs a throw of one entity's work.
+* @returns The views made.
+*/
+function makeParentFirst(sctx, entity, report) {
+	const waiting = sctx.ctx.state.sync.aside.waiting;
+	if (!waiting.delete(entity)) return 0;
+	const parent = parentOf$1(sctx.ctx.deps.world.ecs, entity);
+	let made = parent !== 0 && waiting.has(parent) ? makeParentFirst(sctx, parent, report) : 0;
+	try {
+		if (createView(sctx, entity)) made += 1;
+	} catch (error) {
+		report(entity, error);
+	}
+	return made;
+}
+/**
+* Makes the views of the aside queue while the frame has budget: at least one, the clock read after the first and then
+* every `CLOCK_EVERY` views. An entity that is no longer building but still alive (its build ended before its view was
+* made) goes back to `added`, for the live pass. The made views hang nowhere in the stage, so the version the live
+* tree is counted at stays as it was.
+*
+* @param sctx - Domain context of the sync module.
+* @param report - Logs a throw of one entity's work.
+* @returns The views made.
+*/
+function makeAside(sctx, report) {
+	const state = sctx.ctx.state.sync;
+	const { aside } = state;
+	const { projection, ecs } = sctx.ctx.deps.world;
+	const version = state.passesVersion;
+	let made = 0;
+	let check = 1;
+	while (aside.head < aside.count) {
+		const entity = aside.entities[aside.head] ?? 0;
+		aside.head += 1;
+		if (!aside.waiting.has(entity)) continue;
+		if (!projection.isBuilding(entity)) {
+			aside.waiting.delete(entity);
+			if (ecs.ownerOf(entity) !== void 0) state.added.add(entity);
+			continue;
+		}
+		made += makeParentFirst(sctx, entity, report);
+		if (made >= check) {
+			if (projection.left() <= 0) break;
+			check = made + CLOCK_EVERY;
+		}
+	}
+	if (aside.head >= aside.count) {
+		aside.head = 0;
+		aside.count = 0;
+	}
+	state.passesVersion = version;
+	return made;
+}
+/**
+* Tells whether a node hangs under the stage.
+*
+* @param node - The node.
+* @param stage - The stage.
+* @returns True when the stage is one of its ancestors.
+*/
+function underStage(node, stage) {
+	for (let parent = node.parent; parent !== null; parent = parent.parent) if (parent === stage) return true;
+	return false;
+}
+/**
+* The dev check of a build frame: no view of a building entity hangs under the stage, or it would be drawn and hit
+* before the commit. Named once per build, as `renderer:building-drawn` with the entities. Dev and agent builds only.
+*
+* @param sctx - Domain context of the sync module.
+*/
+function checkDrawn(sctx) {
+	const state = sctx.ctx.state.sync;
+	const stage = sctx.deps.host.stage();
+	if (state.heldViews.reported || stage === void 0) return;
+	const projection = sctx.ctx.deps.world.projection;
+	const drawn = [];
+	for (const [entity, view] of state.views) if (projection.isBuilding(entity) && underStage(view.wrapper ?? view.object, stage)) drawn.push(entity);
+	if (drawn.length === 0) return;
+	state.heldViews.reported = true;
+	sctx.ctx.log.warn("renderer:building-drawn", { entities: drawn });
+}
+/**
+* The building step of a frame, after the live pass: the views of the aside queue are made under the budget, and while
+* views wait to be made or attached, the next frame is asked for. A few field reads and no allocation with no build.
+*
+* @param sctx - Domain context of the sync module.
+* @param report - Logs a throw of one entity's work.
+*/
+function stepAside(sctx, report) {
+	const state = sctx.ctx.state.sync;
+	const { aside } = state;
+	if (aside.made !== 0) aside.made = 0;
+	if (aside.head >= aside.count && state.heldViews.count === 0) return;
+	if (aside.head < aside.count) aside.made = makeAside(sctx, report);
+	sctx.deps.demand.request();
+	if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) checkDrawn(sctx);
+}
+/**
+* Tells whether held views wait for the pass that attaches them: the build their first slot belongs to has ended (a
+* commit, or a discard whose views the pass drops). Read by `still()`: a field read with no build, one set lookup
+* during one.
+*
+* @param sctx - Domain context of the sync module.
+* @returns True when the pass has held views to attach or forget.
+*/
+function heldWaiting(sctx) {
+	const held = sctx.ctx.state.sync.heldViews;
+	return held.count > 0 && !sctx.ctx.deps.world.projection.isBuilding(held.entities[0] ?? 0);
+}
+/**
+* The swap: once the build of the held views ended, every held top is attached in one block, in the order it was made
+* (parents first), and sorted by the rule of the layer list the pass has just applied. A slot whose view went (a
+* discard, a view that left) attaches nothing. The list holds the views of one build only: a build that starts after
+* the commit makes its views after this step. Called by the pass right after `syncLayers`.
+*
+* @param sctx - Domain context of the sync module.
+*/
+function attachHeld(sctx) {
+	if (!heldWaiting(sctx)) return;
+	const state = sctx.ctx.state.sync;
+	const held = state.heldViews;
+	for (let index = 0; index < held.count; index += 1) {
+		const entity = held.entities[index] ?? 0;
+		const view = state.views.get(entity);
+		if (view === void 0 || !view.held) continue;
+		view.held = false;
+		attach$1(sctx, entity, view);
+		resort(sctx, entity, view);
+	}
+	held.count = 0;
+	held.reported = false;
+}
+/**
+* Tells whether an entity of a set belongs to the running build.
+*
+* @param sctx - Domain context of the sync module.
+* @param entities - The set.
+* @returns True when one does.
+*/
+function holdsBuilding(sctx, entities) {
+	const projection = sctx.ctx.deps.world.projection;
+	for (const entity of entities) if (projection.isBuilding(entity)) return true;
+	return false;
+}
+/**
+* The renderer's part of `world.projection.built()`, registered with `onBuild`: no building entity waits in `added`
+* or in the aside queue for its view. True while the renderer draws nothing.
+*
+* @param sctx - Domain context of the sync module.
+* @returns True when the renderer holds the swap back no longer.
+*/
+function buildReady(sctx) {
+	const state = sctx.ctx.state.sync;
+	if (state.root === void 0) return true;
+	if (state.aside.head < state.aside.count) return false;
+	return state.added.size === 0 || !holdsBuilding(sctx, state.added);
+}
+/**
+* The render phase's half of a scene build (the body of `SyncInternal.takeBuildWork`): reads and clears the count of the
+* views the pass made aside in this frame. A field read and no allocation.
+*
+* @param aside - The aside queue.
+* @returns True when the pass made views of the build: the frame did load work.
+*/
+function takeBuildWork(aside) {
+	const made = aside.made > 0;
+	aside.made = 0;
+	return made;
+}
+//#endregion
 //#region src/plugins/renderer/sync/each.ts
 /**
 * Tells whether a change list is an array.
@@ -30212,7 +30799,7 @@ function expectedHostOf(sctx, entity, parent) {
 }
 /**
 * Checks where the views of the given entities hang and reports every one that hangs elsewhere than the ECS says,
-* once per entity. An orphan hangs nowhere on purpose and is skipped.
+* once per entity. An orphan and a held view of a scene build (spec 31) hang nowhere on purpose and are skipped.
 *
 * @param sctx - Domain context of the sync module.
 * @param entities - The entities a pass built, hung again or took out of the orphans.
@@ -30222,7 +30809,7 @@ function checkTree(sctx, entities) {
 	const ecs = sctx.ctx.deps.world.ecs;
 	for (const entity of entities) {
 		const view = state.views.get(entity);
-		if (view === void 0 || state.orphans.has(entity) || state.mismatched.has(entity)) continue;
+		if (view === void 0 || view.held || state.orphans.has(entity) || state.mismatched.has(entity)) continue;
 		const parent = parentOf$1(ecs, entity);
 		const host = (view.wrapper ?? view.object).parent;
 		const expected = expectedHostOf(sctx, entity, parent);
@@ -30497,12 +31084,13 @@ function createSyncApi(ctx, deps) {
 	const onParent = (entity) => stepOn(STEP.parent, entity);
 	const onAdapter = (entity) => stepOn(STEP.adapter, entity);
 	/**
-	* A new `Display` object of the game replaces the old view outright, unless this pass built it.
+	* A new `Display` object of the game replaces the old view outright, unless this pass built it, or it waits aside
+	* for its view (spec 31): the chunk that makes it reads the new object.
 	*
 	* @param entity - The entity.
 	*/
 	const onDisplay = (entity) => {
-		if (built.has(entity)) return;
+		if (built.has(entity) || state.aside.waiting.has(entity)) return;
 		guard(entity, () => {
 			dropView(sctx, entity);
 			createView(sctx, entity);
@@ -30585,12 +31173,13 @@ function createSyncApi(ctx, deps) {
 	};
 	/**
 	* Tells whether the pass has nothing to do: nothing waits to be built, dropped, hung or resolved again, the layer list
-	* is the one built, and no watched component of any entity changed. A still frame returns on this, before any work.
+	* is the one built, no held view waits for its swap, and no watched component of any entity changed. A still frame
+	* returns on this, before any work. The aside queue of a scene build is not read: its work is the build step's.
 	*
 	* @returns True when the pass would change nothing.
 	*/
 	const still = () => {
-		if (state.removed.size > 0 || state.added.size > 0 || state.reparented.size > 0 || state.orphans.size > 0 || state.invalidated.size > 0 || state.viewlessEntries || state.outlinesStale || ctx.deps.world.projection.layers() !== state.layerList) return false;
+		if (state.removed.size > 0 || state.added.size > 0 || state.reparented.size > 0 || state.orphans.size > 0 || state.invalidated.size > 0 || state.viewlessEntries || state.outlinesStale || ctx.deps.world.projection.layers() !== state.layerList || heldWaiting(sctx)) return false;
 		const ecs = ctx.deps.world.ecs;
 		if (!isEmptyList(ecs.changed(Transform)) || !isEmptyList(ecs.changed(Sprite)) || !isEmptyList(ecs.changed(NineSlice)) || !isEmptyList(ecs.changed(Shape)) || !isEmptyList(ecs.changed(Order)) || !isEmptyList(ecs.changed(Layer)) || !isEmptyList(ecs.changed(Parent)) || !isEmptyList(ecs.changed(Display))) return false;
 		for (let index = 0; index < state.adapters.length; index += 1) {
@@ -30625,13 +31214,16 @@ function createSyncApi(ctx, deps) {
 		for (const [entity, view] of state.views) if (view.kind === "NineSlice") guard(entity, () => applyNineSlice(sctx, entity, view));
 	};
 	/**
-	* Takes the entities that are waiting to be built out of the change set. Called only when one waits.
+	* Takes the entities that are waiting to be built out of the change set. Called only when one waits. While a scene is
+	* built aside, its entities go to the aside queue instead (spec 31): world flags them right after their spawn, so
+	* they are sorted here, not when their components came.
 	*
 	* @returns The entities of this pass, so the change step skips what the build just wrote.
 	*/
 	const takeAdded = () => {
 		const built = copyOf(state.added);
 		state.added.clear();
+		if (buildRuns(sctx)) sortAside(sctx, built);
 		return built;
 	};
 	/**
@@ -30684,17 +31276,17 @@ function createSyncApi(ctx, deps) {
 		return viewless;
 	};
 	/**
-	* One pass: removed, layers, added, changed, orphans, invalidated. A despawned entity takes its filter
-	* slots with it, also when its view left in an earlier pass; a live one keeps them for its next
-	* view. A still frame (nothing changed, nothing waits) returns before any work and makes nothing.
+	* The live half of a pass: removed, layers, the held views of a build that ended, added, changed, orphans,
+	* invalidated. A despawned entity takes its filter slots with it, also when its view left in an earlier pass; a live
+	* one keeps them for its next view.
 	*/
-	const pass = () => {
-		if (still()) return;
+	const livePass = () => {
 		state.passesVersion += 1;
 		if (state.removed.size > 0) {
 			for (const entity of state.removed) {
 				guard(entity, () => dropView(sctx, entity));
 				forgetLeft(state, ctx.deps.world.ecs, entity);
+				dropAside(state, entity);
 			}
 			state.removed.clear();
 		}
@@ -30703,6 +31295,7 @@ function createSyncApi(ctx, deps) {
 			deps.demand.whole("layers");
 			deps.host.sceneChanged();
 		}
+		attachHeld(sctx);
 		built = state.added.size === 0 ? nothingBuilt : buildParentFirst(takeAdded());
 		const touched = typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ ? touchedBy() : void 0;
 		applyChanges();
@@ -30715,6 +31308,14 @@ function createSyncApi(ctx, deps) {
 		if (touched !== void 0) checkTree(sctx, touched);
 	};
 	/**
+	* One pass: the live half unless the frame is still, then the build step of a scene built aside (spec 31). A still
+	* frame with no build (nothing changed, nothing waits) does no work and makes nothing.
+	*/
+	const pass = () => {
+		if (!still()) livePass();
+		stepAside(sctx, report);
+	};
+	/**
 	* Forgets every view, layer and pooled object without touching Pixi. Used before a rebuild,
 	* where the old application and everything in it are already gone.
 	*/
@@ -30739,6 +31340,7 @@ function createSyncApi(ctx, deps) {
 		clearFrames(state);
 		destroyPools(state);
 		clearLayers(state);
+		forgetBuild(state);
 		state.root = void 0;
 		state.passesVersion += 1;
 	};
@@ -30840,6 +31442,7 @@ function createSyncApi(ctx, deps) {
 		stepFilters: () => applySwitched(state, deps.kept),
 		drainOverlayEvents: (monitor) => drainOverlayEvents(sctx, monitor),
 		warmStep: () => warmStep(sctx),
+		takeBuildWork: () => takeBuildWork(state.aside),
 		uploadStep: () => uploadStep(sctx),
 		onWarm: (fn) => {
 			state.warm.listeners.push(fn);
@@ -30868,7 +31471,7 @@ function createSyncApi(ctx, deps) {
 		start: () => {
 			if (deps.host.stage() === void 0) return;
 			const ecs = ctx.deps.world.ecs;
-			state.cleanups.push(ecs.onAdded(Sprite, markAdded), ecs.onAdded(NineSlice, markAdded), ecs.onAdded(Shape, markAdded), ecs.onAdded(Display, markAdded), ecs.onRemoved(Sprite, markRemoved), ecs.onRemoved(NineSlice, markRemoved), ecs.onRemoved(Shape, markRemoved), ecs.onRemoved(Display, markRemoved), ecs.onRemoved(Parent, markReparented), ...watchOverlays(sctx), ecs.system(createSyncSystem(pass)));
+			state.cleanups.push(ecs.onAdded(Sprite, markAdded), ecs.onAdded(NineSlice, markAdded), ecs.onAdded(Shape, markAdded), ecs.onAdded(Display, markAdded), ecs.onRemoved(Sprite, markRemoved), ecs.onRemoved(NineSlice, markRemoved), ecs.onRemoved(Shape, markRemoved), ecs.onRemoved(Display, markRemoved), ecs.onRemoved(Parent, markReparented), ...watchOverlays(sctx), ecs.system(createSyncSystem(pass)), ctx.deps.world.projection.onBuild(() => buildReady(sctx)));
 			rebuildAll();
 		}
 	};
@@ -31649,8 +32252,24 @@ function createUploadState() {
 	};
 }
 /**
+* Creates the empty aside queue of a scene build: nothing waits for a view. Its own non-exported function, as
+* `emptyMap`.
+*
+* @returns The aside branch of the sync state.
+*/
+function createAsideQueue() {
+	return {
+		entities: [],
+		count: 0,
+		head: 0,
+		waiting: emptySet$4(),
+		made: 0
+	};
+}
+/**
 * Creates the initial sync state: no root, no layers, no view, no orphan, no pool, no provider, no filter, no
-* filter area, no slice, no hidden mask, no overlay, no warm-up, no upload, no redraw counted and no unseen walk kept.
+* filter area, no slice, no hidden mask, no overlay, no warm-up, no upload, no redraw counted, no unseen walk kept and
+* no scene build.
 *
 * @param debug - The debug switches of the config; copied, so the frozen config stays untouched.
 * @returns The sync branch of the plugin state.
@@ -31709,6 +32328,12 @@ function createSyncState(debug) {
 			enabled: []
 		},
 		hudLayer: void 0,
+		aside: createAsideQueue(),
+		heldViews: {
+			entities: [],
+			count: 0,
+			reported: false
+		},
 		cleanups: []
 	};
 }
@@ -31816,7 +32441,7 @@ function checkAdaptiveScale(adaptiveScale) {
 *   number from 64 to 16384, `keptMb` is not a finite number of at least 0, `warm` is not a
 *   whole number from 0 to 16, or `uploads` is not a whole number from 0 to 8.
 */
-function checkConfig(config) {
+function checkConfig$1(config) {
 	const { maxResolution, keptMb } = config;
 	const { budgetMs, frames } = config.monitor;
 	if (!Number.isFinite(maxResolution) || maxResolution <= 0) throw new Error(`[game] renderer.maxResolution is ${maxResolution}.\n  Give a number above 0.`);
@@ -31841,7 +32466,7 @@ function checkConfig(config) {
 * @throws {Error} When the config fails a check of `checkConfig`.
 */
 function createRendererState(ctx) {
-	checkConfig(ctx.config);
+	checkConfig$1(ctx.config);
 	return {
 		host: createHostState(),
 		viewport: createViewportState(),
@@ -35799,7 +36424,7 @@ function usedMb(state) {
 }
 /**
 * Picks the bundle that leaves next: the loaded one with the smallest use counter that is not
-* pinned, not named by the mounted scene, not permanent and not in the preload queue. Its
+* pinned, not named by the mounted, a leaving or the coming scene, not permanent and not in the preload queue. Its
 * `release` is not read: a `"leave"` bundle is a candidate like any other.
 *
 * @param state - The plugin state.
@@ -35813,6 +36438,7 @@ function pickVictim(state) {
 		if (record.status !== "loaded" || entry === void 0) continue;
 		if (state.pinned.has(name) || isPermanent(entry.tier)) continue;
 		if (state.sceneNamed.includes(name) || state.sceneLeaving.includes(name)) continue;
+		if (state.sceneComing.includes(name)) continue;
 		if (state.queue?.bundles.includes(name) === true) continue;
 		if (record.lastUsed >= smallest) continue;
 		smallest = record.lastUsed;
@@ -35968,9 +36594,9 @@ function featuresOnStack(ctx) {
 }
 /**
 * Tells whether a bundle must stay where the game stands now: it is pinned (a bundle of the node
-* entered last), the mounted scene names it (the last list `sceneBundles` received), a leaving
-* scene named it and its elements still play their exit, its feature is in `onStack`, or its tier
-* is permanent.
+* entered last), the mounted scene names it (the last list `sceneBundles` received), the scene
+* being built names it (the last list `sceneComing` received), a leaving scene named it and its
+* elements still play their exit, its feature is in `onStack`, or its tier is permanent.
 *
 * @param ctx - Domain context of the plugin.
 * @param name - Name of the bundle.
@@ -35978,9 +36604,9 @@ function featuresOnStack(ctx) {
 * @param onStack - The features on the stack, from `featuresOnStack`.
 * @returns True when the bundle is held.
 */
-function isHeld(ctx, name, entry, onStack) {
+function isHeld$1(ctx, name, entry, onStack) {
 	const state = ctx.state;
-	return state.pinned.has(name) || state.sceneNamed.includes(name) || state.sceneLeaving.includes(name) || onStack.has(entry.feature) || isPermanent(entry.tier);
+	return state.pinned.has(name) || state.sceneNamed.includes(name) || state.sceneLeaving.includes(name) || state.sceneComing.includes(name) || onStack.has(entry.feature) || isPermanent(entry.tier);
 }
 /**
 * Unloads every loaded `"leave"` bundle nobody holds any more, with the reason `"leave"`. A
@@ -35999,7 +36625,7 @@ function releaseLeftBundles(ctx) {
 /**
 * Takes the list the mounted scene names now. A bundle the list named before and names no more
 * stays held as a leaving scene's, until nothing carries `Exiting` (F51); a name the list takes
-* again is the mounted scene's once more.
+* again is the mounted scene's once more. The coming list empties: its scene is the mounted one.
 *
 * @param state - The plugin state.
 * @param named - The bundles the mounted scene names now.
@@ -36009,6 +36635,17 @@ function nameSceneBundles(state, named) {
 	for (const name of state.sceneNamed) if (!named.includes(name) && !leaving.includes(name)) leaving.push(name);
 	state.sceneLeaving = leaving;
 	state.sceneNamed = [...named];
+	state.sceneComing = [];
+}
+/**
+* Takes the list the scene being built aside names: each call replaces the one before, and `[]`
+* ends the hold of a discarded build. `nameSceneBundles` empties it at the swap (F61 S2).
+*
+* @param state - The plugin state.
+* @param named - The bundles the coming scene names.
+*/
+function nameComingBundles(state, named) {
+	state.sceneComing = [...named];
 }
 /**
 * Lets the bundles a leaving scene named go once nothing carries `Exiting` any more: each loaded
@@ -36018,14 +36655,17 @@ function nameSceneBundles(state, named) {
 * its feature shows (the splash's 7.5 MiB under the ward). A bundle of another release stays, as
 * it would have. The system `assets.leave` calls it in every phase `sync`: after the reconcile of
 * `layout`, which tags the leaving elements `Exiting` in the frame after the switch, so the hold
-* never ends before the leave begins (F51b). It costs a length read while no scene leaves, and a
-* count read while one does.
+* never ends before the leave begins (F51b). While a scene is built aside (the coming list is
+* set; a scene names its own bundle, so the list of a build is never empty) the leave has not
+* begun: the world holds the scene on screen as it stood until the swap, and what it draws still
+* needs its bundles. It costs two length reads while no scene leaves, and a count read while one
+* does.
 *
 * @param ctx - Domain context of the plugin.
 */
 function releaseSceneLeft(ctx) {
 	const state = ctx.state;
-	if (state.sceneLeaving.length === 0 || state.exiting > 0) return;
+	if (state.sceneLeaving.length === 0 || state.exiting > 0 || state.sceneComing.length > 0) return;
 	const names = state.sceneLeaving;
 	state.sceneLeaving = [];
 	if (state.io === void 0) return;
@@ -36045,7 +36685,7 @@ function releaseSceneLeft(ctx) {
 function unloadIfLeft(ctx, name, onStack) {
 	const entry = ctx.state.manifest.bundles[name];
 	if (ctx.state.records.get(name)?.status !== "loaded" || entry?.release !== "leave") return;
-	if (isHeld(ctx, name, entry, onStack)) return;
+	if (isHeld$1(ctx, name, entry, onStack)) return;
 	unloadBundle(ctx, name, "leave");
 }
 //#endregion
@@ -36438,7 +37078,7 @@ function affordable(ctx, distances) {
 	for (const name of ordered) {
 		const entry = ctx.state.manifest.bundles[name];
 		if (entry === void 0 || entry.tier === "lazy") continue;
-		if (entry.release === "leave" && !isHeld(ctx, name, entry, onStack)) continue;
+		if (entry.release === "leave" && !isHeld$1(ctx, name, entry, onStack)) continue;
 		if (!isStillWanted(ctx.state, name)) continue;
 		if (running + entry.mb > ctx.config.textureBudgetMb) break;
 		running += entry.mb;
@@ -36874,6 +37514,7 @@ function releaseAll(state) {
 	state.sceneId = void 0;
 	state.sceneNamed = [];
 	state.sceneLeaving = [];
+	state.sceneComing = [];
 	state.exiting = 0;
 	state.restPending = false;
 	state.stamps = void 0;
@@ -37023,6 +37664,7 @@ function createAssetsApi(ctx) {
 		audio: (key) => loadedRecord(assets, key)?.audio.get(key),
 		usage: () => usage(assets),
 		sceneBundles: (named) => nameSceneBundles(ctx.state, named),
+		sceneComing: (named) => nameComingBundles(ctx.state, named),
 		has: (bundle) => Object.hasOwn(ctx.state.manifest.bundles, bundle),
 		companions: { add: (companion) => addCompanion(ctx.state, companion) }
 	};
@@ -37691,6 +38333,7 @@ function createAssetsState() {
 		swapping: void 0,
 		sceneNamed: [],
 		sceneLeaving: [],
+		sceneComing: [],
 		exiting: 0,
 		companions: [],
 		restPending: false,
@@ -37759,161 +38402,7 @@ function createScenesApi(ctx) {
 	};
 }
 //#endregion
-//#region src/plugins/scenes/switch.ts
-/**
-* A promise that resolves when the node was aborted. Already aborted resolves at once.
-*
-* @param signal - The abort signal of the node being entered.
-* @returns A promise that resolves on abort and never rejects.
-*/
-function whenAborted$1(signal) {
-	return new Promise((resolve) => {
-		if (signal.aborted) {
-			resolve();
-			return;
-		}
-		signal.addEventListener("abort", () => resolve(), { once: true });
-	});
-}
-/**
-* Waits for the textures of loaded bundles to reach the GPU, or for the abort. It never rejects:
-* a warm that fails (an unload during it) is logged and the switch goes on, its first draw
-* uploads as before. Headless, without a device or with `uploads: 0` the warms answer at once,
-* and textures already on the GPU are not waited for.
-*
-* @param ctx - Domain context of the plugin.
-* @param bundles - The bundles the scene being entered names, all of them loaded.
-* @param signal - The abort signal of the node.
-* @returns A promise that resolves when every warm settled or the node was aborted.
-*/
-async function untilWarmed(ctx, bundles, signal) {
-	const warms = bundles.map((bundle) => ctx.deps.assets.warm(bundle).catch((error) => {
-		ctx.log.warn("scenes: a bundle's textures were not uploaded before the switch", {
-			bundle,
-			error
-		});
-	}));
-	await Promise.race([Promise.all(warms), whenAborted$1(signal)]);
-}
-/**
-* Loads every bundle the scene names at once and returns as soon as all loads settled or the node
-* is aborted. The first load that fails while the node still runs is rethrown, so `flow` rolls
-* the node back; one that fails after the abort is logged, because nobody waits for it any more.
-*
-* @param ctx - Domain context of the plugin.
-* @param bundles - The bundles the scene being entered names, its own bundle first.
-* @param signal - The abort signal of the node.
-* @returns A promise that resolves when the loads settled or the node was aborted.
-* @throws {Error} Whatever the first failed load rejected with, while the node was not aborted.
-*/
-async function untilAborted(ctx, bundles, signal) {
-	const load = {
-		failed: false,
-		error: void 0
-	};
-	const loads = bundles.map((bundle) => ctx.deps.assets.load(bundle).catch((error) => {
-		if (!load.failed) {
-			load.failed = true;
-			load.error = error;
-		}
-		if (signal.aborted) ctx.log.warn("scenes: a cancelled bundle load failed", {
-			bundle,
-			error
-		});
-	}));
-	await Promise.race([Promise.all(loads), whenAborted$1(signal)]);
-	if (load.failed && !signal.aborted) throw load.error;
-}
-/**
-* Reads the committed state a scene's `bundles` gets: the frozen trees of the store, in a frozen
-* wrapper. During the scene stage no node writes, so it is the state the node is entered with.
-*
-* @param ctx - Domain context of the plugin.
-* @returns The committed `player` and `session`.
-*/
-function committedState(ctx) {
-	const { player, session } = ctx.deps.model.store.snapshot();
-	return Object.freeze({
-		player,
-		session
-	});
-}
-/**
-* Tells whether two lists name the same bundles in the same order.
-*
-* @param left - One list.
-* @param right - The other list.
-* @returns True when both have the same names at the same places.
-* @example
-* ```ts
-* sameNames(["location", "ep01"], ["location", "ep02"]); // false
-* ```
-*/
-function sameNames(left, right) {
-	return left.length === right.length && left.every((name, index) => name === right[index]);
-}
-/**
-* Takes the expected scene and clears the record, so one `expect` mounts one scene.
-*
-* @param ctx - Domain context of the plugin.
-* @returns The scene id that was recorded or expected, or `undefined` when there was none.
-*/
-function takePending(ctx) {
-	const target = ctx.state.pending;
-	ctx.state.pending = void 0;
-	return target;
-}
-/**
-* Tells whether the node is a transit node of a fast walk: the walk passes through it and builds
-* no scene there.
-*
-* @param node - The node being entered.
-* @param run - The runner's mode and signal.
-* @returns True for a node without `rest` entered in fast mode.
-*/
-function isFastTransit(node, run) {
-	return run.mode === "fast" && !node.rest;
-}
-/**
-* Reads the scene the node asks for. In fast mode a transit node only records it: the walk passes
-* through many of them and the picture is built once, at the rest point. In live mode a transit
-* node without a scene of its own takes the expected one, so a restore at a popup that waits for
-* its answer builds the scene under it; one with its own scene leaves the record alone.
-*
-* @param ctx - Domain context of the plugin.
-* @param node - The node being entered.
-* @param run - The runner's mode and signal.
-* @returns The scene id to switch to, or `undefined` when nothing has to happen.
-*/
-function targetOf(ctx, node, run) {
-	const state = ctx.state;
-	if (isFastTransit(node, run)) {
-		state.pending = node.scene ?? state.pending;
-		return;
-	}
-	if (!node.rest) return node.scene ?? takePending(ctx);
-	const target = node.scene ?? state.pending;
-	state.pending = void 0;
-	if (target === void 0 && state.current === void 0) ctx.log.warn("scenes: a rest node was entered with no scene", { path: node.path });
-	return target;
-}
-/**
-* Reads the scene an `over` node asks for. An over node takes the expected scene and clears the
-* record, whatever is mounted, so a restore at a popup builds the scene under it, whether the
-* popup rests or waits for its answer. With nothing expected it switches nothing. In fast mode an
-* over transit node takes nothing and leaves the record alone: a walk builds no scene on the way.
-* A scene the over node names itself is only warned about.
-*
-* @param ctx - Domain context of the plugin.
-* @param node - The over node being entered.
-* @param run - The runner's mode and signal.
-* @returns The expected scene id, or `undefined` when nothing has to happen.
-*/
-function overTargetOf(ctx, node, run) {
-	if (node.scene !== void 0) ctx.log.warn("scenes: an over node cannot name a scene", { path: node.path });
-	if (isFastTransit(node, run)) return void 0;
-	return takePending(ctx);
-}
+//#region src/plugins/scenes/swap.ts
 /**
 * The projections of the scene that leaves which the scene that comes does not list. A projection
 * both list stays mounted: the layers of a projection are the ones its spec names, and both scenes
@@ -37927,23 +38416,55 @@ function leavingOf(previous, scene) {
 	return previous.projections.filter((name) => !scene.projections.includes(name));
 }
 /**
-* Builds the scene in one synchronous block: the layers, then the projections only the old scene
-* lists out, then the list of the new scene in (a projection both list stays and takes its new
-* place), the new scene to the world's systems, then the list the scene names to `assets`, then
-* the frame loop out of its idle cap and the adaptive frame rate told of the new screen, and only then the event.
+* Names the switch in the performance log of an agent build: the scenes it went between and,
+* for a scene built aside, the frames and the milliseconds of page clock the build took, and the
+* budget of a frame it ran with.
+*
+* @param ctx - Domain context of the plugin.
+* @param from - The scene that left, `undefined` for the first one.
+* @param to - The scene that is mounted now.
+* @param build - The build that was committed; absent for a one-block switch.
+*/
+function logSwitch(ctx, from, to, build) {
+	const scenes = {
+		from: from ?? null,
+		to
+	};
+	if (build === void 0) {
+		ctx.deps.renderer.monitor.event("scene", scenes);
+		return;
+	}
+	const clock = ctx.deps.time.agentClock();
+	const buildMs = clock === void 0 ? 0 : clock() - build.startedAt;
+	ctx.deps.renderer.monitor.event("scene", {
+		...scenes,
+		buildFrames: build.frames,
+		buildMs,
+		budgetMs: build.budgetMs
+	});
+}
+/**
+* Makes a scene the mounted one in one synchronous block: the layers, then the projections only
+* the old scene lists out, then the new scene in (a `mount` of its list, or the commit of the
+* build that made it aside; a projection both list stays and takes its new place), the new scene
+* to the world's systems, then the list the scene names to `assets`, then the frame loop out of
+* its idle cap and the adaptive frame rate told of the new screen, and only then the event.
 *
 * @param ctx - Domain context of the plugin.
 * @param scene - The scene whose bundles are there.
 * @param named - The bundles the scene names, as they were awaited.
+* @param build - The build to commit in the mount's place; absent for a one-block switch.
+* @throws {Error} Whatever the mount threw: a `view` or an unknown projection.
 */
-function apply(ctx, scene, named) {
+function swapIn(ctx, scene, named, build) {
 	const state = ctx.state;
 	const projection = ctx.deps.world.projection;
-	const from = state.current;
+	const from = build === void 0 ? state.current : build.from;
 	const previous = from === void 0 ? void 0 : state.scenes.get(from);
 	projection.setLayers(scene.layers);
 	if (previous !== void 0) projection.unmount(leavingOf(previous, scene));
-	projection.mount(scene.projections, state.owner);
+	if (build === void 0) projection.mount(scene.projections, state.owner);
+	else projection.commit();
 	state.current = scene.id;
 	ctx.deps.world.ecs.setScene(scene.id);
 	state.named = named;
@@ -37955,16 +38476,424 @@ function apply(ctx, scene, named) {
 		to: scene.id,
 		music: scene.music
 	});
-	if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) ctx.deps.renderer.monitor.event("scene", {
-		from: from ?? null,
-		to: scene.id
+	if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) logSwitch(ctx, from, scene.id, build);
+}
+//#endregion
+//#region src/plugins/scenes/build.ts
+/**
+* @file scenes plugin — the next scene built aside on a live switch (spec 31, F61 S2). The world
+* mounts the coming projections into a table of its own while the old scene stays current, drawn
+* and alive; `ui` and the renderer do their part under the budget of a frame (`buildMs`); the frame
+* `world.projection.built()` first answers true commits it with the swap of a one-block switch. An
+* abort of the node discards the build and leaves the world as it stood.
+*/
+/** Half a second in ms: half of a frame interval is this over the frame rate. */
+const HALF_SECOND_MS = 500;
+/** The budget of a frame when `time` answers no frame rate to halve: half a 60 Hz frame, ms. */
+const FALLBACK_BUDGET_MS = HALF_SECOND_MS / 60;
+/**
+* Tells whether a value is a number a frame can count with: finite and above 0. Pure.
+*
+* @param value - The value.
+* @returns True for a finite number above 0.
+* @example
+* ```ts
+* isPositiveFinite(Number.NaN); // false
+* ```
+*/
+function isPositiveFinite(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0;
+}
+/**
+* Does nothing: the listeners of a build that commits at once, before it registered any.
+*/
+function noListeners() {}
+/**
+* Reads the page clock of an agent build, for the milliseconds a build took.
+*
+* @param ctx - Domain context of the plugin.
+* @returns The page clock in ms, or 0 in a build without the flag.
+*/
+function agentNow(ctx) {
+	const clock = ctx.deps.time.agentClock();
+	return clock === void 0 ? 0 : clock();
+}
+/**
+* The building budget of a frame for a build that starts now: the number a game configured, or
+* for `"auto"` half of the frame interval the loop runs at, `500 / time.rate().fps`, read once
+* here. A rate that is not a finite number above 0 gives half a 60 Hz frame.
+*
+* @param ctx - Domain context of the plugin.
+* @returns Milliseconds per frame the building work may take.
+*/
+function budgetOf(ctx) {
+	const { buildMs } = ctx.config;
+	if (buildMs !== "auto") return buildMs;
+	const { fps } = ctx.deps.time.rate();
+	return isPositiveFinite(fps) ? HALF_SECOND_MS / fps : FALLBACK_BUDGET_MS;
+}
+/**
+* Ends the build with the swap: its listeners go and the record is dropped, then the swap of a
+* one-block switch runs, with the commit in the mount's place, or, for `"mount"`, after the build
+* was discarded, with the mount itself. A swap that throws rejects the switch, so `flow` rolls the
+* node back; the build is discarded and the coming bundles are held no more first, so the next
+* switch can build again.
+*
+* @param ctx - Domain context of the plugin.
+* @param build - The running build.
+* @param how - `"commit"` to commit the build, `"mount"` to discard it and mount in one block.
+*/
+function endBuild(ctx, build, how) {
+	build.off();
+	delete ctx.state.build;
+	if (how === "mount") ctx.deps.world.projection.discard();
+	try {
+		swapIn(ctx, build.scene, build.named, how === "commit" ? build : void 0);
+	} catch (error) {
+		ctx.deps.world.projection.discard();
+		ctx.deps.assets.sceneComing([]);
+		build.reject(error);
+		return;
+	}
+	build.resolve();
+}
+/**
+* The `signals` callback of a running build: counts the frame and commits the build the frame
+* every part of it is done. A world that stopped running live during the build (a walk that went
+* fast, as the restore of a repro walks its route, or a pause) skips its `layout` phase, so `ui`
+* would never lay the coming scene out: the build is given up and the scene mounted in one block,
+* as a switch in that mode is. While the build is not done, a counter step and two calls, no
+* allocation.
+*
+* @param ctx - Domain context of the plugin.
+* @param build - The running build.
+*/
+function stepBuild(ctx, build) {
+	build.frames += 1;
+	const world = ctx.deps.world;
+	if (world.ecs.mode() !== "live") {
+		endBuild(ctx, build, "mount");
+		return;
+	}
+	if (world.projection.built()) endBuild(ctx, build, "commit");
+}
+/**
+* Drops the running build on an abort of its node (a restore, the inbox, a stop of the runner):
+* the world despawns what the build made, the coming bundles are held no more, and the switch
+* returns with the old scene current. The layers, the scene of the world, the named bundles and
+* the mounted projections were never touched. The commit and a stop remove this listener first.
+*
+* @param ctx - Domain context of the plugin.
+* @param build - The build of the aborted node.
+*/
+function abortBuild(ctx, build) {
+	build.off();
+	delete ctx.state.build;
+	ctx.deps.world.projection.discard();
+	ctx.deps.assets.sceneComing([]);
+	build.resolve();
+}
+/**
+* Creates the record of a build that starts now, its listeners not registered yet.
+*
+* @param ctx - Domain context of the plugin.
+* @param scene - The scene being built.
+* @param named - The bundles it names, as they were awaited.
+* @param budgetMs - The building budget of a frame the world was given.
+* @param settle - The callbacks of the switch's promise.
+* @param settle.resolve - Settles the switch.
+* @param settle.reject - Rejects the switch.
+* @returns The record, at frame 0, with no listeners to remove.
+*/
+function startBuildRecord(ctx, scene, named, budgetMs, settle) {
+	return {
+		scene,
+		named,
+		from: ctx.state.current,
+		frames: 0,
+		budgetMs,
+		startedAt: agentNow(ctx),
+		off: noListeners,
+		resolve: settle.resolve,
+		reject: settle.reject
+	};
+}
+/**
+* Registers the listeners of a running build: the `signals` callback that asks every frame
+* whether it is done, and the abort of its node, which discards it. `build.off` removes both; the
+* build becomes the plugin's running one.
+*
+* @param ctx - Domain context of the plugin.
+* @param build - The build that starts waiting for its frames.
+* @param signal - The abort signal of the node, not aborted.
+*/
+function watchBuild(ctx, build, signal) {
+	const onAbort = () => abortBuild(ctx, build);
+	const offFrame = ctx.deps.time.onFrame("signals", () => stepBuild(ctx, build));
+	signal.addEventListener("abort", onAbort, { once: true });
+	build.off = () => {
+		offFrame();
+		signal.removeEventListener("abort", onAbort);
+	};
+	ctx.state.build = build;
+}
+/**
+* Starts the build of a scene aside and answers the promise of the switch. The world mounts what
+* only the coming scene lists, against the committed state, and gets the budget of a frame
+* (`budgetOf`); the coming bundles are held from now.
+* When nothing is left for `ui` and the renderer the commit runs at once, with no frame between.
+* Otherwise a `signals` callback asks every frame whether the build is done, and an abort of the
+* node discards it.
+*
+* @param ctx - Domain context of the plugin.
+* @param scene - The scene whose bundles are there.
+* @param named - The bundles it names, as they were awaited.
+* @param signal - The abort signal of the node, not aborted.
+* @returns The promise of the switch, settled at the commit or the abort; `undefined` when the
+*   world refused to build (a listed projection is mounted under other layer rules), so the
+*   caller switches in one block.
+* @throws {Error} Whatever `world.projection.build` threw: a `view`, an unknown projection or an
+*   undeclared layer. Nothing is built then.
+*/
+function buildAside(ctx, scene, named, signal) {
+	const projection = ctx.deps.world.projection;
+	const budgetMs = budgetOf(ctx);
+	if (!projection.build(scene.projections, ctx.state.owner, scene.layers, budgetMs)) return void 0;
+	ctx.deps.assets.sceneComing(named);
+	if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) {
+		const from = ctx.state.current;
+		ctx.deps.renderer.monitor.event("scene:build", {
+			from: from ?? null,
+			to: scene.id
+		});
+	}
+	return new Promise((resolve, reject) => {
+		const build = startBuildRecord(ctx, scene, named, budgetMs, {
+			resolve,
+			reject
+		});
+		if (projection.built()) {
+			endBuild(ctx, build, "commit");
+			return;
+		}
+		watchBuild(ctx, build, signal);
+	});
+}
+/**
+* Drops a running build when the plugin stops: its frame callback and its abort listener go and
+* the switch returns. Nothing else is called: a teardown context may not call another plugin, and
+* `world.onStop` drops the build table with every entity.
+*
+* @param build - The running build, if any.
+*/
+function dropBuild(build) {
+	if (build === void 0) return;
+	build.off();
+	build.resolve();
+}
+//#endregion
+//#region src/plugins/scenes/switch.ts
+/**
+* A promise that resolves when the node was aborted. Already aborted resolves at once.
+*
+* @param signal - The abort signal of the node being entered.
+* @returns A promise that resolves on abort and never rejects.
+*/
+function whenAborted$1(signal) {
+	return new Promise((resolve) => {
+		if (signal.aborted) {
+			resolve();
+			return;
+		}
+		signal.addEventListener("abort", () => resolve(), { once: true });
 	});
 }
 /**
+* Waits for the textures of loaded bundles to reach the GPU, or for the abort. It never rejects:
+* a warm that fails (an unload during it) is logged and the switch goes on, its first draw
+* uploads as before. Headless, without a device or with `uploads: 0` the warms answer at once,
+* and textures already on the GPU are not waited for.
+*
+* @param ctx - Domain context of the plugin.
+* @param bundles - The bundles the scene being entered names, all of them loaded.
+* @param signal - The abort signal of the node.
+* @returns A promise that resolves when every warm settled or the node was aborted.
+*/
+async function untilWarmed(ctx, bundles, signal) {
+	const warms = bundles.map((bundle) => ctx.deps.assets.warm(bundle).catch((error) => {
+		ctx.log.warn("scenes: a bundle's textures were not uploaded before the switch", {
+			bundle,
+			error
+		});
+	}));
+	await Promise.race([Promise.all(warms), whenAborted$1(signal)]);
+}
+/**
+* Loads every bundle the scene names at once and returns as soon as all loads settled or the node
+* is aborted. The first load that fails while the node still runs is rethrown, so `flow` rolls
+* the node back; one that fails after the abort is logged, because nobody waits for it any more.
+*
+* @param ctx - Domain context of the plugin.
+* @param bundles - The bundles the scene being entered names, its own bundle first.
+* @param signal - The abort signal of the node.
+* @returns A promise that resolves when the loads settled or the node was aborted.
+* @throws {Error} Whatever the first failed load rejected with, while the node was not aborted.
+*/
+async function untilAborted(ctx, bundles, signal) {
+	const load = {
+		failed: false,
+		error: void 0
+	};
+	const loads = bundles.map((bundle) => ctx.deps.assets.load(bundle).catch((error) => {
+		if (!load.failed) {
+			load.failed = true;
+			load.error = error;
+		}
+		if (signal.aborted) ctx.log.warn("scenes: a cancelled bundle load failed", {
+			bundle,
+			error
+		});
+	}));
+	await Promise.race([Promise.all(loads), whenAborted$1(signal)]);
+	if (load.failed && !signal.aborted) throw load.error;
+}
+/**
+* Reads the committed state a scene's `bundles` gets: the frozen trees of the store, in a frozen
+* wrapper. During the scene stage no node writes, so it is the state the node is entered with.
+*
+* @param ctx - Domain context of the plugin.
+* @returns The committed `player` and `session`.
+*/
+function committedState(ctx) {
+	const { player, session } = ctx.deps.model.store.snapshot();
+	return Object.freeze({
+		player,
+		session
+	});
+}
+/**
+* Tells whether two lists name the same bundles in the same order.
+*
+* @param left - One list.
+* @param right - The other list.
+* @returns True when both have the same names at the same places.
+* @example
+* ```ts
+* sameNames(["location", "ep01"], ["location", "ep02"]); // false
+* ```
+*/
+function sameNames(left, right) {
+	return left.length === right.length && left.every((name, index) => name === right[index]);
+}
+/**
+* Takes the expected scene and clears the record, so one `expect` mounts one scene.
+*
+* @param ctx - Domain context of the plugin.
+* @returns The scene id that was recorded or expected, or `undefined` when there was none.
+*/
+function takePending(ctx) {
+	const target = ctx.state.pending;
+	ctx.state.pending = void 0;
+	return target;
+}
+/**
+* Tells whether the node is a transit node of a fast walk: the walk passes through it and builds
+* no scene there.
+*
+* @param node - The node being entered.
+* @param run - The runner's mode and signal.
+* @returns True for a node without `rest` entered in fast mode.
+*/
+function isFastTransit(node, run) {
+	return run.mode === "fast" && !node.rest;
+}
+/**
+* Reads the scene the node asks for. In fast mode a transit node only records it: the walk passes
+* through many of them and the picture is built once, at the rest point. In live mode a transit
+* node without a scene of its own takes the expected one, so a restore at a popup that waits for
+* its answer builds the scene under it; one with its own scene leaves the record alone.
+*
+* @param ctx - Domain context of the plugin.
+* @param node - The node being entered.
+* @param run - The runner's mode and signal.
+* @returns The scene id to switch to, or `undefined` when nothing has to happen.
+*/
+function targetOf(ctx, node, run) {
+	const state = ctx.state;
+	if (isFastTransit(node, run)) {
+		state.pending = node.scene ?? state.pending;
+		return;
+	}
+	if (!node.rest) return node.scene ?? takePending(ctx);
+	const target = node.scene ?? state.pending;
+	state.pending = void 0;
+	if (target === void 0 && state.current === void 0) ctx.log.warn("scenes: a rest node was entered with no scene", { path: node.path });
+	return target;
+}
+/**
+* Reads the scene an `over` node asks for. An over node takes the expected scene and clears the
+* record, whatever is mounted, so a restore at a popup builds the scene under it, whether the
+* popup rests or waits for its answer. With nothing expected it switches nothing. In fast mode an
+* over transit node takes nothing and leaves the record alone: a walk builds no scene on the way.
+* A scene the over node names itself is only warned about.
+*
+* @param ctx - Domain context of the plugin.
+* @param node - The over node being entered.
+* @param run - The runner's mode and signal.
+* @returns The expected scene id, or `undefined` when nothing has to happen.
+*/
+function overTargetOf(ctx, node, run) {
+	if (node.scene !== void 0) ctx.log.warn("scenes: an over node cannot name a scene", { path: node.path });
+	if (isFastTransit(node, run)) return void 0;
+	return takePending(ctx);
+}
+/**
+* Tells whether a switch builds the next scene aside: a live switch while the world runs live and
+* the renderer draws. A fast walk (a restore, a test walk) and a renderer without a device build
+* in one block, as a walk or a headless app sees no frame between. So does a node entered live
+* while the world runs fast or paused by now: a restore of a repro enters its node live and walks
+* fast from there, and a world that skips its `layout` phase never lays the coming scene out.
+*
+* @param ctx - Domain context of the plugin.
+* @param run - The runner's mode and signal.
+* @returns True when the switch builds aside.
+*/
+function buildsAside(ctx, run) {
+	return run.mode === "live" && ctx.deps.world.ecs.mode() === "live" && ctx.deps.renderer.host.ready();
+}
+/**
+* Builds the scene: aside on a live switch with a drawing renderer, resolving at the commit or
+* the abort; in one block otherwise, and when the world refuses to build it aside because a
+* projection both scenes list is declared on other layer rules (named in a dev build).
+*
+* @param ctx - Domain context of the plugin.
+* @param scene - The scene whose bundles are there.
+* @param named - The bundles the scene names, as they were awaited.
+* @param run - The runner's mode and signal, not aborted.
+* @returns A promise that resolves once the scene stands, or the node was aborted.
+* @throws {Error} Whatever the mount or the build threw: a `view` or an unknown projection.
+*/
+async function standUp(ctx, scene, named, run) {
+	if (buildsAside(ctx, run)) {
+		const building = buildAside(ctx, scene, named, run.signal);
+		if (building !== void 0) {
+			await building;
+			return;
+		}
+		if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__) ctx.log.warn("scenes:build-skipped", {
+			scene: scene.id,
+			from: ctx.state.current,
+			projections: scene.projections
+		});
+	}
+	swapIn(ctx, scene, named);
+}
+/**
 * Switches to another scene: it reads what the scene names from the committed state, awaits all
 * of it and only then builds the scene. In live mode it waits between the two for the textures of
 * those bundles to reach the GPU; a fast walk does not, so tests and restores keep their pace. An
-* aborted node, or a plugin stopped during the wait, returns without touching anything.
+* aborted node, or a plugin stopped during the wait, returns without touching anything. A live
+* switch with a drawing renderer resolves at the commit of the scene built aside, frames later.
 *
 * @param ctx - Domain context of the plugin.
 * @param target - Id of the scene to mount.
@@ -37980,7 +38909,7 @@ async function switchTo(ctx, target, run) {
 	if (run.mode === "live" && !run.signal.aborted) await untilWarmed(ctx, named, run.signal);
 	const stopped = ctx.state.teardown === void 0;
 	if (run.signal.aborted || stopped) return;
-	apply(ctx, scene, named);
+	await standUp(ctx, scene, named, run);
 }
 /**
 * Reads again what the mounted scene names, at a node that keeps it: a bundle it names now and
@@ -38016,8 +38945,8 @@ async function reread(ctx, run) {
 * @param run - The runner's mode and signal.
 * @returns A promise that resolves once the scene stands, or at once when nothing changed.
 * @throws {Error} For a scene id no feature declared, and for a `bundles` that throws or returns
-*   something that is not a list of names. A failed load and a failed `mount` also reject, so
-*   `flow` rolls the node back with the old scene still mounted.
+*   something that is not a list of names. A failed load, a failed `mount` and a build whose
+*   `view` throws also reject, so `flow` rolls the node back with the old scene still mounted.
 */
 async function enterScene(ctx, node, run) {
 	const target = node.over ? overTargetOf(ctx, node, run) : targetOf(ctx, node, run);
@@ -38031,8 +38960,9 @@ async function enterScene(ctx, node, run) {
 //#endregion
 //#region src/plugins/scenes/lifecycle.ts
 /**
-* @file scenes plugin — lifecycle: the scenes read out of the feature descriptions in `onStart`,
-* the one `onEnter` registration, and the teardown that removes exactly that registration.
+* @file scenes plugin — lifecycle: the config checked in `onInit`, the scenes read out of the
+* feature descriptions in `onStart`, the one `onEnter` registration, and the teardown that removes
+* exactly that registration.
 */
 /**
 * Resolves the dependency APIs `flow`, `world`, `assets`, `time`, `model` and `renderer` with
@@ -38093,6 +39023,20 @@ function readScenes(ctx) {
 	}
 }
 /**
+* Refuses a building budget a frame cannot count down, in `onInit`, so `createApp` throws: neither
+* `"auto"` nor a finite number above 0. A game written in plain JS passes anything, so the config
+* is a boundary.
+*
+* @param config - The resolved config of the plugin.
+* @throws {Error} When `buildMs` is neither `"auto"` nor a finite number above 0.
+*/
+function checkConfig(config) {
+	const value = config.buildMs;
+	if (value === "auto") return;
+	if (isPositiveFinite(value)) return;
+	throw new Error(`[game] scenes.buildMs is ${String(value)}.\n  Give "auto" or the milliseconds a frame may spend on the next scene, a finite number above 0 such as 4.`);
+}
+/**
 * Starts the plugin in `onStart`: it collects the scenes of the features and registers the one
 * callback that switches them, on the `scene` stage of entering a node.
 *
@@ -38111,8 +39055,9 @@ function startScenes(ctx) {
 }
 /**
 * Removes the `onEnter` callback in `onStop` and forgets every scene and the bundles the mounted
-* one named. Nothing is unmounted: a
-* teardown context may not call another plugin, and `world.onStop` clears every entity anyway.
+* one named. A running build loses its frame callback and its switch returns. Nothing is unmounted
+* or discarded: a teardown context may not call another plugin, and `world.onStop` clears every
+* entity and the build table anyway.
 *
 * @param teardown - What the teardown context carries.
 * @param teardown.state - The plugin state.
@@ -38126,6 +39071,8 @@ function stopScenes(teardown) {
 	const state = teardown.state;
 	state.teardown?.();
 	state.teardown = void 0;
+	dropBuild(state.build);
+	delete state.build;
 	state.scenes.clear();
 	state.current = void 0;
 	state.pending = void 0;
@@ -38170,8 +39117,6 @@ function createScenesState() {
 		teardown: void 0
 	};
 }
-//#endregion
-//#region src/plugins/scenes/index.ts
 /**
 * Scenes plugin: `app.scenes.current()`, and `defineScene` for the game.
 *
@@ -38193,6 +39138,9 @@ function createScenesState() {
 *   layers: { room: {} },
 *   projections: [wardRoom]
 * });
+*
+* // A game gives the next scene a fixed 3 ms of each frame (half of it by default) while the old one stays on the screen.
+* createApp({ plugins: [...screen, boardFeature], pluginConfigs: { scenes: { buildMs: 3 } } });
 * ```
 */
 const scenesPlugin = /*#__PURE__*/ createPlugin$1("scenes", {
@@ -38204,9 +39152,11 @@ const scenesPlugin = /*#__PURE__*/ createPlugin$1("scenes", {
 		modelPlugin,
 		rendererPlugin
 	],
+	config: { buildMs: "auto" },
 	events: (register) => register.map({ "scenes:changed": "The mounted scene changed" }),
 	createState: createScenesState,
 	api: createScenesApi,
+	onInit: ({ config }) => checkConfig(config),
 	onStart: startScenes,
 	onStop: ({ state }) => stopScenes({ state })
 });
@@ -52473,6 +53423,9 @@ function ownerOf(state, name) {
 /**
 * Gives the host as parent to every view of one projection that has no parent and is not held
 * by a drag. The parent is queued while the phase runs, so ownership is decided by name first.
+* A host of the scene `world` builds aside takes only the views of that build, and a live host
+* none of them, until the swap (spec 31): a live view under a hidden host would vanish from the
+* screen, a coming one under a live host would be drawn before its scene.
 *
 * @param ctx - Domain context of the ui plugin.
 * @param state - The jsx state.
@@ -52481,8 +53434,10 @@ function ownerOf(state, name) {
 */
 function parentViews(ctx, state, name, host) {
 	const ecs = ctx.deps.world.ecs;
-	for (const view of ctx.deps.world.projection.entitiesOf(name)) {
-		if (ecs.has(view, Held)) continue;
+	const projection = ctx.deps.world.projection;
+	const aside = projection.isBuilding(host);
+	for (const view of projection.entitiesOf(name)) {
+		if (ecs.has(view, Held) || projection.isBuilding(view) !== aside) continue;
 		if (ecs.has(view, Parent) && !state.released.has(view)) continue;
 		ecs.add(view, Parent({ entity: host }));
 		state.hosted.set(view, host);
@@ -52604,17 +53559,21 @@ function keptSlot(state, root) {
 }
 /**
 * Tells whether a host element may take a root as its slot: it names the root's projection, it is
-* not leaving, and it is not an element of that root itself.
+* not leaving, it is not an element of that root itself, and both stand on the same side of a
+* scene build (spec 31): a root built aside never takes a slot in a live root of the old scene,
+* and a live root none in a root built aside. A kept host takes its coming guest after the swap.
 *
 * @param state - The jsx state.
 * @param root - The root.
 * @param host - An entity of the host set.
+* @param isAside - Whether an entity belongs to the scene `world` builds aside.
 * @returns The host element, or `undefined` when it cannot take the root.
 */
-function slotFor(state, root, host) {
+function slotFor(state, root, host, isAside) {
 	const element = state.elements.get(host);
 	if (element === void 0 || state.exiting.has(host) || element.root === root.entity) return;
-	return hostsOf(element.node).includes(root.name) ? element : void 0;
+	if (!hostsOf(element.node).includes(root.name)) return void 0;
+	return isAside(element.root) === isAside(root.entity) ? element : void 0;
 }
 /**
 * The host element a root is laid out in (spec 16 U3.2). A popup root never is. A root keeps its
@@ -52623,13 +53582,14 @@ function slotFor(state, root, host) {
 *
 * @param state - The jsx state.
 * @param root - The root.
+* @param isAside - Whether an entity belongs to the scene `world` builds aside.
 * @returns The slot, or `undefined` for a root laid out on the viewport.
 */
-function slotOf$1(state, root) {
+function slotOf$1(state, root, isAside) {
 	if (root.popup !== void 0) return void 0;
 	const kept = keptSlot(state, root);
 	if (kept !== void 0) return kept;
-	for (const host of state.hosts) if (slotFor(state, root, host) !== void 0) return host;
+	for (const host of state.hosts) if (slotFor(state, root, host, isAside) !== void 0) return host;
 }
 /**
 * Where an element is drawn at rest, in root coordinates: its drawn rect (`visualRectOf`), and for
@@ -53059,7 +54019,8 @@ function createFields(ctx, links) {
 	}
 	/**
 	* Spawns the four parts of a field, each a child of the field: its pose, its `Parent`, its
-	* visual, in that order, as an element is spawned.
+	* visual, in that order, as an element is spawned. The parts of a field of a scene built aside
+	* are the build's too, as the field is: held with it and dropped by a discard (spec 31).
 	*
 	* @param entity - The field entity.
 	* @param values - What the parts draw.
@@ -53067,15 +54028,22 @@ function createFields(ctx, links) {
 	*/
 	function spawnParts(entity, values) {
 		const ecs = ctx.deps.world.ecs;
+		const projection = ctx.deps.world.projection;
 		const parent = Parent({ entity });
-		const box = (part) => ecs.spawn(UI_OWNER, [
+		const aside = projection.isBuilding(entity);
+		const spawn = (components) => {
+			const part = ecs.spawn(UI_OWNER, components);
+			if (aside) projection.adopt(part);
+			return part;
+		};
+		const box = (part) => spawn([
 			Transform(part.pose),
 			parent,
 			Shape(part.shape)
 		]);
 		return {
 			selection: box(values.selection),
-			text: ecs.spawn(UI_OWNER, [
+			text: spawn([
 				Transform(values.text.pose),
 				parent,
 				Text({
@@ -53806,18 +54774,20 @@ function nodeOf(state, element, resolvedOf, place) {
 /**
 * Every mounted root in the order a reader meets them: the popup roots first, the highest `Order`
 * of them first, then the projection roots in the layer order of the scene, and by their `Order`
-* inside one layer, bottom first, as they draw.
+* inside one layer, bottom first, as they draw. A root of the scene `world` builds aside is left
+* out until the swap: nothing of it is on the screen yet (spec 31).
 *
 * @param state - The jsx state.
 * @param layers - The layer names of the scene, in draw order.
+* @param isAside - Whether an entity belongs to the scene built aside; none leaves no root out.
 * @returns The roots, sorted.
 * @example
 * ```ts
 * sortedRoots({ roots: new Map() } as unknown as JsxState, ["ui"]); // []
 * ```
 */
-function sortedRoots(state, layers) {
-	const roots = [...state.roots.values()];
+function sortedRoots(state, layers, isAside) {
+	const roots = [...state.roots.values()].filter((root) => isAside === void 0 || !isAside(root.entity));
 	const popups = roots.filter((root) => root.popup !== void 0);
 	const screens = roots.filter((root) => root.popup === void 0);
 	const indexOf = (root) => {
@@ -53842,22 +54812,24 @@ function placeOf(root, slotPose) {
 	return (rect) => drawnRect(pose, rect);
 }
 /**
-* Reads every mounted root, popups first, then the projection roots in layer order. The rects of a
-* root laid out in a slot are reported in root coordinates, through the root pose of its slot.
+* Reads every mounted root, popups first, then the projection roots in layer order, and none of the
+* scene `world` builds aside. The rects of a root laid out in a slot are reported in root
+* coordinates, through the root pose of its slot.
 *
 * @param state - The jsx state.
 * @param layers - The layer names of the scene, in draw order.
 * @param resolvedOf - Reads the string `text` resolved for an entity; none in a read without a world.
 * @param slotPose - The root pose of a slot, `rootPoseOf` of `renderer`; none in a read without a world.
+* @param isAside - Whether an entity belongs to the scene `world` builds aside: such a root is not read.
 * @returns One root node, or every root under a `screen` node.
 * @example
 * ```ts
 * readTree({ roots: new Map(), elements: new Map() } as unknown as JsxState).type; // "screen"
 * ```
 */
-function readTree(state, layers = [], resolvedOf, slotPose) {
+function readTree(state, layers = [], resolvedOf, slotPose, isAside) {
 	const nodes = [];
-	for (const root of sortedRoots(state, layers)) {
+	for (const root of sortedRoots(state, layers, isAside)) {
 		const element = root.element === void 0 ? void 0 : state.elements.get(root.element);
 		if (element !== void 0) nodes.push(nodeOf(state, element, resolvedOf, placeOf(root, slotPose)));
 	}
@@ -53900,15 +54872,17 @@ function readingOrder(first, second) {
 /**
 * The root the keyboard works in: the first uncovered popup in reader order, else the last screen
 * root, the one in the top layer. A root of the HUD layer never takes it: the HUD draws above every
-* overlay, so the top sheet under it does. A root on its way out does not count.
+* overlay, so the top sheet under it does. A root on its way out does not count, nor one of the
+* scene `world` builds aside: nothing of it is on the screen before the swap.
 *
 * @param state - The jsx state.
 * @param layers - The layer names of the scene, in draw order.
 * @param hud - The name of the scene's HUD layer (`above: "overlays"`), none without one.
+* @param isAside - Whether an entity belongs to the scene built aside; none leaves no root out.
 * @returns The root, or `undefined` when nothing is mounted.
 */
-function focusRoot(state, layers, hud) {
-	const roots = sortedRoots(state, layers).filter((root) => root.element !== void 0 && !state.removing.has(root.entity));
+function focusRoot(state, layers, hud, isAside) {
+	const roots = sortedRoots(state, layers, isAside).filter((root) => root.element !== void 0 && !state.removing.has(root.entity));
 	return roots.find((root) => root.popup !== void 0 && !root.covered) ?? roots.findLast((root) => root.popup === void 0 && root.layer !== hud);
 }
 /**
@@ -54368,7 +55342,8 @@ function zIndexOnRoot(element) {
 	};
 }
 /**
-* Runs the six rules over every live element.
+* Runs the six rules over every live element on the screen: an element of a root `world` builds
+* aside is not on it before the swap (spec 31).
 *
 * @param ctx - Domain context of the ui plugin.
 * @returns One finding per rule and element, in element order.
@@ -54377,7 +55352,7 @@ function runLint(ctx) {
 	const findings = [];
 	const scale = ctx.deps.renderer.viewport.size().scale;
 	for (const element of ctx.state.jsx.elements.values()) {
-		if (!element.live) continue;
+		if (!element.live || ctx.deps.world.projection.isBuilding(element.root)) continue;
 		for (const finding of [
 			tapTarget(ctx, element, scale),
 			textOverflow(ctx, element),
@@ -56542,6 +57517,8 @@ function createReconciler(ctx, modules, fields) {
 	let slotsRoots = -1;
 	let placedUnder;
 	let rendered = 0;
+	const isAside = (entity) => ctx.deps.world.projection.isBuilding(entity);
+	let released = false;
 	/**
 	* Registers the key of an element under its root, so `entityOf` and `find` answer for it. A key
 	* `ui` gave a node of its own, a spacer's, is never registered.
@@ -56570,7 +57547,9 @@ function createReconciler(ctx, modules, fields) {
 		return range.rowStyle(parent, node, modules.styles.resolveElement(styleOf(node), is));
 	}
 	/**
-	* Creates one element and its subtree.
+	* Creates one element and its subtree. An element of a root built aside is marked as the build's
+	* right after its spawn, before `applyFirst` gives it a visual: the renderer holds its view, and a
+	* discard takes it with the rest (spec 31).
 	*
 	* @param root - The root being reconciled.
 	* @param parent - The parent element, or nothing for a root element.
@@ -56583,6 +57562,7 @@ function createReconciler(ctx, modules, fields) {
 	function enter(root, parent, node, identity, instance, index) {
 		checkTag(node);
 		const entity = ecs.spawn(UI_OWNER, []);
+		if (isAside(root.entity)) ctx.deps.world.projection.adopt(entity);
 		const is = isFlagsOf(node, {
 			pressed: false,
 			hover: false,
@@ -57032,13 +58012,18 @@ function createReconciler(ctx, modules, fields) {
 		root.needsSolve = true;
 	}
 	/**
-	* Starts the exit of an element and of everything under it.
+	* Starts the exit of an element and of everything under it. An element of a root built aside was
+	* never seen: it goes at once, with no exit (spec 31).
 	*
 	* @param element - The element that left the description.
 	* @param cause - Why it leaves: `"change"` for a commit, `"mount"` when it goes with its screen.
 	* @param leads - The element is the top of a root that goes with its screen.
 	*/
 	function exitElement(element, cause, leads = false) {
+		if (isAside(element.root)) {
+			dropElement(element);
+			return;
+		}
 		forgetSubtree(element);
 		forgetInstances(state, element.identity);
 		state.exiting.add(element.entity);
@@ -57128,6 +58113,17 @@ function createReconciler(ctx, modules, fields) {
 		ecs.despawn(element.entity);
 	}
 	/**
+	* Drops an element and everything under it at once, with no exit: its identity, its key and the
+	* local state of its components are forgotten, its nodes freed and its entities despawned.
+	*
+	* @param element - An element of a root built aside that leaves before the swap.
+	*/
+	function dropElement(element) {
+		forgetSubtree(element);
+		forgetInstances(state, element.identity);
+		despawnTree(element);
+	}
+	/**
 	* Despawns every exiting element whose motions finished, and closes a popup whose root is gone.
 	*/
 	function sweep() {
@@ -57291,7 +58287,7 @@ function createReconciler(ctx, modules, fields) {
 	*/
 	function warnTaken(root, slot) {
 		for (const host of state.hosts) {
-			const element = host === slot ? void 0 : slotFor(state, root, host);
+			const element = host === slot ? void 0 : slotFor(state, root, host, isAside);
 			const once = `slot-taken:${root.name}`;
 			if (element === void 0 || element.warned.has(once)) continue;
 			element.warned.add(once);
@@ -57323,7 +58319,7 @@ function createReconciler(ctx, modules, fields) {
 		slotsRoots = state.roots.size;
 		for (const root of state.roots.values()) {
 			if (state.removing.has(root.entity)) continue;
-			const slot = isCyclic(root) ? void 0 : slotOf$1(state, root);
+			const slot = isCyclic(root) ? void 0 : slotOf$1(state, root, isAside);
 			if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ && slot !== void 0) warnTaken(root, slot);
 			if (slot === root.slot) continue;
 			root.slot = slot;
@@ -57458,7 +58454,9 @@ function createReconciler(ctx, modules, fields) {
 	* Keeps an element whose spawn has just been applied: the world calls it from the `Box` hook, at
 	* the flush of phase `layout`. Its enter hook waits for `playEntered`, so the game's systems see
 	* the entity first (F48). The hook itself plays at once, so they see the start pose it writes (F49);
-	* `ui.enter` plays it again when one of them changed what it read.
+	* `ui.enter` plays it again when one of them changed what it read. An element of a scene built
+	* aside plays nothing here: its enter waits for the swap, and `poseReleased` plays it at the same
+	* point of the swap frame (spec 31).
 	*
 	* @param entity - The entity the `Box` was attached to.
 	*/
@@ -57468,21 +58466,45 @@ function createReconciler(ctx, modules, fields) {
 		else entering.list.push(entity);
 		entering.count += 1;
 		const element = state.elements.get(entity);
-		if (arrives(element)) modules.layout.pose(element, overlayOf(element) === void 0 ? void 0 : createSpan());
+		if (arrives(element) && !isAside(entity)) modules.layout.pose(element, overlayOf(element) === void 0 ? void 0 : createSpan());
+	}
+	/**
+	* Plays the enter hooks of the elements a committed build released, at the end of the swap
+	* frame's solve, the point of the frame where a `Box` lands: the game's systems of `sync` see the
+	* start pose they write, as after a mount (F49), and `ui.enter` keeps the play or plays it again
+	* (F48). An element of a build still running, one that played already and a row a range change
+	* scrolled in play nothing here.
+	*/
+	function poseReleased() {
+		const entering = state.entering;
+		for (let index = 0; index < entering.count; index += 1) {
+			const entity = entering.list[index];
+			const element = entity === void 0 ? void 0 : state.elements.get(entity);
+			if (!arrives(element) || element.posed !== void 0 || isAside(element.entity)) continue;
+			modules.layout.pose(element, overlayOf(element) === void 0 ? void 0 : createSpan());
+		}
 	}
 	/**
 	* Plays the enter hooks queued since the last call, in the order the elements came. The `ui.enter`
 	* system calls it in phase `sync`: after the game's systems, which may have written what a hook
 	* reads (a list's scroll), and before `renderer.sync`, so an element is never drawn at its rest
-	* pose by mistake. An element despawned in between plays nothing.
+	* pose by mistake. An element despawned in between plays nothing. An element of a scene built
+	* aside stays queued, in its order, and plays in the first call after the swap (spec 31): its
+	* enter, posed by `poseReleased` in that frame's solve, its loop and the level of an overlay
+	* start in the frame the scene is first drawn.
 	*/
 	function playEntered() {
 		const entering = state.entering;
+		let held = 0;
 		for (let index = 0; index < entering.count; index += 1) {
 			const entity = entering.list[index];
-			if (entity !== void 0) playEnter(entity);
+			if (entity === void 0) continue;
+			if (isAside(entity)) {
+				entering.list[held] = entity;
+				held += 1;
+			} else playEnter(entity);
 		}
-		entering.count = 0;
+		entering.count = held;
 	}
 	/**
 	* Plays the enter hook of an element whose spawn has been applied, once. A row a range change
@@ -57623,13 +58645,22 @@ function createReconciler(ctx, modules, fields) {
 	/**
 	* Reconciles one dirty root: reads its current tree and projection name, then diffs it. The root
 	* stays dirty while the layout engine is not loaded, and a failure is logged for this root only.
+	* A root of the scene `world` builds aside is reconciled like any other and counted, so the
+	* reconcile after the swap finds it (spec 31).
 	*
 	* @param root - A root with work this frame.
 	*/
 	function reconcileDirtyRoot(root) {
+		if (root.aside === void 0 && isAside(root.entity)) {
+			root.aside = true;
+			state.asideRoots += 1;
+		}
 		const tree = ecs.get(root.entity, Tree);
 		const place = ctx.deps.world.projection.keyOf(root.entity);
-		if (place !== void 0) root.name = place.projection;
+		if (place !== void 0 && place.projection !== root.name) {
+			root.name = place.projection;
+			hostsMoved(state);
+		}
 		if (tree !== void 0) root.tree = tree.node;
 		refreshRootOrder(root);
 		root.dirty = !modules.layout.loaded();
@@ -57641,16 +58672,55 @@ function createReconciler(ctx, modules, fields) {
 		}
 	}
 	/**
-	* The first of the two systems of phase `layout`: the sweep, the roots a restore asked to build
-	* again, the roots a scene placed again, the popups that may leave, the pull of the text being
-	* typed, the scroll offsets and the windowed ranges, the bound texts that show a string of
-	* another size, the viewport, the dirty roots and the hosted views.
+	* Finds the roots the last scene build committed: a root counted aside that `world` builds no more
+	* loses its mark, the slots are given out again, so a kept host takes its coming guest in the
+	* swap frame, and this frame's solve poses the held enters (spec 31). A root a discard dropped is
+	* gone from the registry and is not counted.
+	*/
+	function settleAside() {
+		if (state.asideRoots === 0) return;
+		let left = 0;
+		let committed = false;
+		for (const root of state.roots.values()) {
+			if (root.aside === void 0) continue;
+			if (isAside(root.entity)) left += 1;
+			else {
+				delete root.aside;
+				committed = true;
+			}
+		}
+		state.asideRoots = left;
+		if (!committed) return;
+		hostsMoved(state);
+		released = true;
+	}
+	/**
+	* The part of a scene build `ui` does, which `world` asks through `onBuild` (spec 31): done when no
+	* root of the build is dirty (its tree not diffed yet, or the layout engine not loaded) and none
+	* waits for its solve. A root whose first diff threw has no element to solve and does not hold
+	* the swap.
+	*
+	* @returns True when every root built aside is reconciled and solved.
+	*/
+	function asideBuilt() {
+		for (const root of state.roots.values()) {
+			const solves = root.needsSolve && root.element !== void 0 && lookup(root.element) !== void 0;
+			if ((root.dirty || solves) && isAside(root.entity)) return false;
+		}
+		return true;
+	}
+	/**
+	* The first of the two systems of phase `layout`: the sweep, the roots a scene build committed, the
+	* roots a restore asked to build again, the roots a scene placed again, the popups that may leave,
+	* the pull of the text being typed, the scroll offsets and the windowed ranges, the bound texts
+	* that show a string of another size, the viewport, the dirty roots and the hosted views.
 	*
 	* @param time - The frame's `Time`: the scrolls move by its `delta`.
 	*/
 	function reconcile(time = NO_TIME) {
 		sweep();
 		state.reconciles += 1;
+		settleAside();
 		if (state.remount) remountRoots();
 		reorderRoots();
 		settlePopups(ctx, state, unmountRoot);
@@ -57690,7 +58760,8 @@ function createReconciler(ctx, modules, fields) {
 	* The second system of phase `layout`: every root takes its slot, then one solve per marked
 	* root, a root in a slot after the root of its slot and in its content box, then the rects, the
 	* rest poses and the hooks, the scrolls settled on what the solve and the render gave them, the
-	* hosting of the hosts that came, and a sweep of what left with nothing to wait for. The hints released since the last frame step are dropped
+	* hosting of the hosts that came, a sweep of what left with nothing to wait for, and, in the swap
+	* frame of a scene build, the start pose of the enters it held. The hints released since the last frame step are dropped
 	* at its end, so the `change.Box` and `change.Transform` hooks the solve plays get the hint the
 	* reconcile routed, and the next frame starts with none.
 	*
@@ -57711,6 +58782,10 @@ function createReconciler(ctx, modules, fields) {
 			state.risen.clear();
 		}
 		if (state.exiting.size > 0 || state.removing.size > 0) sweep();
+		if (released) {
+			released = false;
+			poseReleased();
+		}
 		state.hints.length = 0;
 		writeCounters();
 	}
@@ -57764,7 +58839,9 @@ function createReconciler(ctx, modules, fields) {
 	* nodes and despawns the root entity. A popup leaves by an event; a projection root leaves the
 	* way its view did, which the world still answers in its removal hook: `"mount"` with its scene,
 	* a load or a restore. A root that goes with its screen ends with the exit of its top element
-	* when that plays one, so a longer exit under it does not hold it and its bundles (F55).
+	* when that plays one, so a longer exit under it does not hold it and its bundles (F55). A root of
+	* a scene built aside was never seen: a discard (`"discard"`), or its key leaving before the swap,
+	* drops it at once with no exit (spec 31).
 	*
 	* @param entity - The root entity.
 	*/
@@ -57773,6 +58850,10 @@ function createReconciler(ctx, modules, fields) {
 		if (root === void 0 || state.removing.has(entity)) return;
 		const element = root.element === void 0 ? void 0 : lookup(root.element);
 		const cause = root.popup === void 0 ? ctx.deps.world.projection.causeOf(entity) ?? "change" : "change";
+		if (cause === "discard" || isAside(entity)) {
+			dropRoot(root, element);
+			return;
+		}
 		state.removing.add(entity);
 		hostsMoved(state);
 		if (element !== void 0) {
@@ -57782,6 +58863,20 @@ function createReconciler(ctx, modules, fields) {
 		ctx.deps.time.wake();
 	}
 	/**
+	* Drops a root of a scene built aside at once: its elements are forgotten and despawned with no
+	* exit, and the root leaves the registry. The world despawns the root entity itself: it is its
+	* view, on its way out.
+	*
+	* @param root - The root.
+	* @param element - Its root element, if it has one.
+	*/
+	function dropRoot(root, element) {
+		if (element !== void 0) dropElement(element);
+		state.roots.delete(root.entity);
+		state.byKey.delete(root.entity);
+		hostsMoved(state);
+	}
+	/**
 	* Re-resolves the style of one element whose pointer or focus flag changed: a press, a release,
 	* the mouse coming over it or leaving it, the keyboard focus arriving or leaving. A new rect
 	* waits for the solve; a new look and a new rest pose apply now. Only this element is restyled:
@@ -57818,7 +58913,8 @@ function createReconciler(ctx, modules, fields) {
 		queueEnter,
 		playEntered,
 		sweep,
-		converged
+		converged,
+		asideBuilt
 	};
 }
 //#endregion
@@ -57894,9 +58990,10 @@ function createJsxApi(ctx, modules) {
 	const state = ctx.state.jsx;
 	const sceneLayers = sceneLayersOf(ctx);
 	const layerNames = () => sceneLayers().names;
+	const isAside = (entity) => ctx.deps.world.projection.isBuilding(entity);
 	const topRoot = () => {
 		const scene = sceneLayers();
-		return focusRoot(state, scene.names, scene.hud);
+		return focusRoot(state, scene.names, scene.hud, isAside);
 	};
 	const fields = createFields(ctx, {
 		layout: modules.layout,
@@ -57907,13 +59004,13 @@ function createJsxApi(ctx, modules) {
 	const resolvedOf = (entity) => ctx.deps.world.ecs.get(entity, Text)?.resolved;
 	const lookup = (entity) => state.elements.get(entity);
 	const find = (key) => {
-		for (const root of sortedRoots(state, layerNames())) {
+		for (const root of sortedRoots(state, layerNames(), isAside)) {
 			const entity = state.byKey.get(root.entity)?.get(key);
 			if (entity !== void 0 && !state.exiting.has(entity)) return entity;
 		}
 	};
 	return {
-		tree: () => readTree(state, layerNames(), resolvedOf, (slot) => rootPoseOf(ctx.deps.world.ecs, slot)),
+		tree: () => readTree(state, layerNames(), resolvedOf, (slot) => rootPoseOf(ctx.deps.world.ecs, slot), isAside),
 		find,
 		lint: () => runLint(ctx),
 		fill: (key, value) => {
@@ -57974,6 +59071,7 @@ function createJsxApi(ctx, modules) {
 		queueEnter: frame.queueEnter,
 		playEntered: frame.playEntered,
 		converged: frame.converged,
+		asideBuilt: frame.asideBuilt,
 		key: (input) => focus.key(input),
 		blur: focus.blur
 	};
@@ -58262,6 +59360,18 @@ function writeRest(ctx, element, parent) {
 	if (visual !== void 0) projection.setRest(element.entity, visual.component, visual.value);
 }
 /**
+* Tells whether an element waits for the swap of a scene `world` builds aside (spec 31): it has not
+* entered, and it belongs to the build. Its hooks wait for its enter at the swap; a change before
+* it plays no motion and is written at once, so the enter starts from where it stands.
+*
+* @param ctx - Domain context of the ui plugin.
+* @param element - The element a hook would play on.
+* @returns True while its motions are held.
+*/
+function isHeld(ctx, element) {
+	return !element.entered && ctx.deps.world.projection.isBuilding(element.entity);
+}
+/**
 * Asks the projection for the handle of a ui-owned entity. A foreign owner is an error in the
 * log and the caller writes the value directly.
 *
@@ -58569,6 +59679,7 @@ function noteEndless(element, motion) {
 * Plays the `change` hook of one extra component whose fields changed. The motion the last change
 * of that name started is cancelled first, so its value stays where it is and the new motion
 * starts from there; the new motion is kept with the element's handles, so an exit waits for it.
+* An element held for the swap of a scene build plays none: the caller writes the fields.
 *
 * @param ctx - Domain context of the ui plugin.
 * @param element - The element that carries the extra.
@@ -58587,7 +59698,7 @@ function playExtraChange(ctx, element, name, values, hint) {
 		element.extraHandles.delete(name);
 	}
 	const hook = element.motion?.change?.[name];
-	if (hook === void 0) return false;
+	if (hook === void 0 || isHeld(ctx, element)) return false;
 	const motion = play(ctx, element, (view) => hook(view, values.previous, values.next, hint));
 	if (motion === void 0) return false;
 	element.extraHandles.set(name, motion);
@@ -58638,8 +59749,9 @@ function still(element) {
 * 0 ms rest track. That track writes the pose as it starts, so the pivot and the position land in
 * the same frame, and ends at the next frame step, where an additive loop re-bases on the new
 * rest. An element that has not spawned yet only records it, and so does one whose
-* `change.Box` motion already played. The content of a scroll keeps its `Transform` and records
-* no rest with the world: the scroll step owns it.
+* `change.Box` motion already played. An element held for the swap of a scene build takes the
+* pose at once, with no hook and no track (spec 31). The content of a scroll keeps its `Transform`
+* and records no rest with the world: the scroll step owns it.
 *
 * @param ctx - Domain context of the ui plugin.
 * @param element - The element whose rect, style or fit may have changed.
@@ -58655,6 +59767,13 @@ function repose(ctx, element, parent, hooked, hint) {
 	if (element.type === "content") return;
 	ctx.deps.world.projection.setRest(element.entity, Transform, next);
 	if (!element.live || hooked) return;
+	if (isHeld(ctx, element)) {
+		ctx.deps.world.ecs.set(element.entity, Transform, {
+			...next,
+			pivot: { ...next.pivot }
+		});
+		return;
+	}
 	const hook = element.motion?.change?.Transform;
 	if (hook !== void 0) {
 		play(ctx, element, (view) => hook(view, previous, next, hint));
@@ -60195,7 +61314,7 @@ function createLayoutApi(ctx) {
 		loop: (element) => startLoop(ctx, element),
 		change: (element, previous, hint) => {
 			const hook = element.motion?.change?.Box;
-			if (hook === void 0) return false;
+			if (hook === void 0 || isHeld(ctx, element)) return false;
 			play(ctx, element, (view) => hook(view, previous, element.rect, hint));
 			return true;
 		},
@@ -60771,8 +61890,9 @@ function registerComponents(ctx, jsx) {
 * step, the three tap listeners (the `LocalWrite` patch, the pointer tap that clears the keyboard
 * focus, and the tap that starts or ends the editing of a text field), the pointer door that opens
 * the keyboard inside the DOM listener, the key listener of the focus and `LocalWrite` as an input
-* control, so the cursor shows a hand over a local-state button. On an agent page also the tap
-* counter of `DebugTrigger` and its check of a view that takes no press.
+* control, so the cursor shows a hand over a local-state button, and `ui`'s part of a scene build
+* (`onBuild`: the roots built aside are reconciled and solved, spec 31). On an agent page also the
+* tap counter of `DebugTrigger` and its check of a view that takes no press.
 *
 * The `Box` hook plays an element's enter hook and queues it, so the game's systems see its start
 * pose (F49); `ui.enter` starts its loop after them and before the frame is drawn, and plays the
@@ -60804,7 +61924,7 @@ function openRegistrations(ctx, jsx, layout) {
 	})), ecs.onAdded(Tree, (entity) => {
 		const place = projection.keyOf(entity);
 		jsx.mountRoot(entity, place?.projection ?? "ui", ecs.get(entity, Layer)?.name ?? "ui");
-	}), ecs.onRemoved(Tree, (entity) => jsx.unmountRoot(entity)), ecs.onAdded(Box, (entity) => jsx.queueEnter(entity)), projection.onConverged(jsx.converged), ecs.onAdded(Pressed, (entity) => jsx.markPointer(entity, "pressed", true)), ecs.onRemoved(Pressed, (entity) => jsx.markPointer(entity, "pressed", false)), ecs.onAdded(PointerOver, (entity) => jsx.markPointer(entity, "hover", true)), ecs.onRemoved(PointerOver, (entity) => jsx.markPointer(entity, "hover", false)), ecs.onRemoved(Parent, () => hostsMoved(ctx.state.jsx)), ecs.onRemoved(Held, () => hostsMoved(ctx.state.jsx)), ctx.deps.flow.fx.handle("popup", layout.popupHandler(jsx)), ctx.deps.flow.fx.handle("guide", layout.guideHandler()), ctx.deps.flow.fx.onHint((hint) => {
+	}), ecs.onRemoved(Tree, (entity) => jsx.unmountRoot(entity)), ecs.onAdded(Box, (entity) => jsx.queueEnter(entity)), projection.onConverged(jsx.converged), projection.onBuild(jsx.asideBuilt), ecs.onAdded(Pressed, (entity) => jsx.markPointer(entity, "pressed", true)), ecs.onRemoved(Pressed, (entity) => jsx.markPointer(entity, "pressed", false)), ecs.onAdded(PointerOver, (entity) => jsx.markPointer(entity, "hover", true)), ecs.onRemoved(PointerOver, (entity) => jsx.markPointer(entity, "hover", false)), ecs.onRemoved(Parent, () => hostsMoved(ctx.state.jsx)), ecs.onRemoved(Held, () => hostsMoved(ctx.state.jsx)), ctx.deps.flow.fx.handle("popup", layout.popupHandler(jsx)), ctx.deps.flow.fx.handle("guide", layout.guideHandler()), ctx.deps.flow.fx.onHint((hint) => {
 		ctx.state.jsx.hints.push(hint);
 	}), ctx.deps.input.onTap(jsx.applyTap), ctx.deps.input.onTap(() => jsx.blur()), ctx.deps.input.onTap(jsx.tapped), ctx.deps.input.onPointer(jsx.pointer), ctx.deps.input.onKey(jsx.key), ctx.deps.input.controls.add(LocalWrite), () => jsx.releaseHosted(), () => ecs.despawnOwnedBy(UI_OWNER));
 	if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__) ctx.state.layout.cleanups.push(ctx.deps.input.onTap((entity) => debugTap(ctx, entity)), ecs.onAdded(DebugTrigger, (entity) => checkTrigger(ctx, entity)));
@@ -60863,6 +61983,7 @@ function stopUi(state) {
 	state.jsx.released.clear();
 	state.jsx.scrolls.clear();
 	state.jsx.remount = false;
+	state.jsx.asideRoots = 0;
 	state.jsx.hints.length = 0;
 	state.jsx.entering.list.length = 0;
 	state.jsx.entering.count = 0;
@@ -61253,7 +62374,8 @@ function createJsxState() {
 		written: 0,
 		debugTaps: [],
 		debugWarned: false,
-		overlays: emptySet()
+		overlays: emptySet(),
+		asideRoots: 0
 	};
 }
 //#endregion
@@ -62838,6 +63960,7 @@ function cubicBezier(x1, y1, x2, y2) {
 * | assets | preloadDepth | 2 |
 * | assets | baseUrl | undefined |
 * | assets | io | undefined, the browser fetch and the renderer textures |
+* | scenes | buildMs | "auto", half of a frame (500 / time.rate().fps), read at each build start; a number fixes it |
 * | anim | maxTracks | 2000 |
 * | anim | reducedMotion | false |
 * | i18n | locale | "en" |