incanto 0.74.0 → 0.76.0

package/dist/{test-CEl0y2Sw.js → test-CVbxnXlv.js}

@@ -1,14 +1,14 @@
 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-CEUGeLuB.js";
-import { v as Engine } from "./register-CjociOtt.js";
+import { G as HudLayer, K as HudWidgetBase, L as resetMemorySaves, N as resolveViewport, b as loadScene, dt as registerBehavior, f as isCloned, i as worldPosition, ot as StubBehavior } from "./pose-ByFB_J3O.js";
+import { b as Engine } from "./register-B768Qedj.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-CDOMybym.js";
-import { a as LIGHT_NODE_TYPES, n as startRecording } from "./replay-B6BbgGM_.js";
+import { a as LIGHT_NODE_TYPES, n as startRecording } from "./replay-DrqQ6dZj.js";
 import { c as getNodeSchema, d as mergeStaticProps, u as getNodeType } from "./touch-CioTZB-y.js";
-import { et as worldPosition, n as registerGameplayBehaviors } from "./gameplay-Bxe1sMVT.js";
-import { t as registerNodes2D } from "./register-DRQyZKGU.js";
-import { n as registerNodes3D, t as resolveEnvironmentHdri } from "./environment-presets-BkqlWewf.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-BxZ5rBe7.js";
+import { n as registerGameplayBehaviors } from "./gameplay-Bfff_beb.js";
+import { t as registerNodes2D } from "./register-7E3P1gz6.js";
+import { n as registerNodes3D, t as resolveEnvironmentHdri } from "./environment-presets-e_9YCnGu.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-B-dIcQsQ.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. */
@@ -59,6 +59,32 @@ function sceneAssetUrls(json) {
 					url: value
 				});
 			}
+			const seen = new Set(out.filter((u) => u.path === path).map((u) => u.url));
+			const deep = (value, where) => {
+				if (typeof value === "string") {
+					if (/^https?:\/\//i.test(value) && !seen.has(value)) {
+						seen.add(value);
+						out.push({
+							path,
+							prop: where,
+							kind: "",
+							url: value
+						});
+					}
+					return;
+				}
+				if (Array.isArray(value)) {
+					value.forEach((item, i) => {
+						deep(item, `${where}[${i}]`);
+					});
+					return;
+				}
+				if (value && typeof value === "object") for (const [key, inner] of Object.entries(value)) deep(inner, `${where}.${key}`);
+			};
+			for (const [key, value] of Object.entries(props)) {
+				if (typeof value === "string") continue;
+				deep(value, key);
+			}
 		}
 		if (Array.isArray(node.children)) for (const c of node.children) visit(c, path);
 	};
@@ -1050,7 +1076,9 @@ function pointAtNode(scene, path, opts = {}) {
 	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());
+	const entries = describeFraming(scene, opts.viewport ? { viewport: opts.viewport } : {}).entries;
+	const here = node.getPath();
+	const seen = entries.find((e) => e.path === here) ?? entries.find((e) => e.path.startsWith(`${here}/`));
 	if (seen && seen.where === "offscreen") return null;
 	if (scene.dimension === "2d") return [at[0] ?? 0, at[1] ?? 0];
 	if (!seen?.screen) return null;
@@ -1186,6 +1214,71 @@ function worldOf(node) {
 /** Trigger volumes are destinations even without a script — that IS their job. */
 const TRIGGERS = new Set(["Area2D", "Area3D"]);
 /**
+* How big is this node, for the purpose of "did the player reach it"?
+*
+* Reach was measured against a node's ORIGIN, which is right for a coin and
+* wrong for anything with size: the origin of a 30×16 m quay is under its
+* middle, so a player who walked every plank of it was reported as never having
+* reached it. And a node earns its place on that list by carrying a GROUP,
+* which is exactly how every example here tags its ground.
+*
+* The half-diagonal of whatever the node declares — its collider first (that is
+* the thing you can stand on), then the mesh it draws — scaled by the node's
+* own scale. A node that declares no size gets 0 and behaves exactly as before.
+* Rotation is ignored on purpose: the diagonal is already the generous case.
+*/
+function reachRadiusOf(node) {
+	const num = (n) => typeof n === "number" && Number.isFinite(n) ? n : NaN;
+	/** Half-extents plus how to turn them into ONE radius for this shape. */
+	let half = null;
+	let round = false;
+	const collider = node.collider;
+	if (collider && typeof collider === "object") {
+		const shape = collider.shape;
+		if (shape === "box" && Array.isArray(collider.size)) {
+			const [x, y, z] = collider.size;
+			half = [
+				num(x) / 2,
+				num(y) / 2,
+				num(z) / 2
+			];
+		} else if (shape === "sphere") {
+			const r = num(collider.radius);
+			half = [
+				r,
+				r,
+				r
+			];
+			round = true;
+		} else if (shape === "capsule" || shape === "cylinder") {
+			const r = num(collider.radius);
+			half = [
+				r,
+				num(collider.height) / 2 + (shape === "capsule" ? r : 0),
+				r
+			];
+		}
+	}
+	if (!half && Array.isArray(node.size) && node.size.length >= 3) {
+		const [x, y, z] = node.size;
+		half = [
+			num(x) / 2,
+			num(y) / 2,
+			num(z) / 2
+		];
+	}
+	if (!half) return 0;
+	const s = Array.isArray(node.scale) ? node.scale : [];
+	const at = (i) => Number.isFinite(num(s[i])) ? num(s[i]) : 1;
+	const [hx, hy, hz] = [
+		half[0] * at(0),
+		half[1] * at(1),
+		half[2] * at(2)
+	];
+	const r = round ? Math.max(hx, hy, hz) : Math.hypot(hx, hy, hz);
+	return Number.isFinite(r) ? r : 0;
+}
+/**
 * Is this node somewhere the player is meant to GO?
 *
 * Author intent, not geometry. Keying off the tree alone reported 150 unreached
@@ -1211,6 +1304,7 @@ function isTarget(node) {
 function makeOracle(engine, player) {
 	let outcome = null;
 	let damage = 0;
+	let playerHealth = false;
 	const offs = [];
 	let declaresEnd = false;
 	/** First verdict wins — a run ends at its first conclusion, not its last. */
@@ -1227,9 +1321,12 @@ function makeOracle(engine, player) {
 			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 === "damaged" && isPlayerSide(node)) {
+				playerHealth = true;
+				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");
@@ -1243,6 +1340,7 @@ function makeOracle(engine, player) {
 		outcome: () => outcome,
 		declaresEnd: () => declaresEnd,
 		damage: () => damage,
+		playerHasHealth: () => playerHealth,
 		dispose: () => {
 			for (const off of offs) off();
 		}
@@ -1291,8 +1389,21 @@ var Driver = class {
 	/** What was pressed most recently, so a freeze can be attributed to it. */
 	lastPressed = null;
 	moveAction;
+	/**
+	* The OTHER characters' move actions — a couch co-op game declares one action
+	* set per player and tells each controller which to read (`moveAction`), and
+	* this bot drove the first vector2 action it found. Measured on a two-player
+	* scene: player one walked 17.3 m and player two walked 0.0 m for the whole
+	* run, and the report said the game could never be won — about a game that is
+	* won by two people walking.
+	*/
+	extraMoves = [];
 	/** The button the scene's controller calls its jump — `jump` unless it says otherwise. */
 	jumpButton = "jump";
+	/** Every controller's jump, so each player's jump gets the jump's odds. */
+	jumpButtons = new Set(["jump"]);
+	/** What the scene's controllers asked to read, in tree order. */
+	controllerActions = [];
 	/**
 	* The action vocabulary this driver was bound to, so it can notice a swap.
 	*
@@ -1407,16 +1518,24 @@ var Driver = class {
 			}
 		}
 		if (root) {
-			const stack = [root];
-			while (stack.length > 0) {
-				const node = stack.pop();
+			const walk = (node) => {
 				if (CONTROLLERS.has(node.constructor.typeName ?? "")) {
-					const want = node.jumpAction;
-					if (typeof want === "string" && want !== "") this.jumpButton = want;
-					break;
+					const jump = node.jumpAction;
+					const move = node.moveAction;
+					this.controllerActions.push({
+						move: typeof move === "string" && move !== "" ? move : "move",
+						jump: typeof jump === "string" && jump !== "" ? jump : "jump"
+					});
 				}
-				for (const child of node.children) stack.push(child);
-			}
+				for (const child of node.children) walk(child);
+			};
+			walk(root);
+			const first = this.controllerActions[0];
+			if (first) this.jumpButton = first.jump;
+			this.jumpButtons = new Set(this.controllerActions.map((c) => c.jump));
+			if (this.jumpButtons.size === 0) this.jumpButtons = new Set([this.jumpButton]);
+			this.vocabulary = "";
+			this.rebind();
 		}
 		this.readsMouse = asks;
 		const design = engine.scene?.viewport?.design;
@@ -1500,6 +1619,14 @@ var Driver = class {
 			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 other of this.extraMoves) {
+			other.left -= dt;
+			if (other.left <= 0) {
+				other.heading = this.rand() * Math.PI * 2;
+				other.left = .5 + this.rand() * 1.5;
+			}
+			this.engine.input.setActionVector(other.action, Math.cos(other.heading), Math.sin(other.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;
@@ -1512,7 +1639,7 @@ var Driver = class {
 				this.held.set(button, -1);
 				continue;
 			}
-			const chance = button === this.jumpButton ? .06 : .02;
+			const chance = this.jumpButtons.has(button) ? .06 : .02;
 			if (this.rand() < chance) {
 				this.engine.input.pressAction(button);
 				this.actionPresses += 1;
@@ -1707,7 +1834,16 @@ var Driver = class {
 		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;
+		const vectors = declared.filter((a) => a.type === "vector2").map((a) => a.name);
+		const wanted = this.controllerActions[0]?.move;
+		this.moveAction = (wanted && vectors.includes(wanted) ? wanted : vectors[0]) ?? null;
+		const others = new Set(this.controllerActions.slice(1).map((c) => c.move).filter((name) => name !== this.moveAction && vectors.includes(name)));
+		this.extraMoves = this.extraMoves.filter((m) => others.has(m.action));
+		for (const action of others) if (!this.extraMoves.some((m) => m.action === action)) this.extraMoves.push({
+			action,
+			heading: this.rand() * Math.PI * 2,
+			left: 0
+		});
 		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);
@@ -1718,6 +1854,7 @@ var Driver = class {
 		this.rebind();
 		for (const button of this.buttons) this.engine.input.releaseAction(button);
 		if (this.moveAction) this.engine.input.setActionVector(this.moveAction, 0, 0);
+		for (const other of this.extraMoves) this.engine.input.setActionVector(other.action, 0, 0);
 	}
 };
 async function runOnce(json, seed, opts, avoid = /* @__PURE__ */ new Set()) {
@@ -1776,7 +1913,11 @@ async function runOnce(json, seed, opts, avoid = /* @__PURE__ */ new Set()) {
 	const targetNodes = [];
 	const collect = (node) => {
 		if (SCREEN_SPACE.has(node.constructor.typeName ?? "")) return;
-		if (node !== player && isTarget(node)) targetNodes.push([node.getPath(), node]);
+		if (node !== player && isTarget(node)) targetNodes.push([
+			node.getPath(),
+			node,
+			reachRadiusOf(node)
+		]);
 		for (const child of node.children) collect(child);
 	};
 	collect(scene.root);
@@ -1834,10 +1975,10 @@ async function runOnce(json, seed, opts, avoid = /* @__PURE__ */ new Set()) {
 		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 (player) for (const [path, node, extent] 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);
+			if (Math.hypot(at[0] - p[0], at[1] - p[1], at[2] - p[2]) <= radius + extent) reached.add(path);
 		}
 		const verdict = oracle.outcome();
 		if (verdict) {
@@ -1904,6 +2045,7 @@ async function runOnce(json, seed, opts, avoid = /* @__PURE__ */ new Set()) {
 		declaresEnd: oracle.declaresEnd(),
 		hazards,
 		hasPlayer: player !== null,
+		playerHasHealth: oracle.playerHasHealth(),
 		froze: driver.paused(),
 		restartedBy,
 		unread: unreadNow
@@ -1935,6 +2077,7 @@ async function playtest(json, opts = {}) {
 	let signals = [];
 	let declaresWin = false;
 	let hasPlayer = false;
+	let playerHasHealth = false;
 	let hazards = 0;
 	const froze = /* @__PURE__ */ new Set();
 	const restarted = /* @__PURE__ */ new Set();
@@ -1951,6 +2094,7 @@ async function playtest(json, opts = {}) {
 		signals = one.signals;
 		declaresWin = declaresWin || one.declaresEnd;
 		hasPlayer = hasPlayer || one.hasPlayer;
+		playerHasHealth = playerHasHealth || one.playerHasHealth;
 		hazards = one.hazards;
 		for (const action of one.froze) froze.add(action);
 		if (one.restartedBy) restarted.add(one.restartedBy);
@@ -2000,6 +2144,7 @@ async function playtest(json, opts = {}) {
 		warnings: [...new Set(runs.flatMap((r) => r.warnings))],
 		declaresWin,
 		hasPlayer,
+		playerHasHealth,
 		hazards,
 		froze: [...froze],
 		restarted: [...restarted],
@@ -2183,7 +2328,8 @@ function playtestText(report) {
 	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 if (hazards === 0 && report.playerHasHealth) lines.push("  danger: no DamageOnContact is wired and no run took a hit — but the player HAS a Health, so either nothing reached it, or the damage comes from a behavior of your own calling `Health.damage()`, which this cannot see. A scripted run is the check.");
+	else if (hazards === 0) lines.push("  danger: nothing in this scene can hurt the player — no DamageOnContact, and no player-side Health to lose. 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");
 }
@@ -2232,11 +2378,73 @@ function failingReplays(report) {
 	}));
 }
 //#endregion
+//#region src/test/start-the-game.ts
+/** Enough for a title screen's worth of buttons, not enough to be a bot. */
+const MAX_PRESSES = 8;
+const START = /play|start|run|begin|resume|continue|new|go\b/i;
+/** What a probe is allowed to sit through before deciding the game is stuck. */
+const MAX_WAIT_FRAMES = 900;
+/**
+* @returns what state the world reached — see `StartResult`.
+*/
+function startTheGame(ctx) {
+	const started = ctx.engine.timeScale !== 0 ? true : pressStart(ctx);
+	return {
+		running: started,
+		controllable: started && waitForControl(ctx)
+	};
+}
+/**
+* Sit out an opening cutscene.
+*
+* A cutscene takes control by switching the controller off, not by stopping the
+* clock, so nothing above can see it. The wait is BOUNDED and it only ever
+* happens to a game that actually switched the controller off — a game that is
+* playable from frame one pays four frames, which every probe in `feel.ts`
+* already spends settling.
+*/
+function waitForControl(ctx) {
+	ctx.step(4);
+	const controller = findController(ctx.root);
+	if (!controller) return true;
+	for (let waited = 0; waited < MAX_WAIT_FRAMES && controller.enabled === false; waited += 30) ctx.step(30);
+	return controller.enabled !== false;
+}
+function findController(root) {
+	const type = root.constructor.typeName ?? "";
+	if (type === "CharacterController2D" || type === "CharacterController3D") return root;
+	for (const child of root.children) {
+		const found = findController(child);
+		if (found) return found;
+	}
+	return null;
+}
+function pressStart(ctx) {
+	const pressable = [];
+	const walk = (node) => {
+		const layer = node;
+		if (typeof layer.focusables === "function") for (const widget of layer.focusables()) {
+			const w = widget;
+			if (typeof w.press === "function") pressable.push(w);
+		}
+		for (const child of node.children) walk(child);
+	};
+	walk(ctx.root);
+	const label = (w) => typeof w.text === "string" ? w.text : "";
+	const order = [...pressable.filter((w) => START.test(label(w))), ...pressable.filter((w) => !START.test(label(w)))];
+	for (const widget of order.slice(0, MAX_PRESSES)) {
+		widget.press();
+		ctx.step(4);
+		if (ctx.engine.timeScale !== 0) return true;
+	}
+	return ctx.engine.timeScale !== 0;
+}
+//#endregion
 //#region src/test/facing.ts
-const DEG2RAD = Math.PI / 180;
+const DEG2RAD$1 = Math.PI / 180;
 /** The forward vector of a yaw (degrees) for a given art convention. */
 function forwardOf(yawDeg, axis) {
-	const yaw = yawDeg * DEG2RAD;
+	const yaw = yawDeg * DEG2RAD$1;
 	const base = [Math.sin(yaw), Math.cos(yaw)];
 	switch (axis) {
 		case "-z": return [-base[0], -base[1]];
@@ -2306,6 +2514,11 @@ async function facingReport(json, opts = {}) {
 		const p = player.position;
 		return [p[0] ?? 0, (is2d ? p[1] : p[2]) ?? 0];
 	};
+	const { running } = startTheGame({
+		engine: session.engine,
+		root: session.scene.root,
+		step: (frames) => session.step(frames * 1e3 / 60)
+	});
 	session.step(500);
 	const from = posOf();
 	if (move) session.engine.input.setActionVector(move, 1, 0);
@@ -2317,7 +2530,9 @@ async function facingReport(json, opts = {}) {
 	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)) {
+	const stillness = is2d ? 2 : .05;
+	const lockedOn = player.children.some((c) => c.lockTarget instanceof Object);
+	if (skin && lockedOn) {
 		session.dispose();
 		return {
 			player: player.getPath(),
@@ -2326,7 +2541,19 @@ async function facingReport(json, opts = {}) {
 			backwards: false,
 			travelled: Math.round(travelled * 1e3) / 1e3,
 			basis: null,
-			noAnswer: skin ? "did-not-move" : "no-skin"
+			noAnswer: "locked-on"
+		};
+	}
+	if (!skin || travelled < stillness) {
+		session.dispose();
+		return {
+			player: player.getPath(),
+			skin: skinPath,
+			dot: null,
+			backwards: false,
+			travelled: Math.round(travelled * 1e3) / 1e3,
+			basis: null,
+			noAnswer: running ? skin ? "did-not-move" : "no-skin" : "paused"
 		};
 	}
 	const heading = is2d ? forward2D(skin, dx, dz, declaredOffset) : {
@@ -2381,7 +2608,7 @@ function forward2D(skin, dx, dy, declaredOffset) {
 		};
 	}
 	if (typeof s.rotation === "number") {
-		const yaw = (s.rotation - declaredOffset) * DEG2RAD;
+		const yaw = (s.rotation - declaredOffset) * DEG2RAD$1;
 		return {
 			forward: [Math.cos(yaw), Math.sin(yaw)],
 			basis: "yaw"
@@ -2396,7 +2623,9 @@ function forward2D(skin, dx, dy, declaredOffset) {
 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 === "locked-on") return `facing: ${report.skin} is LOCKED ON (the controller's \`lockTarget\`), so it faces its target rather than its travel — a strafe is the intended reading, not a defect.`;
 	if (report.noAnswer === "no-heading") return `facing: ${report.skin} declares no heading (no flipX, no rotation) — nothing to compare its travel with`;
+	if (report.noAnswer === "paused") return "facing: this game was PAUSED for the whole probe (`engine.timeScale` 0) and stayed that way after pressing every button on screen — a title screen holds the world until its START is pressed, so nothing moved and nothing was compared.";
 	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)})`;
@@ -2410,6 +2639,56 @@ const REL_TOL = .005;
 function closeEnough(a, b, absTol, relTol) {
 	return Math.abs(a - b) <= Math.max(absTol, relTol * Math.abs(a));
 }
+const RAD2DEG = 180 / Math.PI;
+/**
+* The slack a moving owner earns on one key: speed × window for a position,
+* spin × window (in degrees) for a rotation, nothing for anything else. Keyed
+* by the LAST path segment, so `Wheel0.rotation` is a rotation too.
+*/
+function motionSlack(key, motion) {
+	if (!motion) return 0;
+	const prop = key.slice(key.lastIndexOf(".") + 1);
+	if (prop === "position") return motion.speed * motion.windowSeconds;
+	if (prop === "rotation") return motion.spin * motion.windowSeconds * RAD2DEG;
+	return 0;
+}
+/** Degrees two copies of one orientation may differ by at rest (a float's worth). */
+const ROTATION_TOL_DEG = .01;
+const DEG2RAD = Math.PI / 180;
+const isRotationKey = (key) => key.slice(key.lastIndexOf(".") + 1) === "rotation";
+/** Euler XYZ degrees → unit quaternion [x, y, z, w] (three.js order). */
+function quatOf(e) {
+	const c1 = Math.cos((e[0] ?? 0) * DEG2RAD / 2);
+	const c2 = Math.cos((e[1] ?? 0) * DEG2RAD / 2);
+	const c3 = Math.cos((e[2] ?? 0) * DEG2RAD / 2);
+	const s1 = Math.sin((e[0] ?? 0) * DEG2RAD / 2);
+	const s2 = Math.sin((e[1] ?? 0) * DEG2RAD / 2);
+	const s3 = Math.sin((e[2] ?? 0) * DEG2RAD / 2);
+	return [
+		s1 * c2 * c3 + c1 * s2 * s3,
+		c1 * s2 * c3 - s1 * c2 * s3,
+		c1 * c2 * s3 + s1 * s2 * c3,
+		c1 * c2 * c3 - s1 * s2 * s3
+	];
+}
+/**
+* The angle, in degrees, between two rotations written as the engine writes
+* them: one number (2D, degrees) or an Euler XYZ triple (3D, degrees). Any
+* other shape falls back to the plain component gap.
+*/
+function orientationGapDeg(a, b) {
+	if (a.length === 1 && b.length === 1) {
+		const d = Math.abs(((a[0] ?? 0) - (b[0] ?? 0)) % 360);
+		return Math.min(d, 360 - d);
+	}
+	if (a.length === 3 && b.length === 3) {
+		const p = quatOf(a);
+		const q = quatOf(b);
+		const dot = Math.min(1, Math.abs(p[0] * q[0] + p[1] * q[1] + p[2] * q[2] + p[3] * q[3]));
+		return 2 * Math.acos(dot) / DEG2RAD;
+	}
+	return Math.max(...a.map((v, i) => Math.abs(v - (b[i] ?? 0))));
+}
 function numbers(v) {
 	if (typeof v === "number") return [v];
 	if (Array.isArray(v) && v.every((x) => typeof x === "number")) return v;
@@ -2474,7 +2753,8 @@ function agreementProblems(live, late = [], opts = {}) {
 							});
 							continue;
 						}
-						if (a.every((v, i) => closeEnough(v, b[i], absTol, relTol))) continue;
+						const slack = motionSlack(key, s.motion);
+						if (isRotationKey(key) ? orientationGapDeg(a, b) <= ROTATION_TOL_DEG + slack : a.every((v, i) => closeEnough(v, b[i], absTol + slack, relTol))) continue;
 						found.push({
 							kind: "mismatch",
 							account: s.account,
@@ -2632,6 +2912,21 @@ function instancesByName(engine) {
 * @param clients every client in the match
 * @param observers the clients whose beliefs to record (defaults to `clients`)
 */
+/** The server's queue turns every six frames in the harness — that is latency too. */
+const HARNESS_TURN_SECONDS = .1;
+const DEFAULT_THROTTLE_MS = 50;
+const magnitude = (v) => Array.isArray(v) && v.every((n) => typeof n === "number") ? Math.hypot(...v) : 0;
+/** How fast the owner is moving right now, and how stale its copies may be. */
+function motionOf(node) {
+	const n = node;
+	const net = node.network ?? {};
+	const throttleMs = typeof net.throttleMs === "number" ? Math.max(30, net.throttleMs) : DEFAULT_THROTTLE_MS;
+	return {
+		speed: magnitude(n.linearVelocity),
+		spin: magnitude(n.angularVelocity),
+		windowSeconds: throttleMs / 1e3 + HARNESS_TURN_SECONDS
+	};
+}
 function takeAgreementSnapshots(clients, observers = clients) {
 	const snapshots = [];
 	for (const owner of clients) {
@@ -2668,7 +2963,8 @@ function takeAgreementSnapshots(clients, observers = clients) {
 			account: owner.account,
 			truth,
 			seen,
-			...unreadable.length > 0 ? { unreadable } : {}
+			...unreadable.length > 0 ? { unreadable } : {},
+			motion: motionOf(node)
 		});
 	}
 	return snapshots;
@@ -2754,7 +3050,7 @@ async function makeProbe(json, opts) {
 	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);
+		const want = controllerProp(session.scene.root, prop, player);
 		return want && declared.some((a) => a.name === want && a.type === type) ? want : null;
 	};
 	const move = opts.moveAction ?? named("moveAction", "vector2") ?? moveOptions[0] ?? null;
@@ -2767,34 +3063,44 @@ async function makeProbe(json, opts) {
 			move,
 			jump,
 			sprint,
-			moveOptions
+			moveOptions,
+			paused: false,
+			controllerOff: false
 		};
 	}
 	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]);
-			},
-			onFloor: () => {
-				const body = player;
-				return typeof body.isOnFloor === "function" ? body.isOnFloor() : null;
-			}
+	const 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]);
 		},
+		onFloor: () => {
+			const body = player;
+			return typeof body.isOnFloor === "function" ? body.isOnFloor() : null;
+		}
+	};
+	const state = startTheGame({
+		engine: session.engine,
+		root: session.scene.root,
+		step: (frames) => probe.step(frames)
+	});
+	return {
+		probe,
 		move,
 		jump,
 		sprint,
-		moveOptions
+		moveOptions,
+		paused: !state.running,
+		controllerOff: state.running && !state.controllable
 	};
 }
 /** Let the character settle onto whatever it is standing on. */
@@ -3044,20 +3350,20 @@ async function measureCoyote(json, opts, jump, jumps = 1) {
 	return Math.round((lo + 1) * STEP_MS);
 }
 /**
-* `coyoteSeconds` as written in the scene, in ms — for CONTRAST, never instead.
+* A controller's declared window as written in the scene, in ms — for CONTRAST.
 *
 * 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) {
+function declaredControllerMs(json, prop) {
 	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;
+			const value = n.props?.[prop];
 			if (typeof value === "number" && found === null) found = Math.round(value * 1e3);
 		}
 		for (const child of n.children ?? []) walk(child);
@@ -3170,7 +3476,11 @@ async function feelReport(json, opts = {}) {
 		airtimeMs: null,
 		coyoteMs: null,
 		jumpsInMidair: false,
+		neverJumped: false,
+		controllerOff: false,
 		declaredCoyoteMs: null,
+		declaredJumpBufferMs: null,
+		timeStood: false,
 		declaredMaxJumps: 1,
 		doubleJump: null,
 		jumpBufferMs: null,
@@ -3336,8 +3646,12 @@ async function feelReport(json, opts = {}) {
 		airtimeMs: shape.airtimeMs,
 		coyoteMs: coyote,
 		jumpsInMidair: coyote === null && jump !== null,
-		declaredCoyoteMs: declaredCoyote(json),
+		declaredCoyoteMs: declaredControllerMs(json, "coyoteSeconds"),
+		declaredJumpBufferMs: declaredControllerMs(json, "jumpBufferSeconds"),
 		jumpBufferMs: buffer,
+		timeStood: first.paused && topSpeed <= .05 && shape.apex === null,
+		controllerOff: first.controllerOff && topSpeed <= .05,
+		neverJumped: jump !== null && shape.apex === null && held.apex === null && walking.apex === null && sprinting.apex === null,
 		inputToMotionFrames: latency,
 		declaredMaxJumps: jumps,
 		doubleJump,
@@ -3362,7 +3676,14 @@ function feelText(report) {
 		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.`);
+		if (report.controllerOff) {
+			lines.push("  the player's CONTROLLER was switched off for the whole measurement, and stayed off through fifteen seconds of waiting. A cutscene does this — the clock runs, the world");
+			lines.push("  moves, and only the character is held. Nothing below was measured. Measure the scene the player PLAYS, or end the cutscene sooner than fifteen seconds.");
+		} else if (report.timeStood) {
+			lines.push("  the clock never ran: this game was PAUSED for the whole measurement (`engine.timeScale` 0), and it stayed that way after pressing every button on");
+			lines.push("  screen. A title screen holds the world like this until its START is pressed. NOTHING below was measured — every number is the stopped world, not the game.");
+			lines.push("  Point this at the scene the game PLAYS, or give the start button a label the probe can find (PLAY / START / RESUME).");
+		} else 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`);
@@ -3384,8 +3705,16 @@ function feelText(report) {
 		if (report.doubleJump) lines.push(`  ${report.declaredMaxJumps === 2 ? "double jump" : `${report.declaredMaxJumps} jumps`}      ${report.doubleJump.apex} u   (${report.declaredMaxJumps} TAPS, maxJumps ${report.declaredMaxJumps}${report.doubleJump.airtimeMs !== null ? `, ${ms(report.doubleJump.airtimeMs)} airtime` : ""})`);
 		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)" : ""}`);
+		const declared = (v) => v === null ? "" : `   (the scene declares ${ms(v)})`;
+		lines.push(`  coyote window    ${report.timeStood ? `not measured — the clock was stopped${declared(report.declaredCoyoteMs)}` : report.neverJumped ? `not measured — nothing ever jumped${declared(report.declaredCoyoteMs)}` : report.jumpsInMidair ? "not measurable — this character jumps in MID-AIR" : report.coyoteMs === null ? "always (no window)" : ms(report.coyoteMs)}`);
+		lines.push(`  jump buffer      ${report.timeStood ? `not measured — the clock was stopped${declared(report.declaredJumpBufferMs)}` : report.neverJumped ? `not measured — nothing ever jumped${declared(report.declaredJumpBufferMs)}` : report.jumpBufferMs === null ? "always (no window)" : ms(report.jumpBufferMs)}${report.jumpsInMidair && !report.timeStood && !report.neverJumped ? "   (suspect — see above)" : ""}`);
+		if (report.neverJumped && !report.timeStood) {
+			lines.push("");
+			lines.push(`  note: this scene declares '${report.jumpAction}' and NOTHING left the ground in any`);
+			lines.push("        of the four jump probes — standing, held, walking, sprinting. Check that the");
+			lines.push(`        controller reads '${report.jumpAction}', that its \`jumpVelocity\` is not 0, and that it is \`enabled\`.`);
+			lines.push("        Both windows above are searched by jumping, so neither was measured.");
+		}
 		if (report.jumpsInMidair) {
 			lines.push("");
 			lines.push("  note: a jump still fires a full second after leaving the ground, so");
@@ -3394,12 +3723,12 @@ function feelText(report) {
 			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) {
+		if (report.coyoteMs === 0 && !report.timeStood && !report.neverJumped) {
 			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) {
+		if (report.jumpBufferMs === 0 && !report.timeStood && !report.neverJumped) {
 			lines.push("  note: jump buffer is 0 — a press a few frames before landing is thrown away.");
 			lines.push("        Try jumpBufferSeconds: 0.15.");
 		}
@@ -3413,19 +3742,35 @@ function feelText(report) {
 	}
 	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 ?? "";
+/**
+* The action name the CHOSEN player's controller says it reads.
+*
+* This took the first controller a stack-walk found anywhere in the tree, which
+* in a two-player scene is the LAST one in the file. Measured on
+* `examples/coop-3d`, a local co-op forge: the report chose `Smith1` and then
+* drove it with `jump2`, Smith2's button, so a character that jumps 0.563 m
+* reported `jump apex — (nothing left the ground)` and a coyote window of 0 at
+* a controller declaring `coyoteSeconds: 0.12`. Move survived only because the
+* move probe has a fallback SEARCH; jump has none.
+*
+* Two rules, and `coop-3d` needed both to be wrong at once: ask the player that
+* was chosen FIRST, and walk in document order so "the first controller" means
+* the first one in the file.
+*/
+function controllerProp(root, prop, player = null) {
+	const find = (from) => {
+		const type = from.constructor.typeName ?? "";
 		if (type === "CharacterController2D" || type === "CharacterController3D") {
-			const value = node[prop];
+			const value = from[prop];
 			return typeof value === "string" && value !== "" ? value : null;
 		}
-		for (const child of node.children) stack.push(child);
-	}
-	return null;
+		for (const child of from.children) {
+			const found = find(child);
+			if (found !== null) return found;
+		}
+		return null;
+	};
+	return (player ? find(player) : null) ?? find(root);
 }
 //#endregion
 //#region src/test/multiplay.ts
@@ -3457,6 +3802,7 @@ async function playMultiplayer(opts) {
 		if (frame % 6 === 0) await settle();
 	}
 	await settle();
+	for (const player of players) player.engine.input.clearInjected();
 	for (let frame = 0; frame < 60; frame++) {
 		now += stepMs;
 		for (const player of players) player.engine.tick(now);
@@ -3464,6 +3810,7 @@ async function playMultiplayer(opts) {
 	}
 	await settle();
 	const live = takeAgreementSnapshots(players);
+	const moving = live.filter((s) => (s.motion?.speed ?? 0) > .05 || (s.motion?.spin ?? 0) > .05).map((s) => s.account);
 	const matchDetail = players.map((p) => ({
 		account: p.account,
 		room: p.manager.roomId,
@@ -3496,7 +3843,8 @@ async function playMultiplayer(opts) {
 		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 } : {}
+		...lateJoinRefused ? { lateJoinRefused } : {},
+		moving
 	});
 	dispose();
 	return report;
@@ -3510,11 +3858,14 @@ async function playMultiplayer(opts) {
 */
 async function joinLate(server, first, opts) {
 	try {
-		const { Engine } = await import("./register-CjociOtt.js").then((n) => n.y);
-		const { loadScene } = await import("./save-slots-CEUGeLuB.js").then((n) => n.g);
+		const { Engine } = await import("./register-B768Qedj.js").then((n) => n.x);
+		const { loadScene } = await import("./pose-ByFB_J3O.js").then((n) => n.x);
 		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));
+		engine.setScene(loadScene(jsonClone(opts.scene), {
+			...opts.load,
+			engine
+		}));
 		const manager = await NetworkManager.create(engine, {
 			transport: server.createClient("late"),
 			room: first.manager.roomId
@@ -3551,6 +3902,7 @@ function summarize(players, seconds, frames, matchDetail, agreement) {
 		disagreements: agreement.disagreements,
 		keysCompared: agreement.keysCompared,
 		lateJoinChecked: agreement.lateJoinChecked,
+		moving: agreement.moving,
 		seconds,
 		frames,
 		rooms,
@@ -3606,6 +3958,7 @@ function multiplayText(report) {
 		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)` : ""));
 	}
+	if (report.moving.length > 0) lines.push(`  · ${report.moving.join(", ")} still moving when compared — a copy may trail by one send window, and that is not a disagreement`);
 	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");
@@ -4070,6 +4423,11 @@ function validateScene(json, opts = {}) {
 		throw e;
 	}
 }
+/** Does anything in this tree want a mouse? */
+function hasClickable(node) {
+	if (node.behavior?.constructor.name === "Clickable") return true;
+	return node.children.some(hasClickable);
+}
 /**
 * What an assert's return value MEANS: a failure message, or null for a pass.
 *
@@ -4109,10 +4467,10 @@ async function runScript(json, opts) {
 	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-C-SfvjzH.js").then((n) => n.r);
+		const { enablePhysics2D } = await import("./physics-2d-Tuf5LAyq.js").then((n) => n.r);
 		await enablePhysics2D(engine);
 	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-rOzeg890.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-C5MOujfQ.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const failures = [];
@@ -4134,6 +4492,25 @@ async function runScript(json, opts) {
 		for (let at = hit; at; at = at.parent) if (at === wanted) return true;
 		return false;
 	};
+	/**
+	* Did this click reach the same HANDLER the author asked for?
+	*
+	* Two meshes of one object overlap on screen, and which one the ray meets
+	* first is not something an author chose: `click: '…/Ballista/Frame'` was
+	* reported as a miss because the picker found `…/Ballista/Bolt`, while the
+	* click had gone through the real `Clickable` on their shared parent and
+	* fired it. A click is wrong when it lands on a different THING, not on a
+	* different triangle of the same one.
+	*/
+	const clickOwner = (node) => {
+		for (let at = node; at; at = at.parent) if (at.behavior?.constructor.name === "Clickable") return at;
+		return null;
+	};
+	const sameClick = (wanted, hit) => {
+		if (isSelfOrAncestor(wanted, hit)) return true;
+		const owner = clickOwner(wanted);
+		return owner !== null && owner === clickOwner(hit);
+	};
 	/** 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. */
@@ -4144,6 +4521,13 @@ async function runScript(json, opts) {
 	* it — a behaviour reading `engine.pointerWorld()` must get an answer for the
 	* same cursor the click is at.
 	*/
+	{
+		const view = geometricView(live);
+		engine.toWorld ??= view.toWorld;
+		engine.toScreen ??= view.toScreen;
+		engine.screenRay ??= view.screenRay;
+	}
+	if (hasClickable(live().root)) engine.input.setPointerPosition(0, 0);
 	const armPointer = () => {
 		engine.picker ??= geometricPicker(live);
 		if (!engine.toWorld) {
@@ -4224,7 +4608,7 @@ async function runScript(json, opts) {
 				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({
+				if (wanted && (!under || !sameClick(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.`
@@ -4273,6 +4657,15 @@ async function runScript(json, opts) {
 			releaseAt = -1;
 		}
 		engine.step();
+		if (opts.onFrame) try {
+			opts.onFrame(ctx);
+		} catch (error) {
+			failures.push({
+				atMs: Math.round(t),
+				label: "onFrame",
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}
 		if (t >= nextSnapshot - 1e-6) {
 			snapshots.push({
 				atMs: Math.round(t),
@@ -4302,6 +4695,18 @@ async function runScript(json, opts) {
 		label: "engine",
 		message: `${swallowed} error(s) were swallowed to keep the loop alive — the logs above name the node, the behavior and the phase`
 	});
+	const said = /* @__PURE__ */ new Set();
+	for (const entry of logs) {
+		if (entry.level !== "error") continue;
+		const line = entry.parts.map((part) => part instanceof Error ? `${part.name}: ${part.message}` : String(part)).join(" ").replace(/\s+/g, " ").trim();
+		if (line === "" || said.has(line)) continue;
+		said.add(line);
+		failures.push({
+			atMs: opts.durationMs,
+			label: "engine said",
+			message: line
+		});
+	}
 	engine.dispose();
 	const ok = failures.length === 0;
 	return {
@@ -4350,10 +4755,10 @@ async function createPlaySession(json, opts = {}) {
 	engine.setScene(scene);
 	const physics = opts.physics ?? "auto";
 	if (physics === "2d" || physics === "auto" && scene.dimension === "2d") {
-		const { enablePhysics2D } = await import("./physics-2d-C-SfvjzH.js").then((n) => n.r);
+		const { enablePhysics2D } = await import("./physics-2d-Tuf5LAyq.js").then((n) => n.r);
 		await enablePhysics2D(engine);
 	} else if (physics === "3d" || physics === "auto" && scene.dimension === "3d") {
-		const { enablePhysics3D } = await import("./physics-3d-rOzeg890.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-C5MOujfQ.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const stepMs = 1e3 / (opts.fixedHz ?? 60);