incanto 0.68.0 → 0.69.0

package/dist/{register-ibCjm-wH.js → register-DbVArsns.js}

@@ -1,11 +1,11 @@
-import { O as Node, k as diagnose, w as effectiveOrder } from "./loader-BC4PNtJX.js";
-import { L as translateOn, t as registerCoreNodes } from "./register-3ta-2Xig.js";
+import { O as Node, k as diagnose, w as effectiveOrder } from "./loader-DZE7B07H.js";
+import { L as translateOn, t as registerCoreNodes } from "./register-mmfugpaQ.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-CF70EArN.js";
 import { i as ParticleSim, n as resolveFrames, o as PARTICLE_PRESET_NAMES, r as validateAnimationAliases, s as applyParticlePreset, t as resolveAnimation } from "./sprite-animation-CY-mrr1L.js";
-import { F as localFromWorld, I as worldPosition } from "./gameplay-DM1eu_cV.js";
-import { t as checkSheetGrid } from "./sheet-grid-BT6N_Bjs.js";
+import { F as localFromWorld, I as worldPosition } from "./gameplay-D1KixWK8.js";
+import { t as checkSheetGrid } from "./sheet-grid-Cea343VO.js";
 import { AdditiveBlending, BufferAttribute, BufferGeometry, CanvasTexture, Color, DynamicDrawUsage, Group, InstancedMesh, MathUtils, Matrix4, Mesh, MeshBasicMaterial, NearestFilter, NormalBlending, Object3D, PlaneGeometry, SRGBColorSpace } from "three";
 //#region src/2d/physics/collider-validate.ts
 /**
@@ -1443,9 +1443,11 @@ var TileMap2D = class extends Node2D {
 	_solid = [];
 	/** Rebuild flags — raised when the map-shaping props are REPLACED. */
 	geometryDirty = true;
-	/** Reported once per atlas, so a bad grid says so on the first build only. */
+	/** `texture|highestTile` already reported, so a bad grid says so once. */
 	gridChecked = "";
 	collidersDirty = true;
+	/** The `scale` the colliders were last built for — see `rebuildColliders`. */
+	builtScale = [1, 1];
 	/** Replace the whole array to change the map (mutations are not watched). */
 	get cells() {
 		return this._cells;
@@ -1487,19 +1489,23 @@ var TileMap2D = class extends Node2D {
 		this.rebuildColliders();
 	}
 	update(_dt) {
+		const [sx = 1, sy = 1] = this.scale;
+		if (sx !== this.builtScale[0] || sy !== this.builtScale[1]) this.collidersDirty = true;
 		if (this.collidersDirty) this.rebuildColliders();
 	}
 	rebuildColliders() {
 		this.collidersDirty = false;
 		for (const child of [...this.children]) if (child.name.startsWith("__tileSolid")) child.free();
+		this.builtScale = [this.scale[0] ?? 1, this.scale[1] ?? 1];
 		if (this._solid.length === 0) return;
 		const ts = this.tileSize;
+		const [sx, sy] = this.builtScale;
 		mergeSolidRects(this.grid(), new Set(this._solid)).forEach((r, i) => {
 			const body = new StaticBody2D(`__tileSolid${i}`);
-			body.position = [(r.x + r.w / 2) * ts, (r.y + r.h / 2) * ts];
+			body.position = [(r.x + r.w / 2) * ts * sx, (r.y + r.h / 2) * ts * sy];
 			body.collider = {
 				shape: "rect",
-				size: [r.w * ts, r.h * ts]
+				size: [r.w * ts * sx, r.h * ts * sy]
 			};
 			this.addChild(body);
 		});
@@ -1543,9 +1549,12 @@ var TileMap2D = class extends Node2D {
 			mat.needsUpdate = true;
 			this.geometryDirty = true;
 		}
-		if (this.gridChecked !== this.texture) {
-			this.gridChecked = this.texture;
-			const problem = checkSheetGrid(this.texture, this.tileSize, this.tileSize, image.width, image.height);
+		let highestAsked = -1;
+		for (const row of this.grid()) for (const tile of row) if (tile > highestAsked) highestAsked = tile;
+		const checkKey = `${this.texture}|${highestAsked}`;
+		if (this.gridChecked !== checkKey) {
+			this.gridChecked = checkKey;
+			const problem = checkSheetGrid(this.texture, this.tileSize, this.tileSize, image.width, image.height, highestAsked >= 0 ? highestAsked : void 0, "tile");
 			if (problem) diagnose(this.tree?.engine ?? null, "error", problem);
 		}
 		const columns = this.columns > 0 ? this.columns : Math.max(1, Math.floor(image.width / this.tileSize));

package/dist/{register-3ta-2Xig.js → register-mmfugpaQ.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { C as ORDER_GROUP_BASE, E as InputMap, O as Node, S as createSaveStore, T as resolveOrderGroups, V as Signal, b as restoreBehaviors, k as diagnose, y as captureBehaviors } from "./loader-BC4PNtJX.js";
+import { C as ORDER_GROUP_BASE, E as InputMap, O as Node, S as createSaveStore, T as resolveOrderGroups, V as Signal, b as restoreBehaviors, k as diagnose, y as captureBehaviors } from "./loader-DZE7B07H.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { l as registerNode } from "./registry-CF70EArN.js";
@@ -2031,6 +2031,25 @@ var FrameStatsRing = class {
 		const span = this.spanMs();
 		return span > 0 ? span / (this.count - 1) : 0;
 	}
+	/**
+	* How long ago the newest sample arrived, in ms. `null` with no samples.
+	*
+	* `fps()` is a rate over a WINDOW, so it keeps answering after the frames
+	* stop: a hidden tab, a descheduled loop, a page the browser froze. Measured
+	* on an engine that ticked 40 times and then stopped being ticked:
+	*
+	*   while ticking      : fps 59.9
+	*   after 0 more ticks : fps 59.9      <- the last sample is 668 ms old
+	*
+	* Both numbers are true about the window they describe. What was missing was
+	* any way to ask WHEN that window was, so "60 fps" read the same whether it
+	* was measured 8 ms ago or four seconds ago.
+	*/
+	ageMs(nowMs) {
+		if (this.count === 0) return null;
+		const newest = this.times[(this.head + this.count - 1) % this.capacity];
+		return Math.max(0, nowMs - newest);
+	}
 	/** Forget all samples (engine.stop() — a paused game has no frame rate). */
 	clear() {
 		this.head = 0;
@@ -2433,6 +2452,49 @@ var Engine = class {
 	* learns about Rapier or three. From a behavior, prefer `this.physics`.
 	*/
 	physics = null;
+	/**
+	* How to build a physics world for a scene that needs one.
+	*
+	* `createGame2D`/`createGame3D` install this; core never learns what Rapier
+	* is. It exists because `physics: 'auto'` can only look at the scene the game
+	* BOOTED with, and the most universal act of finishing a game is putting a
+	* title screen in front of it:
+	*
+	* ```
+	* after boot on the title  : engine.physics = null
+	* after goToScene into game: engine.physics = null
+	* player y after 2 s       : 0 -> 0
+	* ```
+	*
+	* The game rendered perfectly and was inert — nothing fell, nothing collided,
+	* nothing could be collected or hurt. One scene swap turned a working game
+	* into a diorama, and nothing was logged.
+	*/
+	physicsProvider = null;
+	ensuring = null;
+	/**
+	* Give the current scene a physics world if it needs one and has none.
+	*
+	* Idempotent and safe to call on every swap: the provider decides whether the
+	* incoming tree actually wants physics, and an explicit `physics: false` at
+	* boot installs no provider at all, so opting out stays opted out.
+	*
+	* Asynchronous because the Rapier WASM has to load. The first frames after a
+	* swap therefore run unsimulated — which every AI behaviour already tolerates
+	* (`moveBody` falls back to a direct write when `_physics` is null) and which
+	* is a hitch, where the alternative was a game that never simulated at all.
+	*/
+	ensurePhysics() {
+		if (this.physics || !this.physicsProvider || !this._scene) return Promise.resolve();
+		if (this.ensuring) return this.ensuring;
+		const root = this._scene.root;
+		this.ensuring = this.physicsProvider(root).catch((e) => {
+			this.log.error(`[incanto] could not enable physics for this scene: ${String(e?.message ?? e)}`);
+		}).finally(() => {
+			this.ensuring = null;
+		});
+		return this.ensuring;
+	}
 	/** Seeded randomness for game logic (deterministic when `seed` is set). */
 	rng;
 	/** The engine log channel (debug overlay + headless harness tail this). */
@@ -2756,6 +2818,7 @@ var Engine = class {
 		return {
 			fps: this.frameStats.fps(),
 			frameMs: this.frameStats.frameMs(),
+			lastFrameAgeMs: this.frameStats.ageMs(performance.now()),
 			nodes: this._scene?.tree.root ? countNodes(this._scene.tree.root) : 0,
 			running: this.disposeScheduler !== null,
 			errors: this.errorCount,
@@ -2808,6 +2871,7 @@ var Engine = class {
 		this._time += dt;
 		this._unscaledTime += this.fixedStep;
 		const startedFixed = performance.now();
+		this.input.beginFrame();
 		scene.tree.fixedUpdate(dt);
 		this.fixedUpdated.emit(dt);
 		const startedUpdate = performance.now();
@@ -2835,6 +2899,7 @@ var Engine = class {
 		this.lastMs = nowMs;
 		const scene = this._scene;
 		if (!scene) return;
+		this.input.beginFrame();
 		this.accumulator += dt;
 		let steps = 0;
 		const startedFixed = performance.now();
@@ -3007,7 +3072,8 @@ var AudioPlayer = class extends Node {
 			name,
 			from: this.getPath(),
 			bus: this.bus === "music" ? "music" : "sfx",
-			at: engine.time
+			at: engine.time,
+			...this.loop ? { loop: true } : {}
 		});
 	}
 	/** Final gain = engine buses × this volume (1 when not in a tree). */
@@ -3040,31 +3106,57 @@ var AudioPlayer = class extends Node {
 		};
 	}
 	/**
-	* Start the sound. `at` schedules it on the AUDIO clock instead of now.
+	* Start the sound, now.
+	*
+	* **Takes no arguments, on purpose.** This is the method scenes wire signals
+	* to — `incanto-audio.md` teaches
+	* `{"signal": "collected", "from": "Player/Collector", "to": "Coin",
+	* "handler": "play"}` — and a signal hands its handler whatever it carries.
+	* `collected` leads with a NUMBER. When this briefly took an optional
+	* scheduling time, that wiring became `play(10)`, which scheduled the pickup
+	* sound at ABSOLUTE audio-clock second 10: inaudible for the first ten
+	* seconds of the game and fine thereafter. The same optional parameter also
+	* made `Function.length` 1, so the engine's own arity checker cried wolf on
+	* the shipped `platformer-2d` template's own harness.
+	*
+	* Scheduling has its own name: {@link playAt}.
+	*/
+	/**
+	* Start the sound at `when` on the AUDIO clock (`engine.sfx.now` + a lead).
 	*
 	* A frame is a 16.67 ms grid at 60 Hz and 33.33 ms at 30, so a sound fired
 	* from `update()` cannot land closer than one frame to where a chart wants
-	* it — measured 0 of 64 notes scheduled on the documented path. Queue it a
-	* lead ahead of `engine.sfx.now` and the same notes land at |mean| 0.000000
-	* ms:
+	* it — measured 0 of 64 notes given a scheduled start. Queue them a lead
+	* ahead and the same notes land at |mean| 0.000000 ms:
 	*
 	* ```ts
-	* const lead = 0.08;                        // schedule this far ahead
-	* for (const note of dueSoon(engine.sfx.now + lead)) {
-	*   hit.play(engine.sfx.now + (note.atSec - songSeconds));
+	* const LEAD = 0.08;
+	* for (const note of dueSoon(engine.sfx.now + LEAD)) {
+	*   hit.playAt(startedAt + note.atSec);
 	* }
 	* ```
 	*
 	* PRESETS only — a `src` clip goes through an `<audio>` element, which has no
-	* scheduling clock, and passing `at` for one is ignored rather than silently
-	* approximated. Everything else is unchanged: the bus gain applies, the sound
-	* lands in `engine.audio.recent()`, and `muted` still silences it, none of
-	* which a hand-rolled `AudioContext` scheduler keeps.
+	* scheduling clock, so `playAt` on one plays immediately rather than being
+	* silently approximated. A time already past plays now (Web Audio's own
+	* rule), so a late scheduler is late, not silent. The bus gain, the
+	* `engine.audio.recent()` entry and `muted` all still apply.
+	*
+	* Separate from {@link play} because `play` is what scenes wire signals to,
+	* and a signal hands its handler whatever it carries.
 	*/
-	play(at) {
+	playAt(when) {
+		if (this.preset !== "custom") {
+			this.note("preset", this.preset);
+			this.playPreset(Number.isFinite(when) ? when : void 0);
+			return;
+		}
+		this.play();
+	}
+	play() {
 		if (this.preset !== "custom") {
 			this.note("preset", this.preset);
-			this.playPreset(at);
+			this.playPreset();
 			return;
 		}
 		if (!this.src) return;

package/dist/{replay-CYvhVHHN.js → replay-BEHLDcQV.js}

@@ -1,5 +1,5 @@
-import { D as handlerShadowWarnings, j as nodeRefWarnings } from "./loader-BC4PNtJX.js";
-import { R as translationKey, k as HudWidgetBase } from "./register-3ta-2Xig.js";
+import { D as handlerShadowWarnings, j as nodeRefWarnings } from "./loader-DZE7B07H.js";
+import { R as translationKey, k as HudWidgetBase } from "./register-mmfugpaQ.js";
 import { o as getNodeType } from "./registry-CF70EArN.js";
 //#region src/core/audit.ts
 const ANIMATED_TYPES = new Set([

package/dist/{replay-Dvn8aeBd.d.ts → replay-BQfkX4x7.d.ts}

@@ -1,4 +1,4 @@
-import { b as Engine } from "./behavior-DoFPYrgo.js";
+import { b as Engine } from "./behavior-rm8vVzu_.js";
 import { s as JsonObject } from "./schema-B6ugCV1Q.js";
 
 //#region src/core/audit.d.ts

package/dist/{sheet-grid-BT6N_Bjs.js → sheet-grid-Cea343VO.js}

@@ -35,7 +35,7 @@ function divisors(total) {
 * known — an animation range that runs off the end is the other half of the
 * same mistake.
 */
-function checkSheetGrid(key, frameWidth, frameHeight, imageWidth, imageHeight, highestFrame) {
+function checkSheetGrid(key, frameWidth, frameHeight, imageWidth, imageHeight, highestFrame, unit = "frame") {
 	if (!imageWidth || !imageHeight || !frameWidth || !frameHeight) return null;
 	if (imageWidth % frameWidth !== 0 || imageHeight % frameHeight !== 0) {
 		const parts = [];
@@ -51,7 +51,11 @@ function checkSheetGrid(key, frameWidth, frameHeight, imageWidth, imageHeight, h
 	}
 	if (highestFrame !== void 0) {
 		const frames = imageWidth / frameWidth * (imageHeight / frameHeight);
-		if (highestFrame >= frames) return `[incanto] spritesheet '${key}' has ${frames} frames (0–${frames - 1}), and an animation asks for frame ${highestFrame}. Those frames draw whatever is at the wrong end of the sheet.`;
+		if (highestFrame >= frames) {
+			const sheet = unit === "tile" ? "tile atlas" : "spritesheet";
+			const asks = unit === "tile" ? "a cell asks for tile" : "an animation asks for frame";
+			return `[incanto] ${sheet} '${key}' has ${frames} ${unit}s (0–${frames - 1}), and ${asks} ${highestFrame}. Those ${unit}s draw whatever is at the wrong end of the sheet.`;
+		}
 	}
 	return null;
 }

package/dist/{split-screen-CYwDkbLF.js → split-screen-CauMwu6y.js}

@@ -1,5 +1,5 @@
-import { O as Node, V as Signal, k as diagnose, n as loadScene, t as buildNodeJson } from "./loader-BC4PNtJX.js";
-import { t as registerCoreNodes, v as Engine } from "./register-3ta-2Xig.js";
+import { O as Node, V as Signal, k as diagnose, n as loadScene, t as buildNodeJson } from "./loader-DZE7B07H.js";
+import { t as registerCoreNodes, 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 { l as registerNode } from "./registry-CF70EArN.js";

package/dist/{split-screen-DhrSzZIB.d.ts → split-screen-Cg76MCV5.d.ts}

@@ -1,6 +1,6 @@
-import { Lt as Signal, b as Engine, jt as Node } from "./behavior-DoFPYrgo.js";
+import { Lt as Signal, b as Engine, jt as Node } from "./behavior-rm8vVzu_.js";
 import { c as JsonValue, i as SceneJson, s as JsonObject } from "./schema-B6ugCV1Q.js";
-import { t as LoadSceneOptions } from "./loader-CcB533FR.js";
+import { t as LoadSceneOptions } from "./loader-DadV2QCT.js";
 
 //#region src/net/types.d.ts
 type Unsubscribe = () => void;

package/dist/{src-D7RIqXYF.js → src-CYEu-_S9.js}

@@ -214,6 +214,6 @@ function newUid() {
 //#endregion
 //#region src/index.ts
 /** Engine version. Kept in sync with package.json by the release pipeline. */
-const VERSION = "0.68.0";
+const VERSION = "0.69.0";
 //#endregion
 export { preloadUrls as a, preloadSceneAssets as i, newUid as n, findPath as o, assetUrls as r, gridFromRows as s, VERSION as t };

package/dist/{teardown-D2NEmxPB.js → teardown-CMqFVxO9.js}

@@ -1,6 +1,6 @@
-import { _ as AudioPlayer } from "./register-3ta-2Xig.js";
-import { i as logReport, o as parseDrive } from "./webgl-unavailable-N9nQqesw.js";
-import { a as frameSignature, i as frameImage, o as frameStats } from "./frame-report-BSMny7oe.js";
+import { _ as AudioPlayer } from "./register-mmfugpaQ.js";
+import { i as logReport, o as parseDrive } from "./webgl-unavailable-Z5_g8x9H.js";
+import { a as frameSignature, i as frameImage, o as frameStats } from "./frame-report-Dlq13Gyj.js";
 //#region src/core/audio-errors.ts
 /** Every AudioPlayer under `root` whose source could not be played. */
 function audioErrors(root) {
@@ -35,7 +35,7 @@ function claimCanvasGestures(canvas) {
 * empty list outside a dev server.
 */
 function wireDevChannel(opts) {
-	const hot = import.meta.hot;
+	const hot = import.meta.hot ?? globalThis.__incantoInspect;
 	const cleanups = [];
 	if (!hot) return cleanups;
 	const onFrameRequest = (data) => {
@@ -59,6 +59,7 @@ function wireDevChannel(opts) {
 			report: {
 				...frameStats(shot.pixels, shot.width, shot.height, { grid: request?.grid }),
 				signature: frameSignature(shot.pixels, shot.width, shot.height),
+				hidden: typeof document !== "undefined" && document.hidden,
 				...droveFrames === null ? {} : { droveFrames },
 				...request?.image ? { image: frameImage(shot.pixels, shot.width, shot.height, (w, h) => Object.assign(document.createElement("canvas"), {
 					width: w,

package/dist/{test-8hoHeRmo.js → test-D6ISmuFE.js}

@@ -1,13 +1,13 @@
-import { f as resolveViewport, n as loadScene, z as registerBehavior } from "./loader-BC4PNtJX.js";
-import { v as Engine } from "./register-3ta-2Xig.js";
+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-CYvhVHHN.js";
-import { n as registerGameplayBehaviors } from "./gameplay-DM1eu_cV.js";
-import { t as registerNodes2D } from "./register-ibCjm-wH.js";
-import { n as registerNodes3D, t as resolveEnvironmentHdri } from "./environment-presets-CybQXNqS.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-CYwDkbLF.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
 /**
@@ -252,7 +252,7 @@ function describeFraming2D(scene, placed, opts) {
 				round(cy),
 				0
 			],
-			view: [vw, vh],
+			view: [round(vw / zoom), round(vh / zoom)],
 			zoom
 		};
 	}
@@ -630,6 +630,23 @@ var Driver = class {
 	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();
 	/**
@@ -680,7 +697,20 @@ var Driver = class {
 	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) {
@@ -689,6 +719,7 @@ var Driver = class {
 		}
 		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);
@@ -702,6 +733,7 @@ var Driver = class {
 			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);
 			}
 		}
@@ -820,9 +852,10 @@ async function runOnce(json, seed, opts) {
 	});
 	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, Math.hypot(at[0] - start[0], at[2] - start[2]));
+		wentAsFarAs = Math.max(wentAsFarAs, travelled(at, start));
 		driver.step(stepMs / 1e3, at);
 		session.step(stepMs);
 		if (player) for (const [path, node] of targetNodes) {
@@ -878,7 +911,8 @@ async function runOnce(json, seed, opts) {
 		signals,
 		declaresEnd: oracle.declaresEnd(),
 		hazards,
-		hasPlayer: player !== null
+		hasPlayer: player !== null,
+		froze: driver.paused()
 	};
 }
 /**
@@ -908,6 +942,7 @@ async function playtest(json, opts = {}) {
 	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);
@@ -916,6 +951,7 @@ async function playtest(json, opts = {}) {
 		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,
@@ -946,6 +982,7 @@ async function playtest(json, opts = {}) {
 		declaresWin,
 		hasPlayer,
 		hazards,
+		froze: [...froze],
 		seconds: opts.seconds ?? 60,
 		feedback: {
 			declaredAudio: feedbackNodes.audio,
@@ -1016,8 +1053,14 @@ function playtestText(report) {
 		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");
@@ -1812,8 +1855,8 @@ async function playMultiplayer(opts) {
 */
 async function joinLate(server, first, opts) {
 	try {
-		const { Engine } = await import("./register-3ta-2Xig.js").then((n) => n.y);
-		const { loadScene } = await import("./loader-BC4PNtJX.js").then((n) => n.r);
+		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));
@@ -2175,10 +2218,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-B7Y6dPZO.js").then((n) => n.r);
+		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-bG3n70Ky.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-DbYaEcZy.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const failures = [];
@@ -2294,10 +2337,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-B7Y6dPZO.js").then((n) => n.r);
+		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-bG3n70Ky.js").then((n) => n.r);
+		const { enablePhysics3D } = await import("./physics-3d-DbYaEcZy.js").then((n) => n.r);
 		await enablePhysics3D(engine);
 	}
 	const stepMs = 1e3 / (opts.fixedHz ?? 60);
@@ -2317,7 +2360,7 @@ async function createPlaySession(json, opts = {}) {
 			timeMs += ticks * stepMs;
 		},
 		capture() {
-			return scene.toJSON();
+			return (engine.scene ?? scene).toJSON();
 		},
 		describe() {
 			return describeCapture(captureScene(engine.scene ?? scene));

package/dist/test.d.ts

@@ -1,8 +1,8 @@
-import { P as Scene, Pt as LogEntry, b as Engine, jt as Node, n as BehaviorCtor } from "./behavior-DoFPYrgo.js";
+import { P as Scene, Pt as LogEntry, b as Engine, jt as Node, n as BehaviorCtor } from "./behavior-rm8vVzu_.js";
 import { c as JsonValue, i as SceneJson, s as JsonObject } from "./schema-B6ugCV1Q.js";
-import { t as LoadSceneOptions } from "./loader-CcB533FR.js";
-import { l as auditScene, o as IncantoError, r as ReplayJson, u as instancedScenes } from "./replay-Dvn8aeBd.js";
-import { l as LocalGameServerOptions, n as SplitScreenPlayer } from "./split-screen-DhrSzZIB.js";
+import { t as LoadSceneOptions } from "./loader-DadV2QCT.js";
+import { l as auditScene, o as IncantoError, r as ReplayJson, u as instancedScenes } from "./replay-BQfkX4x7.js";
+import { l as LocalGameServerOptions, n as SplitScreenPlayer } from "./split-screen-Cg76MCV5.js";
 
 //#region src/test/facing.d.ts
 interface FacingOptions {
@@ -361,6 +361,17 @@ interface PlaytestReport {
   /** How many nodes are wired to hurt the player — see the `danger:` line. */
   hazards: number;
   /**
+  * Actions the bot stopped pressing because they STOPPED THE CLOCK.
+  *
+  * It drove every declared button, 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, everything else identical — a frozen game cannot
+  * hurt you, so the same run also reported the game as having no way to lose.
+  * Named here rather than guessed from the word "pause": a game may call it
+  * `menu` or `escape`, and the bot notices the way a player would.
+  */
+  froze: string[];
+  /**
   * Did `findPlayer` find anyone to drive?
   *
   * `findPlayer`'s own comment says a scene it cannot drive "says so rather

package/dist/test.js

@@ -1,3 +1,3 @@
-import { i as instancedScenes, r as auditScene } from "./replay-CYvhVHHN.js";
-import { C as describeFraming, S as playtestText, _ as facingReport, a as registerAllNodes, b as findPlayer, c as ladderText, d as multiplayText, f as playMultiplayer, g as agreementProblems, h as takeAgreementSnapshots, i as findFloatingProps, l as ladderVerdict, m as feelText, n as createPlaySession, o as runScript, p as feelReport, r as describeCapture, s as validateScene, t as captureScene, u as multiplayProblems, v as facingText, w as framingText, x as playtest, y as failingReplays } from "./test-8hoHeRmo.js";
+import { i as instancedScenes, r as auditScene } from "./replay-BEHLDcQV.js";
+import { C as describeFraming, S as playtestText, _ as facingReport, a as registerAllNodes, b as findPlayer, c as ladderText, d as multiplayText, f as playMultiplayer, g as agreementProblems, h as takeAgreementSnapshots, i as findFloatingProps, l as ladderVerdict, m as feelText, n as createPlaySession, o as runScript, p as feelReport, r as describeCapture, s as validateScene, t as captureScene, u as multiplayProblems, v as facingText, w as framingText, x as playtest, y as failingReplays } from "./test-D6ISmuFE.js";
 export { agreementProblems, auditScene, captureScene, createPlaySession, describeCapture, describeFraming, facingReport, facingText, failingReplays, feelReport, feelText, findFloatingProps, findPlayer, framingText, instancedScenes, ladderText, ladderVerdict, multiplayProblems, multiplayText, playMultiplayer, playtest, playtestText, registerAllNodes, runScript, takeAgreementSnapshots, validateScene };