@moku-labs/game 0.15.36 → 0.15.38

package/dist/{src-BPEIEsWH.mjs → src-B2vblgmb.mjs}

@@ -838,7 +838,7 @@ const BUSY = 4;
 /** The thermal rank from which the rule never steps up: `"moderate"` and every hotter status. */
 const HEAT_LIMIT_RANK = 2;
 /** Milliseconds in a second: turns a rate into the period of one frame. */
-const SECOND_MS$1 = 1e3;
+const SECOND_MS$2 = 1e3;
 /** Every choice `setRate` takes: `"auto"` and the three fixed rates. */
 const RATE_CHOICES = Object.freeze([
 	"auto",
@@ -1432,8 +1432,8 @@ function judgeFrame$1(ctx, g, intervalMs, at) {
 	const { fps } = ctx.state.rate;
 	const higher = stepAbove(g.ladder, fps);
 	const missed = intervalMs > missLineMs(fps, ctx.state.rate.display.hz ?? fps);
-	const heavy = higher !== void 0 && g.lastWorkMs > .5 * SECOND_MS$1 / higher;
-	const busy = missed && g.lastWorkMs > SECOND_MS$1 / fps;
+	const heavy = higher !== void 0 && g.lastWorkMs > .5 * SECOND_MS$2 / higher;
+	const busy = missed && g.lastWorkMs > SECOND_MS$2 / fps;
 	const slot = g.written % 512;
 	evict$2(g, at);
 	g.sampleAt[slot] = at;
@@ -9647,8 +9647,9 @@ function inertHandle() {
 	return INERT;
 }
 /**
-* The fields another writer owns on one component of one entity: the fields a running driver
-* holds, and the fields the component type gives to a plugin for good.
+* The fields another writer owns on one component of one entity: the fields a `mute()` holds and
+* the `initialOnly` fields of a view's projection (one table, `state.mutes`), and the fields the
+* component type gives to a plugin for good.
 *
 * @param pctx - Domain context of the projection module.
 * @param entity - The entity to ask about.
@@ -10803,6 +10804,221 @@ function routeHint(hints, projection, key) {
 	}
 }
 //#endregion
+//#region src/plugins/world/projection/mutes.ts
+/**
+* Tells a table `mute()` made apart from a shared `initialOnly` seed, which is frozen.
+*
+* @param table - A table of `state.mutes`.
+* @returns True when the table may be written.
+*/
+function isOwnTable(table) {
+	return !Object.isFrozen(table);
+}
+/**
+* Tells a field set `mute()` made apart from a set of a shared `initialOnly` seed, which is frozen.
+*
+* @param fields - A field set of one table.
+* @returns True when the set may be written.
+*/
+function isOwnFields(fields) {
+	return !Object.isFrozen(fields);
+}
+/**
+* The table a mute may write: the entity's own one, a copy of the seed it was born with, or a new one.
+*
+* @param stored - The table the entity has now, if any.
+* @returns A writable table.
+*/
+function ownTable(stored) {
+	if (stored === void 0) return /* @__PURE__ */ new Map();
+	return isOwnTable(stored) ? stored : new Map(stored);
+}
+/**
+* The field set a mute may write: the component's own one, a copy of its seed set, or a new one.
+*
+* @param stored - The field set the component has now, if any.
+* @returns A writable set.
+*/
+function ownFields(stored) {
+	if (stored === void 0) return /* @__PURE__ */ new Set();
+	return isOwnFields(stored) ? stored : new Set(stored);
+}
+/**
+* The `initialOnly` fields of one component of a view, from the spec of its projection.
+*
+* @param state - The projection branch of the plugin state.
+* @param entity - The entity of the view.
+* @param name - The component name.
+* @returns The seed set, or `undefined` for an entity that is no view of such a projection.
+*/
+function initialFieldsOf(state, entity, name) {
+	const projection = state.byEntity.get(entity)?.projection;
+	const spec = projection === void 0 ? void 0 : state.specs.get(projection);
+	return spec === void 0 ? void 0 : state.initialOnly.get(spec)?.get(name);
+}
+/**
+* Deletes a released field set once it is empty, and the entity's table once no component is
+* left. Only the table and the set this mute filled are touched, so a remover that runs after a
+* clear or a new birth on the same id never drops a newer mute.
+*
+* @param mutes - The mute tables of every entity.
+* @param entity - The muted entity.
+* @param table - The table the mute wrote.
+* @param name - The muted component's name.
+* @param owned - The field set the remover released from.
+*/
+function dropEmptyMute(mutes, entity, table, name, owned) {
+	if (owned.size > 0 || mutes.get(entity) !== table || table.get(name) !== owned) return;
+	table.delete(name);
+	if (table.size === 0) mutes.delete(entity);
+}
+/**
+* Hands fields of one component of one entity to another writer, until the remover runs. A view
+* born with an `initialOnly` seed gets its own copy first. The remover keeps the seed fields, asked
+* when it runs: a mute made inside the spawn came before the view was known.
+*
+* @param state - The projection branch of the plugin state.
+* @param entity - The entity.
+* @param name - The component name.
+* @param fields - The field names the caller owns.
+* @returns The remover; a no-op when called twice.
+*/
+function muteFields(state, entity, name, fields) {
+	const table = ownTable(state.mutes.get(entity));
+	const owned = ownFields(table.get(name));
+	for (const field of fields) owned.add(field);
+	forgetJoined(state, owned);
+	table.set(name, owned);
+	state.mutes.set(entity, table);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		const kept = initialFieldsOf(state, entity, name);
+		for (const field of fields) if (kept?.has(field) !== true) owned.delete(field);
+		forgetJoined(state, owned);
+		dropEmptyMute(state.mutes, entity, table, name, owned);
+	};
+}
+/**
+* Builds the frozen seed of a projection's `initialOnly` list: component name to its fields, a
+* component named twice with both lists joined.
+*
+* @param spec - The projection spec.
+* @param pairs - Its `initialOnly` list, not empty.
+* @returns The seed.
+* @throws {Error} For a pair with no field.
+*/
+function buildSeed(spec, pairs) {
+	const seed = /* @__PURE__ */ new Map();
+	for (const [component, fields] of pairs) {
+		const name = component.componentName;
+		if (fields.length === 0) throw new Error(`[game] Projection "${spec.name}" lists ${name} in initialOnly with no field.\n  Name the fields only the birth of a view writes, or drop the pair.`);
+		seed.set(name, Object.freeze(/* @__PURE__ */ new Set([...seed.get(name) ?? [], ...fields])));
+	}
+	return Object.freeze(seed);
+}
+/**
+* Checks the `initialOnly` list of a spec and keeps its seed: once per spec, since a name is
+* registered once and `replace` brings a new spec. A spec without the option, or with an empty
+* list, has none.
+*
+* @param state - The projection branch of the plugin state.
+* @param spec - The spec `register` or `replace` stores.
+* @returns The seed, or `undefined`.
+* @throws {Error} For a pair with no field; nothing is kept then.
+*/
+function learnSeed(state, spec) {
+	const pairs = spec.initialOnly;
+	if (pairs === void 0 || pairs.length === 0) return void 0;
+	const seed = buildSeed(spec, pairs);
+	state.initialOnly.set(spec, seed);
+	return seed;
+}
+/**
+* Joins a seed into a table of the entity's own, in place, so the remover of every mute that wrote
+* the table still holds its table and its sets: a component the table lacks gets the shared set
+* of the seed, the set a mute wrote gets the fields of the seed.
+*
+* @param state - The projection branch of the plugin state.
+* @param table - The entity's own table.
+* @param seed - The seed to join.
+*/
+function joinSeed(state, table, seed) {
+	for (const [name, fields] of seed) {
+		const stored = table.get(name);
+		if (stored === void 0) {
+			table.set(name, fields);
+			continue;
+		}
+		const owned = ownFields(stored);
+		for (const field of fields) owned.add(field);
+		forgetJoined(state, owned);
+		table.set(name, owned);
+	}
+}
+/**
+* Gives a view that was just born the seed of its projection, so from now on nothing of the
+* projection writes or compares those fields. The birth itself wrote them from `view`. A view a
+* listener of its spawn muted already keeps its table, and the seed joins it.
+*
+* @param state - The projection branch of the plugin state.
+* @param spec - The projection spec.
+* @param entity - The entity of the new view.
+*/
+function seedMutes(state, spec, entity) {
+	if (spec.initialOnly === void 0) return;
+	const seed = state.initialOnly.get(spec);
+	if (seed === void 0) return;
+	const stored = state.mutes.get(entity);
+	if (stored === void 0) {
+		state.mutes.set(entity, seed);
+		return;
+	}
+	const table = ownTable(stored);
+	joinSeed(state, table, seed);
+	state.mutes.set(entity, table);
+}
+/**
+* Moves a view with a table of its own from one seed to the next: a set of the old seed goes, the
+* new seed joins. A set a mute wrote keeps every field it holds, an old seed's field it copied too,
+* since the table does not say which mute named it. A table left empty goes.
+*
+* @param state - The projection branch of the plugin state.
+* @param entity - The entity of the view.
+* @param stored - The table the view has now, if any.
+* @param from - The seed of the old spec, if any.
+* @param to - The seed of the new spec, if any.
+*/
+function reseedOwn(state, entity, stored, from, to) {
+	const table = ownTable(stored);
+	for (const [name, fields] of from ?? []) if (table.get(name) === fields) table.delete(name);
+	if (to !== void 0) joinSeed(state, table, to);
+	if (table.size === 0) state.mutes.delete(entity);
+	else state.mutes.set(entity, table);
+}
+/**
+* Moves the views of a replaced projection from the seed of the old spec to the seed of the new
+* one. A view that holds the old seed, or none when the old spec had none, takes the new seed. A
+* view a `mute()` gave its own table keeps it: the sets of the old seed in it go, the new seed
+* joins it.
+*
+* @param state - The projection branch of the plugin state.
+* @param name - The projection name.
+* @param from - The seed of the old spec, if any.
+* @param to - The seed of the new spec, if any.
+*/
+function reseedViews(state, name, from, to) {
+	if (from === to) return;
+	for (const view of state.byEntity.values()) {
+		if (view.projection !== name) continue;
+		const stored = state.mutes.get(view.entity);
+		if (stored !== from) reseedOwn(state, view.entity, stored, from, to);
+		else if (to === void 0) state.mutes.delete(view.entity);
+		else state.mutes.set(view.entity, to);
+	}
+}
+//#endregion
 //#region src/plugins/world/projection/reconcile.ts
 /**
 * Creates the empty set of used hints. It lives in its own non-exported function because lint
@@ -10894,6 +11110,7 @@ function enterEntry(pctx, spec, mounted, entry) {
 	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;
+	seedMutes(state, spec, entity);
 	mounted.live.set(entry.key, view);
 	state.byEntity.set(entity, view);
 	state.membershipVersion += 1;
@@ -11739,39 +11956,6 @@ function isConvergeCause(cause) {
 	return cause === "load" || cause === "restore";
 }
 /**
-* Creates the empty mute table of one entity. It lives in its own non-exported function because
-* lint rule L5 refuses a collection built inside an exported declaration.
-*
-* @returns An empty table of component name to owned fields.
-*/
-function emptyMuteTable() {
-	return /* @__PURE__ */ new Map();
-}
-/**
-* Creates the empty field set of one muted component.
-*
-* @returns An empty set of field names.
-*/
-function emptyFieldSet() {
-	return /* @__PURE__ */ new Set();
-}
-/**
-* Deletes a released field set once it is empty, and the entity's table once no component is
-* left. Only the set and table still stored are touched, so a remover that runs after a clear
-* never drops a newer mute.
-*
-* @param mutes - The mute tables of every entity.
-* @param entity - The muted entity.
-* @param name - The muted component's name.
-* @param owned - The field set the remover released from.
-*/
-function dropEmptyMute(mutes, entity, name, owned) {
-	const byComponent = mutes.get(entity);
-	if (owned.size > 0 || byComponent?.get(name) !== owned) return;
-	byComponent.delete(name);
-	if (byComponent.size === 0) mutes.delete(entity);
-}
-/**
 * Creates the empty dirty record the next reconcile reads.
 *
 * @returns Nothing to reconcile yet.
@@ -11876,13 +12060,18 @@ function createProjectionApi(ctx, deps) {
 	return {
 		register: (spec) => {
 			if (state.specs.has(spec.name)) throw new Error(`[game] Projection "${spec.name}" is registered twice.\n  Give the second projection another name.`);
+			learnSeed(state, spec);
 			state.specs.set(spec.name, spec);
 		},
 		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 previous = state.specs.get(spec.name);
+			if (previous === void 0) 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(spec, state.layers);
+			const from = state.initialOnly.get(previous);
+			const seed = learnSeed(state, spec);
 			state.specs.set(spec.name, spec);
+			reseedViews(state, spec.name, from, seed);
 			if (mounted) forceRerun();
 		},
 		setLayers: (list) => {
@@ -11915,22 +12104,7 @@ function createProjectionApi(ctx, deps) {
 			playSettle(pctx, view, spec, restingPeers(mounted), looseComponents(pctx, view));
 			dropIfStill(pctx, view);
 		},
-		mute: (entity, component, fields) => {
-			const byComponent = state.mutes.get(entity) ?? emptyMuteTable();
-			const owned = byComponent.get(component.componentName) ?? emptyFieldSet();
-			for (const field of fields) owned.add(field);
-			forgetJoined(state, owned);
-			byComponent.set(component.componentName, owned);
-			state.mutes.set(entity, byComponent);
-			let released = false;
-			return () => {
-				if (released) return;
-				released = true;
-				for (const field of fields) owned.delete(field);
-				forgetJoined(state, owned);
-				dropEmptyMute(state.mutes, entity, component.componentName, owned);
-			};
-		},
+		mute: (entity, component, fields) => muteFields(state, entity, component.componentName, fields),
 		lift: (entity, on) => {
 			const view = state.byEntity.get(entity);
 			if (view === void 0) return;
@@ -12380,6 +12554,7 @@ function createProjectionState() {
 		keys: emptyMap$9(),
 		keysByEntity: emptyMap$9(),
 		mutes: emptyMap$9(),
+		initialOnly: emptyWeakMap$2(),
 		ownedSets: emptyWeakMap$2(),
 		joinedMutes: emptyWeakMap$2(),
 		converged: [],
@@ -29685,7 +29860,7 @@ function layerOf(sctx, entity) {
 //#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;
+const CLOCK_EVERY$1 = 8;
 /**
 * Tells whether a scene is being built: `left()` answers a finite number only while a build runs.
 *
@@ -29783,7 +29958,7 @@ function makeAside(sctx, report) {
 		made += makeParentFirst(sctx, entity, report);
 		if (made >= check) {
 			if (projection.left() <= 0) break;
-			check = made + CLOCK_EVERY;
+			check = made + CLOCK_EVERY$1;
 		}
 	}
 	if (aside.head >= aside.count) {
@@ -38719,10 +38894,12 @@ function swapIn(ctx, scene, named, build) {
 * `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;
+/** A second in ms: the frame interval is this over the frame rate. */
+const SECOND_MS$1 = 1e3;
+/** The share of a frame interval `"auto"` gives the building work: two thirds. */
+const BUILD_SHARE = 2 / 3;
+/** The budget of a frame when `time` answers no usable frame rate: two thirds of a 60 Hz frame, ≈ 11.1 ms. */
+const FALLBACK_BUDGET_MS = SECOND_MS$1 / 60 * BUILD_SHARE;
 /**
 * Tells whether a value is a number a frame can count with: finite and above 0. Pure.
 *
@@ -38752,8 +38929,8 @@ function agentNow(ctx) {
 }
 /**
 * 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.
+* for `"auto"` two thirds of the frame interval the loop runs at, `(1000 / time.rate().fps) * 2 / 3`,
+* read once here. A rate that is not a finite number above 0 gives two thirds of a 60 Hz frame.
 *
 * @param ctx - Domain context of the plugin.
 * @returns Milliseconds per frame the building work may take.
@@ -38762,7 +38939,7 @@ 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;
+	return isPositiveFinite(fps) ? SECOND_MS$1 / fps * BUILD_SHARE : FALLBACK_BUDGET_MS;
 }
 /**
 * Ends the build with the swap: its listeners go and the record is dropped, then the swap of a
@@ -39371,7 +39548,7 @@ function createScenesState() {
 *   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.
+* // A game gives the next scene a fixed 3 ms of each frame (two thirds of it by default) while the old one stays on the screen.
 * createApp({ plugins: [...screen, boardFeature], pluginConfigs: { scenes: { buildMs: 3 } } });
 * ```
 */
@@ -53712,7 +53889,9 @@ function dropHost(state, entity) {
 	if (state.hosts.delete(entity)) hostsMoved(state);
 }
 /**
-* The element of a host entity while it hosts: mounted, live and not leaving.
+* The element of a host entity while it hosts: mounted, live and not leaving. A host of a root
+* built aside that is applied in parts hosts nothing until the root is whole (spec 33 A7): the
+* last part gives it its views.
 *
 * @param state - The jsx state.
 * @param host - An entity of the host set.
@@ -53720,7 +53899,8 @@ function dropHost(state, entity) {
 */
 function liveHost(state, host) {
 	const element = state.elements.get(host);
-	return element === void 0 || !element.live || state.exiting.has(host) ? void 0 : element;
+	if (element === void 0 || !element.live || state.exiting.has(host)) return void 0;
+	return state.roots.get(element.root)?.applying === void 0 ? element : void 0;
 }
 /**
 * The host that owns the views of a projection: the first live host that names it. A view
@@ -55810,7 +55990,7 @@ function coveredByLive(state, root) {
 * @param root - A mounted root.
 * @returns True when the settle step has to look at it.
 */
-function waits(state, root) {
+function waits$1(state, root) {
 	return (root.popup?.released === true || root.covered) && !state.removing.has(root.entity);
 }
 /**
@@ -55821,7 +56001,7 @@ function waits(state, root) {
 * @returns True when at least one root waits.
 */
 function anyWaits(state) {
-	for (const root of state.roots.values()) if (waits(state, root)) return true;
+	for (const root of state.roots.values()) if (waits$1(state, root)) return true;
 	return false;
 }
 /**
@@ -55844,7 +56024,7 @@ function settlePopups(ctx, state, unmount) {
 * @param unmount - Starts the exit of a root.
 */
 function settleWaiting(ctx, state, unmount) {
-	const waiting = [...state.roots.values()].filter((root) => waits(state, root));
+	const waiting = [...state.roots.values()].filter((root) => waits$1(state, root));
 	const rests = flowRests(ctx.deps.flow.state());
 	waiting.sort((first, second) => second.order - first.order);
 	for (const root of waiting) {
@@ -57184,6 +57364,320 @@ function settleOverlays(ctx, state, layout) {
 	}
 }
 //#endregion
+//#region src/plugins/ui/jsx/parts.ts
+/**
+* How many elements a root built aside makes or applies in a frame between two reads of the
+* frame's budget, from the first read on (spec 33 A2, A6): the clock is read every 8 elements.
+*/
+const CLOCK_EVERY = 8;
+/**
+* The most elements of roots built aside one frame applies. The components `applyFirst` adds are
+* flushed after the system, where the budget does not see them: the cap keeps that flush short
+* (spec 33 A6; 275 elements in one frame took 3.6 ms in Node, about 15 ms on the A26).
+*/
+const APPLY_CAP = 100;
+/** What a parked part holds once it is back in the pool: no nodes and no element, so the pool keeps no tree alive. */
+const NO_NODES = [];
+/**
+* Tells whether a root has parked parts.
+*
+* @param root - The root.
+* @returns True while children of its elements wait.
+*/
+function hasParked(root) {
+	return (root.parked?.length ?? 0) > 0;
+}
+/**
+* Tells whether parts of a root built aside wait: children parked, or its application open.
+* Two field reads; false for every other root.
+*
+* @param root - The root, if it is still known.
+* @returns True while its build waits for a later frame.
+*/
+function waits(root) {
+	return root !== void 0 && (root.applying !== void 0 || hasParked(root));
+}
+/**
+* Builds the parts half of the reconcile: the park queue of each root built aside and the pools of
+* its parts, the drain of the queue, the hold of a dirty root, and the application in parts.
+*
+* @param ctx - Domain context of the ui plugin.
+* @param reconcile - The diff and the application the reconcile lends.
+* @returns The steps the reconcile calls.
+*/
+function createParts(ctx, reconcile) {
+	const state = ctx.state.jsx;
+	const lookup = (entity) => state.elements.get(entity);
+	let entered = 0;
+	let spent = false;
+	let unitRan = false;
+	let applied = 0;
+	let landed = false;
+	const parkedPool = [];
+	const cursorPool = [];
+	/**
+	* Starts the frame's reconcile: no element entered, the budget not read, no building unit run.
+	*/
+	function beginReconcile() {
+		entered = 0;
+		spent = false;
+		unitRan = false;
+	}
+	/**
+	* Starts the frame's solve: no element applied in parts, no application ended.
+	*/
+	function beginSolve() {
+		applied = 0;
+		landed = false;
+	}
+	/**
+	* Tells whether an application of a root built aside ended in this solve: its scrolls settle now.
+	*
+	* @returns True after the last part of an application.
+	*/
+	function hasLanded() {
+		return landed;
+	}
+	/**
+	* Tells whether the frame's building budget is spent, read once every `CLOCK_EVERY` units of
+	* work: a read of the clock costs more than a small unit.
+	*
+	* @param count - The units of work made in this frame so far.
+	* @returns True when the count is a reading point and no budget is left.
+	*/
+	function spentAt(count) {
+		return count > 0 && count % CLOCK_EVERY === 0 && ctx.deps.world.projection.left() <= 0;
+	}
+	/**
+	* Counts an element entered for a root built aside and tells whether its children wait for a
+	* later frame. From the 8th element of the frame the budget is read every 8; once it is spent,
+	* the children of every next element wait. A row a range change scrolls in never parks: the
+	* window moves in one block, as on a live root.
+	*
+	* @returns True when the children of the element wait.
+	*/
+	function parks() {
+		if (reconcile.isMoving()) return false;
+		entered += 1;
+		if (!spent) spent = spentAt(entered);
+		return spent;
+	}
+	/**
+	* Leaves the children of a new element of a root built aside for a later frame: the element
+	* itself exists, so the child list of its parent is complete. The part is queued behind the
+	* root's other parts, with the cause of the diff running now.
+	*
+	* @param root - The root built aside.
+	* @param element - The element that entered.
+	* @param nodes - The children it would have diffed.
+	* @param instance - The identity of the nearest component instance.
+	*/
+	function park(root, element, nodes, instance) {
+		const cause = state.building;
+		const part = parkedPool.pop() ?? {
+			element,
+			nodes,
+			instance,
+			cause
+		};
+		part.element = element;
+		part.nodes = nodes;
+		part.instance = instance;
+		part.cause = cause;
+		root.parked ??= [];
+		root.parked.push(part);
+	}
+	/**
+	* Puts a parked part back in the pool, its element and nodes dropped.
+	*
+	* @param part - A part that was diffed or forgotten.
+	*/
+	function recycle(part) {
+		part.element = void 0;
+		part.nodes = NO_NODES;
+		parkedPool.push(part);
+	}
+	/**
+	* Tells whether the next building unit may run in this frame: the first one always does, so a
+	* build always moves; a later one while the budget lasts.
+	*
+	* @returns True when the unit runs.
+	*/
+	function mayRun() {
+		return !unitRan || ctx.deps.world.projection.left() > 0;
+	}
+	/**
+	* Diffs one parked part under the cause it was parked with. A part whose element left meanwhile
+	* is dropped. A part that throws fails its root alone, as the root's own diff does.
+	*
+	* @param root - The root built aside.
+	* @param part - The part.
+	*/
+	function diffPart(root, part) {
+		const element = part.element;
+		if (element === void 0 || lookup(element.entity) !== element) return;
+		const cause = state.building;
+		unitRan = true;
+		state.building = part.cause;
+		try {
+			reconcile.diffChildren(root, element, part.nodes, part.instance);
+		} catch (error) {
+			ctx.log.error("ui:root-failed", { root: root.name }, asError(error));
+		} finally {
+			state.building = cause;
+		}
+		root.needsSolve = true;
+	}
+	/**
+	* Diffs the parked parts of the roots built aside, each root's in the order they were parked,
+	* while the frame's budget lasts (spec 33 A3). Children that park again go to the end of their
+	* root's queue.
+	*/
+	function drainParked() {
+		if (state.asideRoots === 0) return;
+		for (const root of state.roots.values()) {
+			const parked = root.parked;
+			while (parked !== void 0 && parked.length > 0) {
+				if (!mayRun()) return;
+				const part = parked.shift();
+				if (part === void 0) break;
+				diffPart(root, part);
+				recycle(part);
+			}
+		}
+	}
+	/**
+	* Holds a dirty root built aside for a later frame instead of diffing it now: while parked parts
+	* of it wait, so no element is made twice, and once the frame's budget is spent after its first
+	* building unit. It stays dirty: the next frame lists it again and diffs its newest tree once
+	* (spec 33 A1, A4). The drain runs before, until its queue is empty or the budget is spent, so a
+	* root with parked parts meets a spent budget here too. A live root is never held.
+	*
+	* @param root - A root with work this frame.
+	* @returns True when the root waits.
+	*/
+	function holdRoot(root) {
+		if (!ctx.deps.world.projection.isBuilding(root.entity)) return false;
+		if (hasParked(root) || !mayRun()) {
+			root.dirty = true;
+			return true;
+		}
+		unitRan = true;
+		return false;
+	}
+	/**
+	* Forgets the parked parts and the open application of a root whose build ends here: a drop, a
+	* discard, its exit or a restore.
+	*
+	* @param root - The root.
+	*/
+	function forgetParts(root) {
+		const parked = root.parked;
+		while (parked !== void 0 && parked.length > 0) {
+			const part = parked.pop();
+			if (part !== void 0) recycle(part);
+		}
+		const cursor = root.applying;
+		if (cursor === void 0) return;
+		while (cursor.stack.length > 0) cursor.stack.pop();
+		delete root.applying;
+		cursorPool.push(cursor);
+	}
+	/**
+	* Opens the application of a solved root built aside and applies its first part (spec 33 A6).
+	*
+	* @param root - The root built aside.
+	* @param element - Its root element.
+	* @param quiet - Whether its live elements take their rects with no motion.
+	*/
+	function applyInParts(root, element, quiet) {
+		const cursor = cursorPool.pop() ?? {
+			stack: [],
+			quiet
+		};
+		cursor.quiet = quiet;
+		cursor.stack.push(element);
+		root.applying = cursor;
+		applyPart(root, cursor);
+	}
+	/**
+	* Applies the next elements of an open application, top-down, parent before children in the
+	* order of `applyRects`, until the frame's budget is spent (read every 8 elements of the frame)
+	* or the frame applied `APPLY_CAP` elements of roots built aside. An element that left on the
+	* way is skipped. The last element closes the application.
+	*
+	* @param root - The root built aside.
+	* @param cursor - Its open application.
+	*/
+	function applyPart(root, cursor) {
+		const stack = cursor.stack;
+		while (stack.length > 0 && applied < APPLY_CAP) {
+			if (spentAt(applied)) return;
+			const element = stack.pop();
+			if (element === void 0 || lookup(element.entity) !== element) continue;
+			reconcile.applyElement(element, cursor.quiet);
+			applied += 1;
+			stackChildren(stack, element);
+		}
+		if (stack.length === 0) closeApplication(root, cursor);
+	}
+	/**
+	* Puts the children of an applied element on the stack of its application, the first one on top,
+	* so they come next, in the order of `applyRects`.
+	*
+	* @param stack - The elements still to apply.
+	* @param element - The element just applied.
+	*/
+	function stackChildren(stack, element) {
+		for (let index = element.children.length - 1; index >= 0; index -= 1) {
+			const child = element.children[index];
+			const childElement = child === void 0 ? void 0 : lookup(child);
+			if (childElement !== void 0) stack.push(childElement);
+		}
+	}
+	/**
+	* Ends the application of a root built aside: its scrolls settle in this solve, and its live
+	* hosts take their views in it, now that the root is whole (spec 33 A7).
+	*
+	* @param root - The root built aside.
+	* @param cursor - Its application, empty.
+	*/
+	function closeApplication(root, cursor) {
+		delete root.applying;
+		cursorPool.push(cursor);
+		landed = true;
+		for (const host of state.hosts) if (lookup(host)?.root === root.entity) state.risen.add(host);
+	}
+	/**
+	* Applies the next part of every open application of a root built aside, in mount order, while
+	* the frame's budget lasts. It runs before any root is solved: a root whose application ends
+	* here is solved again in the same call when it asks for it.
+	*/
+	function applyParts() {
+		if (state.asideRoots === 0) return;
+		for (const root of state.roots.values()) {
+			const cursor = root.applying;
+			if (cursor === void 0) continue;
+			if (!mayRun()) return;
+			unitRan = true;
+			applyPart(root, cursor);
+		}
+	}
+	return {
+		beginReconcile,
+		beginSolve,
+		hasLanded,
+		parks,
+		park,
+		waits,
+		drainParked,
+		holdRoot,
+		forgetParts,
+		applyInParts,
+		applyParts
+	};
+}
+//#endregion
 //#region src/plugins/ui/jsx/range.ts
 /**
 * Builds the windowed-scroll half of the reconcile: the row style, the slots a mount or a patch
@@ -57559,8 +58053,8 @@ function sameValue(left, right) {
 * that stays is compared prop by prop, by value: one that says what it said is neither styled nor
 * written. Beside it:
 * the range of a windowed scroll (`range.ts`), the rest and the motion of the extras
-* (`extras.ts`), the hint routed to a keyed element (`hints.ts`) and the remeasure of the texts
-* `text` resolved again (`remeasure.ts`).
+* (`extras.ts`), the hint routed to a keyed element (`hints.ts`), the remeasure of the texts
+* `text` resolved again (`remeasure.ts`) and a scene build in parts (`parts.ts`).
 */
 /** The four components an element may be drawn with; a state change can trade one for another. */
 const VISUALS = [
@@ -58067,6 +58561,11 @@ function createReconciler(ctx, modules, fields) {
 		forgetSubtree,
 		despawnTree
 	});
+	const parts = createParts(ctx, {
+		diffChildren,
+		applyElement,
+		isMoving: range.isMoving
+	});
 	const dirtyList = [];
 	const scrollList = [];
 	const movedRoots = [];
@@ -58137,7 +58636,8 @@ 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 aside = isAside(root.entity);
+		if (aside) ctx.deps.world.projection.adopt(entity);
 		const is = isFlagsOf(node, {
 			pressed: false,
 			hover: false,
@@ -58203,7 +58703,9 @@ function createReconciler(ctx, modules, fields) {
 			epoch: state.epoch,
 			rowHeight: range.rowHeightOf(parent, node)
 		};
-		diffChildren(root, element, childrenOf(node, range.slotsFor(element), element.scroll?.axis), instance);
+		const nodes = childrenOf(node, range.slotsFor(element), element.scroll?.axis);
+		if (aside && parts.parks() && nodes.length > 0) parts.park(root, element, nodes, instance);
+		else diffChildren(root, element, nodes, instance);
 		root.needsSolve = true;
 		return entity;
 	}
@@ -58875,16 +59377,25 @@ function createReconciler(ctx, modules, fields) {
 	* @param quiet - Whether a live element takes its rect with no motion.
 	*/
 	function applyRects(element, quiet = false) {
-		const parent = parentRect(element);
-		if (element.live) applyLive(element, parent, quiet);
-		else applyFirst(element, parent);
-		element.moved = false;
+		applyElement(element, quiet);
 		for (const child of element.children) {
 			const childElement = lookup(child);
 			if (childElement !== void 0) applyRects(childElement, quiet);
 		}
 	}
 	/**
+	* Applies the solved rect of one element: a live one moves, a new one spawns its components.
+	*
+	* @param element - The element to apply.
+	* @param quiet - Whether a live element takes its rect with no motion.
+	*/
+	function applyElement(element, quiet) {
+		const parent = parentRect(element);
+		if (element.live) applyLive(element, parent, quiet);
+		else applyFirst(element, parent);
+		element.moved = false;
+	}
+	/**
 	* Where the element of a root draws: its layer and order, and its slot with the place the slot
 	* lists the root's projection at.
 	*
@@ -59031,7 +59542,8 @@ function createReconciler(ctx, modules, fields) {
 	}
 	/**
 	* Solves one root in a box and applies its rects: a root on the viewport when it is marked, a
-	* root in a slot also when its slot was resized.
+	* root in a slot also when its slot was resized. A root built aside waits while parts of it wait,
+	* and is applied in parts.
 	*
 	* @param root - The root.
 	* @param box - The viewport, or the slot's content box.
@@ -59040,7 +59552,7 @@ function createReconciler(ctx, modules, fields) {
 	*/
 	function solveOne(root, box, quiet) {
 		const element = root.element === void 0 ? void 0 : lookup(root.element);
-		if (element === void 0) return false;
+		if (element === void 0 || parts.waits(root)) return false;
 		const resized = root.slot !== void 0 && !sameBox(root.slotRect, box);
 		if (!root.needsSolve && !resized) return false;
 		if (root.slot !== void 0) root.slotRect = {
@@ -59051,7 +59563,8 @@ function createReconciler(ctx, modules, fields) {
 		};
 		modules.layout.solve(element, box, lookup);
 		root.needsSolve = false;
-		applyRects(element, quiet);
+		if (root.aside !== void 0 && isAside(root.entity) && !element.live) parts.applyInParts(root, element, quiet);
+		else applyRects(element, quiet);
 		return true;
 	}
 	/**
@@ -59213,6 +59726,7 @@ function createReconciler(ctx, modules, fields) {
 		for (const root of state.roots.values()) {
 			if (state.removing.has(root.entity)) continue;
 			const element = root.element === void 0 ? void 0 : lookup(root.element);
+			parts.forgetParts(root);
 			if (element !== void 0) {
 				forgetSubtree(element);
 				forgetInstances(state, element.identity);
@@ -59247,7 +59761,9 @@ function createReconciler(ctx, modules, fields) {
 	}
 	/**
 	* The live scroll containers, which the frame step moves with the finger. Read from the set the
-	* enter fills and the exit empties, so an idle frame walks no other element.
+	* enter fills and the exit empties, so an idle frame walks no other element. A scroll of a root
+	* built aside waits while parts of the root wait: it is ranged, moved and settled once the root
+	* is whole (spec 33 A7).
 	*
 	* @returns Every live element whose tag is `scroll`: the reconciler's own list, valid until the
 	*   next call.
@@ -59256,7 +59772,9 @@ function createReconciler(ctx, modules, fields) {
 		while (scrollList.length > 0) scrollList.pop();
 		for (const entity of state.scrolls) {
 			const element = state.elements.get(entity);
-			if (element?.live === true) scrollList.push(element);
+			if (element?.live !== true) continue;
+			if (state.asideRoots > 0 && parts.waits(state.roots.get(element.root))) continue;
+			scrollList.push(element);
 		}
 		return scrollList;
 	}
@@ -59361,16 +59879,16 @@ function createReconciler(ctx, modules, fields) {
 	}
 	/**
 	* 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.
+	* root of the build is dirty (its tree not diffed yet, or the layout engine not loaded), has
+	* parked parts, waits for its solve or is applied in parts (spec 33 A8). 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;
+			if ((root.dirty || solves || parts.waits(root)) && isAside(root.entity)) return false;
 		}
 		return true;
 	}
@@ -59378,11 +59896,13 @@ function createReconciler(ctx, modules, fields) {
 	* 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.
+	* that show a string of another size, the viewport, the parked parts of a scene build, the dirty
+	* roots and the hosted views.
 	*
 	* @param time - The frame's `Time`: the scrolls move by its `delta`.
 	*/
 	function reconcile(time = NO_TIME) {
+		parts.beginReconcile();
 		sweep();
 		state.reconciles += 1;
 		lookWriter.pass += 1;
@@ -59400,9 +59920,10 @@ function createReconciler(ctx, modules, fields) {
 		if (viewportChanged) state.epoch += 1;
 		const count = dirtyRoots(viewportChanged);
 		rendered = count;
+		parts.drainParked();
 		for (let index = 0; index < count; index += 1) {
 			const root = dirtyList[index];
-			if (root !== void 0) reconcileDirtyRoot(root);
+			if (root !== void 0 && !parts.holdRoot(root)) reconcileDirtyRoot(root);
 		}
 		hostViews(ctx, state);
 		writeCounters();
@@ -59423,12 +59944,13 @@ function createReconciler(ctx, modules, fields) {
 		counters.written = state.written;
 	}
 	/**
-	* 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, 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
+	* The second system of phase `layout`: every root takes its slot, the open applications of roots
+	* built aside take their next part, 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,
+	* 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.
 	*
 	* @param time - The frame's `Time`: a scroll left moving asks for a frame only while it runs.
@@ -59437,10 +59959,12 @@ function createReconciler(ctx, modules, fields) {
 		const viewport = modules.styles.viewport();
 		viewportBox.w = viewport?.width ?? 0;
 		viewportBox.h = viewport?.height ?? 0;
+		parts.beginSolve();
 		assignSlots();
+		parts.applyParts();
 		const changed = layOutRoots(viewportBox);
 		if (changed) ctx.deps.time.wake();
-		if (changed || rendered > 0) modules.layout.settleScroll(scrollContainers(), lookup, time);
+		if (changed || rendered > 0 || parts.hasLanded()) modules.layout.settleScroll(scrollContainers(), lookup, time);
 		rendered = 0;
 		settleOverlays(ctx, state, modules.layout);
 		if (state.risen.size > 0) {
@@ -59516,6 +60040,7 @@ 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";
+		parts.forgetParts(root);
 		if (cause === "discard" || isAside(entity)) {
 			dropRoot(root, element);
 			return;
@@ -64225,9 +64750,11 @@ function scenesFor() {
 /**
 * Types a projection: keyed items of the model turned into entities. `Item` is inferred from the
 * return of `from` and reaches `key`, `view` and every motion hook; `layer` and `lift` stay
-* literal, so `defineScene` can check them against the layers of the scene.
+* literal, so `defineScene` can check them against the layers of the scene. Each pair of
+* `initialOnly` has its field names checked against its own component.
 *
-* @param spec - Name, layer, optional lift layer, `from`, `key`, `view` and the motion hooks.
+* @param spec - Name, layer, optional lift layer, `from`, `key`, `view`, the motion hooks and
+*   the `initialOnly` fields.
 * @returns The same spec, typed.
 * @example
 * ```ts
@@ -64628,7 +65155,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 |
+* | scenes | buildMs | "auto", two thirds of a frame ((1000 / time.rate().fps) * 2 / 3, 11.1 ms at 60 Hz), read at each build start; a number fixes it |
 * | anim | maxTracks | 2000 |
 * | anim | reducedMotion | false |
 * | i18n | locale | "en" |