@moku-labs/game 0.15.4 → 0.15.6

package/dist/{src-tkKl-oCn.mjs → src-DWJabPi4.mjs}

@@ -9719,6 +9719,44 @@ function collectView(pctx, spec, item) {
 	return values;
 }
 /**
+* Tells whether a view is a screen root that draws at the place of its projection in a list: its
+* view described a node, so `collectView` gave it a `Tree` and the `Order` of that place. A view
+* that returned its own components keeps whatever `Order` it gave itself.
+*
+* @param pctx - Domain context of the projection module.
+* @param view - A live view of the projection.
+* @param order - The `Order` of the place the projection had.
+* @returns True when the view draws at that place.
+*/
+function drawsAtPlace(pctx, view, order) {
+	const { Order, Tree } = pctx.deps.components;
+	const rest = view.rest.get(Order.componentName)?.value;
+	return view.rest.has(Tree.componentName) && typeof rest === "object" && "value" in rest && rest.value === order;
+}
+/**
+* Keeps a mounted projection for the scene that comes, as a scene switch does for a projection
+* both scenes list: it stays mounted into the new layer list, and its screen roots take the
+* `Order` of their place in the new list, on the entity and in the rest pose, so the next node of
+* a root compares equal and writes none. Nothing else is touched: no view is spawned or
+* despawned, no motion is cut, no hook runs. A view on its way out keeps the order it leaves with.
+*
+* @param pctx - Domain context of the projection module.
+* @param mounted - The mounted projection the new list names again.
+* @param order - The `Order` of its place in the new list.
+*/
+function placeMounted(pctx, mounted, order) {
+	const previous = mounted.order;
+	mounted.layers = pctx.ctx.state.projection.layers;
+	if (previous === order) return;
+	mounted.order = order;
+	for (const view of mounted.live.values()) {
+		if (!drawsAtPlace(pctx, view, previous)) continue;
+		const value = pctx.deps.components.Order({ value: order });
+		view.rest.set(value.type.componentName, value);
+		writeValue(pctx, view.entity, value);
+	}
+}
+/**
 * Writes the layer of a view.
 *
 * @param pctx - Domain context of the projection module.
@@ -11037,6 +11075,155 @@ 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.
+*
+* @param owner - Who owns the entities of this projection.
+* @param order - The `Order` its screen roots draw at.
+* @param layers - The layer list of the scene it is mounted into.
+* @returns A mounted projection with nothing in it yet.
+*/
+function emptyMounted(owner, order, layers) {
+	return {
+		owner,
+		live: /* @__PURE__ */ new Map(),
+		queue: [],
+		items: /* @__PURE__ */ new Map(),
+		order,
+		layers
+	};
+}
+/**
+* Checks that every layer a projection names is declared by the scene.
+*
+* @param pctx - Domain context of the projection module.
+* @param spec - The projection spec.
+* @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));
+	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.`);
+	}
+}
+/**
+* Tells whether two layer lists declare one layer alike: every field of its entry (`sort`,
+* `above`, whatever a layer declares) the same in both. The renderer keeps the container of a
+* layer that stays, but sorts a view again only when the view changes, so a view kept under
+* another rule would stand at its old place.
+*
+* @param before - The layer list the projection was mounted under.
+* @param after - The layer list of the coming scene.
+* @param name - The layer name.
+* @returns True when both lists hold the layer with the same fields.
+* @example
+* ```ts
+* sameLayer([{ name: "ui", sort: "none" }], [{ name: "ui", sort: "order" }], "ui"); // false
+* ```
+*/
+function sameLayer(before, after, name) {
+	const first = before.find((layer) => layer.name === name);
+	const second = after.find((layer) => layer.name === name);
+	if (first === void 0 || second === void 0) return false;
+	const fields = Object.entries(first);
+	return fields.length === Object.keys(second).length && fields.every(([field, value]) => Object.getOwnPropertyDescriptor(second, field)?.value === value);
+}
+/**
+* Tells whether a projection draws under the same rules in two layer lists: its `layer`, and its
+* `lift` when it has one, declared alike in both.
+*
+* @param before - The layer list the projection was mounted under.
+* @param after - The layer list of the coming scene.
+* @param spec - The projection spec.
+* @returns True when the projection can stay mounted.
+*/
+function drawsAlike(before, after, spec) {
+	return sameLayer(before, after, spec.layer) && (spec.lift === void 0 || sameLayer(before, after, spec.lift));
+}
+/**
+* Unmounts projections: every motion of their views is finished, and the live views and the
+* despawn queue are despawned in the same call. An unknown or unmounted name is skipped.
+*
+* @param pctx - Domain context of the projection module.
+* @param names - Names of the projections to unmount.
+*/
+function unmountNames(pctx, names) {
+	const state = pctx.ctx.state.projection;
+	for (const name of names) {
+		const mounted = state.mounted.get(name);
+		if (mounted === void 0) continue;
+		clearMounted(pctx, mounted);
+		state.mounted.delete(name);
+	}
+}
+/**
+* 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.
+*
+* @param pctx - Domain context of the projection module.
+* @param names - Names of the projections to mount.
+* @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.
+*/
+function sortMount(pctx, names) {
+	const state = pctx.ctx.state.projection;
+	const fresh = [];
+	const again = [];
+	for (const name of 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) {
+			pctx.ctx.log.warn("world:already-mounted", { projection: name });
+			continue;
+		}
+		checkLayers(pctx, spec);
+		if (mounted !== void 0 && drawsAlike(mounted.layers, state.layers, spec)) continue;
+		if (mounted !== void 0) again.push(name);
+		fresh.push(spec);
+	}
+	return {
+		fresh,
+		again
+	};
+}
+/**
+* Mounts the projections of a list under an owner. A new one is reconciled at once, direct. One
+* a scene before mounted stays when the current layer list declares its layers alike, and takes
+* its place in this list; one whose layer is declared otherwise is unmounted and mounted again.
+* One mounted into this scene already is reported and changes nothing. Nothing is mounted when
+* the call throws.
+*
+* @param pctx - Domain context of the projection module.
+* @param names - Names of the projections to mount.
+* @param owner - Who owns the entities of the new ones.
+* @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);
+	unmountNames(pctx, again);
+	for (const name of names) {
+		const order = names.indexOf(name) - names.length;
+		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;
+	reconcile(pctx, {
+		names: fresh.map((spec) => spec.name),
+		direct: true,
+		force: true,
+		converge: false,
+		settle: false
+	});
+}
+//#endregion
 //#region src/plugins/world/projection/api.ts
 /**
 * Tells whether a cause sets the picture instead of playing it.
@@ -11069,25 +11256,8 @@ function isConvergeCause(cause) {
 	return cause === "load" || cause === "restore";
 }
 /**
-* 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.
-*
-* @param owner - Who owns the entities of this projection.
-* @param order - The `Order` its screen roots draw at.
-* @returns A mounted projection with nothing in it yet.
-*/
-function emptyMounted(owner, order) {
-	return {
-		owner,
-		live: /* @__PURE__ */ new Map(),
-		queue: [],
-		items: /* @__PURE__ */ new Map(),
-		order
-	};
-}
-/**
-* Creates the empty mute table of one entity.
+* 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.
 */
@@ -11173,20 +11343,6 @@ function noPeers() {
 	};
 }
 /**
-* Checks that every layer a projection names is declared by the scene.
-*
-* @param pctx - Domain context of the projection module.
-* @param spec - The projection spec.
-* @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));
-	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.`);
-	}
-}
-/**
 * Creates the projection module: the public API `scenes`, `input` and `i18n` call, plus the
 * methods the plugin root drives from the frame and the `model:committed` hook.
 *
@@ -11251,33 +11407,10 @@ function createProjectionApi(ctx, deps) {
 		},
 		layers: () => state.layers,
 		mount: (names, owner) => {
-			const fresh = [];
-			for (const name of 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.`);
-				if (state.mounted.has(name)) {
-					ctx.log.warn("world:already-mounted", { projection: name });
-					continue;
-				}
-				checkLayers(pctx, spec);
-				fresh.push(spec);
-			}
-			for (const spec of fresh) state.mounted.set(spec.name, emptyMounted(owner, names.indexOf(spec.name) - names.length));
-			if (fresh.length > 0) reconcile(pctx, {
-				names: fresh.map((spec) => spec.name),
-				direct: true,
-				force: true,
-				converge: false,
-				settle: false
-			});
+			mountNames(pctx, names, owner);
 		},
 		unmount: (names) => {
-			for (const name of names) {
-				const mounted = state.mounted.get(name);
-				if (mounted === void 0) continue;
-				clearMounted(pctx, mounted);
-				state.mounted.delete(name);
-			}
+			unmountNames(pctx, names);
 		},
 		restOf: (entity, component) => {
 			const stored = (state.byEntity.get(entity)?.rest ?? state.rests.get(entity))?.get(component.componentName);
@@ -12184,7 +12317,7 @@ function withinRatio(differing, bytes) {
 * @param host - The host module (`resolution()`).
 * @returns Device pixels per CSS pixel; `undefined` for the half resolution of `host.pixels`.
 */
-function readResolution(ctx, host) {
+function readResolution$1(ctx, host) {
 	return hasPictures(ctx.state.kept) ? host.resolution() : void 0;
 }
 /**
@@ -12208,7 +12341,7 @@ function hasPictures(kept) {
 * @param decided - The decision of this frame, changed in place when a missed frame is drawn.
 */
 function verifyFrame(ctx, state, host, decided) {
-	const resolution = readResolution(ctx, host);
+	const resolution = readResolution$1(ctx, host);
 	if (decided.reason !== "none") {
 		state.verify.reference = host.pixels(resolution);
 		return;
@@ -15224,7 +15357,7 @@ const BEFORE = {
 * @param resolution - The target's resolution.
 * @returns Texels per CSS px.
 */
-function resolutionOf(filter, resolution) {
+function resolutionOf$1(filter, resolution) {
 	const own = filter.resolution;
 	return own === "inherit" ? resolution : own;
 }
@@ -15244,7 +15377,7 @@ function readStack(slots, resolution, into) {
 		const filter = slots[index]?.filter;
 		if (filter === void 0 || !filter.enabled) continue;
 		enabled += 1;
-		rs = Math.min(rs, resolutionOf(filter, resolution));
+		rs = Math.min(rs, resolutionOf$1(filter, resolution));
 		padding += filter.padding;
 	}
 	into.enabled = enabled;
@@ -21564,7 +21697,7 @@ const NO_DETAIL = Object.freeze({});
 /** The fewest device pixels per CSS pixel `setResolution` draws at. */
 const MIN_RESOLUTION = .5;
 /** The most device pixels per CSS pixel `setResolution` draws at. */
-const MAX_RESOLUTION = 4;
+const MAX_RESOLUTION$1 = 4;
 /**
 * Message of a resolution `setResolution` refuses.
 *
@@ -21572,7 +21705,7 @@ const MAX_RESOLUTION = 4;
 * @returns The message.
 */
 function resolutionMessage(value) {
-	return `[game] renderer.monitor.setResolution(${String(value)}) needs a number from ${MIN_RESOLUTION} to ${MAX_RESOLUTION}.\n  Pass undefined to go back to maxResolution.`;
+	return `[game] renderer.monitor.setResolution(${String(value)}) needs a number from ${MIN_RESOLUTION} to ${MAX_RESOLUTION$1}.\n  Pass undefined to go back to maxResolution.`;
 }
 /**
 * Tells whether `setResolution` takes a value: a number from `MIN_RESOLUTION` to `MAX_RESOLUTION`, or `undefined` to
@@ -21586,7 +21719,7 @@ function resolutionMessage(value) {
 * ```
 */
 function takesResolution(value) {
-	return value === void 0 || typeof value === "number" && value >= MIN_RESOLUTION && value <= MAX_RESOLUTION;
+	return value === void 0 || typeof value === "number" && value >= MIN_RESOLUTION && value <= MAX_RESOLUTION$1;
 }
 /**
 * Creates the monitor module: the counters of the renderer, the capture of a frame, and the
@@ -32094,14 +32227,14 @@ function cancelTracksOf(actx, entity) {
 //#endregion
 //#region src/plugins/anim/tween/driver.ts
 /** The empty field set of every track nobody muted: one frozen set, shared, read every frame. */
-const NO_FIELDS = Object.freeze(/* @__PURE__ */ new Set());
+const NO_FIELDS$1 = Object.freeze(/* @__PURE__ */ new Set());
 /**
 * The muted fields of a timeline step's track: none.
 *
 * @returns The shared empty set; a frame builds no set.
 */
 function noFields() {
-	return NO_FIELDS;
+	return NO_FIELDS$1;
 }
 /**
 * Creates the tween engine `world` runs `ViewHandle.tween`, `toRest` and `all` on. Installed with
@@ -35732,9 +35865,22 @@ function overTargetOf(ctx, node, run) {
 	return takePending(ctx);
 }
 /**
-* Builds the scene in one synchronous block: the layers, then the projections of the old scene
-* out, then the ones of the new scene in, 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 only then the event.
+* 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
+* declare them, so its views stay in the same layer containers.
+*
+* @param previous - The scene that leaves.
+* @param scene - The scene that comes.
+* @returns The names to unmount, in the order the leaving scene lists them.
+*/
+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 only then the event.
 *
 * @param ctx - Domain context of the plugin.
 * @param scene - The scene whose bundles are there.
@@ -35746,7 +35892,7 @@ function apply(ctx, scene, named) {
 	const from = state.current;
 	const previous = from === void 0 ? void 0 : state.scenes.get(from);
 	projection.setLayers(scene.layers);
-	if (previous !== void 0) projection.unmount(previous.projections);
+	if (previous !== void 0) projection.unmount(leavingOf(previous, scene));
 	projection.mount(scene.projections, state.owner);
 	state.current = scene.id;
 	ctx.deps.world.ecs.setScene(scene.id);
@@ -37867,6 +38013,19 @@ function readArea(id, area) {
 	return area;
 }
 /**
+* Reads the declared resolution: texels per CSS px, or 0 for the canvas's. A JavaScript caller may pass anything.
+*
+* @param id - The filter id.
+* @param resolution - What the game declared.
+* @returns The resolution; 0 when it was left out.
+* @throws {Error} When it is given and is not a number from 0 to `MAX_RESOLUTION`.
+*/
+function readResolution(id, resolution) {
+	if (resolution === void 0) return 0;
+	if (typeof resolution === "number" && resolution >= 0 && resolution <= 4) return resolution;
+	throw new Error(`[game] Filter "${id}": resolution must be from 0 to 4, 0 for the resolution of the canvas.\n  Got ${String(resolution)}.`);
+}
+/**
 * Tells whether a value is a list of 2 to 4 finite numbers.
 *
 * @param value - A uniform declaration.
@@ -38157,18 +38316,20 @@ function cacheWithInputs(cache, inputs) {
 * `enabled: true` and `order: 0`. An input `blur` gives the body `sampleBlur(uv)`: the last texture
 * of its chain, read at the body's `uv`. A `fallback` draws instead when the filter is broken.
 * An `area` answers, from the value, the rectangle in the entity's own units outside of which the
-* filter draws nothing: Pixi then renders and fills only that box, not the view's bounds.
+* filter draws nothing: Pixi then renders and fills only that box, not the view's bounds. A
+* `resolution` draws the view and its filters at that many texels per CSS px instead of the
+* canvas's.
 * Register it through the `filters` key of a feature. The README shows a filter with a blur input
 * and one with an `area`.
 *
 * @param id - The filter id, also the component name; unique, and not one of the built-ins.
 * @param spec - Both bodies, the uniforms, the passes one apply costs, the padding, the inputs, the fallback, the
-*   cache category and the area.
+*   cache category, the area and the resolution.
 * @returns The component type, with the frozen `filter` definition attached.
 * @throws {Error} When the id is empty, the WGSL has no `mainFragment`, the GLSL no `void main(`,
 *   a uniform is reserved, badly named or of no known form, the passes or the padding break
 *   their rules, an input or the fallback breaks one of its rules, `passes` is given with inputs,
-*   or `area` is not a function.
+*   `area` is not a function, or `resolution` is not a number from 0 to 4.
 * @example
 * ```ts
 * // features/board/effects.ts: a gold tint a motion hook tweens on a merge, on WebGPU and WebGL.
@@ -38190,6 +38351,7 @@ function defineFilter(id, spec) {
 	checkCost(id, passes, padding, uniforms);
 	checkCache(id, spec.cache);
 	const area = readArea(id, spec.area);
+	const resolution = readResolution(id, spec.resolution);
 	const origin = callsCanvasPixel(spec.wgsl, spec.glsl) ? KEPT_ORIGIN : void 0;
 	const cache = cacheWithInputs(cacheOf(spec.wgsl, spec.glsl, spec.cache), inputs);
 	const filter = Object.freeze({
@@ -38203,6 +38365,7 @@ function defineFilter(id, spec) {
 		fallback,
 		cache,
 		origin,
+		resolution,
 		...area === void 0 ? {} : { area }
 	});
 	if (spec.cache !== false && (readsScreenIn(spec.wgsl) || readsScreenIn(spec.glsl))) screenReaders.add(filter);
@@ -38423,6 +38586,7 @@ const displacementDefaults = {
 };
 const alphaDefaults = {
 	alpha: 1,
+	resolution: 0,
 	enabled: true,
 	order: 0
 };
@@ -38519,11 +38683,16 @@ const Noise = /*#__PURE__*/ component("effects.noise", noiseDefaults);
 const Displacement = /*#__PURE__*/ component("effects.displacement", displacementDefaults);
 /**
 * Pixi's alpha over a view and its subtree as one layer, so overlapping children do not show
-* through each other.
+* through each other. `resolution: 0` draws at the resolution of the canvas; a number draws the
+* subtree at that many texels per CSS px, at most 4, and every other filter of the view with it
+* (Pixi's smallest resolution wins). At `alpha: 1` and `resolution: 0` the filter is switched off
+* after 8 frames there: it would copy the subtree unchanged through a pass of its own, and a
+* keyframe that only touches 1 switches nothing. One render pass per apply.
 *
 * @example
 * ```ts
-* Alpha({ alpha: 0.5 }).value; // { alpha: 0.5, enabled: true, order: 0 }
+* // The fog of a memory screen, drawn at half a texel per CSS px through one pass.
+* Alpha({ resolution: 0.5 }).value; // { alpha: 1, resolution: 0.5, enabled: true, order: 0 }
 * ```
 */
 const Alpha = /*#__PURE__*/ component("effects.alpha", alphaDefaults);
@@ -38648,6 +38817,20 @@ function brokenMark() {
 //#endregion
 //#region src/plugins/effects/filters/instance.ts
 /**
+* @file effects/filters — the only file that builds, writes and destroys Pixi filters. Ours: a
+* `Filter` over a `GpuProgram` of the assembled WGSL and a `GlProgram` of the assembled GLSL, with
+* one `UniformGroup` both read. The Pixi-core kinds: their own class, written through their setters
+* when a field differs from what they were last given. Every kind but `Blur` renders at
+* `resolution: "inherit"`, the resolution of the canvas, so a filtered view stays sharp on DPR 2-3
+* (decision 32), unless its value (`Alpha`) or its definition (`defineFilter`) gives a resolution of
+* its own. An `Alpha` at 1 drawn at the canvas's is switched off once it rested there: it would copy
+* the view unchanged through a pass. Every write compares first: a value the filter holds already writes nothing and
+* asks the renderer for no frame. A destroy frees the uniform buffers first: `Filter.destroy()`
+* leaves them to a GC that runs after a minute (P10). A filter with inputs draws each place of its
+* chains through Pixi's public `applyFilter` from inside its own `apply`, into pooled textures given
+* back in a `finally`; a stand-in draws in place of a broken kind or instance.
+*/
+/**
 * The resolution of every filter but `Blur`: the render target's, so a filter draws at the
 * resolution of the canvas. Pixi's default of 1 would draw it at half the pixels on DPR 2.
 */
@@ -38662,6 +38845,20 @@ const PROBE_VALUE = Object.freeze({
 /** The numbers of a vector field that holds none. */
 const NO_NUMBERS = Object.freeze([]);
 /**
+* The resolution Pixi is given for a resolution of a value or a definition: the number, at most `MAX_RESOLUTION`, or
+* the canvas's for 0 (or less, or not a number).
+*
+* @param resolution - Texels per CSS px; 0 for the canvas's.
+* @returns What a filter's `resolution` takes.
+* @example
+* ```ts
+* resolutionOf(50); // 4
+* ```
+*/
+function resolutionOf(resolution) {
+	return resolution > 0 ? Math.min(resolution, 4) : CANVAS_RESOLUTION;
+}
+/**
 * Tells whether two numbers are the same value for the GPU: equal, or both NaN.
 *
 * @param a - One number.
@@ -38822,7 +39019,7 @@ function createOurs(pixi, definition, value) {
 			glProgram,
 			resources,
 			padding: paddingOf$1(definition, value),
-			resolution: CANVAS_RESOLUTION
+			resolution: resolutionOf(definition.resolution)
 		}),
 		group,
 		definition,
@@ -38864,6 +39061,43 @@ function blurResolution(ectx, value) {
 	return ectx.state.phone ? ectx.config.blur.phoneResolution : 1;
 }
 /**
+* Tells whether an `Alpha` value draws its view unchanged: switched on, at alpha 1, at the canvas's resolution. Its
+* filter would copy the view through a pass of its own. The fields are read by name: a fade reads them every frame.
+*
+* @param value - The stored `Alpha` value.
+* @returns True when the filter may be switched off.
+* @example
+* ```ts
+* drawsUnchanged({ enabled: true, order: 0, alpha: 1, resolution: 0 }); // true
+* ```
+*/
+function drawsUnchanged(value) {
+	const { alpha, resolution } = value;
+	return value.enabled && alpha === 1 && !(typeof resolution === "number" && resolution > 0);
+}
+/**
+* The `enabled` switch of an instance for the stored value of this sync: the value's own, at once, but an `Alpha` that
+* draws its view unchanged is switched off only at its `CALM_AFTER`-th sync in a row so while its filter is on, counted
+* in `calm`: keyframes that touch 1 keep the pass and switch nothing, a fade that ends at 1 lets it go. The filter
+* sync syncs the view again while `calm` counts.
+*
+* @param instance - The instance.
+* @param value - The stored filter value.
+* @returns True when Pixi is to draw the filter.
+*/
+function switchOf(instance, value) {
+	if (instance.kind !== "alpha") return value.enabled;
+	if (!drawsUnchanged(value)) {
+		instance.calm = 0;
+		return value.enabled;
+	}
+	if (!instance.filter.enabled) return false;
+	instance.calm += 1;
+	if (instance.calm < 8) return true;
+	instance.calm = 0;
+	return false;
+}
+/**
 * Composes a colour matrix from the identity: brightness, saturation, contrast, hue, and the
 * grayscale as a negative saturation. `ColorMatrixFilter` multiplies, so it starts from `reset()`.
 *
@@ -39005,10 +39239,11 @@ function createCore(ectx, pixi, core, value, probeMap) {
 			kind: "alpha",
 			filter: new pixi.AlphaFilter({
 				alpha: numberOf$1(value, "alpha"),
-				resolution: CANVAS_RESOLUTION
+				resolution: resolutionOf(numberOf$1(value, "resolution"))
 			}),
 			...appliedOf(value),
-			passes: 1
+			passes: 1,
+			calm: 0
 		};
 	}
 }
@@ -39030,7 +39265,7 @@ function createCore(ectx, pixi, core, value, probeMap) {
 function createFilter(ectx, pixi, kind, value, probeMap) {
 	const body = kind.source === "wgsl" ? createOurs(pixi, kind.definition, value) : createCore(ectx, pixi, kind.core, value, probeMap);
 	if (body === void 0) return void 0;
-	body.filter.enabled = value.enabled;
+	body.filter.enabled = value.enabled && !(body.kind === "alpha" && drawsUnchanged(value));
 	if (body.kind === "wgsl") body.areaStale = body.definition.area !== void 0;
 	const instance = Object.assign(body, {
 		order: value.order,
@@ -39255,7 +39490,8 @@ function wireInputs(ectx, pixi, instance) {
 	};
 	instance.inputs = inputs;
 	instance.filter.apply = (manager, input, output, clearMode) => applyInputs(ectx, pixi, instance, inputs, manager, input, output, clearMode);
-	evaluate(ectx, pixi, instance, inputs, ectx.deps.renderer.host.resolution());
+	const { resolution } = instance.definition;
+	evaluate(ectx, pixi, instance, inputs, resolution > 0 ? resolution : ectx.deps.renderer.host.resolution());
 }
 /**
 * Reads one property of a value a chain returned, whatever its type.
@@ -39730,6 +39966,7 @@ function sameField(a, b) {
 */
 function coreDiffers(instance, value) {
 	const { fields, applied } = instance;
+	if (instance.kind === "alpha") return !sameField(applied.alpha, value.alpha) || !sameField(applied.resolution, value.resolution);
 	for (const field of fields) if (instance.kind === "displacement" && field === "map") {
 		if (mapOf(value) !== instance.map) return true;
 	} else if (!sameField(applied[field], value[field])) return true;
@@ -39759,6 +39996,12 @@ function mapOf(value) {
 function writeCore(ectx, instance, value) {
 	setCore(ectx, instance, value);
 	const { fields, applied } = instance;
+	if (instance.kind === "alpha") {
+		const { alpha, resolution } = value;
+		if (alpha !== void 0) applied.alpha = alpha;
+		if (resolution !== void 0 && resolution !== applied.resolution) applied.resolution = resolution;
+		return;
+	}
 	for (const field of fields) {
 		const next = value[field];
 		if (next !== void 0) applied[field] = next;
@@ -39800,7 +40043,11 @@ function setCore(ectx, instance, value) {
 			instance.map = map;
 			return;
 		}
-		default: instance.filter.alpha = numberOf$1(value, "alpha");
+		default: {
+			const { alpha, resolution } = value;
+			instance.filter.alpha = typeof alpha === "number" ? alpha : 0;
+			if (resolution !== instance.applied.resolution) instance.filter.resolution = resolutionOf(typeof resolution === "number" ? resolution : 0);
+		}
 	}
 }
 /**
@@ -39826,8 +40073,9 @@ function switchOffBroken(instance, before) {
 }
 /**
 * Brings one instance up to the stored value for a frame, comparing before anything is written.
-* A broken instance stays off whatever its component says. Switching on or off is a visible
-* change; so is a new value of a filter that is on. A filter that is off and stays off still gets
+* A broken instance stays off whatever its component says, and an `Alpha` at 1 drawn at the
+* canvas's resolution is switched off at its `CALM_AFTER`-th sync there. Switching on or off is a
+* visible change; so is a new value of a filter that is on. A filter that is off and stays off still gets
 * its new values written, so it is current when it comes back on, but asks for nothing: an off
 * filter draws no pixel. Ours compare on every sync of their view (a view syncs when something of it changed); a core
 * kind only when its component changed.
@@ -39844,13 +40092,14 @@ function writeFilter(ectx, instance, value, changed, before) {
 		switchOffBroken(instance, before);
 		return false;
 	}
-	const toggled = instance.filter.enabled !== value.enabled;
+	const on = switchOf(instance, value);
+	const toggled = instance.filter.enabled !== on;
 	const differs = instance.kind === "wgsl" ? oursDiffer(instance, instance.definition, value) : changed && coreDiffers(instance, value);
 	if (!toggled && !differs) return false;
 	staleArea(instance);
-	const visible = toggled || value.enabled;
+	const visible = toggled || on;
 	if (visible) before();
-	if (toggled) instance.filter.enabled = value.enabled;
+	if (toggled) instance.filter.enabled = on;
 	if (differs) {
 		if (instance.kind === "wgsl") {
 			writeOurs(instance, instance.definition, value);
@@ -40595,8 +40844,10 @@ function judgeArea(ectx, instance) {
 }
 /**
 * The union of the areas of a view's enabled filters, into the scratch box: none while no filter is enabled, and none
-* when an enabled filter has no area (every built-in kind, or a definition that answered `undefined`) — it draws over
-* the view's bounds. A disabled filter, and a kind a debug switch turned off (it is not placed), do not count.
+* when an enabled filter has no area (every other built-in kind, or a definition that answered `undefined`) — it draws
+* over the view's bounds. An `Alpha` does not count: it only scales the pixels the others draw, and makes none where
+* they draw nothing; alone it leaves the view without an area. A disabled filter, and a kind a debug switch turned off
+* (it is not placed), do not count either.
 *
 * @param view - The view's record, its instances placed.
 */
@@ -40607,7 +40858,7 @@ function unionOf(view) {
 	let bottom = Number.NEGATIVE_INFINITY;
 	union.some = false;
 	for (const instance of view.placed) {
-		if (!instance.filter.enabled) continue;
+		if (!instance.filter.enabled || instance.kind === "alpha") continue;
 		if (instance.kind !== "wgsl" || !instance.area.some) {
 			union.some = false;
 			return;
@@ -40619,6 +40870,7 @@ function unionOf(view) {
 		right = Math.max(right, area.x + area.width);
 		bottom = Math.max(bottom, area.y + area.height);
 	}
+	if (!union.some) return;
 	union.x = left;
 	union.y = top;
 	union.width = right - left;
@@ -40834,7 +41086,7 @@ function syncKind(ectx, pixi, entity, view, kind, changed, off) {
 		writeFilter(ectx, instance, value, changed, off ? NO_SIGNAL : view.signal);
 		instance.order = value.order;
 		refreshInputs(ectx, pixi, instance, off);
-		if (instance.kind === "wgsl" && (instance.inputs?.retired.length ?? 0) > 0) markDirty$1(ectx, view);
+		if (instance.kind === "wgsl" && (instance.inputs?.retired.length ?? 0) > 0 || instance.kind === "alpha" && instance.calm > 0) markDirty$1(ectx, view);
 		return installReplacement(view, kind, instance);
 	}
 	instance = firstInstance(ectx, pixi, kind, value);
@@ -41101,7 +41353,8 @@ function dropProbe(ectx, probe) {
 }
 /**
 * A probe of one Pixi-core kind at the frozen defaults of its component; a `Displacement` draws over Pixi's white
-* texture, since its program does not depend on the map. Its `apply` is guarded like any instance's.
+* texture, since its program does not depend on the map. A probe is switched on whatever its defaults: an `Alpha` at 1
+* would be off, and Pixi would warm nothing. Its `apply` is guarded like any instance's.
 *
 * @param ectx - Domain context of the effects plugin.
 * @param pixi - The module the renderer loaded.
@@ -41112,6 +41365,7 @@ function coreProbe(ectx, pixi, id) {
 	const kind = ectx.state.kinds.get(id);
 	const instance = kind === void 0 ? void 0 : createFilter(ectx, pixi, kind, kind.component.defaults, pixi.Texture.WHITE);
 	if (instance === void 0) return void 0;
+	instance.filter.enabled = true;
 	return {
 		filter: instance.filter,
 		destroy: () => destroyFilter(instance)
@@ -47773,20 +48027,68 @@ function resolveContent(ctx, entity, text) {
 	return resolved;
 }
 /**
-* The one system of the plugin: phase `layout`, before the two of `ui`, over every label. Every
-* label is visited every frame: `ui` writes `Text` after this system and change sets clear in
-* phase `signals`, so `changed(Text)` cannot tell which moved. The locale is read once per run,
-* the clock at most once and only when a countdown label asks.
+* The frame the system and the step after the layout flush share, made once per plugin.
 *
 * @param ctx - Domain context of the text plugin.
-* @returns The system definition `world.ecs.system` takes.
+* @returns A frame with no locale and no moment read yet.
 */
-function createTextSystem(ctx) {
-	const frame = {
+function createTextFrame(ctx) {
+	return {
 		now: NaN,
 		locale: "",
 		duration: (ms) => ctx.deps.i18n.duration(ms)
 	};
+}
+/**
+* Empties a list of labels in place: popped, so it keeps its store for the next batch.
+*
+* @param labels - The list.
+*/
+function forgetAdded(labels) {
+	while (labels.length > 0) labels.pop();
+}
+/** A patch with no field: the write marks `Text` changed and changes nothing. Frozen, so no caller fills it. */
+const NO_FIELDS = Object.freeze({});
+/**
+* Writes `Text` once more, with no field, for the labels the step after the last layout flush
+* resolved. `ui` measured them in its solve, before they were resolved, and the change of that
+* frame is gone; this one reaches its remeasure in the same layout phase, so a label whose string
+* measures otherwise than what `ui` measured gets its size. A label whose `Text` left is skipped.
+*
+* @param ctx - Domain context of the text plugin.
+*/
+function writeOnceMore(ctx) {
+	const ecs = ctx.deps.world.ecs;
+	for (const entity of ctx.state.rewrite) if (ecs.get(entity, Text) !== void 0) ecs.set(entity, Text, NO_FIELDS);
+	forgetAdded(ctx.state.rewrite);
+}
+/**
+* Notes a label whose `Text` came, as the world's `onAdded` hook calls it: it is marked for the
+* next layout phase, and while the world is live it is listed for the step after the layout
+* flush. In another mode no layout phase runs and the list would only grow: the label waits for
+* the next live run of the system, which resolves every marked label.
+*
+* @param ctx - Domain context of the text plugin.
+* @param entity - The entity that got a `Text`.
+*/
+function noteAdded(ctx, entity) {
+	ctx.state.dirty.add(entity);
+	if (ctx.deps.world.ecs.mode() === "live") ctx.state.added.push(entity);
+}
+/**
+* The one system of the plugin: phase `layout`, before the two of `ui`, over every label. Every
+* label is visited every frame: `ui` writes `Text` after this system and change sets clear in
+* phase `signals`, so `changed(Text)` cannot tell which moved. The locale is read once per run,
+* the clock at most once and only when a countdown label asks. The labels that came before the run
+* are in its walk, so the list of the labels that came starts again empty: the step after the
+* layout flush takes only the ones the flush brings. The labels that step resolved last get their
+* `Text` written once more first, so `ui` measures the string they show.
+*
+* @param ctx - Domain context of the text plugin.
+* @param frame - What the runs share with the step after the layout flush.
+* @returns The system definition `world.ecs.system` takes.
+*/
+function createTextSystem(ctx, frame) {
 	return system({
 		name: TEXT_SYSTEM_NAME,
 		phase: "layout",
@@ -47794,11 +48096,42 @@ function createTextSystem(ctx) {
 		run: (entities) => {
 			frame.now = NaN;
 			frame.locale = ctx.deps.i18n.locale();
+			forgetAdded(ctx.state.added);
+			if (ctx.state.rewrite.length > 0) writeOnceMore(ctx);
 			for (const row of entities) stepText(ctx, row[0], row[1], frame);
 		}
 	});
 }
 /**
+* Resolves the labels whose `Text` came after the layout system ran. `ui` adds a label in its
+* solve, and the flush at the end of phase `layout` attaches it with the rest of its batch, a bound
+* component included; this runs right after that flush and before phase `sync`, so the renderer
+* builds the label with its string, and lists it, so the next system run writes its `Text` once
+* more for the remeasure of `ui`. A label whose content changed is not among them: it resolves in
+* the next layout phase, as before. While the world is not live its layout phase did not run: the
+* list is dropped, and the labels, marked, wait for the next live run, as every label does.
+*
+* @param ctx - Domain context of the text plugin.
+* @param frame - What the system's runs share.
+*/
+function resolveAdded(ctx, frame) {
+	const added = ctx.state.added;
+	if (added.length === 0) return;
+	if (ctx.deps.world.ecs.mode() !== "live") {
+		added.length = 0;
+		return;
+	}
+	frame.now = NaN;
+	frame.locale = ctx.deps.i18n.locale();
+	for (const entity of added) {
+		const text = ctx.deps.world.ecs.get(entity, Text);
+		if (text === void 0) continue;
+		stepText(ctx, entity, text, frame);
+		ctx.state.rewrite.push(entity);
+	}
+	forgetAdded(added);
+}
+/**
 * Marks labels for the next layout phase: every one of them, or only the ones `keep` names. A
 * locale change names the labels whose content is a message; a dev hot swap names the labels
 * drawn with a replaced font or icon.
@@ -48544,9 +48877,12 @@ function replaceStyles(ctx, styles) {
 	ctx.deps.time.wake();
 }
 /**
-* Opens what the plugin owns: the style table, the font keys, the layout system, the two world
-* hooks of `Text` and the display adapter. The fonts of a bundle that is already loaded are read
-* at once, because the boot bundle lands before this runs.
+* Opens what the plugin owns: the style table, the font keys, the layout system, the step after
+* the layout flush, the two world hooks of `Text` and the display adapter. The step is a frame
+* callback of phase `layout`: `world` registered its own in its `onStart`, which runs before this
+* one (`text` depends on `world`), so the step runs after the world's layout phase and its flush,
+* and before phase `sync`. The fonts of a bundle that is already loaded are read at once, because
+* the boot bundle lands before this runs.
 *
 * @param ctx - Kernel context of the text plugin.
 * @throws {Error} When two features define the same style name.
@@ -48554,18 +48890,18 @@ function replaceStyles(ctx, styles) {
 function startText(ctx) {
 	const tctx = withDeps$1(ctx);
 	const ecs = tctx.deps.world.ecs;
+	const frame = createTextFrame(tctx);
 	buildStyles(tctx);
 	collectFonts(tctx);
-	tctx.state.removers.push(ecs.system(createTextSystem(tctx)), ecs.onAdded(Text, (entity) => {
-		tctx.state.dirty.add(entity);
-	}), ecs.onRemoved(Text, (entity) => {
+	tctx.state.removers.push(ecs.system(createTextSystem(tctx, frame)), tctx.deps.time.onFrame("layout", () => resolveAdded(tctx, frame)), ecs.onAdded(Text, (entity) => noteAdded(tctx, entity)), ecs.onRemoved(Text, (entity) => {
 		forgetText(tctx.state, entity);
 	}), tctx.deps.renderer.sync.displays.provide(Text, createTextAdapter(tctx)));
 	installFonts(tctx);
 }
 /**
-* Closes what the plugin opened: the system, the two world hooks and the adapter. The Pixi
-* objects the adapter built are the renderer's, and it frees them in its own teardown.
+* Closes what the plugin opened: the system, the step after the layout flush, the two world hooks
+* and the adapter. The Pixi objects the adapter built are the renderer's, and it frees them in its
+* own teardown.
 *
 * @param state - The plugin state, the only thing a teardown context carries.
 */
@@ -48582,6 +48918,8 @@ function stopText(state) {
 	state.measured.clear();
 	state.cache.clear();
 	state.dirty.clear();
+	state.added.length = 0;
+	state.rewrite.length = 0;
 	state.warned.clear();
 }
 //#endregion
@@ -48731,6 +49069,8 @@ function createTextState$1() {
 		cache: emptyMap$2(),
 		drawn: emptyWeakMap(),
 		dirty: emptySet$1(),
+		added: [],
+		rewrite: [],
 		generation: 0,
 		warned: emptySet$1(),
 		removers: []
@@ -53462,6 +53802,7 @@ function createReconciler(ctx, modules, fields) {
 	};
 	let slotsVersion = -1;
 	let slotsRoots = -1;
+	let placedUnder;
 	/**
 	* 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.
@@ -54452,6 +54793,18 @@ function createReconciler(ctx, modules, fields) {
 		if (element?.live === true && root.slot === void 0) ecs.set(element.entity, Order, { value: order });
 	}
 	/**
+	* Gives every root the order its entity holds once a new scene stands: a scene that keeps a
+	* projection both scenes list places it again (F23), and its tree stands, so no root is dirty.
+	* The world places it only under a new layer list, so the walk runs once per new list, in the
+	* first layout phase that runs after it, also when the switch came while the world was paused.
+	*/
+	function reorderRoots() {
+		const layers = ctx.deps.world.projection.layers();
+		if (layers === placedUnder) return;
+		placedUnder = layers;
+		for (const root of state.roots.values()) if (!state.removing.has(root.entity)) refreshRootOrder(root);
+	}
+	/**
 	* 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.
 	*
@@ -54473,14 +54826,15 @@ 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 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.
+	* 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.
 	*/
 	function reconcile() {
 		sweep();
 		state.reconciles += 1;
 		if (state.remount) remountRoots();
+		reorderRoots();
 		settlePopups(ctx, state, unmountRoot);
 		fields.pull();
 		const containers = scrollContainers();