incanto 0.69.0 → 0.71.0

package/dist/test-CmN54kWv.js

@@ -0,0 +1,4264 @@
+import { n as jsonEquals, t as jsonClone } from "./json-CfTjpvW8.js";
+import { B as HudLayer, M as resetMemorySaves, O as resolveViewport, V as HudWidgetBase, c as isCloned, h as loadScene, ot as registerBehavior, tt as StubBehavior } from "./save-slots-Bvuh2p_r.js";
+import { v as Engine } from "./register-DuVdzxbq.js";
+import { t as IncantoError } from "./errors-BpWbnbb_.js";
+import { t as Rng } from "./rng-CDOMybym.js";
+import { c as getNodeSchema, d as mergeStaticProps, u as getNodeType } from "./touch-BnCyPA0G.js";
+import { n as startRecording } from "./replay-DEvp3kyV.js";
+import { Q as worldPosition, n as registerGameplayBehaviors } from "./gameplay-CNULJvwh.js";
+import { t as registerNodes2D } from "./register-BYQCBySi.js";
+import { n as registerNodes3D, t as resolveEnvironmentHdri } from "./environment-presets-99BzP_L-.js";
+import { a as NetworkManager, c as readSyncKey, i as sanitizeName, n as registerNodesNet, r as NetworkSpawner, s as findOwnerNode, t as createSplitScreen } from "./split-screen-eULetcg-.js";
+import { Box3, Euler, Frustum, Matrix4, PerspectiveCamera, Quaternion, Ray, Vector3 } from "three";
+//#region src/core/asset-urls.ts
+/** Keys inside a `material` object that hold a texture URL. */
+const MATERIAL_URL_KEYS = ["map", "normalMap"];
+/**
+* Walk the tree and collect every URL-valued asset prop.
+*
+* `$ref` values are somebody else's problem (`validateAssetRefs` resolves them
+* against `assets{}` at load). Unknown node types are skipped rather than
+* thrown on: this is a warning path, and the loader reports an unknown type far
+* better than a walker could.
+*/
+function sceneAssetUrls(json) {
+	const out = [];
+	const root = json?.root;
+	const visit = (n, parentPath) => {
+		if (typeof n !== "object" || n === null) return;
+		const node = n;
+		const path = `${parentPath}/${typeof node.name === "string" ? node.name : "?"}`;
+		const props = node.props ?? {};
+		if (typeof node.type === "string") {
+			let schema = null;
+			try {
+				schema = mergeStaticProps(getNodeType(node.type));
+			} catch {
+				schema = null;
+			}
+			if (schema) for (const [key, def] of Object.entries(schema)) {
+				if (!def.asset) continue;
+				const value = props[key];
+				if (typeof value === "string" && value !== "" && !value.startsWith("$")) {
+					const kind = def.asset.kind;
+					out.push({
+						path,
+						prop: key,
+						kind: typeof kind === "string" ? kind : "",
+						url: value
+					});
+				}
+			}
+			const material = props.material;
+			if (material && typeof material === "object" && !Array.isArray(material)) for (const key of MATERIAL_URL_KEYS) {
+				const value = material[key];
+				if (typeof value === "string" && value !== "" && !value.startsWith("$")) out.push({
+					path,
+					prop: `material.${key}`,
+					kind: "texture",
+					url: value
+				});
+			}
+		}
+		if (Array.isArray(node.children)) for (const c of node.children) visit(c, path);
+	};
+	visit(root, "");
+	return out;
+}
+//#endregion
+//#region src/test/framing.ts
+/**
+* What the camera is actually looking at — without a GPU.
+*
+* Nearly every decision in a 3D game is visual: is the camera framing the
+* island, is anything lit, is the gem buried inside the platform. An agent
+* building a game could answer none of them. `captureScene()` lists nodes and
+* their props, which tells you a gem is at `[4, 1, -2]` and nothing whatsoever
+* about whether you can SEE it — and the engine ships no pixel output at all,
+* so "look at it" was a human's job.
+*
+* This is the geometry half of the answer, and it needs no renderer, no canvas
+* and no browser: the camera's own matrices, the world transforms composed from
+* the tree, and the colliders already declared in the JSON.
+*
+* What it measures: the node's ORIGIN, widened to its declared `size` (a
+* MeshInstance3D's box, a Terrain3D's ground) or its collider when it has one.
+* A 200 m island whose origin is off to the left still counts as on screen,
+* because its box is. For a node that declares neither, read `offscreen` as
+* "its origin is off-screen" — a loaded GLB's real silhouette needs the model,
+* and the model needs a GPU.
+*/
+const DEG = Math.PI / 180;
+const CAMERA_TYPES = new Set(["Camera3D"]);
+const LIGHT_TYPES = new Set(["DirectionalLight3D", "OmniLight3D"]);
+/** Screen-space subtrees: they ignore the camera, so framing has nothing to say. */
+const SCREEN_SPACE$1 = new Set(["UILayer", "HudLayer"]);
+/** Depth a 2D collider is given on the axis it does not have. */
+const FLAT_DEPTH = 1e3;
+/** How far two colliders must actually interpenetrate to be a finding. */
+const TOUCH_EPS_2D = 1;
+const TOUCH_EPS_3D = .01;
+/** What a 2D scene shows when it declares neither a viewport nor a canvas. */
+const DEFAULT_VIEW_2D = [960, 540];
+/** `frameWidth`/`frameHeight` of the spritesheet a node references, if any. */
+function sheetSize(scene, node) {
+	const ref = node.sheet;
+	if (typeof ref !== "string" || !ref.startsWith("$")) return null;
+	const decl = scene.assets?.[ref.slice(1)];
+	const w = decl?.frameWidth;
+	const h = decl?.frameHeight;
+	return typeof w === "number" && typeof h === "number" && w > 0 && h > 0 ? [w, h] : null;
+}
+/**
+* World transform for every node, composed from the tree.
+*
+* NOT read off `_object3D`: that is the renderer's copy, and headless there may
+* be no renderer to have written it. The props are the truth here.
+*/
+/** @internal Shared with `picker.ts` — the same world transforms, once. */
+function place(scene) {
+	const out = [];
+	const walk = (node, parent, hiddenAbove) => {
+		const type = node.constructor.typeName ?? "Node";
+		const n = node;
+		const local = new Matrix4();
+		if (Array.isArray(n.position)) {
+			const r = n.rotation;
+			const euler = typeof r === "number" ? new Euler(0, 0, r * DEG) : new Euler((r?.[0] ?? 0) * DEG, (r?.[1] ?? 0) * DEG, (r?.[2] ?? 0) * DEG, "XYZ");
+			local.compose(new Vector3(n.position[0] ?? 0, n.position[1] ?? 0, n.position[2] ?? 0), new Quaternion().setFromEuler(euler), new Vector3(n.scale?.[0] ?? 1, n.scale?.[1] ?? 1, n.scale?.[2] ?? 1));
+		}
+		const matrix = new Matrix4().multiplyMatrices(parent, local);
+		const hidden = hiddenAbove || node.visible === false;
+		out.push({
+			node,
+			type,
+			matrix,
+			position: new Vector3().setFromMatrixPosition(matrix),
+			hidden,
+			blank: hasNoArt(node, type),
+			scale: new Vector3().setFromMatrixScale(matrix),
+			drawn: sheetSize(scene, node)
+		});
+		if (SCREEN_SPACE$1.has(type)) return;
+		for (const child of node.children) walk(child, matrix, hidden);
+	};
+	walk(scene.root, new Matrix4(), false);
+	return out;
+}
+/**
+* A node draws something if its class builds its own three object — OR hangs
+* one off the inherited container.
+*
+* The second half is not a nicety. `Particles3D` builds its `Points` in
+* `_syncObject3D`, like every 2D drawable does, so a create-hook test alone
+* reported every explosion, every trail of embers and every bit of magic in a
+* 3D scene as drawing nothing. `draws2D` below already carries this warning for
+* exactly the same reason; 3D had one node shaped like the 2D ones and missed
+* it.
+*/
+/** @internal */
+function draws(node) {
+	const proto = Object.getPrototypeOf(node);
+	let base = proto;
+	while (base && base.constructor?.typeName !== "Node3D") {
+		base = Object.getPrototypeOf(base);
+		if (!base) return false;
+	}
+	return HOOKS_3D.some((hook) => proto[hook] !== base[hook]);
+}
+/** Either hook can be where a node's geometry comes from. */
+const HOOKS_3D = ["_createObject3D", "_syncObject3D"];
+/**
+* A 2D node draws something if its class puts pixels on its backing object.
+*
+* NOT `_createObject2D` — the 3D test's counterpart, and wrong here. 2D
+* drawables all inherit the plain container and hang a quad off it in
+* `_syncObject2D`, so the create hook is identical for a sprite and for a bare
+* `Node2D`, and testing it reports a scene full of sprites as drawing nothing.
+*/
+/** @internal */
+/**
+* The art a node needs before it can draw anything, by type.
+*
+* A CLOSED list beside an open one — every node type with an empty-string prop
+* it cannot draw without. `the-art-a-node-needs.test.ts` enumerates that set
+* from the sources and makes each member either land here or be exempted by
+* name with a reason, because a list like this is only ever wrong by omission
+* and the symptom is a report that does NOT mention a node.
+*
+* `Label`/`Label3D` were the two it opened without: text is the art of a text
+* node, and a label with none draws exactly as much as a sprite with no
+* texture. Everything else — `ColorRect2D`, meshes, particles — draws from its
+* own props.
+*/
+const NEEDS_ART = {
+	AnimatedSprite2D: "sheet",
+	AnimatedSprite3D: "sheet",
+	Label: "text",
+	Label3D: "text",
+	ModelInstance3D: "model",
+	Sprite2D: "texture",
+	Sprite3D: "texture",
+	TileMap2D: "texture"
+};
+/** Does this node have a class that draws, and nothing for it to draw? */
+/**
+* Every widget a HudLayer would put on screen, by path.
+*
+* A widget under a hidden widget is not counted — a button in a closed panel is
+* not merely unpressable, it is not there, which is the same rule
+* `HudLayer.focusables()` uses.
+*/
+function hudWidgets(root) {
+	const out = [];
+	const walk = (node, hidden) => {
+		const type = node.constructor.typeName ?? "";
+		const off = hidden || node.visible === false;
+		if (!off && type.startsWith("Ui")) out.push(node.getPath());
+		for (const child of node.children) walk(child, off);
+	};
+	const find = (node) => {
+		if (SCREEN_SPACE$1.has(node.constructor.typeName ?? "")) {
+			walk(node, node.visible === false);
+			return;
+		}
+		for (const child of node.children) find(child);
+	};
+	find(root);
+	return out;
+}
+function hasNoArt(node, type) {
+	const prop = NEEDS_ART[type];
+	if (prop === void 0) return false;
+	return node[prop] === "";
+}
+function draws2D(node) {
+	const proto = Object.getPrototypeOf(node);
+	let base = proto;
+	while (base && base.constructor?.typeName !== "Node2D") {
+		base = Object.getPrototypeOf(base);
+		if (!base) return false;
+	}
+	return proto._syncObject2D !== base._syncObject2D;
+}
+/**
+* A 2D node's half-size in pixels, and where its box hangs off the origin.
+*
+* Most 2D nodes are centred on their origin, but a `TileMap2D` hangs cell (0,0)
+* by its TOP-LEFT corner — a whole level reported as a point at its corner is
+* how you conclude the map is off screen when you are standing on it.
+*/
+/** @internal */
+function box2D(node) {
+	if ((node.constructor.typeName ?? "") === "TileMap2D") {
+		const map = node;
+		const rows = Array.isArray(map.cells) ? map.cells : [];
+		const cols = rows.reduce((n, r) => Math.max(n, String(r).length), 0);
+		const ts = map.tileSize ?? 32;
+		if (rows.length === 0 || cols === 0) return null;
+		const half = [cols * ts / 2, rows.length * ts / 2];
+		return {
+			half,
+			centre: half
+		};
+	}
+	const size = node.size;
+	if (Array.isArray(size) && typeof size[0] === "number" && typeof size[1] === "number") return {
+		half: [Math.abs(size[0]) / 2, Math.abs(size[1]) / 2],
+		centre: [0, 0]
+	};
+	const half = halfExtents(node);
+	return half ? {
+		half: [half.x, half.y],
+		centre: [0, 0]
+	} : null;
+}
+/**
+* How big the node is on screen, from whatever it declares.
+*
+* `size` first (a MeshInstance3D's box, a Terrain3D's ground), then a collider.
+* This is the FRAMING question — "does this thing fill the view" — and a mesh's
+* own size answers it better than the body wrapped around it.
+*/
+/**
+* The node's own box, in its own units — the scene's answer where it has one.
+*
+* A sprite's ANCHOR moves the quad off the origin (`[0.5, 0]` stands it on its
+* feet), exactly as the renderer does it, so a foot-anchored character is
+* measured where it is drawn and not half a body below.
+*
+* @internal
+*/
+function localBox2D(p) {
+	if (p.drawn) {
+		const [w, h] = p.drawn;
+		const anchor = p.node.anchor;
+		const ax = Array.isArray(anchor) && typeof anchor[0] === "number" ? anchor[0] : .5;
+		const ay = Array.isArray(anchor) && typeof anchor[1] === "number" ? anchor[1] : .5;
+		return {
+			half: [w / 2, h / 2],
+			centre: [(.5 - ax) * w, (.5 - ay) * h]
+		};
+	}
+	return box2D(p.node);
+}
+/**
+* A placed node's box in WORLD space — the axis-aligned one that contains the
+* transformed box, so scale AND rotation are in it.
+*
+* `box2D` and `extentOf` read the node's own props, which describe it at
+* scale 1 and rotation 0. `place()` has composed both into its matrices all
+* along and these were the only readers that never asked, so a 200x20 bar
+* rotated 90 degrees was measured 200 wide and 20 tall while it drew 20 wide
+* and 200 tall — the wrong axis, not a near miss.
+*
+* Corners rather than a scale multiply: a rotated box has no half-extent in
+* its own axes any more, and the four (or eight) corners are the only honest
+* answer an AABB can give.
+*
+* @internal
+*/
+function box2DOf(p) {
+	const b = localBox2D(p);
+	if (!b) return null;
+	const min = new Vector3(Infinity, Infinity, 0);
+	const max = new Vector3(-Infinity, -Infinity, 0);
+	const corner = new Vector3();
+	for (const sx of [-1, 1]) for (const sy of [-1, 1]) {
+		corner.set(b.centre[0] + sx * b.half[0], b.centre[1] + sy * b.half[1], 0).applyMatrix4(p.matrix);
+		min.min(corner);
+		max.max(corner);
+	}
+	return {
+		half: [(max.x - min.x) / 2, (max.y - min.y) / 2],
+		centre: [(max.x + min.x) / 2 - p.position.x, (max.y + min.y) / 2 - p.position.y]
+	};
+}
+/** A placed node's 3D half-extent in WORLD space — scale and rotation in it. @internal */
+function extentOfPlaced(p) {
+	const half = extentOf(p.node);
+	if (!half) return null;
+	const min = new Vector3(Infinity, Infinity, Infinity);
+	const max = new Vector3(-Infinity, -Infinity, -Infinity);
+	const corner = new Vector3();
+	for (const sx of [-1, 1]) for (const sy of [-1, 1]) for (const sz of [-1, 1]) {
+		corner.set(sx * half.x, sy * half.y, sz * half.z).applyMatrix4(p.matrix);
+		min.min(corner);
+		max.max(corner);
+	}
+	return new Vector3((max.x - min.x) / 2, (max.y - min.y) / 2, (max.z - min.z) / 2);
+}
+/**
+* Is this world point inside the node's box, EXACTLY — rotation and all?
+*
+* The AABB above is what a report can print; a click deserves the real answer,
+* and the real answer is cheap: put the point in the node's own space, where
+* the box is axis-aligned by construction.
+*
+* @internal
+*/
+function containsPoint2D(p, x, y) {
+	const b = localBox2D(p);
+	if (!b) return false;
+	const local = new Vector3(x, y, 0).applyMatrix4(new Matrix4().copy(p.matrix).invert());
+	return Math.abs(local.x - b.centre[0]) <= b.half[0] && Math.abs(local.y - b.centre[1]) <= b.half[1];
+}
+/** @internal */
+function extentOf(node) {
+	const sections = node.sections;
+	if (Array.isArray(sections) && sections.length > 0) {
+		let x = 0;
+		let y = 0;
+		let z = 0;
+		for (const raw of sections) {
+			if (!raw || typeof raw !== "object") continue;
+			const s = raw;
+			const w = typeof s.width === "number" ? Math.abs(s.width) / 2 : 0;
+			const h = typeof s.height === "number" ? Math.abs(s.height) / 2 : 0;
+			const cy = typeof s.y === "number" ? s.y : 0;
+			const cz = typeof s.z === "number" ? s.z : 0;
+			x = Math.max(x, w);
+			y = Math.max(y, Math.abs(cy) + h);
+			z = Math.max(z, Math.abs(cz));
+		}
+		if (x > 0 || y > 0 || z > 0) return new Vector3(x, y, z);
+	}
+	const treeHeight = node.height;
+	if (node.constructor.typeName === "Tree3D" && typeof treeHeight === "number" && treeHeight > 0) {
+		const count = node.count;
+		const area = node.area;
+		const grove = typeof count === "number" && count > 1 && Array.isArray(area);
+		const x = grove ? Math.abs(area[0] ?? treeHeight) / 2 : treeHeight * .3;
+		const z = grove ? Math.abs(area[1] ?? treeHeight) / 2 : treeHeight * .3;
+		return new Vector3(x, treeHeight / 2, z);
+	}
+	const riverPath = node.path;
+	if (node.constructor.typeName === "River3D" && Array.isArray(riverPath) && riverPath.length > 0) {
+		const width = node.width;
+		const depth = node.depth;
+		const margin = (typeof width === "number" ? Math.abs(width) : 6) / 2;
+		let minX = Number.POSITIVE_INFINITY;
+		let maxX = Number.NEGATIVE_INFINITY;
+		let minZ = Number.POSITIVE_INFINITY;
+		let maxZ = Number.NEGATIVE_INFINITY;
+		for (const point of riverPath) {
+			if (!Array.isArray(point)) continue;
+			const px = point[0];
+			const pz = point[point.length - 1];
+			if (typeof px !== "number" || typeof pz !== "number") continue;
+			minX = Math.min(minX, px);
+			maxX = Math.max(maxX, px);
+			minZ = Math.min(minZ, pz);
+			maxZ = Math.max(maxZ, pz);
+		}
+		if (Number.isFinite(minX)) return new Vector3((maxX - minX) / 2 + margin, Math.max(typeof depth === "number" ? Math.abs(depth) : .8, .5) / 2, (maxZ - minZ) / 2 + margin);
+	}
+	const size = node.size;
+	if (Array.isArray(size) && size.length >= 2 && typeof size[0] === "number") {
+		const mesh = node.mesh;
+		const round = mesh === "sphere" || mesh === "gem" || mesh === "cylinder" || mesh === "capsule";
+		const w = size[0];
+		const h = typeof size[1] === "number" ? size[1] : w;
+		if (round) {
+			const y = mesh === "sphere" || mesh === "gem" ? w : mesh === "capsule" ? h / 2 + w : h / 2;
+			return new Vector3(Math.abs(w), Math.abs(y), Math.abs(w));
+		}
+		const x = w / 2;
+		const y = size.length >= 3 ? h / 2 : x;
+		const z = (size[size.length - 1] ?? w) / 2;
+		return new Vector3(Math.abs(x), Math.abs(y), Math.abs(z));
+	}
+	return halfExtents(node);
+}
+/**
+* Where a node's box sits relative to its own ORIGIN.
+*
+* Every extent this file returns is a half-size around the node's position,
+* which is right for a mesh (a `MeshInstance3D` is centred on itself) and wrong
+* for the two shapes that are anchored at one end: a `Tree3D` stands ON its
+* position, and a `LoftMesh3D`'s sections run from wherever the author put the
+* first one to wherever they put the last.
+*
+* Without this the picker asks a box that reaches as far BELOW a tree as the
+* tree is tall, and half of the tree is not in it. Zero for everything else,
+* which is every other node type.
+*/
+function extentCentreOf(node) {
+	const type = node.constructor.typeName ?? "";
+	if (type === "Tree3D") {
+		const height = node.height;
+		if (typeof height === "number" && height > 0) return new Vector3(0, height / 2, 0);
+	}
+	if (type === "LoftMesh3D") {
+		const sections = node.sections;
+		if (Array.isArray(sections) && sections.length > 0) {
+			let minZ = Number.POSITIVE_INFINITY;
+			let maxZ = Number.NEGATIVE_INFINITY;
+			for (const raw of sections) {
+				const z = raw?.z;
+				if (typeof z !== "number") continue;
+				minZ = Math.min(minZ, z);
+				maxZ = Math.max(maxZ, z);
+			}
+			if (Number.isFinite(minZ)) return new Vector3(0, 0, (minZ + maxZ) / 2);
+		}
+	}
+	return new Vector3();
+}
+/**
+* A COLLIDER's half-extents, when the node declares one.
+*
+* Colliders live on bodies, not meshes — which is exactly right for the
+* overlap report: "the gem is inside the platform" is a question about the
+* physical shapes, and two meshes touching (a floor meeting a wall) is not a
+* finding.
+*/
+/**
+* The half-extent of a node's own COLLIDER, or null.
+*
+* @internal `picker.ts` uses it for a body standing in for a subtree nothing
+* can measure — a `ModelInstance3D` sizes itself from a GLB no harness loads.
+*/
+function halfExtentsOf(node) {
+	return halfExtents(node);
+}
+function halfExtents(node) {
+	const collider = node.collider;
+	if (!collider || typeof collider !== "object") return null;
+	const shape = collider.shape;
+	if (shape === "box") {
+		const size = collider.size ?? [
+			1,
+			1,
+			1
+		];
+		return new Vector3((size[0] ?? 1) / 2, (size[1] ?? 1) / 2, (size[2] ?? 1) / 2);
+	}
+	if (shape === "sphere") {
+		const r = collider.radius ?? .5;
+		return new Vector3(r, r, r);
+	}
+	if (shape === "capsule" || shape === "cylinder") {
+		const r = collider.radius ?? .5;
+		return new Vector3(r, (collider.height ?? 1) / 2 + r, r);
+	}
+	if (shape === "rect") {
+		const size = collider.size ?? [1, 1];
+		return new Vector3((size[0] ?? 1) / 2, (size[1] ?? 1) / 2, .5);
+	}
+	if (shape === "circle") {
+		const r = collider.radius ?? .5;
+		return new Vector3(r, r, .5);
+	}
+	return null;
+}
+/**
+* The same question in 2D: an orthographic window of design pixels, centred on
+* the Camera2D and CLAMPED by its limits.
+*
+* The clamp is not a detail — it is the whole point of `limits`, and a report
+* that skips it describes a view the renderer never draws. A following camera
+* sits at the player's y, which in a 544 px world is hundreds of pixels past
+* anything a 540 px window can show.
+*
+* With no camera at all a 2D scene still draws: the documented default view is
+* `(0,0)`–`(w,h)`, so "no camera" is not "nothing is framed" the way it is in 3D.
+*/
+/**
+* The `Camera2D` a 2D frame is drawn through: the `current` one, else the first.
+*
+* @internal shared with `picker.ts`, which has to agree with this file about
+* what a click can reach — a harness that clicks what the camera cannot see
+* proves a click the game will not honour.
+*/
+function camera2D(placed) {
+	const cameras = placed.filter((p) => p.type === "Camera2D");
+	return cameras.find((p) => p.node.current === true) ?? cameras[0] ?? null;
+}
+/**
+* The world rect that camera shows, in design pixels, CLAMPED by its limits.
+*
+* The clamp is not a detail — it is the whole point of `limits`, and a report
+* that skips it describes a view the renderer never draws. With no camera at
+* all a 2D scene still draws: the documented default view is `(0,0)`–`(w,h)`.
+*
+* @internal shared with `picker.ts`.
+*/
+function viewRect2D(chosen, vw, vh) {
+	if (!chosen) return {
+		minX: 0,
+		minY: 0,
+		maxX: vw,
+		maxY: vh
+	};
+	const cam = chosen.node;
+	const zoom = Math.max(.01, cam.zoom ?? 1);
+	const halfW = vw / (2 * zoom);
+	const halfH = vh / (2 * zoom);
+	let cx = chosen.position.x;
+	let cy = chosen.position.y;
+	const limits = cam.limits ?? [];
+	if (limits.length === 4) {
+		const [minX, minY, maxX, maxY] = limits;
+		cx = clampCentred(cx, minX + halfW, maxX - halfW);
+		cy = clampCentred(cy, minY + halfH, maxY - halfH);
+	}
+	return {
+		minX: cx - halfW,
+		minY: cy - halfH,
+		maxX: cx + halfW,
+		maxY: cy + halfH
+	};
+}
+function describeFraming2D(scene, placed, opts) {
+	const design = resolveViewport(scene.viewport)?.design;
+	const [vw, vh] = opts.viewport ?? design ?? DEFAULT_VIEW_2D;
+	const chosen = camera2D(placed);
+	let camera = null;
+	const view = viewRect2D(chosen, vw, vh);
+	if (chosen) {
+		const cam = chosen.node;
+		const zoom = Math.max(.01, cam.zoom ?? 1);
+		const cx = (view.minX + view.maxX) / 2;
+		const cy = (view.minY + view.maxY) / 2;
+		camera = {
+			path: chosen.node.getPath(),
+			at: [
+				round(cx),
+				round(cy),
+				0
+			],
+			view: [round(vw / zoom), round(vh / zoom)],
+			zoom
+		};
+	}
+	const wanted = opts.types ? new Set(opts.types) : null;
+	const centre = [(view.minX + view.maxX) / 2, (view.minY + view.maxY) / 2];
+	const entries = [];
+	for (const p of placed) {
+		if (p.type === "Camera2D") continue;
+		if (!(wanted ? wanted.has(p.type) : draws2D(p.node))) continue;
+		const b = box2DOf(p);
+		const cx = p.position.x + (b?.centre[0] ?? 0);
+		const cy = p.position.y + (b?.centre[1] ?? 0);
+		const hx = b?.half[0] ?? 0;
+		const hy = b?.half[1] ?? 0;
+		const onScreen = cx + hx >= view.minX && cx - hx <= view.maxX && cy + hy >= view.minY && cy - hy <= view.maxY;
+		entries.push({
+			path: p.node.getPath(),
+			type: p.type,
+			at: [
+				round(p.position.x),
+				round(p.position.y),
+				0
+			],
+			where: p.hidden ? "hidden" : p.blank ? "blank" : onScreen ? "onScreen" : "offscreen",
+			screen: [round((cx - centre[0]) / ((view.maxX - view.minX) / 2)), round((cy - centre[1]) / ((view.maxY - view.minY) / 2))],
+			distance: round(Math.hypot(cx - centre[0], cy - centre[1]))
+		});
+	}
+	return {
+		dimension: "2d",
+		camera,
+		entries,
+		widgets: hudWidgets(scene.root),
+		lights: [],
+		overlaps: findOverlaps(placed, TOUCH_EPS_2D)
+	};
+}
+function clampCentred(v, lo, hi) {
+	if (lo > hi) return (lo + hi) / 2;
+	return Math.min(hi, Math.max(lo, v));
+}
+function describeFraming(scene, opts = {}) {
+	const placed = place(scene);
+	if (scene.dimension === "2d") return describeFraming2D(scene, placed, opts);
+	const cameras = placed.filter((p) => CAMERA_TYPES.has(p.type));
+	const chosen = cameras.find((p) => p.node.current === true) ?? cameras[0] ?? null;
+	const lights = [];
+	for (const p of placed) if (LIGHT_TYPES.has(p.type)) lights.push(`${p.node.getPath()} (${p.type})`);
+	const env = scene.environment;
+	if (env) {
+		if (env.preset !== void 0) lights.push(`environment.preset = ${JSON.stringify(env.preset)}`);
+		if (env.sky !== void 0) lights.push("environment.sky");
+		if (env.hdri !== void 0) lights.push("environment.hdri");
+		const ambient = env.ambient;
+		if (typeof ambient?.intensity === "number" && ambient.intensity > 0) lights.push(`environment.ambient.intensity = ${ambient.intensity}`);
+	}
+	const wanted = opts.types ? new Set(opts.types) : null;
+	const subjects = placed.filter((p) => !CAMERA_TYPES.has(p.type) && !LIGHT_TYPES.has(p.type) && (wanted ? wanted.has(p.type) : draws(p.node)));
+	const entries = [];
+	let camera = null;
+	if (chosen) {
+		const node = chosen.node;
+		const cam = new PerspectiveCamera(node.fov ?? 60, opts.aspect ?? 16 / 9, node.near ?? .1, node.far ?? 1e3);
+		cam.matrixWorld.copy(chosen.matrix);
+		cam.matrixWorldInverse.copy(chosen.matrix).invert();
+		cam.updateProjectionMatrix();
+		const orientation = new Quaternion().setFromRotationMatrix(chosen.matrix);
+		const forward = new Vector3(0, 0, -1).applyQuaternion(orientation);
+		const up = new Vector3(0, 1, 0).applyQuaternion(orientation);
+		const right = new Vector3(1, 0, 0).applyQuaternion(orientation);
+		camera = {
+			path: chosen.node.getPath(),
+			at: chosen.position.toArray(),
+			forward: [
+				round(forward.x),
+				round(forward.y),
+				round(forward.z)
+			],
+			up: [
+				round(up.x),
+				round(up.y),
+				round(up.z)
+			],
+			rollDeg: round(Math.atan2(right.y, up.y) * 180 / Math.PI),
+			fovDeg: node.fov ?? 60
+		};
+		if (up.y < 0 && Math.abs(forward.y) <= .98) camera.upsideDown = true;
+		if (!cam.projectionMatrix.elements.every((v) => Number.isFinite(v))) {
+			for (const p of subjects) entries.push({
+				path: p.node.getPath(),
+				type: p.type,
+				at: p.position.toArray(),
+				where: "offscreen",
+				screen: [0, 0],
+				distance: round(p.position.distanceTo(chosen.position))
+			});
+			return {
+				dimension: "3d",
+				camera: {
+					...camera,
+					degenerate: true
+				},
+				entries,
+				widgets: hudWidgets(scene.root),
+				lights,
+				overlaps: findOverlaps(placed, TOUCH_EPS_3D)
+			};
+		}
+		const frustum = new Frustum().setFromProjectionMatrix(new Matrix4().multiplyMatrices(cam.projectionMatrix, cam.matrixWorldInverse));
+		for (const p of subjects) {
+			const distance = p.position.distanceTo(chosen.position);
+			if (p.hidden || p.blank) {
+				entries.push({
+					path: p.node.getPath(),
+					type: p.type,
+					at: p.position.toArray(),
+					where: p.hidden ? "hidden" : "blank",
+					distance: round(distance)
+				});
+				continue;
+			}
+			const view = p.position.clone().applyMatrix4(cam.matrixWorldInverse);
+			const half = extentOfPlaced(p);
+			const box = half ? new Box3().setFromCenterAndSize(p.position, half.clone().multiplyScalar(2)) : null;
+			if (box ? !frustum.intersectsBox(box) && view.z > -(node.near ?? .1) : view.z > -(node.near ?? .1)) {
+				entries.push({
+					path: p.node.getPath(),
+					type: p.type,
+					at: p.position.toArray(),
+					where: "behind",
+					distance: round(distance)
+				});
+				continue;
+			}
+			const ndc = p.position.clone().project(cam);
+			let onScreen = Math.abs(ndc.x) <= 1 && Math.abs(ndc.y) <= 1;
+			if (!onScreen && box) onScreen = frustum.intersectsBox(box);
+			entries.push({
+				path: p.node.getPath(),
+				type: p.type,
+				at: p.position.toArray(),
+				where: onScreen ? "onScreen" : "offscreen",
+				screen: [round(ndc.x), round(ndc.y)],
+				distance: round(distance)
+			});
+		}
+	}
+	return {
+		dimension: "3d",
+		camera,
+		entries,
+		widgets: hudWidgets(scene.root),
+		lights,
+		overlaps: findOverlaps(placed, TOUCH_EPS_3D)
+	};
+}
+/**
+* Declared colliders that intersect.
+*
+* The colliders, not the meshes: they are in the JSON, so this needs no GPU and
+* no loaded model — and a prop buried inside a platform is the thing you were
+* trying to see anyway.
+*/
+function findOverlaps(placed, epsilon) {
+	const shapes = [];
+	for (const p of placed) {
+		const shape = shapeOf(p.node, p.position);
+		if (!shape) continue;
+		shapes.push({
+			path: p.node.getPath(),
+			internal: p.node.name.startsWith("__"),
+			shape
+		});
+	}
+	const out = [];
+	for (let i = 0; i < shapes.length; i++) for (let j = i + 1; j < shapes.length; j++) {
+		const a = shapes[i];
+		const b = shapes[j];
+		if (!a || !b) continue;
+		if (a.path.startsWith(`${b.path}/`) || b.path.startsWith(`${a.path}/`)) continue;
+		if (a.internal && b.internal) continue;
+		if (penetrates(a.shape, b.shape, epsilon)) out.push({
+			a: a.path,
+			b: b.path
+		});
+	}
+	return out;
+}
+function shapeOf(node, centre) {
+	const collider = node.collider;
+	const kind = collider?.shape;
+	if (kind === "sphere" || kind === "circle") return {
+		kind: "ball",
+		centre,
+		radius: collider?.radius ?? .5
+	};
+	const half = halfExtents(node);
+	if (!half) return null;
+	return {
+		kind: "box",
+		centre,
+		half: kind === "rect" ? new Vector3(half.x, half.y, FLAT_DEPTH) : half
+	};
+}
+/** True when the two shapes share more than `eps` of space, in every axis. */
+function penetrates(a, b, eps) {
+	if (a.kind === "ball" && b.kind === "ball") return a.centre.distanceTo(b.centre) < a.radius + b.radius - eps;
+	if (a.kind === "ball" || b.kind === "ball") {
+		const ball = a.kind === "ball" ? a : b;
+		const box = a.kind === "ball" ? b : a;
+		return new Vector3(Math.max(0, Math.abs(ball.centre.x - box.centre.x) - box.half.x), Math.max(0, Math.abs(ball.centre.y - box.centre.y) - box.half.y), Math.max(0, Math.abs(ball.centre.z - box.centre.z) - box.half.z)).length() < ball.radius - eps;
+	}
+	return Math.abs(a.centre.x - b.centre.x) < a.half.x + b.half.x - eps && Math.abs(a.centre.y - b.centre.y) < a.half.y + b.half.y - eps && Math.abs(a.centre.z - b.centre.z) < a.half.z + b.half.z - eps;
+}
+function round(n) {
+	return Math.round(n * 1e3) / 1e3;
+}
+/** The report as something to read in a terminal. */
+function framingText(report) {
+	const lines = [];
+	const is2d = report.dimension === "2d";
+	const unit = is2d ? "px" : "m";
+	const c = report.camera;
+	if (c && is2d) {
+		const [vw = 0, vh = 0] = c.view ?? [];
+		const zoom = c.zoom === 1 ? "" : ` zoom ${c.zoom}`;
+		lines.push(`camera ${c.path} centred [${c.at[0]}, ${c.at[1]}] showing ${vw}×${vh}px${zoom}`);
+	} else if (c) {
+		lines.push(`camera ${c.path} at [${c.at.map(round).join(", ")}] looking [${(c.forward ?? []).join(", ")}] up [${(c.up ?? []).join(", ")}] fov ${c.fovDeg}`);
+		if (c.rollDeg !== void 0 && Math.abs(c.rollDeg) > .5 && !c.upsideDown) lines.push(`camera ${c.path} rolls the horizon ${c.rollDeg}° — deliberate is a dutch angle, accidental is a two-angle \`rotation\` guess. \`lookAt\` aims with world up and cannot roll.`);
+		if (c.upsideDown) lines.push(`camera ${c.path} is UPSIDE DOWN — its up vector is [${(c.up ?? []).join(", ")}], so the whole frame is rolled over. Every other number in this report is the same as an upright camera would print. Check the third element of \`rotation\`.`);
+		if (c.degenerate) lines.push(`camera ${c.path} has a DEGENERATE frustum (fov ${c.fovDeg}) — its projection matrix is not finite, so every vertex lands at NaN and the screen is black. fov must be between 0 and 180 exclusive, near above 0, and near below far.`);
+	} else if (is2d) lines.push("camera: NONE — the view is (0,0)–(design), which may be intentional");
+	else lines.push("camera: NONE — this scene frames nothing (no Camera3D)");
+	if (!is2d) lines.push(report.lights.length ? `lit by: ${report.lights.join(", ")}` : "lit by: NOTHING — this scene renders black");
+	const on = report.entries.filter((e) => e.where === "onScreen");
+	const off = report.entries.filter((e) => e.where === "offscreen");
+	const behind = report.entries.filter((e) => e.where === "behind");
+	const hidden = report.entries.filter((e) => e.where === "hidden");
+	const blank = report.entries.filter((e) => e.where === "blank");
+	lines.push((is2d ? `${on.length} in view, ${off.length} outside it` : `${on.length} on screen, ${off.length} off screen, ${behind.length} behind the camera`) + (hidden.length > 0 ? `, ${hidden.length} hidden (visible: false)` : "") + (blank.length > 0 ? `, ${blank.length} with no art to draw` : ""));
+	if (report.widgets.length > 0) lines.push(`${report.widgets.length} HUD widget(s) on screen — ${report.widgets.slice(0, 4).join(", ")}` + (report.widgets.length > 4 ? `, +${report.widgets.length - 4} more` : ""));
+	if (report.entries.length === 0 && report.widgets.length === 0) lines.push("nothing on screen — this scene has no drawable node and no HUD widget in it. A scene that draws nothing looks exactly like one that failed to load.");
+	if (report.entries.length > 0 && on.length === 0 && blank.length > 0) lines.push(`NOTHING IS DRAWN — ${blank.length} of ${report.entries.length} drawable node(s) have no art (a sprite with no texture, a tilemap with no atlas), and none of the rest is on screen. The canvas is blank; declare the assets and point the nodes at them.`);
+	if (report.entries.length > 0 && on.length === 0 && hidden.length > 0) lines.push(`NOTHING IS DRAWN — ${hidden.length} of ${report.entries.length} drawable node(s) are hidden, and none of the rest is on screen. \`visible: false\` is a full stop: the renderer skips the node and its whole subtree.`);
+	for (const e of report.entries) {
+		const at = `[${(is2d ? e.at.slice(0, 2) : e.at).map(round).join(", ")}]`;
+		const screen = e.screen ? ` screen [${e.screen.join(", ")}]` : "";
+		lines.push(`  ${e.where.padEnd(9)} ${e.path} (${e.type}) ${at}${screen} ${e.distance}${unit}`);
+	}
+	for (const o of report.overlaps) lines.push(`  overlap  ${o.a} ∩ ${o.b}`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/test/picker.ts
+const DEFAULT_VIEW = [960, 540];
+const CAMERAS = new Set(["Camera3D"]);
+const LIGHTS = new Set(["DirectionalLight3D", "OmniLight3D"]);
+/**
+* A picker over `scene`, in the scene's own units.
+*
+* 2D takes WORLD pixels — headless there is no canvas to convert from, and the
+* design window is the coordinate space every 2D position in the file is
+* already written in. 3D takes pixels within `viewport` and casts a ray from
+* the scene's current camera.
+*
+* A hidden node is never picked, which matches what the player can click.
+*/
+function geometricPicker(scene, opts = {}) {
+	if (typeof scene === "function") return (x, y) => geometricPicker(scene(), opts)(x, y);
+	return scene.dimension === "2d" ? picker2D(scene, opts) : picker3D(scene, opts);
+}
+function picker2D(scene, opts) {
+	const design = scene.viewport?.design;
+	const [vw = DEFAULT_VIEW[0], vh = DEFAULT_VIEW[1]] = opts.viewport ?? design ?? DEFAULT_VIEW;
+	return (x, y) => {
+		const view = viewRect2D(camera2D(place(scene)), vw, vh);
+		if (x < view.minX || x > view.maxX || y < view.minY || y > view.maxY) return null;
+		let best = null;
+		let seen = 0;
+		for (const p of drawables(scene, true)) {
+			seen += 1;
+			if (!containsPoint2D(p, x, y)) continue;
+			const order = orderOf(p.node) * 1e6 + seen;
+			if (!best || order >= best.order) best = {
+				node: p.node,
+				order
+			};
+		}
+		return best?.node ?? null;
+	};
+}
+/** The camera a click is seen through: the `current` one, else the first. */
+function cameraOf(scene) {
+	const placed = place(scene);
+	return placed.find((p) => CAMERAS.has(p.type) && p.node.current === true) ?? placed.find((p) => CAMERAS.has(p.type)) ?? null;
+}
+/** The three.js camera posed where `chosen` is, ready to project through. */
+function cameraAt(chosen, vw, vh) {
+	const node = chosen.node;
+	const cam = new PerspectiveCamera(node.fov ?? 60, vw / vh, node.near ?? .1, node.far ?? 1e3);
+	cam.matrixWorld.copy(chosen.matrix);
+	cam.matrixWorldInverse.copy(chosen.matrix).invert();
+	cam.updateProjectionMatrix();
+	return cam;
+}
+/**
+* `engine.toWorld` / `engine.toScreen` from GEOMETRY, with no renderer — the
+* aiming half of a mouse game, the way `geometricPicker` is the clicking half.
+*
+* A renderer installs these on the engine so a Behavior can ask where the
+* cursor IS; headless nothing did, so a drag-and-launch, a tower placed on the
+* map or a unit steered by the cursor could be clicked in a harness and never
+* aimed. 2D is the identity (the picker's coordinates are already world pixels
+* — there is no canvas to convert from); 3D unprojects onto the `groundY`
+* plane, which is where a 3D game puts the thing you pointed at.
+*/
+function geometricView(scene, opts = {}) {
+	const live = () => typeof scene === "function" ? scene() : scene;
+	const [vw = DEFAULT_VIEW[0], vh = DEFAULT_VIEW[1]] = opts.viewport ?? DEFAULT_VIEW;
+	const groundY = opts.groundY ?? 0;
+	return {
+		toWorld: (x, y) => {
+			const now = live();
+			if (now.dimension === "2d") return [x, y];
+			const chosen = cameraOf(now);
+			if (!chosen) return null;
+			const cam = cameraAt(chosen, vw, vh);
+			const origin = new Vector3().setFromMatrixPosition(chosen.matrix);
+			const dir = new Vector3(x / vw * 2 - 1, -(y / vh * 2 - 1), .5).unproject(cam).sub(origin);
+			if (Math.abs(dir.y) < 1e-6) return null;
+			const t = (groundY - origin.y) / dir.y;
+			if (t < 0) return null;
+			return [
+				origin.x + dir.x * t,
+				groundY,
+				origin.z + dir.z * t
+			];
+		},
+		/**
+		* The general form of `toWorld`, and the one a shot needs.
+		*
+		* `toWorld` lands on a plane; a game aiming at whatever the cursor is OVER
+		* feeds this straight to `engine.physics.castRay`. The renderer installs
+		* one and the geometric side did not, so a tower placed on uneven ground —
+		* the case the docs send you here for — was the half of a 3D mouse game
+		* that stayed untestable after the other two were closed.
+		*
+		* 2D has no depth to cast into, so it answers null there, exactly as
+		* `Renderer2D` installs nothing.
+		*/
+		screenRay: (x, y) => {
+			const now = live();
+			if (now.dimension === "2d") return null;
+			const chosen = cameraOf(now);
+			if (!chosen) return null;
+			const cam = cameraAt(chosen, vw, vh);
+			const origin = new Vector3().setFromMatrixPosition(chosen.matrix);
+			const dir = new Vector3(x / vw * 2 - 1, -(y / vh * 2 - 1), .5).unproject(cam).sub(origin);
+			if (dir.lengthSq() < 1e-12) return null;
+			dir.normalize();
+			return {
+				origin: origin.toArray(),
+				dir: dir.toArray()
+			};
+		},
+		toScreen: (world) => {
+			const now = live();
+			if (now.dimension === "2d") return {
+				x: world[0] ?? 0,
+				y: world[1] ?? 0,
+				behind: false
+			};
+			const chosen = cameraOf(now);
+			if (!chosen) return null;
+			const cam = cameraAt(chosen, vw, vh);
+			const p = new Vector3(world[0] ?? 0, world[1] ?? 0, world[2] ?? 0).project(cam);
+			return {
+				x: (p.x + 1) / 2 * vw,
+				y: (1 - p.y) / 2 * vh,
+				behind: p.z > 1
+			};
+		}
+	};
+}
+function picker3D(scene, opts) {
+	const chosen = cameraOf(scene);
+	const [vw = DEFAULT_VIEW[0], vh = DEFAULT_VIEW[1]] = opts.viewport ?? DEFAULT_VIEW;
+	return (x, y) => {
+		if (!chosen) return null;
+		if (x < 0 || x > vw || y < 0 || y > vh) return null;
+		const cam = cameraAt(chosen, vw, vh);
+		const ndc = new Vector3(x / vw * 2 - 1, -(y / vh * 2 - 1), .5);
+		const origin = new Vector3().setFromMatrixPosition(chosen.matrix);
+		const dir = ndc.clone().unproject(cam).sub(origin);
+		if (dir.lengthSq() < 1e-12) return null;
+		const ray = new Ray(origin, dir.normalize());
+		let best = null;
+		const hit = new Vector3();
+		for (const p of drawables(scene, false)) {
+			const half = extentOf(p.node);
+			if (!half) continue;
+			const toLocal = new Matrix4().copy(p.matrix).invert();
+			const localRay = new Ray().copy(ray).applyMatrix4(toLocal);
+			const box = new Box3().setFromCenterAndSize(extentCentreOf(p.node), half.clone().multiplyScalar(2));
+			if (!localRay.intersectBox(box, hit)) continue;
+			hit.applyMatrix4(p.matrix);
+			const distance = origin.distanceTo(hit);
+			if (!best || distance < best.distance) best = {
+				node: p.node,
+				distance
+			};
+		}
+		return best?.node ?? null;
+	};
+}
+/**
+* Everything that draws, minus what the cursor can never be over.
+*
+* `!p.hidden` and `!p.blank` are the same rule `nodeFromHits` applies to a real
+* raycast: a pixel the frame does not draw has nothing under it. The two
+* answers have to agree, or a harness proves a click the game will not honour.
+*/
+function drawables(scene, is2d) {
+	const placed = place(scene);
+	const drawn = (p) => !p.hidden && !p.blank && !CAMERAS.has(p.type) && !LIGHTS.has(p.type) && (is2d ? draws2D(p.node) : draws(p.node));
+	const measured = (p) => (is2d ? localBox2D(p) : extentOf(p.node)) !== null;
+	const out = placed.filter((p) => drawn(p) && measured(p));
+	const covered = /* @__PURE__ */ new Set();
+	for (const p of out) for (let at = p.node; at; at = at.parent) covered.add(at);
+	const subtreeDraws = (node) => placed.some((q) => drawn(q) && q.node !== node && isUnder(q.node, node));
+	for (const p of placed) {
+		if (p.hidden || covered.has(p.node) || drawn(p)) continue;
+		if (halfExtentsOf(p.node) === null || !subtreeDraws(p.node)) continue;
+		out.push(p);
+	}
+	return out;
+}
+/** Is `node` inside `root`'s subtree? */
+function isUnder(node, root) {
+	for (let at = node; at; at = at.parent) if (at === root) return true;
+	return false;
+}
+function orderOf(node) {
+	const n = node;
+	return n.effectiveRenderOrder ?? n.renderOrder ?? 0;
+}
+/**
+* Where a node is, in the coordinates `geometricPicker` answers in.
+*
+* The click half of a headless driver: `at %Mole` has to become a point before
+* a press can land on it, and the space differs by dimension — 2D pixels are
+* the world, 3D pixels are a projection through the scene's camera. Both
+* drivers that click headlessly (`runScript` and `incanto-play`) need exactly
+* this, and the first one had it inline.
+*/
+function pointAtNode(scene, path, opts = {}) {
+	const node = scene.root.getNodeOrNull(path);
+	if (!node) return null;
+	const at = worldPosition(node);
+	if (at.length < 2) return null;
+	const seen = describeFraming(scene, opts.viewport ? { viewport: opts.viewport } : {}).entries.find((e) => e.path === node.getPath());
+	if (seen && seen.where === "offscreen") return null;
+	if (scene.dimension === "2d") return [at[0] ?? 0, at[1] ?? 0];
+	if (!seen?.screen) return null;
+	const [vw = DEFAULT_VIEW[0], vh = DEFAULT_VIEW[1]] = opts.viewport ?? DEFAULT_VIEW;
+	return [(seen.screen[0] + 1) / 2 * vw, (1 - seen.screen[1]) / 2 * vh];
+}
+//#endregion
+//#region src/test/playtest.ts
+/**
+* Behaviours that ASK about the mouse — the open set `Clickable` is one member
+* of. A game can be entirely mouse-driven and carry no `Clickable` at all: a
+* slingshot, a drawing game, a box-select, a swipe. Property names survive
+* minification, so this reads a built game too.
+*/
+const ASKS_ABOUT_THE_MOUSE = /\b(mouseJustPressed|mouseJustReleased|mousePressed|pointerPosition|pointerWorld|toWorld)\b/;
+/** Frames one drag takes: long enough that a game reading per frame sees a move. */
+const DRAG_FRAMES = 6;
+/**
+* The node types that call `engine.effects.record` — the DECLARED half of the
+* `feels` rung's comparison. Three of the four were listed and `Trail3D` was
+* not, so a trail could only ever be reported as wired-but-never-fired.
+*/
+const EFFECT_NODE_TYPES = new Set([
+	"Particles2D",
+	"Particles3D",
+	"Trail3D"
+]);
+/**
+* Screen-space subtrees, skipped whole. Shared with `framing.ts`, which is
+* where the set already lived.
+*/
+const SCREEN_SPACE = new Set(["UILayer", "HudLayer"]);
+/**
+* Out of the world, in pixels — about two screens under the spawn.
+*
+* Generous on purpose: a player who has actually left the level is falling
+* forever, so a far line costs a few frames and never mistakes a long drop
+* down a shaft for one.
+*/
+const FALL_2D_PX = 1e3;
+/** "Reached it", in pixels — one 32 px tile, next to a ~34 px character. */
+const REACH_2D_PX = 32;
+/**
+* How hard this scene pulls, in its own units — 0 only for a scene that says so.
+*
+* Gravity is what makes "left the world downward" mean anything, and a
+* top-down game has none. But ABSENT is not ZERO: the physics adapters default
+* an undeclared scene to [0, 980] px/s² in 2D and [0, -9.81, 0] m/s² in 3D, so
+* a platformer that never wrote a physics header still falls, and reading
+* absent as zero would have stopped reporting the pit it fell into.
+*/
+/** Is anything in this tree driving the player without a down? */
+function hasTopDownController(root) {
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (node.constructor.typeName === "CharacterController2D") {
+			if (node.mode === "topDown") return true;
+		}
+		for (const child of node.children) stack.push(child);
+	}
+	return false;
+}
+function gravityMagnitude(physics) {
+	const g = physics?.gravity;
+	if (g === void 0) return 1;
+	if (!Array.isArray(g)) return 1;
+	return g.reduce((sum, v) => sum + (typeof v === "number" ? Math.abs(v) : 0), 0);
+}
+/** Furthest the player ever got from its spawn, below which it went nowhere. */
+const STUCK_3D_M = 3;
+const STUCK_2D_PX = 96;
+const CONTROLLERS = new Set(["CharacterController2D", "CharacterController3D"]);
+/**
+* Who the driver is playing as.
+*
+* In order: the body carrying a character controller, then group `player`, then
+* a node literally called Player. A scene that satisfies none of them is not
+* one this can drive, and says so rather than guessing.
+*/
+function findPlayer(root) {
+	let found = null;
+	const walk = (node) => {
+		if (found) return;
+		for (const child of node.children) if (CONTROLLERS.has(child.constructor.typeName ?? "")) {
+			found = node;
+			return;
+		}
+		for (const child of node.children) walk(child);
+	};
+	walk(root);
+	if (found) return found;
+	let byGroup = null;
+	const groups = (node) => {
+		if (byGroup) return;
+		if (node.isInGroup("player")) byGroup = node;
+		for (const child of node.children) groups(child);
+	};
+	groups(root);
+	if (byGroup) return byGroup;
+	return root.getNodeOrNull("%Player");
+}
+function positionOf$1(node) {
+	const p = node.position;
+	if (!Array.isArray(p)) return [
+		0,
+		0,
+		0
+	];
+	return [
+		p[0] ?? 0,
+		p[1] ?? 0,
+		p[2] ?? 0
+	];
+}
+/** World position by walking the parent chain — no renderer, no matrices. */
+function worldOf(node) {
+	let x = 0;
+	let y = 0;
+	let z = 0;
+	for (let n = node; n; n = n.parent) {
+		const [px, py, pz] = positionOf$1(n);
+		x += px;
+		y += py;
+		z += pz;
+	}
+	return [
+		x,
+		y,
+		z
+	];
+}
+/** Trigger volumes are destinations even without a script — that IS their job. */
+const TRIGGERS = new Set(["Area2D", "Area3D"]);
+/**
+* Is this node somewhere the player is meant to GO?
+*
+* Author intent, not geometry. Keying off the tree alone reported 150 unreached
+* nodes on the village scene and 138 of them were roof beams and fence posts —
+* a report nobody would read twice. A node is a destination when the author
+* marked it as one: it runs a behavior, it carries a group, or it is a trigger
+* volume. Decoration is silent.
+*/
+function isTarget(node) {
+	const type = node.constructor.typeName ?? "";
+	if (type.startsWith("Ui")) return false;
+	if (TRIGGERS.has(type)) return true;
+	if (node.groups.size > 0) return true;
+	return node.script?.name !== void 0;
+}
+/**
+* What the SCENE says winning and losing are.
+*
+* Nothing here is a heuristic about game design — `GameFlow` already models
+* `'won'`/`'gameover'`, `ScoreKeeper` already emits `won`/`lost`, and `Health`
+* already emits `died`. The scene declared all of it; this only listens.
+*/
+function makeOracle(engine, player) {
+	let outcome = null;
+	let damage = 0;
+	const offs = [];
+	let declaresEnd = false;
+	/** First verdict wins — a run ends at its first conclusion, not its last. */
+	const settle = (verdict) => {
+		if (outcome === null) outcome = verdict;
+	};
+	const isPlayerSide = (node) => {
+		for (let at = node; at; at = at.parent) if (at === player) return true;
+		return false;
+	};
+	const walk = (node) => {
+		if (node.behavior) for (const signal of node.declaredSignalNames()) {
+			if (signal === "won" || signal === "lost" || signal === "flowChanged") declaresEnd = true;
+			if (signal === "won") offs.push(node.on(signal, () => settle("won")));
+			if (signal === "lost") offs.push(node.on(signal, () => settle("lost")));
+			if (signal === "died" && isPlayerSide(node)) offs.push(node.on(signal, () => settle("lost")));
+			if (signal === "damaged" && isPlayerSide(node)) offs.push(node.on(signal, () => {
+				damage += 1;
+			}));
+			if (signal === "flowChanged") offs.push(node.on(signal, (state) => {
+				if (state === "won") settle("won");
+				if (state === "gameover") settle("lost");
+			}));
+		}
+		for (const child of node.children) walk(child);
+	};
+	const root = engine.scene?.root;
+	if (root) walk(root);
+	return {
+		outcome: () => outcome,
+		declaresEnd: () => declaresEnd,
+		damage: () => damage,
+		dispose: () => {
+			for (const off of offs) off();
+		}
+	};
+}
+/**
+* A monkey with a memory.
+*
+* Not an attempt to play well — an attempt to play DIFFERENTLY, which is what
+* makes automated testers find what humans do not. It holds a direction for a
+* while (a per-frame coin flip goes nowhere), presses buttons at intervals, and
+* biases its next heading toward the part of the world it has visited least.
+* That last part is the whole difference between "wanders near spawn forever"
+* and "eventually finds the door".
+*/
+var Driver = class {
+	engine;
+	rand;
+	heading = 0;
+	headingLeft = 0;
+	visits = /* @__PURE__ */ new Map();
+	buttons;
+	/**
+	* Buttons the bot pressed and will never press again, because pressing them
+	* STOPPED THE CLOCK.
+	*
+	* It drove every declared button action, and `incanto-your-first-game.md`
+	* tells you to declare `pause`. Measured on one losable scene: 0/10 losses
+	* with `pause` declared, 10/10 without it, same seed, same everything else.
+	* A frozen game cannot hurt you, so the run also reported the game as having
+	* no way to lose.
+	*
+	* This is OBSERVED, not guessed from the name — a game is free to call it
+	* `menu`, `escape`, `halt` or nothing at all, and the bot notices the same
+	* way a player would: the world stopped moving.
+	*/
+	frozeTheGame = /* @__PURE__ */ new Set();
+	/**
+	* Buttons an EARLIER run proved reload the scene, so this one never tries.
+	*
+	* Unlike a pause, a restart cannot be recovered from mid-run — the tree the
+	* driver holds is gone — so the blame has to outlive the run that paid for
+	* it. One run of the ten is spent learning; the other nine play the game.
+	*/
+	avoid = /* @__PURE__ */ new Set();
+	/** What was pressed most recently, so a freeze can be attributed to it. */
+	lastPressed = null;
+	moveAction;
+	/** The button the scene's controller calls its jump — `jump` unless it says otherwise. */
+	jumpButton = "jump";
+	/**
+	* The action vocabulary this driver was bound to, so it can notice a swap.
+	*
+	* A game that changes scene changes its `input{}` with it, and the bot had
+	* captured the FIRST scene's list once, in the constructor. So it went on
+	* pressing buttons the new scene never declared — and `releaseAction` on an
+	* action the current scene does not declare is a hard `BAD_FORMAT`, which is
+	* correct for game code and fatal here: it threw out of `runOnce`, and an
+	* eight-run playtest of a two-scene game died with a raw stack trace instead
+	* of eight results.
+	*
+	* Measured on `examples/village-quest-3d`, whose grove declares `pause` and
+	* whose village does not:
+	*
+	* ```
+	* ✗ plays — the playtest could not run — playtest failed: Unknown input
+	*   action 'pause'. Declared actions: [move, jump, sprint, interact, attack,
+	*   restart].
+	* ```
+	*
+	* The report has always called `swapped` a normal outcome. The driver had not
+	* been told.
+	*/
+	vocabulary = "";
+	held = /* @__PURE__ */ new Map();
+	/**
+	* Everything in the scene a click can reach.
+	*
+	* The bot drove declared ACTIONS and nothing else, so on a mouse game it could
+	* only ever watch. Measured across one round: a turn-based tactics game, a
+	* tower defense and a duel all reported the identical
+	* `? plays — 8 runs played without reaching a win`, and nobody filed it
+	* because the message is gracious about it. A whole class — tactics, RTS,
+	* tower defense, point-and-click, board games — was structurally unmeasurable
+	* by the rung that exists to answer "does this game work".
+	*
+	* Headless there is no raycast, so a picker is installed that answers from the
+	* TREE — the exact recipe `incanto-physics-and-input.md` gives for testing a
+	* mouse game — and the click goes through the real `Clickable`, the real
+	* `mouseJustPressed` edge, and the real connection. Nothing is faked but the
+	* cursor's arrival.
+	*/
+	clickables;
+	/**
+	* Does anything in this game ASK about the mouse?
+	*
+	* `Clickable` is a closed list of one beside the open set it stands for —
+	* every behaviour that reads the cursor. A drag-and-launch, a drawing game, a
+	* box-select and a swipe carry no `Clickable` at all, and the bot reported
+	* them as games nobody could drive.
+	*
+	* Read from the behaviour's own source, which is the only place the question
+	* is answerable before a frame has run. Property names survive minification,
+	* so this holds in a built game too.
+	*/
+	readsMouse;
+	view;
+	drags = 0;
+	dragCooldown = 0;
+	/** Frames left in the gesture in flight; 0 = none. */
+	dragFrames = 0;
+	dragFrom = [0, 0];
+	dragTo = [0, 0];
+	clickCooldown = 0;
+	/**
+	* HUD widgets pressed this run — the whole interface of a menu game.
+	*
+	* The bot looked for a character controller, a `player` group, a node named
+	* Player, a `Clickable`, and a behaviour that reads the cursor. A `UiButton`
+	* was on none of those lists, so an idle game built from the tarball — whose
+	* every verb is a button — reported
+	*
+	*   · nothing here is drivable … there was nobody to move and nothing to
+	*     point at
+	*   ✗ stuck in 2/2
+	*
+	* about a game that plays perfectly. The same closed-dictionary shape the
+	* `click` step had one layer up, and the same answer: press them.
+	*/
+	presses = 0;
+	/** Declared button actions pressed — see `PlaytestRun.actionPresses`. */
+	actionPresses = 0;
+	/** HUD drags that landed — see `PlaytestRun.widgetDrags`. */
+	widgetDrags = 0;
+	dragWidgetCooldown = 0;
+	pressCooldown = 0;
+	clicking = null;
+	/** press -> release -> let go. `clicked` fires on RELEASE, so the picker must
+	*  still be answering with the same node on the frame the release is read. */
+	clickPhase = "idle";
+	constructor(engine, rand) {
+		this.engine = engine;
+		this.rand = rand;
+		this.moveAction = null;
+		this.buttons = [];
+		this.rebind();
+		this.clickables = [];
+		const root = engine.scene?.root;
+		let asks = false;
+		if (root) {
+			const walk = (node) => {
+				if (node.behavior?.constructor.name === "Clickable") this.clickables.push(node);
+				if (node.behavior && ASKS_ABOUT_THE_MOUSE.test(node.behavior.constructor.toString())) asks = true;
+				for (const child of node.children) walk(child);
+			};
+			walk(root);
+			if (this.clickables.length > 0 && !engine.picker) engine.picker = () => this.clicking;
+			if (asks && !engine.toWorld) {
+				const view = geometricView(() => engine.scene);
+				engine.toWorld = view.toWorld;
+				engine.toScreen ??= view.toScreen;
+			}
+		}
+		if (root) {
+			const stack = [root];
+			while (stack.length > 0) {
+				const node = stack.pop();
+				if (CONTROLLERS.has(node.constructor.typeName ?? "")) {
+					const want = node.jumpAction;
+					if (typeof want === "string" && want !== "") this.jumpButton = want;
+					break;
+				}
+				for (const child of node.children) stack.push(child);
+			}
+		}
+		this.readsMouse = asks;
+		const design = engine.scene?.viewport?.design;
+		this.view = [design?.[0] ?? 960, design?.[1] ?? 540];
+	}
+	/** How many nodes this bot can click. Reported, so a ✓ says what it drove. */
+	get clickableCount() {
+		return this.clickables.length;
+	}
+	/**
+	* Clicks this run LANDED — the half the report was missing.
+	*
+	* The bot has driven the mouse for a while; nothing counted it. So a flip
+	* puzzle whose every tile the bot clicked, whose `clicked` wires all fired
+	* and whose board changed state, was reported as
+	* `nothing here is drivable … the runs went nowhere because there was nobody
+	* to move`, every run `stuck`, and the ladder's advice was to add a character
+	* controller to a game that has no character. The evidence was in the same
+	* report's own `fired` list.
+	*/
+	get widgetsPressed() {
+		return this.presses;
+	}
+	/** Declared button actions pressed this run — the keyboard's share. */
+	get actionsPressed() {
+		return this.actionPresses;
+	}
+	/** HUD drags this run that landed on a drop target. */
+	get slotsDragged() {
+		return this.widgetDrags;
+	}
+	get clicksLanded() {
+		return this.clicks;
+	}
+	/** Drags this run COMPLETED — press, move, release. */
+	get dragsMade() {
+		return this.drags;
+	}
+	clicks = 0;
+	/** Grid cell key — coarse on purpose, this is novelty not navigation. */
+	cell(p) {
+		return `${Math.round(p[0] / 4)},${Math.round(p[2] / 4)}`;
+	}
+	/** Seconds the clock has been stopped for, so a hit-stop is not a pause. */
+	frozenFor = 0;
+	/** What was pressed when the clock stopped — read at the deadline, not then. */
+	frozeSuspect = null;
+	/** Actions this run avoided after they stopped the clock. */
+	paused() {
+		return [...this.frozeTheGame];
+	}
+	/** Never press these — an earlier run watched them reload the scene. */
+	avoidPressing(buttons) {
+		this.avoid = buttons;
+	}
+	/** Whatever was pressed most recently, so a reload can be attributed to it. */
+	blame() {
+		return this.lastPressed;
+	}
+	step(dt, at) {
+		this.rebind();
+		if (this.engine.timeScale === 0) {
+			if (this.frozenFor === 0) this.frozeSuspect = this.lastPressed;
+			this.frozenFor += dt;
+			if (this.frozenFor >= .5) {
+				if (this.frozeSuspect) this.frozeTheGame.add(this.frozeSuspect);
+				for (const button of this.buttons) {
+					this.engine.input.releaseAction(button);
+					this.held.set(button, -1);
+				}
+				this.engine.timeScale = 1;
+				this.lastPressed = null;
+				this.frozeSuspect = null;
+				this.frozenFor = 0;
+			}
+		} else this.frozenFor = 0;
+		this.visits.set(this.cell(at), (this.visits.get(this.cell(at)) ?? 0) + 1);
+		this.headingLeft -= dt;
+		if (this.headingLeft <= 0) {
+			this.heading = this.pickHeading(at);
+			this.headingLeft = .4 + this.rand() * 1.2;
+		}
+		if (this.moveAction) this.engine.input.setActionVector(this.moveAction, Math.cos(this.heading), Math.sin(this.heading));
+		for (const button of this.buttons) {
+			if (this.frozeTheGame.has(button) || this.avoid.has(button)) continue;
+			const left = (this.held.get(button) ?? 0) - dt;
+			if (left > 0) {
+				this.held.set(button, left);
+				continue;
+			}
+			if (left > -.05 && left <= 0) {
+				this.engine.input.releaseAction(button);
+				this.held.set(button, -1);
+				continue;
+			}
+			const chance = button === this.jumpButton ? .06 : .02;
+			if (this.rand() < chance) {
+				this.engine.input.pressAction(button);
+				this.actionPresses += 1;
+				this.lastPressed = button;
+				this.held.set(button, .08 + this.rand() * .12);
+			}
+		}
+		this.maybeClick(dt);
+		this.maybeDrag(dt);
+		this.maybePressWidget(dt);
+		this.maybeDragWidget(dt);
+	}
+	/**
+	* Every focusable widget a player can currently see.
+	*
+	* Recomputed each time rather than captured: a menu game's buttons come and
+	* go — a shop opens, a pause panel closes — and `HudLayer.focusables()`
+	* already answers "on screen only", walking no further into a hidden panel
+	* than a player's eye does.
+	*/
+	shownWidgets() {
+		const root = this.engine.scene?.root;
+		if (!root) return [];
+		const out = [];
+		const walk = (node) => {
+			if (node instanceof HudLayer) {
+				out.push(...node.focusables());
+				return;
+			}
+			for (const child of node.children) walk(child);
+		};
+		walk(root);
+		return out;
+	}
+	/** Press one of them, occasionally — the menu game's equivalent of a step. */
+	maybePressWidget(dt) {
+		this.pressCooldown -= dt;
+		if (this.pressCooldown > 0) return;
+		this.pressCooldown = .25;
+		const widgets = this.shownWidgets();
+		if (widgets.length === 0) return;
+		const target = widgets[Math.floor(this.rand() * widgets.length)];
+		if (!target) return;
+		target._activate(this.rand() < .5 ? 0 : this.rand() < .5 ? -1 : 1);
+		this.presses += 1;
+	}
+	/** Every widget in the tree that can be picked up, or dropped onto. */
+	dragParts() {
+		const root = this.engine.scene?.root;
+		const items = [];
+		const targets = [];
+		if (!root) return {
+			items,
+			targets
+		};
+		const walk = (node) => {
+			if (node instanceof HudWidgetBase) {
+				if (!node.visible) return;
+				if (node.draggable) items.push(node);
+				if (node.dropTarget) targets.push(node);
+			}
+			for (const child of node.children) walk(child);
+		};
+		walk(root);
+		return {
+			items,
+			targets
+		};
+	}
+	/**
+	* Pick something up and put it somewhere, occasionally.
+	*
+	* `dropOnto` is the same entry point a harness uses and the same rules as the
+	* pointer path — a drop back into the slot it came from is not a move, so the
+	* bot picks a target that is not the item's own parent and lets the widget
+	* refuse anything else.
+	*/
+	maybeDragWidget(dt) {
+		this.dragWidgetCooldown -= dt;
+		if (this.dragWidgetCooldown > 0) return;
+		this.dragWidgetCooldown = .3;
+		const { items, targets } = this.dragParts();
+		if (items.length === 0 || targets.length === 0) return;
+		const item = items[Math.floor(this.rand() * items.length)];
+		const target = targets[Math.floor(this.rand() * targets.length)];
+		if (!item || !target || item === target || item.parent === target) return;
+		if (item.dropOnto(target)) this.widgetDrags += 1;
+	}
+	/**
+	* Press and release over one Clickable, occasionally.
+	*
+	* `clicked` fires on RELEASE over the same node the press started on, so this
+	* has to hold the target across two frames — which is also what makes it a
+	* real click rather than a synthetic signal.
+	*/
+	/**
+	* Drag: press somewhere, move, let go somewhere else.
+	*
+	* The gesture `maybeClick` cannot make and a whole genre is made of — a
+	* slingshot pulled back, a box drawn across a map, a swipe. The points are in
+	* the scene's own design rect, which in 2D IS world space (the coordinates
+	* every position in the file is written in) and in 3D is the canvas.
+	*
+	* Only when the game asks about the mouse: a game that never reads the cursor
+	* must not be handed gestures it cannot see, which would make the report a
+	* claim about a game nobody shipped.
+	*/
+	maybeDrag(dt) {
+		if (!this.readsMouse || this.clickPhase !== "idle") return;
+		if (this.dragFrames > 0) {
+			this.dragFrames -= 1;
+			const done = this.dragFrames === 0;
+			const t = done ? 1 : 1 - this.dragFrames / DRAG_FRAMES;
+			this.engine.input.setPointerPosition((this.dragFrom[0] ?? 0) + ((this.dragTo[0] ?? 0) - (this.dragFrom[0] ?? 0)) * t, (this.dragFrom[1] ?? 0) + ((this.dragTo[1] ?? 0) - (this.dragFrom[1] ?? 0)) * t);
+			if (done) {
+				this.engine.input.handleMouseButton(0, false);
+				this.drags += 1;
+			}
+			return;
+		}
+		this.dragCooldown -= dt;
+		if (this.dragCooldown > 0) return;
+		this.dragCooldown = .4 + this.rand() * .8;
+		const scene = this.engine.scene;
+		const [w, h] = this.view;
+		const view = scene ? viewRect2D(scene.dimension === "2d" ? camera2D(place(scene)) : null, w, h) : {
+			minX: 0,
+			minY: 0,
+			maxX: w,
+			maxY: h
+		};
+		const at = () => [view.minX + this.rand() * (view.maxX - view.minX), view.minY + this.rand() * (view.maxY - view.minY)];
+		this.dragFrom = at();
+		this.dragTo = at();
+		this.dragFrames = DRAG_FRAMES;
+		this.engine.input.setPointerPosition(this.dragFrom[0], this.dragFrom[1]);
+		this.engine.input.handleMouseButton(0, true);
+	}
+	maybeClick(dt) {
+		if (this.clickables.length === 0) return;
+		this.engine.input.setPointerPosition(1, 1);
+		if (this.clickPhase === "pressed") {
+			this.engine.input.handleMouseButton(0, false);
+			this.clickPhase = "released";
+			return;
+		}
+		if (this.clickPhase === "released") {
+			this.clicking = null;
+			this.clickPhase = "idle";
+			return;
+		}
+		this.clickCooldown -= dt;
+		if (this.clickCooldown > 0) return;
+		this.clickCooldown = .25 + this.rand() * .6;
+		const target = this.clickables[Math.floor(this.rand() * this.clickables.length)];
+		if (!target || target.tree === null) return;
+		this.clicking = target;
+		this.clickPhase = "pressed";
+		this.clicks += 1;
+		this.engine.input.handleMouseButton(0, true);
+	}
+	/** Prefer the least-visited neighbouring cell; ties break randomly. */
+	pickHeading(at) {
+		let best = Number.POSITIVE_INFINITY;
+		let bestAngle = this.rand() * Math.PI * 2;
+		for (let i = 0; i < 8; i++) {
+			const angle = i / 8 * Math.PI * 2 + this.rand() * .3;
+			const probe = [
+				at[0] + Math.cos(angle) * 4,
+				at[1],
+				at[2] + Math.sin(angle) * 4
+			];
+			const seen = (this.visits.get(this.cell(probe)) ?? 0) + this.rand();
+			if (seen < best) {
+				best = seen;
+				bestAngle = angle;
+			}
+		}
+		return bestAngle;
+	}
+	/**
+	* Re-read the action list, and forget what the last scene declared.
+	*
+	* Called every step, not just on a swap: `declaredActions()` is a handful of
+	* strings, and the alternative is a flag somebody has to remember to set.
+	* Buttons that survive the swap keep their hold timer; ones that do not are
+	* dropped WITHOUT a release, because there is nothing left to release them
+	* on.
+	*/
+	rebind() {
+		const declared = this.engine.input.declaredActions();
+		const signature = declared.map((a) => `${a.type}:${a.name}`).join(",");
+		if (signature === this.vocabulary) return;
+		this.vocabulary = signature;
+		this.moveAction = declared.find((a) => a.type === "vector2")?.name ?? null;
+		this.buttons = declared.filter((a) => a.type === "button").map((a) => a.name);
+		const still = new Set(this.buttons);
+		for (const button of [...this.held.keys()]) if (!still.has(button)) this.held.delete(button);
+		if (this.lastPressed && !still.has(this.lastPressed)) this.lastPressed = null;
+		if (this.frozeSuspect && !still.has(this.frozeSuspect)) this.frozeSuspect = null;
+	}
+	release() {
+		this.rebind();
+		for (const button of this.buttons) this.engine.input.releaseAction(button);
+		if (this.moveAction) this.engine.input.setActionVector(this.moveAction, 0, 0);
+	}
+};
+async function runOnce(json, seed, opts, avoid = /* @__PURE__ */ new Set()) {
+	const session = await createPlaySession(json, {
+		seed,
+		...opts.behaviors ? { behaviors: opts.behaviors } : {},
+		stubMissingBehaviors: opts.stubMissingBehaviors ?? true,
+		...opts.resolveScene ? { resolveScene: opts.resolveScene } : {}
+	});
+	const { engine, scene } = session;
+	const player = findPlayer(scene.root);
+	const oracle = makeOracle(engine, player);
+	const targets = [];
+	const signals = [];
+	const fired = /* @__PURE__ */ new Set();
+	const offs = [];
+	const wired = /* @__PURE__ */ new Set();
+	for (const conn of scene.source.connections ?? []) {
+		if (typeof conn.from !== "string" || typeof conn.signal !== "string") continue;
+		const node = scene.root.getNodeOrNull(conn.from);
+		if (node) wired.add(`${node.getPath()}.${conn.signal}`);
+	}
+	/**
+	* Wired signals inside a screen-space subtree — collected, not walked.
+	*
+	* The early return below drops the whole HUD, which is right for TARGETS (a
+	* HUD is not somewhere the player can walk) and took the signals with it. So
+	* every wire an author draws on a widget — `pressed` on a button, `changed`
+	* on a slider, `dropped` on an inventory slot — was invisible to the line
+	* that exists to say "this wire does nothing", for the entire HUD.
+	*/
+	const collectSignals = (node) => {
+		for (const signal of node.declaredSignalNames()) {
+			const key = `${node.getPath()}.${signal}`;
+			if (wired.has(key)) signals.push(key);
+			offs.push(node.on(signal, () => void fired.add(key)));
+		}
+		for (const child of node.children) collectSignals(child);
+	};
+	const walkAll = (node) => {
+		if (SCREEN_SPACE.has(node.constructor.typeName ?? "")) {
+			collectSignals(node);
+			return;
+		}
+		const isDestination = node !== player && isTarget(node);
+		if (isDestination) targets.push(node.getPath());
+		for (const signal of node.declaredSignalNames()) {
+			const key = `${node.getPath()}.${signal}`;
+			if (wired.has(key) || isDestination) signals.push(key);
+			offs.push(node.on(signal, () => void fired.add(key)));
+		}
+		for (const child of node.children) walkAll(child);
+	};
+	walkAll(scene.root);
+	const hazards = countHazardsIn(json);
+	const targetNodes = [];
+	const collect = (node) => {
+		if (SCREEN_SPACE.has(node.constructor.typeName ?? "")) return;
+		if (node !== player && isTarget(node)) targetNodes.push([node.getPath(), node]);
+		for (const child of node.children) collect(child);
+	};
+	collect(scene.root);
+	const start = player ? worldOf(player) : [
+		0,
+		0,
+		0
+	];
+	const down = scene.dimension === "2d" ? 1 : -1;
+	const pull = gravityMagnitude(scene.physics);
+	const topDown = hasTopDownController(scene.root);
+	const floor = opts.fallBelow ?? (pull > 0 && !topDown ? start[1] + down * (down > 0 ? FALL_2D_PX : 50) : null);
+	const radius = opts.reachRadius ?? (down > 0 ? REACH_2D_PX : 2);
+	const recorder = startRecording(engine);
+	const botRng = new Rng((seed ^ 2654435769) >>> 0);
+	const rand = () => botRng.next();
+	const driver = new Driver(engine, rand);
+	driver.avoidPressing(avoid);
+	const reached = /* @__PURE__ */ new Set();
+	const stepMs = 1e3 / 60;
+	const deadline = (opts.seconds ?? 60) * 1e3;
+	let outcome = null;
+	let swappedAtMs = null;
+	let restartedBy = null;
+	const heardSoFar = /* @__PURE__ */ new Set();
+	const shownSoFar = /* @__PURE__ */ new Set();
+	const playing = scene.source.name;
+	const offSwap = engine.sceneChanged.connect((next) => {
+		swappedAtMs ??= session.timeMs;
+		if (next && next.source.name === playing) restartedBy ??= driver.blame();
+	});
+	let at = start;
+	let wentAsFarAs = 0;
+	const travelled = (a, b) => scene.dimension === "2d" ? Math.hypot((a[0] ?? 0) - (b[0] ?? 0), (a[1] ?? 0) - (b[1] ?? 0)) : Math.hypot((a[0] ?? 0) - (b[0] ?? 0), (a[2] ?? 0) - (b[2] ?? 0));
+	const cloneCensus = () => {
+		const out = /* @__PURE__ */ new Map();
+		const walk = (node) => {
+			if (isCloned(node)) {
+				const at2 = node.wiringPath();
+				out.set(at2, (out.get(at2) ?? 0) + 1);
+				return;
+			}
+			for (const child of node.children) walk(child);
+		};
+		const root = engine.scene?.root;
+		if (root) walk(root);
+		return out;
+	};
+	let halfway = null;
+	while (session.timeMs < deadline) {
+		if (halfway === null && session.timeMs >= deadline / 2) halfway = cloneCensus();
+		at = player ? worldOf(player) : start;
+		wentAsFarAs = Math.max(wentAsFarAs, travelled(at, start));
+		driver.step(stepMs / 1e3, at);
+		for (const path of engine.audio.sources()) heardSoFar.add(path);
+		for (const path of engine.effects.sources()) shownSoFar.add(path);
+		session.step(stepMs);
+		if (player) for (const [path, node] of targetNodes) {
+			if (reached.has(path)) continue;
+			const p = worldOf(node);
+			if (Math.hypot(at[0] - p[0], at[1] - p[1], at[2] - p[2]) <= radius) reached.add(path);
+		}
+		const verdict = oracle.outcome();
+		if (verdict) {
+			outcome = verdict;
+			break;
+		}
+		if (engine.stats().errors > 0) {
+			outcome = "error";
+			break;
+		}
+		if (player && floor !== null && (at[1] - floor) * down > 0) {
+			outcome = "fell";
+			break;
+		}
+		if (swappedAtMs !== null) {
+			outcome = "swapped";
+			break;
+		}
+	}
+	driver.release();
+	offSwap();
+	const aliveClones = [...cloneCensus()].map(([path, count]) => ({
+		path,
+		count,
+		half: halfway?.get(path) ?? 0
+	})).sort((a, b) => b.count - a.count);
+	const WENT_NOWHERE = scene.dimension === "2d" ? STUCK_2D_PX : STUCK_3D_M;
+	outcome ??= wentAsFarAs > WENT_NOWHERE || driver.clicksLanded > 0 || driver.dragsMade > 0 || driver.widgetsPressed > 0 || driver.slotsDragged > 0 ? "unfinished" : "stuck";
+	for (const path of engine.audio.sources()) heardSoFar.add(path);
+	for (const path of engine.effects.sources()) shownSoFar.add(path);
+	const heard = [...heardSoFar];
+	const shown = [...shownSoFar];
+	const bad = outcome !== "won" && outcome !== "unfinished";
+	const run = {
+		seed,
+		outcome,
+		timeMs: session.timeMs,
+		reached: [...reached],
+		fired: [...fired],
+		damageTaken: oracle.damage(),
+		errors: engine.stats().errors,
+		errorMessages: logLines(engine, "error"),
+		aliveClones,
+		warnings: logLines(engine, "warn"),
+		replay: bad ? recorder.stop() : null,
+		endedAt: at,
+		heard: [...new Set(heard)],
+		shown: [...new Set(shown)],
+		clicks: driver.clicksLanded,
+		drags: driver.dragsMade,
+		presses: driver.widgetsPressed,
+		actionPresses: driver.actionsPressed,
+		widgetDrags: driver.slotsDragged
+	};
+	if (!bad) recorder.stop();
+	for (const off of offs) off();
+	oracle.dispose();
+	const unreadNow = session.engine.input.unreadActions();
+	session.dispose();
+	return {
+		run,
+		targets,
+		signals,
+		declaresEnd: oracle.declaresEnd(),
+		hazards,
+		hasPlayer: player !== null,
+		froze: driver.paused(),
+		restartedBy,
+		unread: unreadNow
+	};
+}
+/**
+* How many nodes the scene FILE wires to hurt the player.
+*
+* Read from the JSON, not the tree: a `Spawner` detaches its prefab at ready, so
+* a wave game's hazards exist only in the file until the first wave lands.
+*/
+function countHazardsIn(json) {
+	let n = 0;
+	const walk = (node) => {
+		if (typeof node !== "object" || node === null) return;
+		const nd = node;
+		if (nd.script?.name === "DamageOnContact") n += 1;
+		if (Array.isArray(nd.children)) for (const child of nd.children) walk(child);
+	};
+	walk(json?.root);
+	return n;
+}
+/** Play the scene `runs` times and report what happened. */
+async function playtest(json, opts = {}) {
+	const count = Number.isFinite(opts.runs) ? Math.max(1, opts.runs) : 20;
+	const base = opts.seed ?? 1;
+	const runs = [];
+	let targets = [];
+	let signals = [];
+	let declaresWin = false;
+	let hasPlayer = false;
+	let hazards = 0;
+	const froze = /* @__PURE__ */ new Set();
+	const restarted = /* @__PURE__ */ new Set();
+	/**
+	* An action is inert only if NO run read it — one run that took a branch the
+	* others missed is enough to clear it.
+	*/
+	let unread = null;
+	for (let i = 0; i < count; i++) {
+		resetMemorySaves();
+		const one = await runOnce(json, base + i, opts, restarted);
+		runs.push(one.run);
+		targets = one.targets;
+		signals = one.signals;
+		declaresWin = declaresWin || one.declaresEnd;
+		hasPlayer = hasPlayer || one.hasPlayer;
+		hazards = one.hazards;
+		for (const action of one.froze) froze.add(action);
+		if (one.restartedBy) restarted.add(one.restartedBy);
+		unread = unread === null ? one.unread : unread.filter((a) => one.unread.includes(a));
+	}
+	const probe = await createPlaySession(json, {
+		seed: base,
+		stubMissingBehaviors: opts.stubMissingBehaviors ?? true,
+		...opts.resolveScene ? { resolveScene: opts.resolveScene } : {}
+	});
+	const actions = probe.engine.input.declaredActions().map((a) => a.name);
+	const feedbackNodes = {
+		audio: [],
+		effects: []
+	};
+	const walkFeedback = (node) => {
+		const type = node.constructor.typeName ?? "";
+		const path = node.getPath();
+		if (type === "AudioPlayer") feedbackNodes.audio.push(path);
+		if (EFFECT_NODE_TYPES.has(type)) feedbackNodes.effects.push(path);
+		for (const child of node.children) walkFeedback(child);
+	};
+	const walkFeedbackJson = (value, path = "") => {
+		if (!value || typeof value !== "object") return;
+		const node = value;
+		if (node.root !== void 0) {
+			walkFeedbackJson(node.root, "");
+			return;
+		}
+		if (typeof node.name !== "string") return;
+		const here = `${path}/${node.name}`;
+		if (node.type === "AudioPlayer" && !feedbackNodes.audio.includes(here)) feedbackNodes.audio.push(here);
+		if (typeof node.type === "string" && EFFECT_NODE_TYPES.has(node.type) && !feedbackNodes.effects.includes(here)) feedbackNodes.effects.push(here);
+		if (Array.isArray(node.children)) for (const child of node.children) walkFeedbackJson(child, here);
+	};
+	const probeRoot = probe.scene.tree.root;
+	if (probeRoot) walkFeedback(probeRoot);
+	probe.dispose();
+	walkFeedbackJson(json);
+	return {
+		runs,
+		targets,
+		signals: [...new Set(signals)],
+		actions,
+		inertActions: unread ?? [],
+		errorMessages: [...new Set(runs.flatMap((r) => r.errorMessages))],
+		warnings: [...new Set(runs.flatMap((r) => r.warnings))],
+		declaresWin,
+		hasPlayer,
+		hazards,
+		froze: [...froze],
+		restarted: [...restarted],
+		seconds: opts.seconds ?? 60,
+		feedback: {
+			declaredAudio: feedbackNodes.audio,
+			declaredEffects: feedbackNodes.effects,
+			heard: [...new Set(runs.flatMap((r) => r.heard))],
+			shown: [...new Set(runs.flatMap((r) => r.shown))]
+		}
+	};
+}
+/**
+* The error lines the engine logged during a run, deduped and trimmed to the
+* sentence that identifies the fault.
+*
+* A quarantined script reports ONCE per node — the engine already made sure of
+* that — but two runs of the same broken game produce the same line twice, and
+* a report that prints it twenty times is a report nobody reads to the end.
+*/
+function logLines(engine, level) {
+	const out = /* @__PURE__ */ new Set();
+	for (const entry of engine.log.entries()) {
+		if (entry.level !== level) continue;
+		const said = entry.parts.map((part) => part instanceof Error ? `${part.name}: ${part.message}` : String(part)).join(" ").replace(/^\[incanto\] /, "").replace(/\s+/g, " ").trim();
+		if (said) out.add(said);
+	}
+	return [...out];
+}
+function pct(n, total) {
+	return `${n}/${total}`;
+}
+function median(values) {
+	if (values.length === 0) return 0;
+	const s = [...values].sort((a, b) => a - b);
+	return s[Math.floor(s.length / 2)];
+}
+/**
+* The report, as prose an agent reads and a person skims.
+*
+* Deliberately says what is WRONG and stays quiet about what is fine — a wall
+* of green is a wall nobody reads.
+*/
+function playtestText(report) {
+	const { runs, targets, signals, hazards } = report;
+	const total = runs.length;
+	const lines = [];
+	lines.push(`${total} runs × up to ${report.seconds}s`);
+	lines.push("");
+	const won = runs.filter((r) => r.outcome === "won");
+	if (won.length > 0) lines.push(`  ✓ reached "won" in ${pct(won.length, total)}   median ${Math.round(median(won.map((r) => r.timeMs)) / 1e3)}s`);
+	else lines.push(report.declaresWin ? `  ✗ never reached "won" in ${total} runs — a win IS declared, and no run got to it` : `  · no win declared in this scene — nothing emits won/lost, so there is nothing to reach`);
+	/**
+	* How the runs ENDED — and the one section below the player-less branch's
+	* early `return` that was never about walking.
+	*
+	* A mouse game whose behaviour threw was reported as `never reached "won"`,
+	* because everything after that return was written off as "about someone
+	* WALKING" and this list went with it. Only `fell` is; the rest is how the
+	* run ended, which every game has. `playtestFailed` knew (exit 1 on `error`)
+	* while the prose beside it did not, and an instrument's exit code and its
+	* own report must not know different things.
+	*/
+	const pushWarnings = () => {
+		const said = report.warnings ?? [];
+		if (said.length === 0) return;
+		lines.push(`  ! ${said[0]}`);
+		for (const line of said.slice(1, 3)) lines.push(`  ! ${line}`);
+		if (said.length > 3) lines.push(`  ! … and ${said.length - 3} more`);
+	};
+	/**
+	* What the runs were still holding when they ended, by template.
+	*
+	* The MEDIAN across runs, because one run that happened to end mid-wave says
+	* less than what every run ends with. Reported, never judged: `4 × Tower` is
+	* furniture and `5 × Bolt` is a leak, and the engine cannot tell which of an
+	* author's clones are meant to outlive the run — but the author can, in one
+	* glance, which is exactly what was missing when a shipped game kept every
+	* projectile that missed alive forever.
+	*/
+	const pushAlive = () => {
+		const worst = /* @__PURE__ */ new Map();
+		for (const run of runs) for (const { path, count, half } of run.aliveClones ?? []) {
+			const at = worst.get(path);
+			if (!at || count > at.end) worst.set(path, {
+				end: count,
+				half
+			});
+		}
+		const named = [...worst].filter(([, x]) => x.end >= 4).map(([path, x]) => ({
+			path,
+			...x
+		})).sort((a, b) => b.end - a.end);
+		if (named.length === 0) return;
+		const shown = named.slice(0, 3).map((x) => `${x.end} × ${x.path} (${x.half} at halfway)`);
+		lines.push(`  · made and still held: ${shown.join(", ")}` + (named.length > 3 ? ` (+${named.length - 3} more)` : "") + " — clones alive when the run ended, and how many there were at the halfway mark. Furniture holds steady; a leak climbs.");
+	};
+	const pushOutcomes = () => {
+		for (const bad of [
+			"error",
+			"fell",
+			"lost",
+			"stuck",
+			"unfinished",
+			"swapped"
+		]) {
+			const hits = runs.filter((r) => r.outcome === bad);
+			if (hits.length === 0) continue;
+			const where = bad === "fell" ? ` (last at y=${hits[0].endedAt[1].toFixed(1)})` : "";
+			const mark = bad === "unfinished" || bad === "swapped" ? "·" : "✗";
+			const what = bad === "unfinished" ? "ran out of time still playing" : bad === "swapped" ? "the game changed scene — this bot is bound to the tree it started in, so nothing after the swap was measured (not a defect)" : `${bad} in ${pct(hits.length, total)}`;
+			lines.push(bad === "unfinished" || bad === "swapped" ? `  ${mark} ${pct(hits.length, total)} ${what}` : `  ${mark} ${what}${where}`);
+			if (bad === "error") {
+				const said = report.errorMessages ?? [];
+				for (const line of said.slice(0, 3)) lines.push(`      ${line}`);
+				if (said.length > 3) lines.push(`      … and ${said.length - 3} more`);
+			}
+		}
+	};
+	const clicks = runs.reduce((n, r) => n + r.clicks, 0);
+	const drags = runs.reduce((n, r) => n + r.drags, 0);
+	const presses = runs.reduce((n, r) => n + r.presses, 0);
+	const keys = runs.reduce((n, r) => n + r.actionPresses, 0);
+	const slots = runs.reduce((n, r) => n + r.widgetDrags, 0);
+	if (!report.hasPlayer) {
+		const named = report.actions.slice(0, 4).join(", ");
+		const hands = [];
+		if (clicks > 0) hands.push(`${clicks} click(s)`);
+		if (drags > 0) hands.push(`${drags} drag(s)`);
+		if (presses > 0) hands.push(`${presses} HUD press(es)`);
+		if (slots > 0) hands.push(`${slots} slot drag(s)`);
+		if (keys > 0) hands.push(`${keys} press(es) of ${report.actions.length} declared action(s) (${named}${report.actions.length > 4 ? ", …" : ""})`);
+		lines.push(hands.length > 0 ? `  · played with ${hands.join(", ")} across ${total} runs, and no character to walk. Nothing below is about walking, so it is not reported.` + (keys > 0 ? " A game whose verbs are keys is played by TIMING them, which a random bot does not do — read the outcomes below as a floor, not a verdict." : "") : "  · nothing here is drivable — no character controller, no node in the `player` group, no node named Player, nothing carrying `Clickable`, no focusable HUD widget on screen, no declared input action, and no behaviour that reads the cursor. The runs went nowhere because there was nobody to move and nothing to press, not because anything is wedged.");
+		if ((clicks > 0 || drags > 0 || keys > 0 || slots > 0) && report.signals.length > 0) {
+			const fired = new Set(runs.flatMap((r) => r.fired));
+			const silent = report.signals.filter((s) => !fired.has(s));
+			lines.push(silent.length === 0 ? `  ✓ every one of the ${report.signals.length} wired signal(s) fired` : `  · ${report.signals.length - silent.length} of ${report.signals.length} wired signal(s) fired; never fired: ${silent.slice(0, 5).join(", ")}` + (silent.length > 5 ? ` (+${silent.length - 5} more)` : ""));
+		}
+		pushOutcomes();
+		pushWarnings();
+		if (report.froze.length > 0) lines.push(`  · the bot stopped pressing ${report.froze.map((x) => `\`${x}\``).join(", ")} — pressing it stopped the clock, and a run spent inside a pause menu measures nothing. Your game is fine; this is the bot getting out of its own way.`);
+		if (report.restarted.length > 0) lines.push(`  · the bot stopped pressing ${report.restarted.map((x) => `\`${x}\``).join(", ")} — pressing it reloaded the scene, which ends the run: the bot is bound to the tree it started in. One run paid for that; the rest played the game.`);
+		pushAlive();
+		return lines.join("\n");
+	}
+	pushOutcomes();
+	pushWarnings();
+	const everReached = new Set(runs.flatMap((r) => r.reached));
+	const missed = targets.filter((path) => !everReached.has(path));
+	const anySwapped = runs.some((r) => r.outcome === "swapped");
+	if (missed.length > 0 && anySwapped) lines.push(`  · ${missed.length} destination(s) unmeasured — a run changed scene and the bot stopped there. Judge these with a scripted run.`);
+	else if (missed.length > 0) {
+		lines.push("");
+		lines.push(`  never reached (${missed.length} of ${targets.length}):`);
+		for (const path of missed.slice(0, 12)) lines.push(`    ${path}`);
+		if (missed.length > 12) lines.push(`    …and ${missed.length - 12} more`);
+	}
+	const everFired = new Set(runs.flatMap((r) => r.fired));
+	const silent = signals.filter((s) => !everFired.has(s));
+	if (silent.length > 0) {
+		lines.push("");
+		lines.push(`  never fired (${silent.length} of ${signals.length}):`);
+		for (const s of silent.slice(0, 12)) lines.push(`    ${s}`);
+		if (silent.length > 12) lines.push(`    …and ${silent.length - 12} more`);
+	}
+	const damage = runs.reduce((n, r) => n + r.damageTaken, 0);
+	const lost = runs.filter((r) => r.outcome === "lost").length;
+	if (report.froze.length > 0) {
+		lines.push("");
+		lines.push(`  · the bot stopped pressing ${report.froze.map((a) => `\`${a}\``).join(", ")} — pressing it stopped the clock, and a run spent inside a pause menu measures nothing. Your game is fine; this is the bot getting out of its own way.`);
+	}
+	if (report.restarted.length > 0) {
+		lines.push("");
+		lines.push(`  · the bot stopped pressing ${report.restarted.map((a) => `\`${a}\``).join(", ")} — pressing it reloaded the scene, which ends the run: the bot is bound to the tree it started in. One run paid for that; the rest played the game.`);
+	}
+	pushAlive();
+	if (report.inertActions.length > 0) {
+		lines.push("");
+		lines.push(`  · declared and never read: ${report.inertActions.map((a) => `\`${a}\``).join(", ")} — the scene binds a key for it and no code asks whether it is pressed, so the control list promises something the game does not do. Read it, or drop it from \`input\`. (An action only polled on a screen no run reached is a false alarm.)`);
+	}
+	lines.push("");
+	if (damage > 0) lines.push(`  danger: ${damage} hits across ${total} runs (${(damage / total).toFixed(1)} per run)`);
+	else if (hazards === 0 && lost > 0) lines.push(`  danger: nothing DEALT DAMAGE — no DamageOnContact, no hazard group — and yet ${lost} of ${total} runs were lost. The loss comes from something else: a fall, a timer, a trigger, or running out of lives.`);
+	else if (hazards === 0) lines.push("  danger: nothing in this scene can hurt the player — no DamageOnContact, no hazard group. A game with no way to lose is a walkabout.");
+	else lines.push(`  danger: ${hazards} hazard(s) are wired and none of them landed a hit in ${total} runs. They may be unreachable — or the bot may simply have outrun them, which a real player would not. Judge it with a scripted run.`);
+	return lines.join("\n");
+}
+/**
+* Did this playtest find something WRONG? — the exit code, as a function.
+*
+* `incanto-playtest` exited 1 whenever no run reached a win, and its own report
+* says when that is not a failure. Measured on a walkabout scene:
+*
+* ```
+*   · no win declared in this scene — nothing emits won/lost, so there is
+*     nothing to reach
+*   · 2/2 ran out of time still playing
+*   $ echo $?
+*   1
+* ```
+*
+* The `·` is this file's own marker for "not applicable", printed above an exit
+* code that says failure — so a CI step on a walkabout, a title screen, or any
+* scene whose ending is a quest a random walker cannot finish is red forever,
+* and its author learns to stop reading it. `incanto-verify` already reads the
+* JSON and calls those `unmeasured`; only the standalone bin disagreed.
+*
+* What stays a failure regardless of a declared win: a run that THREW, and a
+* run that left the world. Neither is a matter of what the scene set out to be.
+*/
+function playtestFailed(report) {
+	const any = (o) => report.runs.some((r) => r.outcome === o);
+	if (any("error") || any("fell")) return true;
+	if (!report.hasPlayer) return false;
+	if (!report.declaresWin) return false;
+	return !any("won");
+}
+/** The failing runs worth saving, newest problem first. */
+function failingReplays(report) {
+	const order = [
+		"error",
+		"fell",
+		"stuck",
+		"lost"
+	];
+	return report.runs.filter((r) => r.replay !== null).sort((a, b) => order.indexOf(a.outcome) - order.indexOf(b.outcome)).map((r) => ({
+		seed: r.seed,
+		outcome: r.outcome,
+		replay: r.replay
+	}));
+}
+//#endregion
+//#region src/test/facing.ts
+const DEG2RAD = Math.PI / 180;
+/** The forward vector of a yaw (degrees) for a given art convention. */
+function forwardOf(yawDeg, axis) {
+	const yaw = yawDeg * DEG2RAD;
+	const base = [Math.sin(yaw), Math.cos(yaw)];
+	switch (axis) {
+		case "-z": return [-base[0], -base[1]];
+		case "+x": return [base[1], -base[0]];
+		case "-x": return [-base[1], base[0]];
+		default: return base;
+	}
+}
+/**
+* The skin, and the yaw the art is DECLARED to be rotated by.
+*
+* `skinYawOffset` is how a model that does not face +Z says so, and it is the
+* supported fix rather than a bug. Subtracting it is what stops this check
+* crying wolf on every correctly-configured non-+Z model.
+*/
+function findSkin(player, explicit) {
+	if (explicit) return {
+		skin: player.getNodeOrNull(explicit) ?? null,
+		declaredOffset: 0
+	};
+	for (const child of player.children) {
+		const ctl = child;
+		if (typeof ctl.skinPath === "string" && ctl.skinPath !== "") {
+			const skin = child.getNodeOrNull(ctl.skinPath);
+			if (skin) return {
+				skin,
+				declaredOffset: ctl.skinYawOffset ?? 0
+			};
+		}
+	}
+	return {
+		skin: player.getNodeOrNull("%Skin") ?? null,
+		declaredOffset: 0
+	};
+}
+/**
+* Drive the player forward and compare where the skin points with where it went.
+*
+* The travel direction is measured, not assumed: whatever the input map means by
+* "up", the character ends up going somewhere, and that somewhere is the truth
+* the art has to agree with.
+*/
+async function facingReport(json, opts = {}) {
+	const session = await createPlaySession(json, {
+		seed: opts.seed ?? 1,
+		...opts.behaviors ? { behaviors: opts.behaviors } : {},
+		stubMissingBehaviors: opts.stubMissingBehaviors ?? true,
+		...opts.resolveScene ? { resolveScene: opts.resolveScene } : {}
+	});
+	const player = findPlayer(session.scene.root);
+	if (!player) {
+		session.dispose();
+		return {
+			player: null,
+			skin: null,
+			dot: null,
+			backwards: false,
+			travelled: 0,
+			basis: null,
+			noAnswer: "no-player"
+		};
+	}
+	const is2d = session.scene.dimension === "2d";
+	const declared = session.engine.input.declaredActions();
+	const move = opts.moveAction ?? declared.find((a) => a.type === "vector2")?.name ?? null;
+	const posOf = () => {
+		const p = player.position;
+		return [p[0] ?? 0, (is2d ? p[1] : p[2]) ?? 0];
+	};
+	session.step(500);
+	const from = posOf();
+	if (move) session.engine.input.setActionVector(move, 1, 0);
+	session.step(700);
+	const to = posOf();
+	if (move) session.engine.input.setActionVector(move, 0, 0);
+	const dx = to[0] - from[0];
+	const dz = to[1] - from[1];
+	const travelled = Math.hypot(dx, dz);
+	const { skin, declaredOffset } = findSkin(player, opts.skinPath);
+	const skinPath = skin ? skin.getPath() : null;
+	if (!skin || travelled < (is2d ? 2 : .05)) {
+		session.dispose();
+		return {
+			player: player.getPath(),
+			skin: skinPath,
+			dot: null,
+			backwards: false,
+			travelled: Math.round(travelled * 1e3) / 1e3,
+			basis: null,
+			noAnswer: skin ? "did-not-move" : "no-skin"
+		};
+	}
+	const heading = is2d ? forward2D(skin, dx, dz, declaredOffset) : {
+		forward: forwardOf((skin.rotation?.[1] ?? 0) - declaredOffset, opts.forwardAxis ?? "+z"),
+		basis: "yaw"
+	};
+	session.dispose();
+	if (!heading.basis) return {
+		player: player.getPath(),
+		skin: skinPath,
+		dot: null,
+		backwards: false,
+		travelled: Math.round(travelled * 1e3) / 1e3,
+		basis: null,
+		noAnswer: "no-heading"
+	};
+	const dot = (heading.forward[0] * dx + heading.forward[1] * dz) / travelled;
+	return {
+		player: player.getPath(),
+		skin: skinPath,
+		dot: Math.round(dot * 1e3) / 1e3,
+		backwards: dot < -.5,
+		travelled: Math.round(travelled * 1e3) / 1e3,
+		basis: heading.basis,
+		noAnswer: null
+	};
+}
+/**
+* Which way 2D art points, and what was read to decide.
+*
+* A 2D skin says it in one of two ways and it is not the 3D one:
+*
+* - `flipX` — the side-on convention. Art faces +x unflipped, -x flipped.
+*   Only answers a horizontally-dominant heading; a character walking straight
+*   down a screen has nothing to disagree with.
+* - `rotation` — a NUMBER of degrees, not a 3-vector, clockwise in a y-DOWN
+*   space (see `Node2D`), so heading 0 is +x and +90 is +y. Top-down art.
+*
+* `flipX` wins when both exist, because a sprite that is being flipped is one
+* whose facing is being driven.
+*/
+function forward2D(skin, dx, dy, declaredOffset) {
+	const s = skin;
+	if (typeof s.flipX === "boolean") {
+		if (Math.abs(dx) <= Math.abs(dy)) return {
+			forward: [0, 0],
+			basis: null
+		};
+		return {
+			forward: [s.flipX ? -1 : 1, 0],
+			basis: "flipX"
+		};
+	}
+	if (typeof s.rotation === "number") {
+		const yaw = (s.rotation - declaredOffset) * DEG2RAD;
+		return {
+			forward: [Math.cos(yaw), Math.sin(yaw)],
+			basis: "yaw"
+		};
+	}
+	return {
+		forward: [0, 0],
+		basis: null
+	};
+}
+/** One line for a report, or the failure spelled out. */
+function facingText(report) {
+	if (!report.player) return "facing: no player to drive";
+	if (report.skin === null) return `facing: ${report.player} has no skin to check`;
+	if (report.noAnswer === "no-heading") return `facing: ${report.skin} declares no heading (no flipX, no rotation) — nothing to compare its travel with`;
+	if (report.dot === null) return `facing: ${report.player} did not move — nothing to compare`;
+	if (report.backwards) return `facing: ${report.skin} RUNS BACKWARDS (dot ${report.dot.toFixed(2)}) — the skin points away from the direction of travel. The rule is +Z forward, yaw = atan2(dx, dz), with NO +180; for art that faces another way set skinYawOffset rather than adding to the yaw.`;
+	return `facing: ${report.skin} faces its travel (dot ${report.dot.toFixed(2)})`;
+}
+//#endregion
+//#region src/test/agreement.ts
+/** Absolute slack, for values that are still converging out of a lerp. */
+const ABS_TOL = .001;
+/** Relative slack, so a large coordinate is not held to the absolute one. */
+const REL_TOL = .005;
+function closeEnough(a, b, absTol, relTol) {
+	return Math.abs(a - b) <= Math.max(absTol, relTol * Math.abs(a));
+}
+function numbers(v) {
+	if (typeof v === "number") return [v];
+	if (Array.isArray(v) && v.every((x) => typeof x === "number")) return v;
+	return null;
+}
+/**
+* Every way the clients disagree, most structural first.
+*
+* @param live snapshots taken after the match has quiesced
+* @param late the same, for a client that joined AFTER everything settled
+*/
+function agreementProblems(live, late = [], opts = {}) {
+	const absTol = opts.absTol ?? ABS_TOL;
+	const relTol = opts.relTol ?? REL_TOL;
+	const out = [];
+	const compare = (snapshots, lateJoin) => {
+		const found = [];
+		for (const s of snapshots) {
+			if (!lateJoin) for (const key of s.unreadable ?? []) found.push({
+				kind: "unreadable",
+				account: s.account,
+				observer: s.account,
+				key,
+				summary: `${s.account} declares \`${key}\` in its \`network.sync\` and cannot READ it — it is never sent, so no client will ever see it change. Check the prop name and the node path (the key is a last-dot split: \`Skin.animation\`).`
+			});
+			for (const [observer, seen] of Object.entries(s.seen)) {
+				if (seen === null) {
+					found.push({
+						kind: "missing",
+						account: s.account,
+						observer,
+						key: "",
+						summary: `${observer} never materialised ${s.account} at all — a NetworkSpawner spawns one instance per OTHER account, so check its \`scene\` key is registered and its \`source\` names a real collection.`
+					});
+					continue;
+				}
+				for (const [key, truth] of Object.entries(s.truth)) {
+					const mine = seen[key];
+					if (mine === void 0) {
+						found.push({
+							kind: lateJoin ? "erased" : "absent",
+							account: s.account,
+							observer,
+							key,
+							truth,
+							summary: lateJoin ? `${observer} joined late and never got ${s.account}'s \`${key}\` — the live clients have it, so the value is gone from the AUTHORITATIVE state, not from the wire. A partial patch replaces the stored \`sync\` object.` : `${observer} has no \`${key}\` for ${s.account} — the key path does not resolve on the spawned scene (a renamed child?), or it was never sent.`
+						});
+						continue;
+					}
+					const a = numbers(truth);
+					const b = numbers(mine);
+					if (a && b) {
+						if (a.length !== b.length) {
+							found.push({
+								kind: "shape",
+								account: s.account,
+								observer,
+								key,
+								truth,
+								seen: mine,
+								summary: `${observer} holds ${b.length} components of ${s.account}'s \`${key}\` where there are ${a.length} — the interpolator treats a missing component as already correct, so this never converges and never complains.`
+							});
+							continue;
+						}
+						if (a.every((v, i) => closeEnough(v, b[i], absTol, relTol))) continue;
+						found.push({
+							kind: "mismatch",
+							account: s.account,
+							observer,
+							key,
+							truth,
+							seen: mine,
+							summary: `${observer} has ${s.account}'s \`${key}\` as ${JSON.stringify(mine)}, not ${JSON.stringify(truth)}.`
+						});
+						continue;
+					}
+					if (jsonEquals(truth, mine)) continue;
+					found.push({
+						kind: "mismatch",
+						account: s.account,
+						observer,
+						key,
+						truth,
+						seen: mine,
+						summary: `${observer} has ${s.account}'s \`${key}\` as ${JSON.stringify(mine)}, not ${JSON.stringify(truth)}.`
+					});
+				}
+			}
+		}
+		return found;
+	};
+	out.push(...compare(live, false));
+	if (late.length > 0) {
+		const alreadyAbsent = new Set(out.filter((d) => d.kind === "absent").map((d) => `${d.account}|${d.key}`));
+		for (const d of compare(late, true)) {
+			if (d.kind === "erased" && alreadyAbsent.has(`${d.account}|${d.key}`)) continue;
+			out.push(d);
+		}
+	}
+	const rank = {
+		missing: 0,
+		unspawned: 1,
+		unreadable: 2,
+		erased: 3,
+		absent: 4,
+		shape: 5,
+		mismatch: 6
+	};
+	return out.sort((x, y) => rank[x.kind] - rank[y.kind]);
+}
+/**
+* Collections that arrived and became nothing, and collections two clients
+* disagree about.
+*
+* Pure over snapshots, like `agreementProblems`, and reported in the same
+* shape so one verdict covers both halves of what a spawner does.
+*/
+function collectionProblems(snapshots) {
+	const out = [];
+	for (const s of snapshots) {
+		if (s.received.length === 0) continue;
+		if (s.materialised.length === 0) {
+			out.push({
+				kind: "unspawned",
+				account: s.account,
+				observer: s.account,
+				key: s.id,
+				summary: `${s.account}: ${s.spawner} received ${s.received.length} entit${s.received.length === 1 ? "y" : "ies"} for collection '${s.id}' and materialised NONE — check its \`scene\` key is registered with \`manager.registerScene\`.`
+			});
+			continue;
+		}
+		if (s.materialised.length !== s.received.length) out.push({
+			kind: "unspawned",
+			account: s.account,
+			observer: s.account,
+			key: s.id,
+			summary: `${s.account}: ${s.spawner} holds ${s.materialised.length} instance(s) for ${s.received.length} entit${s.received.length === 1 ? "y" : "ies"} in collection '${s.id}' — some entity never became a node, or one outlived its entity.`
+		});
+	}
+	const byId = /* @__PURE__ */ new Map();
+	for (const s of snapshots) {
+		const list = byId.get(s.id) ?? [];
+		list.push(s);
+		byId.set(s.id, list);
+	}
+	for (const [id, list] of byId) {
+		const first = list[0];
+		if (!first || list.length < 2) continue;
+		const mine = [...first.received].sort().join(",");
+		for (const other of list.slice(1)) {
+			if ([...other.received].sort().join(",") === mine) continue;
+			out.push({
+				kind: "mismatch",
+				account: first.account,
+				observer: other.account,
+				key: id,
+				summary: `${other.account} and ${first.account} hold different contents for collection '${id}' (${other.received.length} vs ${first.received.length} entities) — they are playing different games.`
+			});
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/test/agreement-snapshot.ts
+/** Is any behavior in this tree a stand-in for TypeScript that was not loaded? */
+function hasStubbedBehavior(root) {
+	if (root.behavior instanceof StubBehavior) return true;
+	for (const child of root.children) if (hasStubbedBehavior(child)) return true;
+	return false;
+}
+/** The last-dot split of the RECEIVE side, applied to a spawned instance. */
+function readFromInstance(instance, key) {
+	const lastDot = key.lastIndexOf(".");
+	const target = lastDot === -1 ? instance : instance.getNodeOrNull(key.slice(0, lastDot));
+	if (!target) return void 0;
+	return target[lastDot === -1 ? key : key.slice(lastDot + 1)];
+}
+/**
+* The interpolation TARGET a spawner holds for one of its instances.
+*
+* Found by asking every spawner in the tree, rather than by walking up from the
+* instance: a spawner's children are its own, so exactly one answers.
+*/
+function replicatedPositionOf(engine, instance) {
+	const root = engine.scene?.tree.root;
+	if (!root) return void 0;
+	let found;
+	const walk = (node) => {
+		if (found) return;
+		const asSpawner = node;
+		if (typeof asSpawner.replicatedPosition === "function") {
+			const target = asSpawner.replicatedPosition(instance);
+			if (target) {
+				found = target;
+				return;
+			}
+		}
+		for (const child of node.children) walk(child);
+	};
+	walk(root);
+	return found;
+}
+/** Every spawned instance in a client's tree, by the child name a spawner gives it. */
+function instancesByName(engine) {
+	const out = /* @__PURE__ */ new Map();
+	const root = engine.scene?.tree.root;
+	if (!root) return out;
+	const walk = (node) => {
+		for (const child of node.children) {
+			if (!out.has(child.name)) out.set(child.name, child);
+			walk(child);
+		}
+	};
+	walk(root);
+	return out;
+}
+/**
+* One snapshot per account: its own truth, and what each other client believes.
+*
+* @param clients every client in the match
+* @param observers the clients whose beliefs to record (defaults to `clients`)
+*/
+function takeAgreementSnapshots(clients, observers = clients) {
+	const snapshots = [];
+	for (const owner of clients) {
+		const root = owner.engine.scene?.tree.root;
+		if (!root) continue;
+		const node = findOwnerNode(root);
+		if (!node) continue;
+		const keys = Array.isArray(node.network?.sync) ? node.network.sync : [];
+		if (keys.length === 0) continue;
+		const stubbed = hasStubbedBehavior(root);
+		const truth = {};
+		const unreadable = [];
+		for (const key of keys) {
+			const value = readSyncKey(node, key);
+			if (value === void 0) {
+				if (!stubbed) unreadable.push(key);
+			} else truth[key] = value;
+		}
+		const seen = {};
+		for (const other of observers) {
+			if (other.account === owner.account) continue;
+			const instance = instancesByName(other.engine).get(sanitizeName(owner.account));
+			if (!instance) {
+				seen[other.account] = null;
+				continue;
+			}
+			const held = {};
+			for (const key of Object.keys(truth)) held[key] = readFromInstance(instance, key);
+			const target = replicatedPositionOf(other.engine, instance);
+			if (target && "position" in held) held.position = [...target];
+			seen[other.account] = held;
+		}
+		snapshots.push({
+			account: owner.account,
+			truth,
+			seen,
+			...unreadable.length > 0 ? { unreadable } : {}
+		});
+	}
+	return snapshots;
+}
+/**
+* What every `collection:` spawner RECEIVED, and what it made of it.
+*
+* The account-keyed comparison above cannot see these: a bullet has no account.
+* A spawner can take a hundred entities off the wire and materialise none of
+* them — an unregistered `scene` key does exactly that — and until this
+* existed the `agrees` rung had nothing to say about it.
+*/
+function takeCollectionSnapshots(clients) {
+	const out = [];
+	for (const client of clients) {
+		const root = client.engine.scene?.tree.root;
+		const manager = NetworkManager.get(client.engine);
+		if (!root || !manager) continue;
+		const walk = (node) => {
+			const source = node.source;
+			if (typeof source === "string" && source.startsWith("collection:")) {
+				const id = source.slice(11);
+				out.push({
+					account: client.account,
+					spawner: node.getPath(),
+					id,
+					received: Object.keys(manager.latestCollection(id)),
+					materialised: node.children.map((c) => c.name)
+				});
+			}
+			for (const child of node.children) walk(child);
+		};
+		walk(root);
+	}
+	return out;
+}
+//#endregion
+//#region src/test/feel.ts
+const STEP_MS = 1e3 / 60;
+/** World units a 300-frame hold must cover before it counts as "it moved". */
+const MOVED = .05;
+/** Drop height for the buffer probe — long enough to outlast a coyote window. */
+const DROP = 12;
+/** Metres a 3D probe is lifted/dropped from. */
+const UNIT_LIFT = 40;
+/** Pixels a 2D probe is lifted/dropped from — a 2D world is ~30x the numbers. */
+const PX_LIFT = 1200;
+function positionOf(node) {
+	const p = node.position;
+	return [
+		p?.[0] ?? 0,
+		p?.[1] ?? 0,
+		p?.[2] ?? 0
+	];
+}
+/**
+* A body's velocity, whichever name it keeps it under.
+*
+* `RigidBody2D/3D` call it `linearVelocity` (the solver owns it);
+* `CharacterBody2D/3D` call it `velocity` (Godot semantics — the game owns it
+* and calls moveAndSlide). Reading only the first reported **zero for every
+* CharacterBody game**, so `incanto-feel` answered `topSpeed 0` and every
+* derived window as null — a feel report that cannot see the character move.
+* It went unnoticed because every test in feel.test.ts drives a RigidBody3D.
+*/
+function velocityOf(node) {
+	const body = node;
+	const v = body.linearVelocity ?? body.velocity;
+	return [
+		v?.[0] ?? 0,
+		v?.[1] ?? 0,
+		v?.[2] ?? 0
+	];
+}
+async function makeProbe(json, opts) {
+	const session = await createPlaySession(json, {
+		seed: opts.seed ?? 1,
+		...opts.behaviors ? { behaviors: opts.behaviors } : {},
+		stubMissingBehaviors: opts.stubMissingBehaviors ?? true,
+		...opts.resolveScene ? { resolveScene: opts.resolveScene } : {}
+	});
+	const player = findPlayer(session.scene.root);
+	const declared = session.engine.input.declaredActions();
+	const moveOptions = declared.filter((a) => a.type === "vector2").map((a) => a.name);
+	const named = (prop, type) => {
+		const want = controllerProp(session.scene.root, prop);
+		return want && declared.some((a) => a.name === want && a.type === type) ? want : null;
+	};
+	const move = opts.moveAction ?? named("moveAction", "vector2") ?? moveOptions[0] ?? null;
+	const jump = opts.jumpAction ?? named("jumpAction", "button") ?? (declared.some((a) => a.name === "jump" && a.type === "button") ? "jump" : null);
+	if (!player) {
+		session.dispose();
+		return {
+			probe: null,
+			move,
+			jump,
+			moveOptions
+		};
+	}
+	const is2d = session.scene.dimension === "2d";
+	return {
+		probe: {
+			session,
+			engine: session.engine,
+			player,
+			is2d,
+			up: is2d ? -1 : 1,
+			lift: is2d ? PX_LIFT : UNIT_LIFT,
+			step: (frames = 1) => session.step(frames * STEP_MS),
+			pos: () => positionOf(player),
+			vel: () => velocityOf(player),
+			speed: () => {
+				const v = velocityOf(player);
+				return Math.hypot(v[0], v[2]);
+			}
+		},
+		move,
+		jump,
+		moveOptions
+	};
+}
+/** Let the character settle onto whatever it is standing on. */
+function settle$1(probe) {
+	probe.step(60);
+}
+/** Speed in the plane the character walks on — x/z in 3D, x/y in 2D. */
+function planar(probe, v) {
+	return probe.is2d ? Math.hypot(v[0], v[1]) : Math.hypot(v[0], v[2]);
+}
+/** The four ways one vector2 action can be pushed, best guess first. */
+const AXES = [
+	[1, 0],
+	[0, -1],
+	[0, 1],
+	[-1, 0]
+];
+/** Hold one direction and learn what this character's plateau actually is. */
+function measureAccel(probe, move, axis) {
+	settle$1(probe);
+	const before = probe.pos();
+	probe.engine.input.setActionVector(move, axis[0], axis[1]);
+	let latency = null;
+	const samples = [];
+	let planarTop = 0;
+	for (let f = 1; f <= 300; f++) {
+		probe.step();
+		if (latency === null) {
+			const p = probe.pos();
+			if (Math.hypot(p[0] - before[0], p[2] - before[2]) > .01) latency = f;
+		}
+		samples.push(probe.speed());
+		planarTop = Math.max(planarTop, planar(probe, probe.vel()));
+	}
+	const sorted = [...samples].sort((x, y) => x - y);
+	const top = sorted[Math.floor(sorted.length * .9)] ?? 0;
+	const peak = sorted[sorted.length - 1] ?? 0;
+	probe.engine.input.setActionVector(move, 0, 0);
+	const after = probe.pos();
+	const d = probe.is2d ? [
+		after[0] - before[0],
+		after[1] - before[1],
+		0
+	] : [
+		after[0] - before[0],
+		0,
+		after[2] - before[2]
+	];
+	const travelled = Math.hypot(d[0], d[1], d[2]);
+	const dir = travelled > 1e-6 ? [
+		d[0] / travelled,
+		d[1] / travelled,
+		d[2] / travelled
+	] : [
+		0,
+		0,
+		0
+	];
+	return {
+		top: top > .05 ? top : planarTop,
+		peak,
+		latencyFrames: latency,
+		travelled,
+		dir
+	};
+}
+/**
+* Time from standstill to 95% of top speed.
+*
+* Two passes on purpose: the first learns what top speed IS (it depends on the
+* scene's own props and surface), the second times the climb to 95% of it. One
+* pass would have to guess the target.
+*/
+function timeToFullSpeed(probe, move, axis, top) {
+	settle$1(probe);
+	const target = top * .95;
+	probe.engine.input.setActionVector(move, axis[0], axis[1]);
+	for (let f = 1; f <= 600; f++) {
+		probe.step();
+		if (probe.speed() >= target) {
+			probe.engine.input.setActionVector(move, 0, 0);
+			return Math.round(f * STEP_MS);
+		}
+	}
+	probe.engine.input.setActionVector(move, 0, 0);
+	return null;
+}
+function timeToStop(probe, move, axis, top) {
+	settle$1(probe);
+	probe.engine.input.setActionVector(move, axis[0], axis[1]);
+	for (let f = 0; f < 600 && probe.speed() < top * .9; f++) probe.step();
+	probe.engine.input.setActionVector(move, 0, 0);
+	for (let f = 1; f <= 600; f++) {
+		probe.step();
+		if (probe.speed() < top * .05) return Math.round(f * STEP_MS);
+	}
+	return null;
+}
+function turnaround(probe, move, axis, top, dir) {
+	settle$1(probe);
+	probe.engine.input.setActionVector(move, axis[0], axis[1]);
+	for (let f = 0; f < 600 && probe.speed() < top * .9; f++) probe.step();
+	probe.engine.input.setActionVector(move, -axis[0], -axis[1]);
+	for (let f = 1; f <= 600; f++) {
+		probe.step();
+		const v = probe.vel();
+		if (v[0] * dir[0] + v[1] * dir[1] + v[2] * dir[2] < -top * .9) return Math.round(f * STEP_MS);
+	}
+	probe.engine.input.setActionVector(move, 0, 0);
+	return null;
+}
+/**
+* How high one jump goes — TAPPED by default, HELD when asked.
+*
+* This pressed for exactly one frame and released, which is a tap. With
+* `jumpCutMultiplier` — the variable-height jump the 3D character skill
+* recommends at `0.45` — a tap is a fraction of the real jump, and this number
+* is what the skill tells you to size your level against. Measured on one
+* scene, changing only that prop:
+*
+* ```
+* jumpCutMultiplier 1     apex 1.831 u   time to apex 433 ms   airtime 717 ms
+* jumpCutMultiplier 0.45  apex 0.478 u   time to apex 200 ms   airtime 367 ms
+* ```
+*
+* Under-reporting the jump by ~4x is how a level ends up with gaps the player
+* clears effortlessly, or ledges they cannot understand missing. Both are
+* reported now, and the text names which is which.
+*/
+function jumpShape(probe, jump, hold = false) {
+	settle$1(probe);
+	const floor = probe.pos()[1];
+	probe.engine.input.pressAction(jump);
+	probe.step();
+	if (!hold) probe.engine.input.releaseAction(jump);
+	let apex = 0;
+	let toApex = 0;
+	let airtime = null;
+	for (let f = 2; f <= 600; f++) {
+		probe.step();
+		const h = (probe.pos()[1] - floor) * probe.up;
+		if (h > apex) {
+			apex = h;
+			toApex = f;
+		}
+		if (apex > .02 && h <= .02 && airtime === null) {
+			airtime = Math.round(f * STEP_MS);
+			break;
+		}
+	}
+	if (hold) probe.engine.input.releaseAction(jump);
+	const noise = probe.up > 0 ? .02 : 2;
+	if (apex <= noise) return {
+		apex: null,
+		toApexMs: null,
+		airtimeMs: null
+	};
+	return {
+		apex: Number(apex.toFixed(3)),
+		toApexMs: Math.round(toApex * STEP_MS),
+		airtimeMs: airtime
+	};
+}
+/**
+* How long after leaving the ground a jump still fires — measured, not read.
+*
+* Binary search over the delay: lift the character clear of its support (the
+* same thing walking off a ledge does), wait, press, and see whether it
+* launched. A `coyoteSeconds` the controller never consults reports 0 here,
+* which is the whole point — that was a real bug in this engine's 3D controller
+* until 0.37 and the schema looked correct the entire time.
+*/
+async function measureCoyote(json, opts, jump) {
+	const fired = async (delayFrames) => {
+		const { probe } = await makeProbe(json, opts);
+		if (!probe) return false;
+		settle$1(probe);
+		const p = probe.pos();
+		probe.player.position = [
+			p[0],
+			p[1] + probe.lift * probe.up,
+			p[2]
+		];
+		probe.step(delayFrames);
+		const before = probe.vel()[1];
+		probe.engine.input.pressAction(jump);
+		probe.step();
+		const after = probe.vel()[1];
+		probe.session.dispose();
+		return (after - before) * probe.up > 1;
+	};
+	if (!await fired(1)) return 0;
+	let lo = 1;
+	let hi = 60;
+	if (await fired(hi)) return null;
+	while (hi - lo > 1) {
+		const mid = Math.floor((lo + hi) / 2);
+		if (await fired(mid)) lo = mid;
+		else hi = mid;
+	}
+	return Math.round(lo * STEP_MS);
+}
+/**
+* `coyoteSeconds` as written in the scene, in ms — for CONTRAST, never instead.
+*
+* The whole point of this module is that a number is measured rather than read
+* off the schema. This one is read, and it earns its place by disagreeing: a
+* controller that declares 0.12 and measures "always" is telling you something
+* neither number says alone.
+*/
+function declaredCoyote(json) {
+	let found = null;
+	const walk = (node) => {
+		if (!node || typeof node !== "object") return;
+		const n = node;
+		if (typeof n.type === "string" && /^CharacterController[23]D$/.test(n.type)) {
+			const value = n.props?.coyoteSeconds;
+			if (typeof value === "number" && found === null) found = Math.round(value * 1e3);
+		}
+		for (const child of n.children ?? []) walk(child);
+	};
+	walk(json?.root);
+	return found;
+}
+/**
+* How long BEFORE landing a press still survives.
+*
+* Same shape: drop the character, press at T frames before it would touch down,
+* and check whether it left the ground again afterwards.
+*/
+async function measureBuffer(json, opts, jump) {
+	const survived = async (earlyFrames) => {
+		const { probe } = await makeProbe(json, opts);
+		if (!probe) return false;
+		settle$1(probe);
+		const floor = probe.pos()[1];
+		const drop = (probe.up > 0 ? DROP : probe.lift / 3) * probe.up;
+		probe.player.position = [
+			probe.pos()[0],
+			floor + drop,
+			probe.pos()[2]
+		];
+		let frames = 0;
+		while ((probe.pos()[1] - floor) * probe.up > .05 && frames < 200) {
+			probe.step();
+			frames += 1;
+		}
+		const fallFrames = frames;
+		probe.session.dispose();
+		const second = await makeProbe(json, opts);
+		if (!second.probe) return false;
+		const p2 = second.probe;
+		settle$1(p2);
+		p2.player.position = [
+			p2.pos()[0],
+			floor + drop,
+			p2.pos()[2]
+		];
+		p2.step(Math.max(0, fallFrames - earlyFrames));
+		p2.engine.input.pressAction(jump);
+		p2.step();
+		p2.engine.input.releaseAction(jump);
+		let rose = false;
+		for (let f = 0; f < 40; f++) {
+			p2.step();
+			if (p2.vel()[1] * p2.up > 1) rose = true;
+		}
+		p2.session.dispose();
+		return rose;
+	};
+	if (!await survived(1)) return 0;
+	let lo = 1;
+	let hi = 30;
+	if (await survived(hi)) return null;
+	while (hi - lo > 1) {
+		const mid = Math.floor((lo + hi) / 2);
+		if (await survived(mid)) lo = mid;
+		else hi = mid;
+	}
+	return Math.round(lo * STEP_MS);
+}
+async function feelReport(json, opts = {}) {
+	const first = await makeProbe(json, opts);
+	const move = first.move;
+	const jump = first.jump;
+	if (!first.probe) return {
+		player: null,
+		moveAction: move,
+		jumpAction: jump,
+		topSpeed: 0,
+		peakSpeed: null,
+		timeToFullSpeedMs: null,
+		timeToStopMs: null,
+		turnaroundMs: null,
+		jumpApex: null,
+		heldJumpApex: null,
+		heldAirtimeMs: null,
+		timeToApexMs: null,
+		airtimeMs: null,
+		coyoteMs: null,
+		jumpsInMidair: false,
+		declaredCoyoteMs: null,
+		jumpBufferMs: null,
+		inputToMotionFrames: null,
+		moveAxis: null,
+		moveTried: [],
+		errorMessages: [],
+		warnings: []
+	};
+	const playerPath = first.probe.player.getPath();
+	const said = {
+		errors: /* @__PURE__ */ new Set(),
+		warnings: /* @__PURE__ */ new Set()
+	};
+	const collect = (probe) => {
+		if (!probe) return;
+		for (const entry of probe.session.engine.log.entries()) {
+			const line = entry.parts.map((part) => part instanceof Error ? `${part.name}: ${part.message}` : String(part)).join(" ").replace(/^\[incanto\] /, "").replace(/\s+/g, " ").trim();
+			if (!line) continue;
+			if (entry.level === "error") said.errors.add(line);
+			else if (entry.level === "warn") said.warnings.add(line);
+		}
+	};
+	const fresh = async () => (await makeProbe(json, opts)).probe;
+	let topSpeed = 0;
+	let peak = null;
+	let latency = null;
+	let action = move;
+	let axis = null;
+	let dir = [
+		0,
+		0,
+		0
+	];
+	const tried = move ? [move] : [];
+	if (move) {
+		const primary = measureAccel(first.probe, move, AXES[0]);
+		collect(first.probe);
+		first.probe.session.dispose();
+		let best = primary.travelled > MOVED ? primary : null;
+		if (best) axis = AXES[0];
+		else {
+			const actions = opts.moveAction === void 0 ? [move, ...first.moveOptions.filter((n) => n !== move)] : [move];
+			search: for (const candidate of actions) {
+				if (!tried.includes(candidate)) tried.push(candidate);
+				for (const way of AXES) {
+					if (candidate === move && way === AXES[0]) continue;
+					const probe = await fresh();
+					if (!probe) break search;
+					const ramp = measureAccel(probe, candidate, way);
+					collect(probe);
+					probe.session.dispose();
+					if (ramp.travelled > MOVED && (!best || ramp.travelled > best.travelled)) {
+						best = ramp;
+						action = candidate;
+						axis = way;
+					}
+				}
+			}
+		}
+		if (best) {
+			topSpeed = Number(best.top.toFixed(2));
+			peak = best.peak > best.top * 1.1 ? Number(best.peak.toFixed(2)) : null;
+			latency = best.latencyFrames;
+			dir = best.dir;
+		}
+	} else {
+		collect(first.probe);
+		first.probe.session.dispose();
+	}
+	let toFull = null;
+	let toStop = null;
+	let turn = null;
+	if (action && axis && topSpeed > .05) {
+		const a = await fresh();
+		if (a) {
+			toFull = timeToFullSpeed(a, action, axis, topSpeed);
+			collect(a);
+			a.session.dispose();
+		}
+		const b = await fresh();
+		if (b) {
+			toStop = timeToStop(b, action, axis, topSpeed);
+			collect(b);
+			b.session.dispose();
+		}
+		const c = await fresh();
+		if (c) {
+			turn = turnaround(c, action, axis, topSpeed, dir);
+			collect(c);
+			c.session.dispose();
+		}
+	}
+	const NO_SHAPE = {
+		apex: null,
+		toApexMs: null,
+		airtimeMs: null
+	};
+	let shape = NO_SHAPE;
+	let held = NO_SHAPE;
+	let coyote = null;
+	let buffer = null;
+	if (jump) {
+		const d = await fresh();
+		if (d) {
+			shape = jumpShape(d, jump);
+			collect(d);
+			d.session.dispose();
+		}
+		const h = await fresh();
+		if (h) {
+			held = jumpShape(h, jump, true);
+			collect(h);
+			h.session.dispose();
+		}
+		coyote = await measureCoyote(json, opts, jump);
+		buffer = await measureBuffer(json, opts, jump);
+	}
+	return {
+		player: playerPath,
+		moveAction: action,
+		jumpAction: jump,
+		topSpeed,
+		peakSpeed: peak,
+		timeToFullSpeedMs: toFull,
+		timeToStopMs: toStop,
+		turnaroundMs: turn,
+		jumpApex: shape.apex,
+		heldJumpApex: held.apex,
+		heldAirtimeMs: held.airtimeMs,
+		timeToApexMs: shape.toApexMs,
+		airtimeMs: shape.airtimeMs,
+		coyoteMs: coyote,
+		jumpsInMidair: coyote === null && jump !== null,
+		declaredCoyoteMs: declaredCoyote(json),
+		jumpBufferMs: buffer,
+		inputToMotionFrames: latency,
+		moveAxis: axis,
+		moveTried: tried,
+		errorMessages: [...said.errors],
+		warnings: [...said.warnings]
+	};
+}
+const ms = (v) => v === null ? "—" : `${v} ms`;
+/** Numbers, not grades. What "good" means here is a genre decision. */
+function feelText(report) {
+	if (!report.player) return "feel: no player found — this needs a body with a CharacterController, a node in group \"player\", or one named Player.";
+	const lines = [];
+	lines.push(`feel of ${report.player}`);
+	lines.push("");
+	for (const line of (report.errorMessages ?? []).slice(0, 3)) lines.push(`  ✗ ${line}`);
+	for (const line of (report.warnings ?? []).slice(0, 3)) lines.push(`  ! ${line}`);
+	if ((report.errorMessages?.length ?? 0) + (report.warnings?.length ?? 0) > 0) lines.push("");
+	if (!report.moveAction) lines.push("  pushed           nothing — this scene declares no vector2 action");
+	else if (!report.moveAxis) {
+		const names = report.moveTried.map((n) => `'${n}'`).join(", ");
+		lines.push(`  pushed           ${names} every way (±x, ±y) — the player did not move`);
+		lines.push("");
+		lines.push(`  could not move ${report.player}: no motion in 300 frames with ${names} pushed ±x and ±y. Either the movement is not wired to a vector action, or it is driven by buttons. Nothing below was measured.`);
+	} else lines.push(`  pushed           '${report.moveAction}' [${report.moveAxis.join(", ")}]`);
+	if (report.moveAxis) {
+		lines.push(`  top speed        ${report.topSpeed} u/s`);
+		lines.push(`  to full speed    ${ms(report.timeToFullSpeedMs)}`);
+		if (report.peakSpeed !== null) lines.push(`  peak             ${report.peakSpeed} u/s   ← SOMETHING ELSE moved it`);
+		lines.push(`  to a stop        ${ms(report.timeToStopMs)}`);
+		lines.push(`  turnaround       ${ms(report.turnaroundMs)}`);
+		lines.push(`  input → motion   ${report.inputToMotionFrames === null ? "—" : `${report.inputToMotionFrames} frame(s)`}`);
+	}
+	if (report.jumpAction) {
+		lines.push("");
+		lines.push(`  jump apex        ${report.jumpApex === null ? "— (nothing left the ground)" : `${report.jumpApex} u   (tapped)`}`);
+		const cut = report.heldJumpApex !== null && report.jumpApex !== null && Math.abs(report.heldJumpApex - report.jumpApex) > .02;
+		if (cut) lines.push(`  held apex        ${report.heldJumpApex} u   ← size your level against THIS`);
+		lines.push(`  time to apex     ${ms(report.timeToApexMs)}`);
+		lines.push(`  airtime          ${ms(report.airtimeMs)}${cut && report.heldAirtimeMs !== null ? `   (${ms(report.heldAirtimeMs)} held)` : ""}`);
+		lines.push(`  coyote window    ${report.jumpsInMidair ? "not measurable — this character jumps in MID-AIR" : report.coyoteMs === null ? "always (no window)" : ms(report.coyoteMs)}`);
+		lines.push(`  jump buffer      ${report.jumpBufferMs === null ? "always (no window)" : ms(report.jumpBufferMs)}${report.jumpsInMidair ? "   (suspect — see above)" : ""}`);
+		if (report.jumpsInMidair) {
+			lines.push("");
+			lines.push("  note: a jump still fires a full second after leaving the ground, so");
+			lines.push("        \"how long after leaving the ground\" has no answer here. A double");
+			lines.push("        jump does this, and so does any behaviour that pushes the body up");
+			lines.push("        while `jump` is held — a glide, a jetpack, an updraft.");
+			if (report.declaredCoyoteMs !== null) lines.push(`        The controller DECLARES coyoteSeconds ${ms(report.declaredCoyoteMs)}; this probe cannot confirm it.`);
+		}
+		if (report.coyoteMs === 0) {
+			lines.push("");
+			lines.push("  note: coyote window is 0 — a jump that only fires while the ground check");
+			lines.push("        is true reads to players as unresponsive controls. Try coyoteSeconds: 0.12.");
+		}
+		if (report.jumpBufferMs === 0) {
+			lines.push("  note: jump buffer is 0 — a press a few frames before landing is thrown away.");
+			lines.push("        Try jumpBufferSeconds: 0.15.");
+		}
+	}
+	if (report.peakSpeed !== null) {
+		lines.push("");
+		lines.push(`  note: one frame hit ${report.peakSpeed} u/s while the character SUSTAINS ${report.topSpeed}. Something other than its own movement moved it during the`);
+		lines.push("        measurement — a knockback from an enemy the probe walked into, a launcher,");
+		lines.push("        a conveyor. `top speed` is the 90th percentile so the transient does not");
+		lines.push("        own the number, but measure feel somewhere nothing can hit you.");
+	}
+	return lines.join("\n");
+}
+/** The action name a `CharacterController2D/3D` in this tree says it reads. */
+function controllerProp(root, prop) {
+	const stack = [root];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		const type = node.constructor.typeName ?? "";
+		if (type === "CharacterController2D" || type === "CharacterController3D") {
+			const value = node[prop];
+			return typeof value === "string" && value !== "" ? value : null;
+		}
+		for (const child of node.children) stack.push(child);
+	}
+	return null;
+}
+//#endregion
+//#region src/test/multiplay.ts
+/** Run a whole match headlessly and report what the clients ended up sharing. */
+async function playMultiplayer(opts) {
+	const count = opts.players ?? 2;
+	const seconds = opts.seconds ?? 5;
+	const stepMs = opts.stepMs ?? 1e3 / 60;
+	const accounts = Array.from({ length: count }, (_, i) => `p${i + 1}`);
+	const { server, players, dispose } = await createSplitScreen({
+		scene: opts.scene,
+		...opts.server ? { server: opts.server } : {},
+		...opts.scenes ? { scenes: opts.scenes } : {},
+		...opts.seed !== void 0 ? { seed: opts.seed } : {},
+		...opts.load ? { load: opts.load } : {},
+		accounts,
+		setup: () => {}
+	});
+	await opts.start?.(players);
+	await settle();
+	const frames = Math.max(1, Math.round(seconds * 1e3 / stepMs));
+	let now = 0;
+	for (let frame = 0; frame < frames; frame++) {
+		now += stepMs;
+		for (const player of players) {
+			await opts.drive?.(player, frame, now / 1e3);
+			player.engine.tick(now);
+		}
+		if (frame % 6 === 0) await settle();
+	}
+	await settle();
+	for (let frame = 0; frame < 60; frame++) {
+		now += stepMs;
+		for (const player of players) player.engine.tick(now);
+		if (frame % 6 === 0) await settle();
+	}
+	await settle();
+	const live = takeAgreementSnapshots(players);
+	const matchDetail = players.map((p) => ({
+		account: p.account,
+		room: p.manager.roomId,
+		spawners: spawnerCounts(p.engine),
+		spawned: Object.fromEntries(spawnerCounts(p.engine).map((sp) => [sp.name, sp.children])),
+		sawAccounts: Object.keys(p.manager.latestUserStates ?? {}).filter((a) => a !== p.account),
+		errors: p.engine.stats().errors
+	}));
+	let lateSnapshots = [];
+	let lateJoinChecked = false;
+	let lateJoinRefused = false;
+	if ((opts.lateJoin ?? true) && players.length > 0) {
+		const joiner = await Promise.race([joinLate(server, players[0], opts), new Promise((resolve) => {
+			setTimeout(() => resolve(null), LATE_JOIN_TIMEOUT_MS).unref?.();
+		})]);
+		if (joiner === null && (opts.lateJoin ?? true)) lateJoinRefused = true;
+		if (joiner) {
+			for (let frame = 0; frame < 60; frame++) {
+				now += stepMs;
+				for (const player of [...players, joiner]) player.engine.tick(now);
+				if (frame % 6 === 0) await settle();
+			}
+			await settle();
+			lateSnapshots = takeAgreementSnapshots(players, [joiner]);
+			lateJoinChecked = true;
+		}
+	}
+	const collections = takeCollectionSnapshots(players);
+	const report = summarize(players, seconds, frames, matchDetail, {
+		disagreements: [...agreementProblems(live, lateSnapshots), ...collectionProblems(collections)],
+		keysCompared: live.reduce((n, s) => n + Object.keys(s.truth).length * Object.keys(s.seen).length, 0) + collections.reduce((n, c) => n + c.received.length, 0),
+		lateJoinChecked,
+		...lateJoinRefused ? { lateJoinRefused } : {}
+	});
+	dispose();
+	return report;
+}
+/**
+* One more client, against the SAME server and the SAME room.
+*
+* `createSplitScreen` builds all its panels up front, so this is the ten lines
+* of it that matter — and the room id has to come from panel 0 or the joiner
+* lands in its own auto-assigned room and reports everything as missing.
+*/
+async function joinLate(server, first, opts) {
+	try {
+		const { Engine } = await import("./register-DuVdzxbq.js").then((n) => n.y);
+		const { loadScene } = await import("./save-slots-Bvuh2p_r.js").then((n) => n.g);
+		const { jsonClone } = await import("./json-CfTjpvW8.js").then((n) => n.i);
+		const engine = new Engine(opts.seed !== void 0 ? { seed: opts.seed + 999 } : {});
+		engine.setScene(loadScene(jsonClone(opts.scene), opts.load));
+		const manager = await NetworkManager.create(engine, {
+			transport: server.createClient("late"),
+			room: first.manager.roomId
+		});
+		for (const [name, json] of Object.entries(opts.scenes ?? {})) manager.registerScene(name, json);
+		return {
+			account: "late",
+			engine,
+			manager
+		};
+	} catch {
+		return null;
+	}
+}
+/** How long a late joiner waits before the match is declared wedged. */
+const LATE_JOIN_TIMEOUT_MS = 15e3;
+/** Give the server's promise queue a turn. */
+function settle() {
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function summarize(players, seconds, frames, matchDetail, agreement) {
+	const rooms = players.map((p) => p.manager.roomId);
+	const detail = matchDetail.map((d, i) => ({
+		...d,
+		errors: players[i]?.engine.stats().errors ?? d.errors
+	}));
+	const problems = [
+		...agreement.lateJoinRefused ? ["the server never answered a late joiner within 15s — it is wedged. LocalGameServer runs one call at a time, so look for an await that never settles or a nested `$lock` on the same key ($lock is NOT reentrant)."] : [],
+		...multiplayProblems(detail, rooms),
+		...agreement.disagreements.map((d) => d.summary)
+	];
+	return {
+		ok: problems.length === 0,
+		disagreements: agreement.disagreements,
+		keysCompared: agreement.keysCompared,
+		lateJoinChecked: agreement.lateJoinChecked,
+		seconds,
+		frames,
+		rooms,
+		players: detail,
+		roomState: players[0]?.manager.latestRoomState ?? {},
+		problems
+	};
+}
+/**
+* What is wrong with a finished match, in the order it matters.
+*
+* Pure, and exported, because every one of these is a SILENT failure — the test
+* for "the clients ended up in different rooms" must not depend on being able
+* to reproduce different rooms.
+*/
+function multiplayProblems(detail, rooms) {
+	const problems = [];
+	if (new Set(rooms).size > 1) problems.push(`the clients joined ${new Set(rooms).size} different rooms (${rooms.join(", ")}) — nobody can see anybody. A scene's \`multiplayer.room\` of "auto" is SERVER-ASSIGNED; name a room, or let the harness pin one.`);
+	else if (detail.length > 1) {
+		const blind = detail.filter((d) => d.sawAccounts.length === 0);
+		if (blind.length > 0) problems.push(`${blind.map((d) => d.account).join(", ")} never saw another account's state — an owner node replicates only what its \`network.sync\` lists, and only when it changes.`);
+		for (const d of detail) {
+			if (d.sawAccounts.length === 0) continue;
+			for (const spawner of d.spawners) {
+				if (spawner.source !== "users" || spawner.children > 0) continue;
+				problems.push(`${d.account}: ${spawner.name} saw ${d.sawAccounts.length} other account(s) and materialised NONE of them — check its \`scene\` key is registered with \`manager.registerScene\`.`);
+			}
+		}
+	}
+	for (const d of detail) if (d.errors > 0) problems.push(`${d.account}: ${d.errors} frame error(s) — read engine.log.`);
+	return problems;
+}
+function spawnerCounts(engine) {
+	const out = [];
+	const root = engine.scene?.tree.root;
+	if (!root) return out;
+	const walk = (node) => {
+		if (node instanceof NetworkSpawner) out.push({
+			name: node.name,
+			source: node.source,
+			children: node.children.length
+		});
+		for (const child of node.children) walk(child);
+	};
+	walk(root);
+	return out;
+}
+/** The report as the one paragraph a reader needs. */
+function multiplayText(report) {
+	const lines = [`multiplayer: ${report.players.length} clients, ${report.seconds}s, room ${[...new Set(report.rooms)].join(" + ")}`];
+	lines.push(report.keysCompared === 0 ? "  agrees: nothing to compare — no owner node declared any sync keys" : `  agrees: ${report.keysCompared} replicated value(s) compared across clients${report.lateJoinChecked ? " + a late joiner" : ""}, over one in-memory server (not a live wire)`);
+	for (const p of report.players) {
+		const spawned = Object.entries(p.spawned).map(([name, n]) => `${name}=${n}`).join(" ");
+		lines.push(`  ${p.account}: sees [${p.sawAccounts.join(", ") || "—"}]` + (spawned ? ` spawned ${spawned}` : "") + (p.errors ? ` · ${p.errors} error(s)` : ""));
+	}
+	for (const problem of report.problems) lines.push(`  ✗ ${problem}`);
+	if (report.ok) lines.push("  ✓ every client in one room, seeing the others");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/test/verify-ladder.ts
+/**
+* The verification ladder, as one answer.
+*
+* The rungs already exist — `incanto-check` says the scene loads,
+* `incanto-playtest` says it can be finished, `incanto-frame` says something
+* was drawn. They are documented together and used apart, because using them
+* together means knowing three things nobody writes down:
+*
+*   the ORDER (a scene that does not load cannot be played or drawn, so the
+*     first red rung is the only one worth reading)
+*   that an unmeasured rung is not a failing one — "no dev server" means the
+*     question was never asked, and answering it "fail" sends an agent editing
+*     a scene that is fine
+*   what to do NEXT, which is one sentence and never the whole report
+*
+* Pure: the rungs are run by the CLI, this decides what they add up to.
+*/
+const RUNTIME_NOISE = /^\((node|bun):\d+\)|^\s*\(Use `node --trace|ExperimentalWarning|DeprecationWarning|Warning: .*deprecat/i;
+/**
+* …and a STACK FRAME is not a message either.
+*
+* The same failure one class along. `incanto-frame` could not reach the page,
+* undici threw, and the `draws` rung reported its summary as
+*
+*   ? draws — node:internal/deps/undici/undici:13502
+*
+* which is the first line of the crash: a file and a line number, no sentence.
+* `TypeError: fetch failed` was three lines below it, under the caret and the
+* offending source line.
+*/
+const STACK_FURNITURE = /^\s*at\s|^\s*\^+\s*$|^[\w./-]*:\d+$|^\s*\.\.\.\s*\d+|[;{]\s*$/;
+/** `TypeError: fetch failed` — the line a person would read out loud. */
+const LOOKS_LIKE_A_MESSAGE = /^[A-Z][\w$]*(Error|Exception)\b/;
+/**
+* What a spawned tool actually SAID, given its stderr.
+*
+* Used by every rung in `incanto-verify`; it lives here rather than in the bin
+* so it can be tested without a built `dist` — the bin loads the library at
+* runtime, so a regex only the bin knows is a regex nothing checks.
+*/
+function firstLine(text) {
+	const lines = (text ?? "").split("\n").map((l) => l.trim()).filter(Boolean);
+	const named = lines.find((l) => LOOKS_LIKE_A_MESSAGE.test(l));
+	if (named) return named;
+	return lines.find((l) => !RUNTIME_NOISE.test(l) && !STACK_FURNITURE.test(l)) ?? lines.find((l) => !RUNTIME_NOISE.test(l)) ?? lines[0] ?? null;
+}
+const MARK = {
+	pass: "✓",
+	fail: "✗",
+	unmeasured: "?",
+	skipped: "·"
+};
+/**
+* The `says` rung, from `incanto-logs`' report — the one rung whose whole job is
+* "what is the running game SAYING".
+*
+* It read `ok` and printed "no errors, no failed assets", which threw away
+* every WARNING the page had reported. The engine warns about exactly the
+* things that leave a game running and wrong — a camera whose `follow` resolves
+* to a node with no position, a `DayNight` with no sky to move, a `Buoyancy`
+* with no water, a body with no collider — and the headline command showed a
+* tick over all of it.
+*
+* Warnings are NOT a failure (an author may have chosen to live with one), so
+* this keeps `pass` and carries them the way `loads` has always carried
+* `incanto-check`'s: as notes under the rung, printed with a `!`.
+*
+* Pure, so it can be tested without a browser — the bin owns fetching the
+* report, this owns what it means.
+*/
+function saysRung(report) {
+	if (!report) return {
+		name: "says",
+		status: "unmeasured",
+		summary: "no page to ask"
+	};
+	const warnings = (report.grouped ?? []).filter((g) => g.level === "warn");
+	if (!report.ok) {
+		const asset = report.assetErrors?.[0];
+		return {
+			name: "says",
+			status: "fail",
+			summary: asset ? `asset ${asset.ref} never loaded: ${asset.error}` : report.worst?.message ?? `${report.stats?.errors ?? 0} errors were swallowed`,
+			fix: "read it in full: `incanto-logs`"
+		};
+	}
+	if (warnings.length === 0) return {
+		name: "says",
+		status: "pass",
+		summary: "no errors, no failed assets"
+	};
+	const distinct = warnings.length;
+	return {
+		name: "says",
+		status: "pass",
+		summary: `no errors — ${distinct} warning${distinct === 1 ? "" : "s"}, and the game is running`,
+		notes: warnings.slice(0, 3).map((g) => `${g.message}${g.count > 1 ? ` ×${g.count}` : ""}`),
+		...warnings.length > 3 ? { fix: "the rest are in `incanto-logs`" } : {}
+	};
+}
+/**
+* What to say when the bot could not WALK — which is not the same as could not
+* play.
+*
+* This branch was "nobody to move", said about games the bot had played for
+* eight runs. The MOUSE half was fixed when a flip puzzle whose every tile the
+* bot clicked was told to add a character controller; the KEYBOARD half was
+* found the same way, one genre along: a sokoban declares `move`, `undo` and
+* `restart`, a behaviour reads them every frame and moves plain nodes, and the
+* bot pressed them 989 times across eight runs — while the rung said
+*
+*   ? plays — nothing here is drivable — 8 runs had nobody to move and
+*     nothing to click
+*
+* Both halves of that sentence were false. A whole class — sokoban, snake,
+* tetris, roguelikes, typing games, anything on a grid — has no character to
+* add, and the advice was to add one anyway.
+*
+* PRESSED and READ, not merely declared: `inertActions` is the report's own
+* list of actions nothing asks about, and a scene where every one of them is
+* inert really does have nothing driving it.
+*
+* Pure, so the wording can be tested without running a game.
+*/
+function unmeasuredPlays(report) {
+	const runs = report.runs ?? [];
+	const total = runs.length;
+	const clicks = runs.reduce((n, r) => n + (r.clicks ?? 0), 0);
+	const keyed = runs.reduce((n, r) => n + (r.actionPresses ?? 0), 0);
+	const live = (report.actions ?? []).filter((a) => !(report.inertActions ?? []).includes(a));
+	const ending = report.declaresWin ? "and no run reached the win" : "and no win to reach";
+	if (clicks > 0) return {
+		summary: `played with the MOUSE — ${clicks} click(s) across ${total} runs, ${ending}`,
+		fix: "a mouse game is played, not walked — emit `won`/`lost` and this rung can pass"
+	};
+	if (keyed > 0 && live.length > 0) return {
+		summary: `played with the KEYBOARD — ${keyed} press(es) of ${live.length} declared action(s) (${live.slice(0, 4).join(", ")}) across ${total} runs, ${ending}`,
+		fix: "a game played by KEYS is played, not walked — emit `won`/`lost` and this rung can pass. (A random presser will not solve a puzzle: drive the solution in a scripted `runScript` harness, and let this rung tell you about crashes.)"
+	};
+	if (report.hasPlayer === false) return {
+		summary: `nothing here is drivable — ${total} runs had nobody to move and nothing to click`,
+		fix: "give the player a character controller, the `player` group, or the name Player — or `Clickable` on what the cursor drives"
+	};
+	return {
+		summary: `${total} runs went nowhere, and your behaviours were not loaded — that is most of what moves a character`,
+		fix: `name them: \`incanto-verify ${report.scene ?? "src/game.scene.json"} --behaviors src/behaviors.ts\``
+	};
+}
+/**
+* What the run HEARD and SHOWED, as one rung.
+*
+* Pure, like `saysRung` and `unmeasuredPlays`: the bin owns running the
+* playtest, this owns what its feedback log means. Extracted when the
+* all-silent branch was found printing a COUNT with nothing beside it —
+* `racing-3d` reports 20 emitters and its scene declares none of them (they are
+* a pool of `new Particles3D()` built in `onReady`), so an author counted
+* twenty in a message and found zero in their JSON.
+*/
+function feelsRung(fb, opts = {}) {
+	if (!fb) return {
+		name: "feels",
+		status: "skipped",
+		summary: "not run — the playtest did not report"
+	};
+	const declaredPaths = [...fb.declaredAudio ?? [], ...fb.declaredEffects ?? []];
+	const declared = declaredPaths.length;
+	const fired = new Set([...fb.heard ?? [], ...fb.shown ?? []]);
+	if (declared === 0) return {
+		name: "feels",
+		status: "skipped",
+		summary: "this game declares no sound and no effects"
+	};
+	const some = (list) => `${list.slice(0, 3).join(", ")}${list.length > 3 ? ` +${list.length - 3}` : ""}`;
+	if (fired.size === 0) {
+		if (opts.played === false) return {
+			name: "feels",
+			status: "unmeasured",
+			summary: `${declared} sound/effect node(s) in the tree and none fired — but no run got the game moving, so nothing here was measured — ${some(declaredPaths)}`,
+			fix: "drive it in a scripted run (`runScript` from `incanto/test`): a sustained throttle, a real fight, the actual verb. A random bot that never gets going triggers nothing, and that is a fact about the bot."
+		};
+		return {
+			name: "feels",
+			status: "fail",
+			summary: `${declared} sound/effect node(s) in the tree, and not one fired in any run — ${some(declaredPaths)}`,
+			fix: "connect them — a signal to `play` on an AudioPlayer, or `replay()` on a one-shot; `engine.audio.recent()` and `engine.effects.recent()` say what did fire"
+		};
+	}
+	const silent = declaredPaths.filter((path) => !fired.has(path));
+	if (silent.length === 0) return {
+		name: "feels",
+		status: "pass",
+		summary: `every one of the ${declared} sound/effect nodes fired`
+	};
+	return {
+		name: "feels",
+		status: "unmeasured",
+		summary: `${declared - silent.length} of ${declared} fired — silent: ${some(silent)}`,
+		fix: "a silent emitter is either a broken wire or a moment random play never reached — the two look identical from here. Reach it in a scripted run (`runScript` from `incanto/test`), and this rung can tell you which."
+	};
+}
+function ladderVerdict(rungs, ctx = {}) {
+	const failed = rungs.find((r) => r.status === "fail");
+	const unmeasured = rungs.filter((r) => r.status === "unmeasured");
+	const next = failed ? failed.fix ?? failed.summary : unmeasured[0]?.fix ?? unmeasured[0]?.summary ?? null;
+	const ambiguous = rungs.length === 0 && (ctx.candidates?.length ?? 0) > 1;
+	return {
+		ok: !failed,
+		rungs,
+		unmeasured: unmeasured.map((r) => r.name),
+		next: ambiguous ? "name the one you mean: `incanto-verify <scene.json>`" : next ?? null,
+		candidates: ctx.candidates ?? [],
+		measured: rungs.length > 0
+	};
+}
+/** The ladder as a person or an agent reads it: every rung, then the one action. */
+function ladderText(v) {
+	if (v.rungs.length === 0) {
+		if (v.candidates.length > 1) return [
+			`${v.candidates.length} scenes here, and guessing between them would verify the wrong one:`,
+			...v.candidates.map((c) => `  ${c}`),
+			"",
+			`next: ${v.next}`
+		].join("\n");
+		return "nothing to verify — no scene was given and none was found";
+	}
+	const lines = [];
+	for (const r of v.rungs) {
+		lines.push(`${MARK[r.status]} ${r.name} — ${r.summary}`);
+		for (const note of r.notes ?? []) lines.push(`    ! ${note}`);
+	}
+	lines.push("");
+	if (!v.ok) lines.push("NOT verified.");
+	else if (v.unmeasured.length > 0) lines.push(`passes what was measured — ${v.unmeasured.join(", ")} not measured.`);
+	else lines.push("verified: it loads, it plays, and it draws.");
+	if (v.next) lines.push(`next: ${v.next}`);
+	return lines.join("\n");
+}
+//#endregion
+//#region src/test/index.ts
+/**
+* incanto/test — the browserless verification harness.
+*
+* The agent loop is "author → VERIFY → fix", and production environments
+* (e.g. the agent8 VM) have no browser. This module makes the scene state
+* itself the screenshot:
+*
+* - `validateScene(json)`  — every hard load error, without a browser
+* - `runScript(json, ...)` — scripted play by ACTION intent at a fixed
+*   timestep, with inline assertions and periodic snapshots
+* - `captureScene(scene)` / `describeCapture(capture)` — a structural,
+*   grep-able "text screenshot" of the live tree
+*
+* Deterministic by construction: fixed timestep, seeded `engine.rng`,
+* no requestAnimationFrame.
+*/
+/** Node types whose whole job is to sit on the ground. Characters, water,
+* clouds, birds and lights are all legitimately off it. */
+const GROUNDED_TYPES = ["MeshInstance3D", "InstancedMesh3D"];
+/** Under one of these, the BODY owns where the thing stands — a character's
+* skin hangs at whatever offset its rig wants, and is not a floating prop. */
+const BODY_OWNED = new Set([
+	"Area3D",
+	"CharacterBody3D",
+	"RigidBody3D",
+	"StaticBody3D"
+]);
+/**
+* Every prop that is floating or buried.
+*
+* THE most repeated mistake in scene authoring, by humans and agents alike, is
+* a hand-computed Y: correct when it is written and wrong the moment anything
+* reshapes the ground under it — a river carving its bed, a new seed, a
+* generator that mirrors a carve slightly differently. This is the check that
+* catches it, and `snapToGround` is the fix that stops it happening.
+*
+* Anything explicitly marked `snapToGround: false` is skipped: that is the
+* author saying "yes, this hangs in the air", which a bridge deck, a lantern
+* and a cloud all legitimately do.
+*
+* ```ts
+* const off = findFloatingProps(gameJson);
+* ok(`nothing floats (${off.length})`, off.length === 0);
+* ```
+*/
+function findFloatingProps(json, opts = {}) {
+	registerAllNodes();
+	const tolerance = opts.tolerance ?? .1;
+	const types = new Set(opts.types ?? GROUNDED_TYPES);
+	let scene;
+	try {
+		scene = loadScene(json, {
+			stubMissingBehaviors: true,
+			engine: new Engine({ scheduler: () => () => {} })
+		});
+	} catch (error) {
+		throw new IncantoError("BAD_FORMAT", `findFloatingProps: the scene does not load, so nothing could be measured. ${error?.message ?? String(error)}`);
+	}
+	let ground = null;
+	const findGround = (node) => {
+		if (!ground && node.constructor.typeName === "Terrain3D" && typeof node.heightAt === "function") ground = node;
+		for (const child of node.children) findGround(child);
+	};
+	findGround(scene.root);
+	if (!ground) throw new IncantoError("NODE_NOT_FOUND", "findFloatingProps: no Terrain3D in this scene, so there is no ground to measure against. This check reads terrain height; a level built from mesh floors needs a physics raycast instead.");
+	const out = [];
+	const walk = (node, path, ox, oy, oz, yaw, bodyOwned) => {
+		const n = node;
+		let wx = ox;
+		let wy = oy;
+		let wz = oz;
+		let ownYaw = yaw;
+		if (Array.isArray(n.position)) {
+			const c = Math.cos(yaw);
+			const s = Math.sin(yaw);
+			const lx = n.position[0] ?? 0;
+			const lz = n.position[2] ?? 0;
+			wx = ox + lx * c + lz * s;
+			wz = oz - lx * s + lz * c;
+			wy = oy + (n.position[1] ?? 0);
+			ownYaw = yaw + (n.rotation?.[1] ?? 0) * Math.PI / 180;
+		}
+		const type = node.constructor.typeName ?? "";
+		const soil = ground;
+		if (types.has(type) && n.visible !== false && n.snapToGround !== false && !bodyOwned) {
+			const rows = node.transforms;
+			if (Array.isArray(rows) && rows.length > 0) {
+				let worst = null;
+				for (const row of rows) {
+					const scale = row[4] ?? 1;
+					const half = (n.size?.[1] ?? 0) * scale / 2;
+					const gap = wy + (row[1] ?? 0) - half - soil.heightAt(wx + (row[0] ?? 0), wz + (row[2] ?? 0));
+					if (Math.abs(gap) > tolerance && (!worst || Math.abs(gap) > Math.abs(worst.gap))) worst = {
+						path,
+						gap: Math.round(gap * 100) / 100
+					};
+				}
+				if (worst) out.push(worst);
+			} else {
+				const half = (n.size?.[1] ?? 0) / 2;
+				const gap = wy - half - soil.heightAt(wx, wz);
+				if (Math.abs(gap) > tolerance) out.push({
+					path,
+					gap: Math.round(gap * 100) / 100
+				});
+			}
+		}
+		const childBodyOwned = bodyOwned || BODY_OWNED.has(type) || n.snapToGround === false;
+		for (const child of node.children) walk(child, `${path}/${child.name}`, wx, wy, wz, ownYaw, childBodyOwned);
+	};
+	walk(scene.root, `/${scene.root.name}`, 0, 0, 0, 0, false);
+	return out;
+}
+function registerAllNodes() {
+	registerNodes2D();
+	registerNodes3D();
+	registerNodesNet();
+	registerGameplayBehaviors();
+}
+/** Snapshot the live tree: every node, every schema prop's current value. */
+function captureScene(scene) {
+	const nodes = [];
+	const walk = (node) => {
+		const ctor = node.constructor;
+		const schema = mergeStaticProps(ctor);
+		const props = {};
+		for (const key of Object.keys(schema)) props[key] = jsonClone(node[key]);
+		const capture = {
+			path: node.getPath(),
+			type: ctor.typeName,
+			props
+		};
+		const painted = node._paintedText?.();
+		if (typeof painted === "string") capture.text = painted;
+		if (node.uid) capture.uid = node.uid;
+		if (node.groups.size > 0) capture.groups = [...node.groups];
+		if (Object.keys(node.tags).length > 0) capture.tags = jsonClone(node.tags);
+		if (typeof node.script?.name === "string") capture.script = node.script.name;
+		nodes.push(capture);
+		for (const child of node.children) walk(child);
+	};
+	walk(scene.root);
+	const out = {
+		name: scene.name,
+		nodes
+	};
+	if (scene.dimension) out.dimension = scene.dimension;
+	return out;
+}
+/**
+* Render a capture as one grep-able line per node, showing only NON-DEFAULT
+* props — the same delta discipline as scene JSON, so the interesting state
+* stands out.
+*/
+function describeCapture(capture) {
+	const lines = [`scene ${capture.name}${capture.dimension ? ` (${capture.dimension})` : ""}`];
+	for (const node of capture.nodes) {
+		const schema = defaultsFor(node.type);
+		const deltas = Object.entries(node.props).filter(([key, value]) => !schema || !jsonEquals(value, schema[key]?.default ?? null)).map(([key, value]) => `${key}=${JSON.stringify(value)}`);
+		const extras = [
+			node.text !== void 0 ? `paints=${JSON.stringify(node.text)}` : "",
+			node.script ? `script=${node.script}` : "",
+			node.groups ? `groups=${node.groups.join(",")}` : "",
+			...deltas
+		].filter(Boolean);
+		lines.push(`${node.path} ${node.type}${extras.length ? ` ${extras.join(" ")}` : ""}`);
+	}
+	return lines.join("\n");
+}
+function defaultsFor(typeName) {
+	try {
+		return getNodeSchema(typeName);
+	} catch {
+		return null;
+	}
+}
+/**
+* Run every hard load-time check headlessly. Unregistered behaviors are
+* stubbed by default (structure-only validation, no TypeScript needed) —
+* pass the real classes via `behaviors` to validate script props too.
+*/
+/**
+* `environment.preset` is resolved deep inside Renderer3D, which no headless
+* tool reaches — so a typo there passed `incanto-check` and hard-failed at boot.
+* It cannot live in the core loader (core must never import 3d), but it belongs
+* exactly here: the test entry already registers the 3D nodes.
+*/
+function checkEnvironment(json) {
+	const env = json?.environment;
+	if (!env || typeof env !== "object") return;
+	if (env.preset === void 0) return;
+	if (typeof env.preset !== "string") throw new IncantoError("BAD_FORMAT", `Scene "environment.preset" must be a string, got ${JSON.stringify(env.preset)}.`);
+	try {
+		resolveEnvironmentHdri(env);
+	} catch (error) {
+		throw new IncantoError("BAD_FORMAT", error instanceof Error ? error.message : String(error));
+	}
+}
+function validateScene(json, opts = {}) {
+	registerAllNodes();
+	for (const [name, ctor] of Object.entries(opts.behaviors ?? {})) registerBehavior(name, ctor, { replace: true });
+	const engine = new Engine({ scheduler: () => () => {} });
+	try {
+		checkEnvironment(json);
+		loadScene(json, {
+			engine,
+			resolveScene: opts.resolveScene,
+			...opts.declaredAssets ? { declaredAssets: opts.declaredAssets } : {},
+			stubMissingBehaviors: !opts.strictBehaviors
+		}).root.free();
+		return { ok: true };
+	} catch (e) {
+		if (e instanceof IncantoError) return {
+			ok: false,
+			error: e
+		};
+		throw e;
+	}
+}
+/**
+* What an assert's return value MEANS: a failure message, or null for a pass.
+*
+* `false` and a throw were the only failures this API had, so an assert that
+* returned a MESSAGE — the natural way to write one that explains itself —
+* passed by not being `false`. Measured on a tower defense built from the
+* published package: four asserts of the form `(ctx) => problem ?? null`, a
+* keep that had fallen with 0 lives, and `VERIFY OK`.
+*
+* A number or an object is a failure too, naming the contract: a check nobody
+* can read is not a check, and `0` and `{ ok: false }` both used to pass.
+*/
+function assertVerdict(value) {
+	if (value === false) return "assert returned false";
+	if (typeof value === "string") return value === "" ? null : value;
+	if (value === true || value === void 0 || value === null) return null;
+	return `assert returned ${typeof value} (${JSON.stringify(value)}) — this API reads only \`false\`, a non-empty string, or a throw as a failure, so this check cannot fail. Return a boolean or a message.`;
+}
+/**
+* Load a scene and play it headlessly at a fixed timestep, driving input by
+* ACTION intent. This is the e2e loop without a browser: script → simulate →
+* snapshot → assert.
+*/
+async function runScript(json, opts) {
+	registerAllNodes();
+	for (const [name, ctor] of Object.entries(opts.behaviors ?? {})) registerBehavior(name, ctor, { replace: true });
+	const engine = new Engine({
+		seed: opts.seed,
+		fixedHz: opts.fixedHz,
+		scheduler: () => () => {}
+	});
+	const scene = loadScene(structuredClone(json), {
+		engine,
+		resolveScene: opts.resolveScene
+	});
+	engine.setScene(scene);
+	if (opts.locale) engine.locale.locale = opts.locale;
+	const physics = opts.physics ?? "auto";
+	if (physics === "2d" || physics === "auto" && scene.dimension === "2d") {
+		const { enablePhysics2D } = await import("./physics-2d-FhrXUc6B.js").then((n) => n.r);
+		await enablePhysics2D(engine);
+	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
+		const { enablePhysics3D } = await import("./physics-3d-CFEGxBXZ.js").then((n) => n.r);
+		await enablePhysics3D(engine);
+	}
+	const failures = [];
+	const snapshots = [];
+	const live = () => engine.scene ?? scene;
+	const ctx = {
+		engine,
+		get scene() {
+			return live();
+		},
+		timeMs: 0,
+		getNode: (path) => live().root.getNode(path),
+		capture: () => captureScene(live())
+	};
+	/** Is `hit` the node we aimed at, or something of its own? */
+	const isSelfOrAncestor = (wanted, hit) => {
+		for (let at = hit; at; at = at.parent) if (at === wanted) return true;
+		return false;
+	};
+	/** Frames on which a queued mouse release is due — see `ScriptStep.click`. */
+	let releaseAt = -1;
+	/** The button `click` pressed, so the queued release lets go of the same one. */
+	let releaseButton = 0;
+	/**
+	* Only ours, never theirs: a game that answers picks itself must keep
+	* answering them, or the harness is testing the harness. Aiming comes with
+	* it — a behaviour reading `engine.pointerWorld()` must get an answer for the
+	* same cursor the click is at.
+	*/
+	const armPointer = () => {
+		engine.picker ??= geometricPicker(live);
+		if (!engine.toWorld) {
+			const view = geometricView(live);
+			engine.toWorld = view.toWorld;
+			engine.toScreen ??= view.toScreen;
+			engine.screenRay ??= view.screenRay;
+		}
+	};
+	/**
+	* A HUD widget the click names, or null — a click on the HUD is not a click
+	* in the world.
+	*
+	* `click: 'Hud/Buy'` used to fail with `resolves to no node — nothing to
+	* point at`, about a node the same run's `describe()` prints. A widget is not
+	* a `Node2D`, so it has no world position, and `pointAtNode` answers null the
+	* same way it does for a path that matches nothing.
+	*
+	* That message was the small half. The large half is that an entire family of
+	* games — a menu, a shop, a settings screen, an idle game, a card game — is
+	* played by pressing `UiButton`s, and the documented verb for pressing things
+	* could not press one. `UiButton.press()` has always been public and says
+	* "same path as a click (tests, gamepad menus)"; nothing routed a click to it.
+	*/
+	const widgetAt = (target) => {
+		if (typeof target !== "string") return null;
+		const node = live().root.getNodeOrNull(target);
+		return node instanceof HudWidgetBase ? node : null;
+	};
+	/**
+	* Can a player see it? A widget under a hidden panel is not on screen, and a
+	* click a player could not make is a harness testing itself.
+	*/
+	const widgetIsShown = (widget) => {
+		for (let at = widget; at; at = at.parent) {
+			if (at instanceof HudWidgetBase && !at.visible) return false;
+			if (at instanceof HudLayer) return at.visible;
+		}
+		return false;
+	};
+	/** Resolve a step's cursor target and move there; false = it resolved to nothing. */
+	const moveTo = (target, step, what) => {
+		const resolved = typeof target === "function" ? target(ctx) : target;
+		if (resolved === null) return null;
+		const where = pointOf(resolved);
+		if (!where) {
+			failures.push({
+				atMs: step.atMs,
+				label: step.label,
+				message: `${what} target '${String(resolved)}' resolves to no node — nothing to point at`
+			});
+			return false;
+		}
+		armPointer();
+		engine.input.setPointerPosition(where[0], where[1]);
+		return true;
+	};
+	const applyStep = (step, tick) => {
+		if (step.press) engine.input.pressAction(step.press);
+		if (step.release) engine.input.releaseAction(step.release);
+		if (step.vector) engine.input.setActionVector(...step.vector);
+		if (step.key) engine.input.handleKey(step.key[0], step.key[1]);
+		if (step.at !== void 0) moveTo(step.at, step, "at");
+		if (step.mouse !== void 0) {
+			armPointer();
+			engine.input.handleMouseButton(step.button ?? 0, step.mouse === "down");
+		}
+		const widget = step.click === void 0 ? null : widgetAt(step.click);
+		if (widget) if (!widgetIsShown(widget)) failures.push({
+			atMs: step.atMs,
+			label: step.label,
+			message: `click target '${String(step.click)}' is a HUD widget nobody can see — it or something above it has \`visible: false\`, so a player could not press it`
+		});
+		else widget._click();
+		else if (step.click !== void 0 && moveTo(step.click, step, "click") === true) {
+			const named = typeof step.click === "string" ? step.click : null;
+			if (named !== null) {
+				const at = engine.input.pointerPosition();
+				const under = at ? engine.pickAt(at.x, at.y) : null;
+				const wanted = live().root.getNodeOrNull(named);
+				if (wanted && (!under || !isSelfOrAncestor(wanted, under))) failures.push({
+					atMs: step.atMs,
+					label: step.label,
+					message: `clicked '${named}' and the picker found ${under ? `'${under.getPath()}'` : "nothing"} there. A node is pickable when something can measure it: a \`size\` prop, a collider, or a spritesheet asset with \`frameWidth\`/\`frameHeight\`. A \`Sprite2D\` takes its size from the decoded texture, which headless never exists — give it a collider, or click the node that has the shape.`
+				});
+			}
+			releaseButton = step.button ?? 0;
+			engine.input.handleMouseButton(releaseButton, true);
+			releaseAt = tick + 1;
+		}
+		step.do?.(ctx);
+		if (step.assert) try {
+			const verdict = assertVerdict(step.assert(ctx));
+			if (verdict) failures.push({
+				atMs: step.atMs,
+				label: step.label,
+				message: verdict
+			});
+		} catch (e) {
+			failures.push({
+				atMs: step.atMs,
+				label: step.label,
+				message: e instanceof Error ? e.message : String(e)
+			});
+		}
+	};
+	const stepMs = 1e3 / (opts.fixedHz ?? 60);
+	const totalTicks = Math.round(opts.durationMs / stepMs);
+	const steps = [...opts.steps ?? []].sort((a, b) => a.atMs - b.atMs);
+	let stepIndex = 0;
+	let nextSnapshot = opts.snapshotEveryMs ?? Number.POSITIVE_INFINITY;
+	for (let i = 1; i <= totalTicks; i++) {
+		const t = i * stepMs;
+		ctx.timeMs = t;
+		while (stepIndex < steps.length && steps[stepIndex].atMs <= t) {
+			applyStep(steps[stepIndex], i);
+			stepIndex += 1;
+		}
+		if (releaseAt === i) {
+			engine.input.handleMouseButton(releaseButton, false);
+			releaseAt = -1;
+		}
+		engine.step();
+		if (t >= nextSnapshot - 1e-6) {
+			snapshots.push({
+				atMs: Math.round(t),
+				capture: captureScene(live())
+			});
+			nextSnapshot += opts.snapshotEveryMs;
+		}
+	}
+	/** Where a `click` step points: a node, or a literal point. */
+	function pointOf(target) {
+		return Array.isArray(target) ? target : pointAtNode(live(), target);
+	}
+	for (; stepIndex < steps.length; stepIndex++) {
+		const missed = steps[stepIndex];
+		failures.push({
+			atMs: missed.atMs,
+			label: missed.label,
+			message: `step never executed — atMs ${missed.atMs} is beyond the ${opts.durationMs ?? 0}ms run`
+		});
+	}
+	const finalCapture = captureScene(live());
+	const logs = [...engine.log.entries()];
+	const simulatedMs = Math.round(engine.time * 1e3);
+	const swallowed = engine.stats().errors;
+	if (swallowed > 0) failures.push({
+		atMs: opts.durationMs,
+		label: "engine",
+		message: `${swallowed} error(s) were swallowed to keep the loop alive — the logs above name the node, the behavior and the phase`
+	});
+	engine.dispose();
+	const ok = failures.length === 0;
+	return {
+		ok,
+		failures,
+		snapshots,
+		logs,
+		finalCapture,
+		describe: () => {
+			const engineWarnings = logs.filter((l) => l.level === "warn" || l.level === "error");
+			const budget = Math.abs(simulatedMs - opts.durationMs) > Math.max(50, opts.durationMs * .02) ? ` (of ${opts.durationMs}ms of steps — the game clock ran slower, or stopped)` : "";
+			const head = `run ${ok ? "OK" : "FAILED"} — ${simulatedMs}ms simulated${budget}, ${failures.length} failure(s), ${logs.length} log(s)`;
+			const fails = failures.map((f) => `  ✗ at ${f.atMs}ms${f.label ? ` [${f.label}]` : ""}: ${f.message}`);
+			const noisy = engineWarnings.map((l) => `  ! ${l.level}: ${l.parts.map((p) => typeof p === "string" ? p : String(p)).join(" ")}`);
+			return [
+				head,
+				...fails,
+				...noisy,
+				describeCapture(finalCapture)
+			].join("\n");
+		}
+	};
+}
+/**
+* The headless play loop behind `incanto-play`: load → feed inputs by intent
+* (`session.engine.input.pressAction(...)`) → `step(ms)` → `capture()` the
+* state AS A SCENE FILE. What a screenshot is to humans, the capture is to
+* agents: complete, structured, and in the exact format they already read.
+*/
+async function createPlaySession(json, opts = {}) {
+	registerAllNodes();
+	for (const [name, ctor] of Object.entries(opts.behaviors ?? {})) registerBehavior(name, ctor, { replace: true });
+	const engine = new Engine({
+		seed: opts.seed,
+		fixedHz: opts.fixedHz,
+		scheduler: () => () => {}
+	});
+	const scene = loadScene(structuredClone(json), {
+		resolveScene: opts.resolveScene,
+		stubMissingBehaviors: opts.stubMissingBehaviors,
+		engine
+	});
+	engine.setScene(scene);
+	const physics = opts.physics ?? "auto";
+	if (physics === "2d" || physics === "auto" && scene.dimension === "2d") {
+		const { enablePhysics2D } = await import("./physics-2d-FhrXUc6B.js").then((n) => n.r);
+		await enablePhysics2D(engine);
+	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
+		const { enablePhysics3D } = await import("./physics-3d-CFEGxBXZ.js").then((n) => n.r);
+		await enablePhysics3D(engine);
+	}
+	const stepMs = 1e3 / (opts.fixedHz ?? 60);
+	let timeMs = 0;
+	let logCursor = 0;
+	return {
+		engine,
+		get scene() {
+			return engine.scene ?? scene;
+		},
+		get timeMs() {
+			return timeMs;
+		},
+		step(ms) {
+			const ticks = Math.max(1, Math.round(ms / stepMs));
+			for (let i = 0; i < ticks; i++) engine.step();
+			timeMs += ticks * stepMs;
+		},
+		capture() {
+			return (engine.scene ?? scene).toJSON();
+		},
+		describe() {
+			return describeCapture(captureScene(engine.scene ?? scene));
+		},
+		framing() {
+			return framingText(describeFraming(engine.scene ?? scene));
+		},
+		drainLogs() {
+			const all = engine.log.entries();
+			const fresh = all.filter((e) => e.seq > logCursor);
+			if (all.length > 0) logCursor = all[all.length - 1].seq;
+			return [...fresh];
+		},
+		dispose() {
+			engine.dispose();
+		}
+	};
+}
+//#endregion
+export { geometricPicker as A, facingReport as C, playtest as D, findPlayer as E, sceneAssetUrls as F, pointAtNode as M, describeFraming as N, playtestFailed as O, framingText as P, collectionProblems as S, failingReplays as T, feelReport as _, registerAllNodes as a, takeCollectionSnapshots as b, feelsRung as c, ladderVerdict as d, saysRung as f, playMultiplayer as g, multiplayText as h, findFloatingProps as i, geometricView as j, playtestText as k, firstLine as l, multiplayProblems as m, createPlaySession as n, runScript as o, unmeasuredPlays as p, describeCapture as r, validateScene as s, captureScene as t, ladderText as u, feelText as v, facingText as w, agreementProblems as x, takeAgreementSnapshots as y };