incanto 0.69.0 → 0.71.0

package/dist/test-D6ISmuFE.js

@@ -1,2383 +0,0 @@
-import { f as resolveViewport, n as loadScene, z as registerBehavior } from "./loader-DZE7B07H.js";
-import { v as Engine } from "./register-mmfugpaQ.js";
-import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { n as jsonEquals, t as jsonClone } from "./json-CwwhxQgb.js";
-import { i as getNodeSchema, s as mergeStaticProps } from "./registry-CF70EArN.js";
-import { n as startRecording } from "./replay-BEHLDcQV.js";
-import { n as registerGameplayBehaviors } from "./gameplay-D1KixWK8.js";
-import { t as registerNodes2D } from "./register-DbVArsns.js";
-import { n as registerNodes3D, t as resolveEnvironmentHdri } from "./environment-presets-BO-7XoFV.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-CauMwu6y.js";
-import { Box3, Euler, Matrix4, PerspectiveCamera, Quaternion, Vector3 } from "three";
-//#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",
-	"SpotLight3D"
-]);
-/** Screen-space subtrees: they ignore the camera, so framing has nothing to say. */
-const SCREEN_SPACE = 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];
-/**
-* 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.
-*/
-function place(scene) {
-	const out = [];
-	const walk = (node, parent) => {
-		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);
-		out.push({
-			node,
-			type,
-			matrix,
-			position: new Vector3().setFromMatrixPosition(matrix)
-		});
-		if (SCREEN_SPACE.has(type)) return;
-		for (const child of node.children) walk(child, matrix);
-	};
-	walk(scene.root, new Matrix4());
-	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.
-*/
-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.
-*/
-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.
-*/
-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.
-*/
-function extentOf(node) {
-	const size = node.size;
-	if (Array.isArray(size) && size.length >= 2 && typeof size[0] === "number") {
-		const x = size[0] / 2;
-		const y = typeof size[1] === "number" && size.length >= 3 ? size[1] / 2 : x;
-		const z = (size[size.length - 1] ?? size[0]) / 2;
-		return new Vector3(Math.abs(x), Math.abs(y), Math.abs(z));
-	}
-	return halfExtents(node);
-}
-/**
-* 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.
-*/
-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.
-*/
-function describeFraming2D(scene, placed, opts) {
-	const design = resolveViewport(scene.viewport)?.design;
-	const [vw, vh] = opts.viewport ?? design ?? DEFAULT_VIEW_2D;
-	const cameras = placed.filter((p) => p.type === "Camera2D");
-	const chosen = cameras.find((p) => p.node.current === true) ?? cameras[0] ?? null;
-	let camera = null;
-	let view = {
-		minX: 0,
-		minY: 0,
-		maxX: vw,
-		maxY: vh
-	};
-	if (chosen) {
-		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);
-		}
-		view = {
-			minX: cx - halfW,
-			minY: cy - halfH,
-			maxX: cx + halfW,
-			maxY: cy + halfH
-		};
-		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 = box2D(p.node);
-		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: 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,
-		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 forward = new Vector3(0, 0, -1).applyQuaternion(new Quaternion().setFromRotationMatrix(chosen.matrix));
-		camera = {
-			path: chosen.node.getPath(),
-			at: chosen.position.toArray(),
-			forward: [
-				round(forward.x),
-				round(forward.y),
-				round(forward.z)
-			],
-			fovDeg: node.fov ?? 60
-		};
-		for (const p of subjects) {
-			const view = p.position.clone().applyMatrix4(cam.matrixWorldInverse);
-			const distance = p.position.distanceTo(chosen.position);
-			if (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) {
-				const half = extentOf(p.node);
-				if (half) onScreen = cornersOnScreen(new Box3().setFromCenterAndSize(p.position, half.clone().multiplyScalar(2)), cam);
-			}
-			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,
-		lights,
-		overlaps: findOverlaps(placed, TOUCH_EPS_3D)
-	};
-}
-function cornersOnScreen(box, cam) {
-	const min = box.min;
-	const max = box.max;
-	for (const x of [min.x, max.x]) for (const y of [min.y, max.y]) for (const z of [min.z, max.z]) {
-		const ndc = new Vector3(x, y, z).project(cam);
-		if (Math.abs(ndc.x) <= 1 && Math.abs(ndc.y) <= 1 && ndc.z <= 1) return true;
-	}
-	return false;
-}
-/**
-* 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(", ")}] fov ${c.fovDeg}`);
-	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");
-	lines.push(is2d ? `${on.length} in view, ${off.length} outside it` : `${on.length} on screen, ${off.length} off screen, ${behind.length} behind the camera`);
-	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/playtest.ts
-/**
-* 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.
-*/
-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 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" && node === player) offs.push(node.on(signal, () => settle("lost")));
-			if (signal === "damaged" && node === player) 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();
-	/** What was pressed most recently, so a freeze can be attributed to it. */
-	lastPressed = null;
-	moveAction;
-	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;
-	clickCooldown = 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;
-		const declared = engine.input.declaredActions();
-		this.moveAction = declared.find((a) => a.type === "vector2")?.name ?? null;
-		this.buttons = declared.filter((a) => a.type === "button").map((a) => a.name);
-		this.clickables = [];
-		const root = engine.scene?.root;
-		if (root) {
-			const walk = (node) => {
-				if (node.behavior?.constructor.name === "Clickable") this.clickables.push(node);
-				for (const child of node.children) walk(child);
-			};
-			walk(root);
-			if (this.clickables.length > 0 && !engine.picker) engine.picker = () => this.clicking;
-		}
-	}
-	/** How many nodes this bot can click. Reported, so a ✓ says what it drove. */
-	get clickableCount() {
-		return this.clickables.length;
-	}
-	/** Grid cell key — coarse on purpose, this is novelty not navigation. */
-	cell(p) {
-		return `${Math.round(p[0] / 4)},${Math.round(p[2] / 4)}`;
-	}
-	/** Actions this run avoided after they stopped the clock. */
-	paused() {
-		return [...this.frozeTheGame];
-	}
-	step(dt, at) {
-		if (this.engine.timeScale === 0) {
-			if (this.lastPressed) this.frozeTheGame.add(this.lastPressed);
-			for (const button of this.buttons) {
-				this.engine.input.releaseAction(button);
-				this.held.set(button, -1);
-			}
-			this.engine.timeScale = 1;
-			this.lastPressed = null;
-		}
-		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)) 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 === "jump" ? .06 : .02;
-			if (this.rand() < chance) {
-				this.engine.input.pressAction(button);
-				this.lastPressed = button;
-				this.held.set(button, .08 + this.rand() * .12);
-			}
-		}
-		this.maybeClick(dt);
-	}
-	/**
-	* 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.
-	*/
-	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.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;
-	}
-	release() {
-		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) {
-	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}`);
-	}
-	const walkAll = (node) => {
-		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 (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 floor = opts.fallBelow ?? (pull > 0 ? 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 rand = () => engine.rng.next();
-	const driver = new Driver(engine, rand);
-	const reached = /* @__PURE__ */ new Set();
-	const stepMs = 1e3 / 60;
-	const deadline = (opts.seconds ?? 60) * 1e3;
-	let outcome = null;
-	let swappedAtMs = null;
-	const offSwap = engine.sceneChanged.connect(() => {
-		swappedAtMs ??= session.timeMs;
-	});
-	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));
-	while (session.timeMs < deadline) {
-		at = player ? worldOf(player) : start;
-		wentAsFarAs = Math.max(wentAsFarAs, travelled(at, start));
-		driver.step(stepMs / 1e3, at);
-		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 WENT_NOWHERE = scene.dimension === "2d" ? STUCK_2D_PX : STUCK_3D_M;
-	outcome ??= wentAsFarAs > WENT_NOWHERE ? "unfinished" : "stuck";
-	const heard = engine.audio.recent().map((e) => e.from);
-	const shown = engine.effects.recent().map((e) => e.from);
-	const bad = outcome !== "won" && outcome !== "unfinished";
-	const run = {
-		seed,
-		outcome,
-		timeMs: session.timeMs,
-		reached: [...reached],
-		fired: [...fired],
-		damageTaken: oracle.damage(),
-		errors: engine.stats().errors,
-		replay: bad ? recorder.stop() : null,
-		endedAt: at,
-		heard: [...new Set(heard)],
-		shown: [...new Set(shown)]
-	};
-	if (!bad) recorder.stop();
-	for (const off of offs) off();
-	oracle.dispose();
-	session.dispose();
-	return {
-		run,
-		targets,
-		signals,
-		declaresEnd: oracle.declaresEnd(),
-		hazards,
-		hasPlayer: player !== null,
-		froze: driver.paused()
-	};
-}
-/**
-* 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 = 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();
-	for (let i = 0; i < count; i++) {
-		const one = await runOnce(json, base + i, opts);
-		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);
-	}
-	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 (type === "Particles2D" || type === "Particles3D") feedbackNodes.effects.push(path);
-		for (const child of node.children) walkFeedback(child);
-	};
-	const probeRoot = probe.scene.tree.root;
-	if (probeRoot) walkFeedback(probeRoot);
-	probe.dispose();
-	return {
-		runs,
-		targets,
-		signals: [...new Set(signals)],
-		actions,
-		inertActions: [],
-		declaresWin,
-		hasPlayer,
-		hazards,
-		froze: [...froze],
-		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))]
-		}
-	};
-}
-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`);
-	if (!report.hasPlayer) {
-		lines.push("  · nothing here is drivable — no character controller, no node in the `player` group, no node named Player. The runs went nowhere because there was nobody to move, not because anything is wedged.");
-		return lines.join("\n");
-	}
-	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}`);
-	}
-	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.`);
-	}
-	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");
-}
-/** 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
-		};
-	}
-	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, 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 < .05) {
-		session.dispose();
-		return {
-			player: player.getPath(),
-			skin: skinPath,
-			dot: null,
-			backwards: false,
-			travelled
-		};
-	}
-	const [fx, fz] = forwardOf((skin.rotation?.[1] ?? 0) - declaredOffset, opts.forwardAxis ?? "+z");
-	const dot = (fx * dx + fz * dz) / travelled;
-	session.dispose();
-	return {
-		player: player.getPath(),
-		skin: skinPath,
-		dot: Math.round(dot * 1e3) / 1e3,
-		backwards: dot < -.5,
-		travelled: Math.round(travelled * 1e3) / 1e3
-	};
-}
-/** 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.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) 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,
-		erased: 1,
-		absent: 2,
-		shape: 3,
-		mismatch: 4
-	};
-	return out.sort((x, y) => rank[x.kind] - rank[y.kind]);
-}
-//#endregion
-//#region src/test/agreement-snapshot.ts
-/** 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)];
-}
-/** 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 truth = {};
-		for (const key of keys) {
-			const value = readSyncKey(node, key);
-			if (value !== void 0) 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);
-			seen[other.account] = held;
-		}
-		snapshots.push({
-			account: owner.account,
-			truth,
-			seen
-		});
-	}
-	return snapshots;
-}
-//#endregion
-//#region src/test/feel.ts
-const STEP_MS = 1e3 / 60;
-/** 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 move = opts.moveAction ?? declared.find((a) => a.type === "vector2")?.name ?? null;
-	const jump = opts.jumpAction ?? (declared.some((a) => a.name === "jump" && a.type === "button") ? "jump" : null);
-	if (!player) {
-		session.dispose();
-		return {
-			probe: null,
-			move,
-			jump
-		};
-	}
-	const is2d = session.scene.dimension === "2d";
-	return {
-		probe: {
-			session,
-			engine: session.engine,
-			player,
-			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
-	};
-}
-/** Let the character settle onto whatever it is standing on. */
-function settle$1(probe) {
-	probe.step(60);
-}
-/** Hold one direction and learn what this character's plateau actually is. */
-function measureAccel(probe, move) {
-	settle$1(probe);
-	const before = probe.pos();
-	probe.engine.input.setActionVector(move, 1, 0);
-	let latency = null;
-	let top = 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;
-		}
-		top = Math.max(top, probe.speed());
-	}
-	probe.engine.input.setActionVector(move, 0, 0);
-	return {
-		top,
-		latencyFrames: latency
-	};
-}
-/**
-* 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, top) {
-	settle$1(probe);
-	const target = top * .95;
-	probe.engine.input.setActionVector(move, 1, 0);
-	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, top) {
-	settle$1(probe);
-	probe.engine.input.setActionVector(move, 1, 0);
-	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, top) {
-	settle$1(probe);
-	probe.engine.input.setActionVector(move, 1, 0);
-	for (let f = 0; f < 600 && probe.speed() < top * .9; f++) probe.step();
-	probe.engine.input.setActionVector(move, -1, 0);
-	for (let f = 1; f <= 600; f++) {
-		probe.step();
-		if (probe.vel()[0] < -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);
-}
-/**
-* 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,
-		timeToFullSpeedMs: null,
-		timeToStopMs: null,
-		turnaroundMs: null,
-		jumpApex: null,
-		heldJumpApex: null,
-		heldAirtimeMs: null,
-		timeToApexMs: null,
-		airtimeMs: null,
-		coyoteMs: null,
-		jumpBufferMs: null,
-		inputToMotionFrames: null
-	};
-	const playerPath = first.probe.player.getPath();
-	let topSpeed = 0;
-	let latency = null;
-	if (move) {
-		const ramp = measureAccel(first.probe, move);
-		topSpeed = Number(ramp.top.toFixed(2));
-		latency = ramp.latencyFrames;
-	}
-	first.probe.session.dispose();
-	const fresh = async () => (await makeProbe(json, opts)).probe;
-	let toFull = null;
-	let toStop = null;
-	let turn = null;
-	if (move && topSpeed > .05) {
-		const a = await fresh();
-		if (a) {
-			toFull = timeToFullSpeed(a, move, topSpeed);
-			a.session.dispose();
-		}
-		const b = await fresh();
-		if (b) {
-			toStop = timeToStop(b, move, topSpeed);
-			b.session.dispose();
-		}
-		const c = await fresh();
-		if (c) {
-			turn = turnaround(c, move, topSpeed);
-			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);
-			d.session.dispose();
-		}
-		const h = await fresh();
-		if (h) {
-			held = jumpShape(h, jump, true);
-			h.session.dispose();
-		}
-		coyote = await measureCoyote(json, opts, jump);
-		buffer = await measureBuffer(json, opts, jump);
-	}
-	return {
-		player: playerPath,
-		moveAction: move,
-		jumpAction: jump,
-		topSpeed,
-		timeToFullSpeedMs: toFull,
-		timeToStopMs: toStop,
-		turnaroundMs: turn,
-		jumpApex: shape.apex,
-		heldJumpApex: held.apex,
-		heldAirtimeMs: held.airtimeMs,
-		timeToApexMs: shape.toApexMs,
-		airtimeMs: shape.airtimeMs,
-		coyoteMs: coyote,
-		jumpBufferMs: buffer,
-		inputToMotionFrames: latency
-	};
-}
-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("");
-	lines.push(`  top speed        ${report.topSpeed} u/s`);
-	lines.push(`  to full speed    ${ms(report.timeToFullSpeedMs)}`);
-	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.coyoteMs === null ? "always (no window)" : ms(report.coyoteMs)}`);
-		lines.push(`  jump buffer      ${report.jumpBufferMs === null ? "always (no window)" : ms(report.jumpBufferMs)}`);
-		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.");
-		}
-	}
-	return lines.join("\n");
-}
-//#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,
-		spawned: spawnerCounts(p.engine),
-		sawAccounts: Object.keys(p.manager.latestUserStates ?? {}).filter((a) => a !== p.account),
-		errors: p.engine.stats().errors
-	}));
-	let lateSnapshots = [];
-	let lateJoinChecked = false;
-	if ((opts.lateJoin ?? true) && players.length > 0) {
-		const joiner = await joinLate(server, players[0], opts);
-		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 report = summarize(players, seconds, frames, matchDetail, {
-		disagreements: agreementProblems(live, lateSnapshots),
-		keysCompared: live.reduce((n, s) => n + Object.keys(s.truth).length * Object.keys(s.seen).length, 0),
-		lateJoinChecked
-	});
-	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-mmfugpaQ.js").then((n) => n.y);
-		const { loadScene } = await import("./loader-DZE7B07H.js").then((n) => n.r);
-		const { jsonClone } = await import("./json-CwwhxQgb.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;
-	}
-}
-/** 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 = [...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.`);
-		const empty = detail.filter((d) => Object.keys(d.spawned).length > 0 && Object.values(d.spawned).every((n) => n === 0));
-		if (empty.length > 0 && blind.length === 0) problems.push(`${empty.map((d) => d.account).join(", ")} has a NetworkSpawner that materialised nothing — check its \`scene\` key is registered and its \`source\` names a real collection.`);
-	}
-	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[node.name] = 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
-const MARK = {
-	pass: "✓",
-	fail: "✗",
-	unmeasured: "?",
-	skipped: "·"
-};
-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 ?? []
-	};
-}
-/** 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([
-	"CharacterBody3D",
-	"RigidBody3D",
-	"StaticBody3D",
-	"AreaBody3D"
-]);
-/**
-* 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 });
-	} 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);
-		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 });
-	try {
-		checkEnvironment(json);
-		loadScene(json, {
-			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;
-	}
-}
-/**
-* 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), { 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-CF5yyjbj.js").then((n) => n.r);
-		await enablePhysics2D(engine);
-	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-DbYaEcZy.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())
-	};
-	const applyStep = (step) => {
-		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]);
-		step.do?.(ctx);
-		if (step.assert) try {
-			if (step.assert(ctx) === false) failures.push({
-				atMs: step.atMs,
-				label: step.label,
-				message: "assert returned false"
-			});
-		} 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]);
-			stepIndex += 1;
-		}
-		engine.step();
-		if (t >= nextSnapshot - 1e-6) {
-			snapshots.push({
-				atMs: Math.round(t),
-				capture: captureScene(live())
-			});
-			nextSnapshot += opts.snapshotEveryMs;
-		}
-	}
-	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}ms run`
-		});
-	}
-	const finalCapture = captureScene(live());
-	const logs = [...engine.log.entries()];
-	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 head = `run ${ok ? "OK" : "FAILED"} — ${opts.durationMs}ms simulated, ${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-CF5yyjbj.js").then((n) => n.r);
-		await enablePhysics2D(engine);
-	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-DbYaEcZy.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 { describeFraming as C, playtestText as S, facingReport as _, registerAllNodes as a, findPlayer as b, ladderText as c, multiplayText as d, playMultiplayer as f, agreementProblems as g, takeAgreementSnapshots as h, findFloatingProps as i, ladderVerdict as l, feelText as m, createPlaySession as n, runScript as o, feelReport as p, describeCapture as r, validateScene as s, captureScene as t, multiplayProblems as u, facingText as v, framingText as w, playtest as x, failingReplays as y };