incanto 0.68.0 → 0.70.0

package/dist/{create-game-IZIydDwI.js → create-game-Bwvh6q8A.js}

@@ -1,15 +1,15 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { d as computeViewport, f as resolveViewport, k as diagnose, n as loadScene, z as registerBehavior } from "./loader-BC4PNtJX.js";
-import { _ as AudioPlayer, v as Engine } from "./register-3ta-2Xig.js";
+import { o as __exportAll } from "./json-CfTjpvW8.js";
+import { E as resolveViewport, T as computeViewport, it as registerBehavior, p as loadScene, q as diagnose } from "./save-slots-BXVg148r.js";
+import { C as qualityRendering, _ as AudioPlayer, v as Engine } from "./register-6DYnKZcy.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { n as attachTouchControls } from "./touch-DEAmqGdf.js";
-import { n as withWebGLContext, r as resolveRendering } from "./webgl-unavailable-N9nQqesw.js";
-import { a as openBundledEditor, c as claimCanvasGestures, i as devServerLibrary, l as audioErrors, n as pauseWhenHidden, r as crossFade, s as wireDevChannel, t as teardown } from "./teardown-D2NEmxPB.js";
-import { o as frameStats } from "./frame-report-BSMny7oe.js";
-import { n as registerGameplayBehaviors } from "./gameplay-DM1eu_cV.js";
-import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-ibCjm-wH.js";
+import { n as attachTouchControls } from "./touch-BnCyPA0G.js";
+import { n as withWebGLContext, r as resolveRendering } from "./webgl-unavailable-C8aDbGmR.js";
+import { a as devServerLibrary, c as applyDriveStep, d as audioErrors, i as crossFade, l as wireDevChannel, n as teardown, o as openBundledEditor, r as pauseWhenHidden, t as nodeFromHits, u as claimCanvasGestures } from "./picking-CQJ_PJKh.js";
+import { o as frameStats } from "./frame-report-Dlq13Gyj.js";
+import { n as registerGameplayBehaviors } from "./gameplay-BfHkuzVb.js";
+import { g as PhysicsBody2D, n as UILayer, t as registerNodes2D, u as Camera2D, y as Node2D } from "./register-Bkk0wSDB.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
-import { n as enablePhysics2D } from "./physics-2d-B7Y6dPZO.js";
+import { n as enablePhysics2D } from "./physics-2d-CE0Qvy3V.js";
 import { Box3, BufferAttribute, BufferGeometry, Color, LineBasicMaterial, LineSegments, LinearFilter, NearestFilter, OrthographicCamera, Raycaster, SRGBColorSpace, Scene, TextureLoader, Vector2, Vector3, WebGLRenderer } from "three";
 //#region src/2d/assets.ts
 /**
@@ -101,6 +101,20 @@ var AssetStore2D = class {
 	getTexture(ref) {
 		return this.resolve(ref).texture;
 	}
+	/**
+	* Hand the GPU back.
+	*
+	* `AssetStore3D` has had this since it was written and the 2D twin never got
+	* one, so a game that swapped scenes or unmounted kept every texture it had
+	* ever decoded. `Renderer2D.dispose` walked its scene graph and disposed
+	* `material.map` instead — which frees only what is CURRENTLY drawn (a sheet
+	* loaded and never used stayed resident), and disposes the STORE'S texture
+	* out from under a caller who injected their own store.
+	*/
+	dispose() {
+		for (const entry of this.entries.values()) entry.texture?.dispose();
+		this.entries.clear();
+	}
 	getSheet(ref) {
 		const entry = this.resolve(ref);
 		if (entry.type !== "spritesheet") throw new IncantoError("BAD_FORMAT", `Asset '${ref}' is a plain texture; a spritesheet (with frameWidth/frameHeight) is required here.`);
@@ -433,18 +447,32 @@ var Renderer2D = class {
 	engine;
 	/** The texture store. Public so `renderer.assets.status(key)` is reachable. */
 	assets;
+	ownsAssets;
 	loadedAssetScenes = /* @__PURE__ */ new WeakSet();
 	disconnect;
 	canvas;
 	constructor(opts) {
 		this.canvas = opts.canvas;
 		this.engine = opts.engine;
+		const cw = opts.canvas.clientWidth || opts.canvas.width || 1;
+		const ch = opts.canvas.clientHeight || opts.canvas.height || 1;
+		this.lastView = {
+			cx: cw / 2,
+			cy: ch / 2,
+			zoom: 1,
+			w: cw,
+			h: ch
+		};
 		this.assets = opts.assets ?? new AssetStore2D(void 0, this.engine);
+		this.ownsAssets = !opts.assets;
 		const rendering = resolveRendering(opts.engine.scene?.environment, {
 			antialias: true,
 			pixelRatio: 1,
 			preserveDrawingBuffer: false
 		}, globalThis.devicePixelRatio ?? 1, opts);
+		const tier = qualityRendering(opts.engine.settings.get("quality"));
+		rendering.antialias = rendering.antialias && tier.antialias;
+		rendering.pixelRatio = Math.min(rendering.pixelRatio, tier.pixelRatio);
 		this.webgl = withWebGLContext(() => new WebGLRenderer({
 			canvas: opts.canvas,
 			antialias: rendering.antialias,
@@ -452,6 +480,20 @@ var Renderer2D = class {
 		}));
 		this.webgl.info.autoReset = false;
 		this.engine.picker = (x, y) => this.pick(x, y);
+		this.engine.toWorld = (x, y) => {
+			if (!this.hasRendered) return null;
+			const w = this.worldFromScreen(x, y);
+			return [w.x, w.y];
+		};
+		this.engine.toScreen = (world) => {
+			if (!this.hasRendered) return null;
+			const s = this.screenFromWorld(world[0] ?? 0, world[1] ?? 0);
+			return {
+				x: s.x,
+				y: s.y,
+				behind: false
+			};
+		};
 		this.basePixelRatio = rendering.pixelRatio;
 		this.webgl.setPixelRatio(rendering.pixelRatio);
 		this.webgl.info.autoReset = false;
@@ -568,6 +610,7 @@ var Renderer2D = class {
 			h
 		};
 		this.lastViewport = view;
+		this.hasRendered = true;
 		if (view && (view.offsetX > .5 || view.offsetY > .5)) {
 			this.webgl.setScissorTest(false);
 			this.webgl.setViewport(0, 0, w, h);
@@ -595,13 +638,29 @@ var Renderer2D = class {
 		h: 1
 	};
 	lastViewport = null;
-	lastView = {
-		cx: 0,
-		cy: 0,
-		zoom: 1,
-		w: 1,
-		h: 1
-	};
+	/**
+	* The view the LAST render used — and, before there has been one, the
+	* documented default: the whole canvas, centred, at zoom 1.
+	*
+	* It started as `{cx: 0, cy: 0, w: 1, h: 1}`, a one-pixel canvas nobody has,
+	* and `worldFromScreen` answered from it with a straight face. Measured in a
+	* browser on a 960x540 canvas with the camera at (160, 80), before the first
+	* frame: `toWorld(480, 270)` returned `[479.5, 269.5]` — the arithmetic of a
+	* 1x1 window, and a confident number rather than a refusal.
+	*/
+	lastView;
+	/**
+	* Has a frame been DRAWN?
+	*
+	* `Renderer3D` refuses every screen-space question until it has one
+	* (`if (!this.lastCamera) return null`, in `pick`, `rayFromScreen` and
+	* `worldFromScreen`); the flat renderer had no equivalent, so the engine-level
+	* `toWorld`/`toScreen` and `pick` answered from a view no frame had used. The
+	* hazard is real in exactly the place agents work: a background tab does not
+	* run rAF, so `await createGame2D(...)` there is followed by any number of
+	* questions with no frame behind them.
+	*/
+	hasRendered = false;
 	/** The world view used by the LAST render (center/zoom/canvas size). */
 	view() {
 		return { ...this.lastView };
@@ -630,11 +689,13 @@ var Renderer2D = class {
 	* Hits resolve through `userData.incantoNode` and prefer higher renderOrder.
 	*/
 	pick(sx, sy) {
+		if (!this.hasRendered) return null;
 		const { w, h } = this.lastView;
 		const ox = this.lastViewport?.offsetX ?? 0;
 		const oy = this.lastViewport?.offsetY ?? 0;
 		const cw = this.lastViewport?.contentW ?? w;
 		const ch = this.lastViewport?.contentH ?? h;
+		if (sx < ox || sx > ox + cw || sy < oy || sy > oy + ch) return null;
 		pickNdc.set((sx - ox) / cw * 2 - 1, -((sy - oy) / ch * 2 - 1));
 		const ui = this.hit(this.uiScene, this.uiCam);
 		if (ui) return ui;
@@ -642,20 +703,7 @@ var Renderer2D = class {
 	}
 	hit(scene, cam) {
 		raycaster.setFromCamera(pickNdc, cam);
-		const hits = raycaster.intersectObjects(scene.children, true);
-		let best = null;
-		for (const hit of hits) {
-			let obj = hit.object;
-			while (obj && !obj.userData.incantoNode) obj = obj.parent;
-			const node = obj?.userData.incantoNode;
-			if (!node) continue;
-			const order = hit.object.renderOrder ?? 0;
-			if (!best || order >= best.order) best = {
-				node,
-				order
-			};
-		}
-		return best?.node ?? null;
+		return nodeFromHits(raycaster.intersectObjects(scene.children, true), { byRenderOrder: true });
 	}
 	/** Does the UI pass draw this node (i.e. is it under a UILayer)? */
 	isUiNode(node) {
@@ -714,16 +762,16 @@ var Renderer2D = class {
 	}
 	dispose() {
 		if (this.engine.picker) this.engine.picker = null;
+		if (this.engine.toWorld) this.engine.toWorld = null;
+		if (this.engine.toScreen) this.engine.toScreen = null;
 		this.disconnect();
 		for (const scene of [this.worldScene, this.uiScene]) scene.traverse((obj) => {
 			const mesh = obj;
 			if (!mesh.isMesh) return;
 			const mats = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
-			for (const mat of mats) {
-				mat?.map?.dispose();
-				mat?.dispose();
-			}
+			for (const mat of mats) mat?.dispose();
 		});
+		if (this.ownsAssets) this.assets.dispose();
 		this.webgl.dispose();
 	}
 };
@@ -768,13 +816,25 @@ async function createGame2D(opts) {
 	engine.setScene(scene);
 	let physics = null;
 	if (opts.physics === true || (opts.physics ?? "auto") === "auto" && hasBody(scene.root)) physics = await enablePhysics2D(engine);
+	if (opts.physics !== false) engine.physicsProvider = async (root) => {
+		if (engine.physics || !hasBody(root)) return;
+		physics = await enablePhysics2D(engine);
+	};
 	const cleanups = [];
 	const keyboard = opts.keyboard ?? (typeof window !== "undefined" ? window : false);
 	if (keyboard) engine.input.attachKeyboard(keyboard);
-	if (opts.pointer) {
+	let pointerAttached = false;
+	const attachPointerIfWanted = () => {
+		if (pointerAttached || opts.pointer === false) return;
+		const root = engine.scene?.root;
+		if (!root) return;
+		if (opts.pointer === void 0 && !wantsPointer(root)) return;
+		pointerAttached = true;
 		const lockOnClick = typeof opts.pointer === "object" ? opts.pointer.lockOnClick ?? false : false;
 		engine.input.attachPointer(opts.canvas, { lockOnClick });
-	}
+	};
+	attachPointerIfWanted();
+	cleanups.push(engine.sceneChanged.connect(() => attachPointerIfWanted()));
 	cleanups.push(wireAudioUnlock(engine, scene.root, opts.canvas));
 	cleanups.push(engine.settings.bindAudio(engine.audio));
 	cleanups.push(pauseWhenHidden(engine));
@@ -803,6 +863,7 @@ async function createGame2D(opts) {
 		canvas: opts.canvas,
 		engine,
 		...opts.pixelRatio !== void 0 ? { pixelRatio: opts.pixelRatio } : {},
+		...opts.preserveDrawingBuffer !== void 0 ? { preserveDrawingBuffer: opts.preserveDrawingBuffer } : {},
 		...opts.antialias !== void 0 ? { antialias: opts.antialias } : {}
 	});
 	cleanups.push(engine.settings.bindFrameCap((fps) => {
@@ -827,26 +888,15 @@ async function createGame2D(opts) {
 			requestAnimationFrame(tick);
 		};
 		if (typeof requestAnimationFrame === "function") requestAnimationFrame(tick);
-		for (const step of steps) switch (step.kind) {
-			case "press":
-				engine.input.pressAction(step.action);
-				break;
-			case "release":
-				engine.input.releaseAction(step.action);
-				break;
-			case "vector":
-				engine.input.setActionVector(step.action, step.x, step.y);
-				break;
-			case "key":
-				engine.input.handleKey(step.code, step.down);
-				break;
-			case "pointer":
-				engine.input.handlePointerMove(step.dx, step.dy);
-				break;
-			case "step":
-				await new Promise((r) => setTimeout(r, step.ms));
-				break;
-		}
+		const target = {
+			engine,
+			project: (x, y) => {
+				const at = renderer.screenFromWorld;
+				return at ? at.call(renderer, x, y) : null;
+			},
+			wait: (ms) => new Promise((r) => setTimeout(r, ms))
+		};
+		for (const step of steps) await applyDriveStep(target, step);
 		watching = false;
 		return frames;
 	};
@@ -872,10 +922,11 @@ async function createGame2D(opts) {
 			if (!editorSwitch) return;
 			const open = editorSwitch.open ?? openBundledEditor;
 			const reboot = async (working) => {
-				await createGame2D({
+				const next = await createGame2D({
 					...opts,
 					scene: working
 				});
+				editorSwitch?.onReboot?.(next);
 			};
 			await crossFade(async () => {
 				disposeGame();
@@ -888,7 +939,7 @@ async function createGame2D(opts) {
 						...editorSwitch.library ? { library: editorSwitch.library === true ? devServerLibrary() : editorSwitch.library } : {}
 					});
 				} catch (error) {
-					console.error("[incanto] could not open the editor:", error);
+					diagnose(engine, "error", "[incanto] could not open the editor:", error);
 					await reboot(sourceJson);
 				}
 			}, "opening the editor…");
@@ -908,9 +959,24 @@ async function createGame2D(opts) {
 		}
 	}
 	engine.start();
+	/**
+	* Has this handle already been torn down?
+	*
+	* After one ✎→▶ editor round trip the handle `createGame*` returned is
+	* ORPHANED: `reboot()` builds a replacement and the app still holds the old
+	* one. Calling `game.openEditor()` on it then booted a THIRD game on top of
+	* the live one, and `game.dispose()` tore down a game that was already gone
+	* while leaving the live one running. A second `dispose()` also re-entered
+	* Rapier's already-nulled `world.free()` and printed an engine error.
+	*
+	* A stale handle does nothing rather than something destructive.
+	*/
+	let disposed = false;
 	function disposeGame() {
+		if (disposed) return;
+		disposed = true;
 		teardown([
-			physics ? ["physics", () => physics?.dispose()] : null,
+			["physics", () => physics?.dispose()],
 			["app cleanups", () => {
 				for (const cleanup of cleanups) cleanup();
 			}],
@@ -950,7 +1016,10 @@ async function createGame2D(opts) {
 				...renderer.stats?.()
 			};
 		},
-		openEditor: editorSwitch ? editorAction.run : null,
+		openEditor: editorSwitch ? async () => {
+			if (disposed) return;
+			await editorAction.run();
+		} : null,
 		dispose: disposeGame
 	};
 }
@@ -1009,5 +1078,23 @@ function wireAudioUnlock(engine, root, canvas) {
 	for (const s of sources) s.target.addEventListener?.(s.type, unlock, { passive: true });
 	return detachAll;
 }
+/**
+* Does this tree have anything the CURSOR drives?
+*
+* `physics: 'auto'` has always meant "on iff the tree needs it"; the pointer had
+* no such default, so a board of `Clickable`s booted without `pointer: true` did
+* nothing when clicked — and the skill that introduces the behaviour says it
+* "needs no code at all". This makes that true.
+*
+* Only `Clickable`, deliberately: a behaviour of your own that reads
+* `pointerPosition()` is invisible from here, and guessing wider would attach a
+* pointer to games that never asked (and, with `lockOnClick`, capture a cursor
+* nobody wanted).
+*/
+function wantsPointer(root) {
+	if (root.behavior?.constructor.name === "Clickable") return true;
+	for (const child of root.children) if (wantsPointer(child)) return true;
+	return false;
+}
 //#endregion
 export { AssetStore2D as a, syncTree2D as i, create_game_exports as n, Renderer2D as r, createGame2D as t };

package/dist/{create-game-DbWtVTxD.js → create-game-C7ffQWW7.js}

@@ -1,16 +1,16 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { c as parseEnvironment3D, k as diagnose, n as loadScene, s as horizonColorFromSky, u as sunDirectionFromSky, z as registerBehavior } from "./loader-BC4PNtJX.js";
-import { C as qualityRendering, _ as AudioPlayer, v as Engine, x as qualityCaps } from "./register-3ta-2Xig.js";
+import { o as __exportAll } from "./json-CfTjpvW8.js";
+import { it as registerBehavior, p as loadScene, q as diagnose, v as horizonColorFromSky, x as sunDirectionFromSky, y as parseEnvironment3D } from "./save-slots-BXVg148r.js";
+import { C as qualityRendering, S as qualityEnvironment, _ as AudioPlayer, v as Engine, x as qualityCaps } from "./register-6DYnKZcy.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { n as attachTouchControls } from "./touch-DEAmqGdf.js";
-import { n as withWebGLContext, r as resolveRendering } from "./webgl-unavailable-N9nQqesw.js";
-import { a as openBundledEditor, c as claimCanvasGestures, i as devServerLibrary, l as audioErrors, n as pauseWhenHidden, o as poseFromRenderer, r as crossFade, s as wireDevChannel, t as teardown } from "./teardown-D2NEmxPB.js";
-import { o as frameStats } from "./frame-report-BSMny7oe.js";
-import { J as createCausticsQuad, K as Node3D, U as PhysicsBody3D, n as registerGameplayBehaviors } from "./gameplay-DM1eu_cV.js";
+import { n as attachTouchControls } from "./touch-BnCyPA0G.js";
+import { n as withWebGLContext, r as resolveRendering } from "./webgl-unavailable-C8aDbGmR.js";
+import { a as devServerLibrary, c as applyDriveStep, d as audioErrors, i as crossFade, l as wireDevChannel, n as teardown, o as openBundledEditor, r as pauseWhenHidden, s as poseFromRenderer, t as nodeFromHits, u as claimCanvasGestures } from "./picking-CQJ_PJKh.js";
+import { o as frameStats } from "./frame-report-Dlq13Gyj.js";
+import { G as Node3D, H as PhysicsBody3D, n as registerGameplayBehaviors, q as createCausticsQuad } from "./gameplay-BfHkuzVb.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
-import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-CybQXNqS.js";
-import { n as enablePhysics3D } from "./physics-3d-bG3n70Ky.js";
-import { ACESFilmicToneMapping, AmbientLight, Box3, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
+import { E as Camera3D, U as TextureCache3D, g as ModelInstance3D, n as registerNodes3D, t as resolveEnvironmentHdri, v as DirectionalLight3D } from "./environment-presets-D6Q5BxeE.js";
+import { n as enablePhysics3D } from "./physics-3d-CpH-2gn5.js";
+import { ACESFilmicToneMapping, AmbientLight, Box3, BufferAttribute, BufferGeometry, Color, DepthTexture, EquirectangularReflectionMapping, FloatType, Fog, HalfFloatType, LineBasicMaterial, LineSegments, LoadingManager, Matrix4, Mesh, PCFShadowMap, PMREMGenerator, PerspectiveCamera, PlaneGeometry, Quaternion, Raycaster, Scene, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget, WebGLRenderer } from "three";
 import { VRMLoaderPlugin, VRMUtils } from "@pixiv/three-vrm";
 import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js";
 import { RGBELoader } from "three/examples/jsm/loaders/RGBELoader.js";
@@ -72,7 +72,12 @@ var AssetStore3D = class {
 	*/
 	constructor(engine = null) {
 		this.engine = engine;
-		this.loader = new GLTFLoader();
+		const manager = new LoadingManager();
+		manager.onError = (url) => {
+			if (this.models.has(url) || this.animations.has(url)) return;
+			this.textures.noteError(url, "a model needs this texture and it did not load");
+		};
+		this.loader = new GLTFLoader(manager);
 		this.loader.register((parser) => new VRMLoaderPlugin(parser));
 		this.textures = new TextureCache3D({ diagnostics: engine ? { warn: (...parts) => diagnose(engine, "warn", ...parts) } : null });
 	}
@@ -1353,7 +1358,7 @@ function walk(node, parentObj, state) {
 	for (const child of node.children) walk(child, nextParent, state);
 	if (node instanceof Node3D) {
 		const obj = node._ensureObject3D();
-		if (node.static && !state.ignoreStatic) {
+		if (node.static && !state.ignoreStatic && node._staticReady(state.assets ?? null)) {
 			obj.userData.incantoStaticSynced = true;
 			obj.userData.incantoStatic = true;
 			warnStaticHazards(node);
@@ -1374,7 +1379,7 @@ function warnStaticHazards(root) {
 		for (const c of n.children) scan(c);
 	};
 	scan(root);
-	if (hazards.length > 0) console.warn(`[incanto] static subtree '${root.name}' freezes animated/per-frame nodes: ${hazards.join(", ")} — they will stop updating. Unmark static or move them out.`);
+	if (hazards.length > 0) diagnose(root.tree?.engine ?? null, "warn", `[incanto] static subtree '${root.name}' freezes animated/per-frame nodes: ${hazards.join(", ")} — they will stop updating. Unmark static or move them out.`);
 }
 function prune(obj, visited) {
 	const ch = obj.children;
@@ -1494,6 +1499,16 @@ var Renderer3D = class {
 		}));
 		this.webgl.info.autoReset = false;
 		this.engine.picker = (x, y) => this.pick(x, y);
+		this.engine.toWorld = (x, y) => {
+			const w = this.worldFromScreen(x, y);
+			return w ? [
+				w.x,
+				w.y,
+				w.z
+			] : null;
+		};
+		this.engine.toScreen = (world) => this.screenFromWorld(world[0] ?? 0, world[1] ?? 0, world[2] ?? 0);
+		this.engine.screenRay = (x, y) => this.rayFromScreen(x, y);
 		this.basePixelRatio = rendering.pixelRatio;
 		this.webgl.setPixelRatio(rendering.pixelRatio);
 		this.adaptive = opts.adaptiveResolution === false ? null : new AdaptiveResolution();
@@ -2067,6 +2082,7 @@ var Renderer3D = class {
 	rayFromScreen(sx, sy) {
 		const cam = this.lastCamera;
 		if (!cam) return null;
+		if (sx < 0 || sx > this.lastSize.w || sy < 0 || sy > this.lastSize.h) return null;
 		pickNdc.set(sx / this.lastSize.w * 2 - 1, -(sy / this.lastSize.h * 2 - 1));
 		pickRaycaster.setFromCamera(pickNdc, cam);
 		const o = pickRaycaster.ray.origin;
@@ -2095,14 +2111,7 @@ var Renderer3D = class {
 		if (!cam) return null;
 		pickNdc.set(sx / this.lastSize.w * 2 - 1, -(sy / this.lastSize.h * 2 - 1));
 		pickRaycaster.setFromCamera(pickNdc, cam);
-		const hits = pickRaycaster.intersectObjects(this.threeScene.children, true);
-		for (const hit of hits) {
-			let obj = hit.object;
-			while (obj && !obj.userData.incantoNode) obj = obj.parent;
-			const node = obj?.userData.incantoNode;
-			if (node) return node;
-		}
-		return null;
+		return nodeFromHits(pickRaycaster.intersectObjects(this.threeScene.children, true));
 	}
 	/**
 	* GPU counters for the last rendered frame — EVERY pass of it, summed (see
@@ -2154,6 +2163,9 @@ var Renderer3D = class {
 	}
 	dispose() {
 		if (this.engine.picker) this.engine.picker = null;
+		if (this.engine.toWorld) this.engine.toWorld = null;
+		if (this.engine.toScreen) this.engine.toScreen = null;
+		if (this.engine.screenRay) this.engine.screenRay = null;
 		this.disconnect();
 		this.threeScene.traverse((obj) => {
 			const mesh = obj;
@@ -2249,14 +2261,26 @@ async function createGame3D(opts) {
 	await report(.06, "scene");
 	let physics = null;
 	if (opts.physics === true || (opts.physics ?? "auto") === "auto" && hasBody(scene.root)) physics = await enablePhysics3D(engine);
+	if (opts.physics !== false) engine.physicsProvider = async (root) => {
+		if (engine.physics || !hasBody(root)) return;
+		physics = await enablePhysics3D(engine);
+	};
 	await report(.1, "physics");
 	const cleanups = [];
 	const keyboard = opts.keyboard ?? (typeof window !== "undefined" ? window : false);
 	if (keyboard) engine.input.attachKeyboard(keyboard);
-	if (opts.pointer) {
+	let pointerAttached = false;
+	const attachPointerIfWanted = () => {
+		if (pointerAttached || opts.pointer === false) return;
+		const root = engine.scene?.root;
+		if (!root) return;
+		if (opts.pointer === void 0 && !wantsPointer(root)) return;
+		pointerAttached = true;
 		const lockOnClick = typeof opts.pointer === "object" ? opts.pointer.lockOnClick ?? true : true;
 		engine.input.attachPointer(opts.canvas, { lockOnClick });
-	}
+	};
+	attachPointerIfWanted();
+	cleanups.push(engine.sceneChanged.connect(() => attachPointerIfWanted()));
 	cleanups.push(wireAudioUnlock(engine, scene.root, opts.canvas));
 	if (!opts.pageGestures) claimCanvasGestures(opts.canvas);
 	const touchMode = opts.touch ?? "auto";
@@ -2301,10 +2325,11 @@ async function createGame3D(opts) {
 			const camera = poseFromRenderer(renderer);
 			const open = editorSwitch.open ?? openBundledEditor;
 			const reboot = async (working) => {
-				await createGame3D({
+				const next = await createGame3D({
 					...opts,
 					scene: working
 				});
+				editorSwitch?.onReboot?.(next);
 			};
 			await crossFade(async () => {
 				disposeGame();
@@ -2318,7 +2343,7 @@ async function createGame3D(opts) {
 						...editorSwitch.library ? { library: editorSwitch.library === true ? devServerLibrary() : editorSwitch.library } : {}
 					});
 				} catch (error) {
-					console.error("[incanto] could not open the editor:", error);
+					diagnose(engine, "error", "[incanto] could not open the editor:", error);
 					await reboot(sourceJson);
 				}
 			}, "opening the editor…");
@@ -2351,8 +2376,12 @@ async function createGame3D(opts) {
 	} catch {}
 	cleanups.push(engine.settings.bindAudio(engine.audio));
 	cleanups.push(engine.settings.bindLocale(engine.locale));
-	cleanups.push(engine.settings.bindQuality((patch) => {
+	const applyTier = (patch) => {
 		applyQualityTier3D(engine, patch);
+	};
+	cleanups.push(engine.settings.bindQuality(applyTier));
+	cleanups.push(engine.sceneChanged.connect(() => {
+		applyTier(qualityEnvironment(engine.settings.get("quality")));
 	}));
 	cleanups.push(engine.settings.bindFrameCap((fps) => {
 		engine.maxFps = fps;
@@ -2382,26 +2411,15 @@ async function createGame3D(opts) {
 			requestAnimationFrame(tick);
 		};
 		requestAnimationFrame(tick);
-		for (const s of steps) switch (s.kind) {
-			case "press":
-				engine.input.pressAction(s.action);
-				break;
-			case "release":
-				engine.input.releaseAction(s.action);
-				break;
-			case "vector":
-				engine.input.setActionVector(s.action, s.x, s.y);
-				break;
-			case "key":
-				engine.input.handleKey(s.code, s.down);
-				break;
-			case "pointer":
-				engine.input.handlePointerMove(s.dx, s.dy);
-				break;
-			case "step":
-				await new Promise((r) => setTimeout(r, s.ms));
-				break;
-		}
+		const target = {
+			engine,
+			project: (x, y, z) => {
+				const at = renderer.screenFromWorld;
+				return at ? at.call(renderer, x, y, z) : null;
+			},
+			wait: (ms) => new Promise((r) => setTimeout(r, ms))
+		};
+		for (const s of steps) await applyDriveStep(target, s);
 		watching = false;
 		return frames;
 	};
@@ -2414,9 +2432,24 @@ async function createGame3D(opts) {
 	}));
 	cleanups.push(pauseWhenHidden(engine));
 	await report(1, "ready");
+	/**
+	* Has this handle already been torn down?
+	*
+	* After one ✎→▶ editor round trip the handle `createGame*` returned is
+	* ORPHANED: `reboot()` builds a replacement and the app still holds the old
+	* one. Calling `game.openEditor()` on it then booted a THIRD game on top of
+	* the live one, and `game.dispose()` tore down a game that was already gone
+	* while leaving the live one running. A second `dispose()` also re-entered
+	* Rapier's already-nulled `world.free()` and printed an engine error.
+	*
+	* A stale handle does nothing rather than something destructive.
+	*/
+	let disposed = false;
 	function disposeGame() {
+		if (disposed) return;
+		disposed = true;
 		teardown([
-			physics ? ["physics", () => physics?.dispose()] : null,
+			["physics", () => physics?.dispose()],
 			["app cleanups", () => {
 				for (const cleanup of cleanups) cleanup();
 			}],
@@ -2456,7 +2489,10 @@ async function createGame3D(opts) {
 				...renderer.stats?.()
 			};
 		},
-		openEditor: editorSwitch ? editorAction.run : null,
+		openEditor: editorSwitch ? async () => {
+			if (disposed) return;
+			await editorAction.run();
+		} : null,
 		dispose: disposeGame
 	};
 }
@@ -2515,5 +2551,23 @@ function wireAudioUnlock(engine, root, canvas) {
 	for (const s of sources) s.target.addEventListener?.(s.type, unlock, { passive: true });
 	return detachAll;
 }
+/**
+* Does this tree have anything the CURSOR drives?
+*
+* `physics: 'auto'` has always meant "on iff the tree needs it"; the pointer had
+* no such default, so a board of `Clickable`s booted without `pointer: true` did
+* nothing when clicked — and the skill that introduces the behaviour says it
+* "needs no code at all". This makes that true.
+*
+* Only `Clickable`, deliberately: a behaviour of your own that reads
+* `pointerPosition()` is invisible from here, and guessing wider would attach a
+* pointer to games that never asked (and, with `lockOnClick`, capture a cursor
+* nobody wanted).
+*/
+function wantsPointer(root) {
+	if (root.behavior?.constructor.name === "Clickable") return true;
+	for (const child of root.children) if (wantsPointer(child)) return true;
+	return false;
+}
 //#endregion
 export { Environment3D as a, AssetStore3D as c, syncTree as i, create_game_exports as n, applyQualityTier3D as o, Renderer3D as r, setEnvironment3D as s, createGame3D as t };

package/dist/debug.d.ts

@@ -1,4 +1,4 @@
-import { Ft as LogLevel, T as RendererStats, b as Engine } from "./behavior-DoFPYrgo.js";
+import { Ft as LogLevel, T as RendererStats, b as Engine } from "./behavior-DZExDn9o.js";
 
 //#region src/debug/panel.d.ts
 /** Minimal document surface the overlay needs (injectable for tests). */

package/dist/debug.js

@@ -1,6 +1,5 @@
-import { t as jsonClone } from "./json-CwwhxQgb.js";
-import { s as mergeStaticProps } from "./registry-CF70EArN.js";
-import { r as capturePointer } from "./touch-DEAmqGdf.js";
+import { t as jsonClone } from "./json-CfTjpvW8.js";
+import { d as mergeStaticProps, r as capturePointer } from "./touch-BnCyPA0G.js";
 import { t as debugSources } from "./debug-draw-BM3DsvtT.js";
 //#region src/debug/capture.ts
 /**

package/dist/diagnostics-Cu85N3tL.d.ts

@@ -0,0 +1,12 @@
+//#region src/core/diagnostics.d.ts
+/** The minimum an engine has to look like to receive a diagnostic. */
+interface DiagnosticSink {
+  log: {
+    warn(...parts: unknown[]): void;
+    error(...parts: unknown[]): void;
+    info(...parts: unknown[]): void;
+    debug(...parts: unknown[]): void;
+  };
+}
+//#endregion
+export { DiagnosticSink as t };