incanto 0.55.0 → 0.57.0

package/dist/{loader-BTkHYrQn.js → loader-BcrRSjxB.js}

@@ -173,172 +173,557 @@ function diagnose(engine, level, ...parts) {
 	else console.info(...parts);
 }
 //#endregion
-//#region src/core/input.ts
-/** Keys typed into editable elements belong to the page UI, not the game. */
-function isEditableTarget(target) {
-	const el = target;
-	return !!el && (el.isContentEditable === true || el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT");
+//#region src/core/node.ts
+function validateName(name) {
+	if (name === "" || name.includes("/") || name.includes("%")) throw new IncantoError("TREE_VIOLATION", `Invalid node name '${name}'. Names must be non-empty and must not contain '/' or '%'.`);
 }
 /**
-* Declarative input from scene JSON `input{}` — DOM-free logic (feed key state
-* via `handleKey`, or wire a browser with `attachKeyboard(window)`).
+* Base class of everything in an Incanto scene (Godot's Node model).
 *
-* Convention: vector2 follows the 2D y-down space (up = -y). `justPressed` /
-* `justReleased` are one-frame edges, settled by the Engine each tick.
+* Pure data + tree structure: no rendering, no DOM, no three.js — renderer
+* adapters subscribe from the outside.
 */
-var InputMap = class {
-	actions = /* @__PURE__ */ new Map();
-	down = /* @__PURE__ */ new Set();
-	pressedEdge = /* @__PURE__ */ new Set();
-	releasedEdge = /* @__PURE__ */ new Set();
-	detach = null;
-	/** Load (or extend with) scene-JSON action declarations. Hard-validates shape. */
-	declare(decls) {
-		for (const [name, action] of parseInputDecls(decls)) this.actions.set(name, action);
-	}
+var Node = class {
+	static typeName = "Node";
+	_name;
+	_parent = null;
+	_children = [];
+	_groups = /* @__PURE__ */ new Set();
+	_signals = /* @__PURE__ */ new Map();
+	_declared = null;
+	_tree = null;
+	_ready = false;
 	/**
-	* Where the pointer is, in CANVAS pixels (top-left origin), or null when it
-	* has never been over the canvas.
-	*
-	* This is what a click-driven game asks for. `pointerDelta()` answers "how far
-	* did the mouse move" — the mouse-look question — and for a whole class of
-	* genres that is the wrong question and the only one the engine could answer.
-	* Pair it with `renderer.pick(x, y)` to get the node under the cursor.
+	* Optional STABLE identifier (scene JSON `uid`) — unlike names (unique only
+	* among siblings) a uid is unique across the whole scene, so scripts and
+	* tools can address a node no matter where it moves.
 	*/
-	pointerPosition() {
-		return this.pointerPos ? { ...this.pointerPos } : null;
+	uid = null;
+	/** Free-form JSON identity for game logic (e.g. `{kind: 'ITEM', value: 10}`). */
+	tags = {};
+	/** Behavior attachment blob from scene JSON (resolved by the loader). */
+	script = null;
+	/** The resolved behavior instance (set by the loader from `script`). */
+	behavior = null;
+	/** Replication config blob from scene JSON (interpreted in M6; preserved until then). */
+	network = null;
+	constructor(name) {
+		const ctor = this.constructor;
+		this._name = name ?? ctor.typeName;
+		validateName(this._name);
 	}
-	/**
-	* @internal Feed a pointer position. `target` scales client → canvas pixels
-	* so a CSS-stretched canvas still reports coordinates its renderer can use.
-	*/
-	setPointerPosition(clientX, clientY, target) {
-		const rect = target?.getBoundingClientRect?.();
-		if (!rect || rect.width === 0 || rect.height === 0) {
-			this.pointerPos = {
-				x: clientX,
-				y: clientY
-			};
-			return;
-		}
-		this.pointerPos = {
-			x: clientX - rect.left,
-			y: clientY - rect.top
-		};
+	get name() {
+		return this._name;
 	}
-	pointerPos = null;
-	/** Feed a key state change (code = KeyboardEvent.code, e.g. 'Space', 'KeyW'). */
-	handleKey(code, isDown) {
-		if (isDown) {
-			if (!this.down.has(code)) {
-				this.down.add(code);
-				this.pressedEdge.add(code);
-			}
-		} else if (this.down.has(code)) {
-			this.down.delete(code);
-			this.releasedEdge.add(code);
-		}
+	set name(value) {
+		validateName(value);
+		const old = this._name;
+		if (this._parent) this._name = uniqueSiblingName(value, this._parent._children, this);
+		else this._name = value;
+		if (this._tree && this._name !== old) this._tree._reindexName(this, old);
 	}
-	injectedDown = /* @__PURE__ */ new Set();
-	injectedPressed = /* @__PURE__ */ new Set();
-	injectedReleased = /* @__PURE__ */ new Set();
-	injectedVectors = /* @__PURE__ */ new Map();
-	/**
-	* Press a button ACTION directly — no key codes involved. This is how
-	* scripted gameplay tests and touch buttons drive the game by intent
-	* (`press('jump')`) instead of reverse-engineering keybinds.
-	*/
-	/**
-	* Every action this scene declared, with its kind.
-	*
-	* A scene states its own control vocabulary in `input{}`, which means a tool
-	* can drive a game it has never seen — the automated playtester's entire
-	* premise. Nothing else could ask: `actions` was private.
-	*/
-	declaredActions() {
-		const out = [];
-		for (const [name, def] of this.actions) out.push({
-			name,
-			type: def.type
-		});
-		return out;
+	get parent() {
+		return this._parent;
 	}
-	pressAction(action) {
-		this.button(action);
-		if (!this.injectedDown.has(action)) {
-			this.injectedDown.add(action);
-			this.injectedPressed.add(action);
-		}
+	get children() {
+		return this._children;
 	}
-	/** Release an injected button action (yields one justReleased frame). */
-	releaseAction(action) {
-		this.button(action);
-		if (this.injectedDown.delete(action)) this.injectedReleased.add(action);
+	get groups() {
+		return this._groups;
 	}
-	/**
-	* Feed an analog direction for a vector2 ACTION — virtual joysticks and
-	* scripted runs. Persists until replaced; (0, 0) clears the injection.
-	* Combines with key state in getVector (clamped to unit length).
-	*/
-	setActionVector(action, x, y) {
-		if (this.get(action).type !== "vector2") throw new IncantoError("BAD_FORMAT", `Input action '${action}' is a button — use pressAction/releaseAction, not setActionVector.`);
-		if (!Number.isFinite(x) || !Number.isFinite(y)) throw new IncantoError("BAD_FORMAT", `setActionVector('${action}') needs finite numbers, got (${x}, ${y}).`);
-		if (x === 0 && y === 0) this.injectedVectors.delete(action);
-		else this.injectedVectors.set(action, {
-			x,
-			y
-		});
+	/** The SceneTree this node is attached to, or null while detached. */
+	get tree() {
+		return this._tree;
 	}
-	/**
-	* Actions the scene wants on-screen touch controls for, in declaration
-	* order (`"touch": "joystick"` on vector2, `"touch": "button"` on buttons).
-	* The touch overlay (core/touch.ts) renders these.
-	*/
-	touchControls() {
-		const out = [];
-		for (const [name, def] of this.actions) if (def.touch) out.push({
-			action: name,
-			kind: def.touch
-		});
-		return out;
+	/** Whether onReady has run (it runs at most once per instance). */
+	get isReady() {
+		return this._ready;
 	}
-	/** Drop all injected action state (held buttons, vectors, pending edges). */
-	clearInjected() {
-		this.injectedDown.clear();
-		this.injectedPressed.clear();
-		this.injectedReleased.clear();
-		this.injectedVectors.clear();
+	addChild(child) {
+		if (child._parent !== null) throw new IncantoError("TREE_VIOLATION", `Cannot add '${child.name}': it already has parent '${child._parent.name}'. removeChild/reparent first.`);
+		for (let n = this; n; n = n._parent) if (n === child) throw new IncantoError("TREE_VIOLATION", `Cannot add '${child.name}' to '${this.name}': it is this node or an ancestor (cycle).`);
+		child._name = uniqueSiblingName(child._name, this._children, child);
+		child._parent = this;
+		this._children.push(child);
+		if (this._tree) {
+			child._propagateEnterTree(this._tree);
+			child._propagateReady();
+		}
+		return child;
 	}
-	dx = 0;
-	dy = 0;
-	wheel = 0;
-	/** Mouse buttons feed the same code space as keys: Mouse0/Mouse1/Mouse2. */
-	handleMouseButton(button, isDown) {
-		this.handleKey(`Mouse${button}`, isDown);
+	removeChild(child) {
+		const i = this._children.indexOf(child);
+		if (i === -1) throw new IncantoError("TREE_VIOLATION", `'${child.name}' is not a child of '${this.name}'.`);
+		if (child._tree) child._propagateExitTree();
+		this._children.splice(i, 1);
+		child._parent = null;
 	}
-	/** Accumulate look deltas (movementX/Y under pointer lock, else move deltas). */
-	handlePointerMove(dx, dy) {
-		this.dx += dx;
-		this.dy += dy;
+	reparent(newParent) {
+		this._parent?.removeChild(this);
+		newParent.addChild(this);
 	}
-	handleWheel(deltaY) {
-		this.wheel += deltaY;
+	findChild(name, recursive = true) {
+		for (const c of this._children) if (c._name === name) return c;
+		if (recursive) for (const c of this._children) {
+			const found = c.findChild(name, true);
+			if (found) return found;
+		}
+		return null;
 	}
-	/** Drain the accumulated pointer delta (read once per frame). */
-	pointerDelta() {
-		const d = {
-			x: this.dx,
-			y: this.dy
+	/** Topmost ancestor (the node itself when detached). */
+	getRoot() {
+		let n = this;
+		while (n._parent) n = n._parent;
+		return n;
+	}
+	/** Depth-first search of THIS subtree for the node carrying `uid`. */
+	getNodeByUid(uid) {
+		if (this.uid === uid) return this;
+		for (const child of this.children) {
+			const found = child.getNodeByUid(uid);
+			if (found) return found;
+		}
+		return null;
+	}
+	/** Every node in THIS subtree named `name` — names repeat, so a list. */
+	getNodesByName(name) {
+		if (this._tree && this._parent === null) {
+			const set = this._tree._nodesNamed(name);
+			return set ? [...set] : [];
+		}
+		const out = [];
+		const walk = (node) => {
+			if (node.name === name) out.push(node);
+			for (const child of node.children) walk(child);
 		};
-		this.dx = 0;
-		this.dy = 0;
-		return d;
+		walk(this);
+		return out;
 	}
-	/** Drain the accumulated wheel delta. */
-	wheelDelta() {
-		const w = this.wheel;
-		this.wheel = 0;
-		return w;
+	getPath() {
+		const parts = [];
+		for (let n = this; n; n = n._parent) parts.unshift(n._name);
+		return `/${parts.join("/")}`;
+	}
+	getNode(path) {
+		const found = this.resolve(path);
+		if (found) return found;
+		throw new IncantoError("NODE_NOT_FOUND", `No node at '${path}' from '${this.getPath()}'. Children here: [${this._children.map((c) => c._name).join(", ")}].`);
+	}
+	getNodeOrNull(path) {
+		return this.resolve(path);
+	}
+	resolve(path) {
+		const parsed = parseNodePath(path);
+		if (parsed.kind === "unique") {
+			const tree = this._tree;
+			if (tree) {
+				const set = tree._nodesNamed(parsed.name);
+				if (!set || set.size === 0) return null;
+				if (set.size > 1) {
+					const paths = [];
+					for (const m of set) paths.push(m.getPath());
+					throw new IncantoError("DUPLICATE_UNIQUE_NAME", `'%${parsed.name}' is ambiguous: ${set.size} nodes named '${parsed.name}' (${paths.join(", ")}).`);
+				}
+				for (const m of set) return m;
+			}
+			const matches = [];
+			collectByName(this.getRoot(), parsed.name, matches);
+			if (matches.length > 1) throw new IncantoError("DUPLICATE_UNIQUE_NAME", `'%${parsed.name}' is ambiguous: ${matches.length} nodes named '${parsed.name}' (${matches.map((m) => m.getPath()).join(", ")}).`);
+			return matches[0] ?? null;
+		}
+		let current;
+		let segments = parsed.segments;
+		if (parsed.kind === "absolute") {
+			const root = this.getRoot();
+			if (segments[0] !== root._name && segments[0] !== "root") return null;
+			current = root;
+			segments = segments.slice(1);
+		} else current = this;
+		for (const seg of segments) {
+			if (!current) return null;
+			if (seg === "..") {
+				current = current._parent;
+				continue;
+			}
+			current = current._children.find((c) => c._name === seg) ?? null;
+		}
+		return current;
+	}
+	addToGroup(group) {
+		this._groups.add(group);
+	}
+	removeFromGroup(group) {
+		this._groups.delete(group);
+	}
+	isInGroup(group) {
+		return this._groups.has(group);
+	}
+	declaredSignals() {
+		if (!this._declared) {
+			this._declared = /* @__PURE__ */ new Set();
+			let ctor = this.constructor;
+			while (typeof ctor === "function") {
+				const own = ctor;
+				if (Object.hasOwn(ctor, "signals") && own.signals) for (const s of own.signals) this._declared.add(s);
+				ctor = Object.getPrototypeOf(ctor);
+			}
+		}
+		return this._declared;
+	}
+	/** Declare an ad-hoc signal on THIS instance (static `signals` covers types). */
+	declareSignal(name) {
+		this.declaredSignals().add(name);
+	}
+	/** Every signal this instance may emit (static + behavior + ad-hoc). */
+	declaredSignalNames() {
+		return [...this.declaredSignals()];
+	}
+	assertDeclared(name) {
+		if (this.declaredSignals().has(name)) return;
+		const ctor = this.constructor;
+		const declared = [...this.declaredSignals()];
+		throw new IncantoError("UNKNOWN_SIGNAL", `Unknown signal '${name}' on '${this.getPath()}' (${ctor.typeName}). Declared signals: [${declared.join(", ")}]. Declare it with "static signals = ['${name}']" on the node class or its behavior, or call node.declareSignal('${name}').`, {
+			signal: name,
+			path: this.getPath(),
+			nodeType: ctor.typeName,
+			validOptions: declared
+		});
+	}
+	/** Get the named DECLARED signal (creating its Signal object on demand). */
+	signal(name) {
+		this.assertDeclared(name);
+		let sig = this._signals.get(name);
+		if (!sig) {
+			sig = new Signal();
+			this._signals.set(name, sig);
+		}
+		return sig;
+	}
+	on(signal, fn, opts) {
+		return this.signal(signal).connect(fn, opts);
+	}
+	off(signal, fn) {
+		this._signals.get(signal)?.disconnect(fn);
+	}
+	emit(signal, ...args) {
+		this.assertDeclared(signal);
+		this._signals.get(signal)?.emit(...args);
+	}
+	/**
+	* Defer destruction to the end of the current update pass (flushed by the
+	* SceneTree). Frees immediately when detached from any tree.
+	*/
+	queueFree() {
+		if (this._tree) this._tree._queueFree(this);
+		else this.free();
+	}
+	/** Immediately detach and tear down this node and its children. */
+	free() {
+		const tree = this._tree;
+		for (const child of [...this._children]) child.free();
+		this._parent?.removeChild(this);
+		if (this._tree) this._propagateExitTree();
+		tree?._detachRoot(this);
+		for (const sig of this._signals.values()) sig.disconnectAll();
+		this._signals.clear();
+	}
+	/** @internal */
+	_propagateEnterTree(tree) {
+		this._tree = tree;
+		tree._indexName(this);
+		this.onEnterTree();
+		this.behavior?.onEnterTree?.();
+		for (const c of [...this._children]) if (c._tree !== tree) c._propagateEnterTree(tree);
+	}
+	/** @internal */
+	_propagateReady() {
+		for (const c of [...this._children]) if (c._tree) c._propagateReady();
+		if (!this._ready) {
+			this._ready = true;
+			this.onReady();
+			this.behavior?.onReady?.();
+		}
+	}
+	/** @internal */
+	_propagateExitTree() {
+		for (const c of [...this._children]) c._propagateExitTree();
+		this.onExitTree();
+		this.behavior?.onExitTree?.();
+		this._tree?._unindexName(this);
+		this._tree = null;
+	}
+	/** @internal */
+	_propagateUpdate(dt) {
+		if (!this.errored) try {
+			this.update(dt);
+		} catch (error) {
+			this._quarantine("update", error, "node");
+		}
+		if (this.behavior && !this.behaviorErrored) try {
+			this.behavior.update?.(dt);
+		} catch (error) {
+			this._quarantine("update", error, "behavior");
+		}
+		const kids = this._children;
+		for (let i = 0, n = kids.length; i < n; i++) kids[i]?._propagateUpdate(dt);
+	}
+	/** @internal */
+	_propagateFixedUpdate(dt) {
+		if (!this.errored) try {
+			this.fixedUpdate(dt);
+		} catch (error) {
+			this._quarantine("fixedUpdate", error, "node");
+		}
+		if (this.behavior && !this.behaviorErrored) try {
+			this.behavior.fixedUpdate?.(dt);
+		} catch (error) {
+			this._quarantine("fixedUpdate", error, "behavior");
+		}
+		const kids = this._children;
+		for (let i = 0, n = kids.length; i < n; i++) kids[i]?._propagateFixedUpdate(dt);
+	}
+	/**
+	* Report an engine-level problem about THIS node.
+	*
+	* Goes to `engine.log` (what the debug overlay, `runScript()` and any agent
+	* tool read) as well as the console. A `console.warn` alone is invisible to
+	* every channel except a human with devtools open.
+	*/
+	diagnose(level, ...parts) {
+		diagnose(this._tree?.engine ?? null, level, ...parts);
+	}
+	/**
+	* This node threw and is being skipped. Its CHILDREN still run.
+	*
+	* The alternative is what used to happen: the exception escaped into the rAF
+	* callback, the loop was never rescheduled, and the game froze — permanently,
+	* silently, with `stats().running` still reporting true. In a vibe-coded
+	* project the least-tested code in the repo is a behavior's `update`, so this
+	* is not an edge case; it is Tuesday.
+	*
+	* Set it back to false to try the node again (the debug overlay's "resume").
+	*/
+	errored = false;
+	/**
+	* This node's SCRIPT threw and is being skipped — the node itself still runs.
+	*
+	* A behavior is your code; the node is the engine's. A typo in the first must
+	* not switch off the second, or breaking a sword script stops the character
+	* from walking.
+	*/
+	behaviorErrored = false;
+	/**
+	* Report ONCE and stop running this node's own update.
+	*
+	* Once, because a behavior that throws throws every frame: sixty identical
+	* stack traces a second buries the one line that matters and costs more than
+	* the game did.
+	*/
+	_quarantine(phase, error, what) {
+		const where = `${this.getPath()} (${this.constructor.typeName ?? "Node"})`;
+		let message;
+		if (what === "behavior") {
+			this.behaviorErrored = true;
+			message = `[incanto] behavior '${this.behavior?.constructor.name ?? "?"}' on ${where} threw in ${phase} — THE SCRIPT is now skipped; the node itself and the rest of the scene keep running.`;
+		} else {
+			this.errored = true;
+			message = `[incanto] ${where} threw in ${phase} — this node is now SKIPPED. Its children and the rest of the scene keep running.`;
+		}
+		const engine = this._tree?.engine;
+		engine?.log.error(message, error);
+		engine?._nodeErrored(this);
+		console.error(message, error);
+	}
+	onEnterTree() {}
+	onReady() {}
+	onExitTree() {}
+	update(_dt) {}
+	fixedUpdate(_dt) {}
+};
+function collectByName(node, name, out) {
+	if (node.name === name) out.push(node);
+	for (const c of node.children) collectByName(c, name, out);
+}
+/**
+* Deterministic sibling auto-rename: keep the requested name when free,
+* otherwise increment its trailing number ('Enemy' → 'Enemy2', 'Enemy2' → 'Enemy3').
+*/
+function uniqueSiblingName(requested, siblings, self) {
+	const taken = new Set(siblings.filter((s) => s !== self).map((s) => s.name));
+	if (!taken.has(requested)) return requested;
+	const m = requested.match(/^(.*?)(\d+)$/);
+	const stem = m ? m[1] : requested;
+	let counter = m ? Number(m[2]) + 1 : 2;
+	while (taken.has(`${stem}${counter}`)) counter += 1;
+	return `${stem}${counter}`;
+}
+//#endregion
+//#region src/core/input.ts
+/** Keys typed into editable elements belong to the page UI, not the game. */
+function isEditableTarget(target) {
+	const el = target;
+	return !!el && (el.isContentEditable === true || el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT");
+}
+/**
+* Declarative input from scene JSON `input{}` — DOM-free logic (feed key state
+* via `handleKey`, or wire a browser with `attachKeyboard(window)`).
+*
+* Convention: vector2 follows the 2D y-down space (up = -y). `justPressed` /
+* `justReleased` are one-frame edges, settled by the Engine each tick.
+*/
+var InputMap = class {
+	actions = /* @__PURE__ */ new Map();
+	down = /* @__PURE__ */ new Set();
+	pressedEdge = /* @__PURE__ */ new Set();
+	releasedEdge = /* @__PURE__ */ new Set();
+	detach = null;
+	/** Load (or extend with) scene-JSON action declarations. Hard-validates shape. */
+	declare(decls) {
+		for (const [name, action] of parseInputDecls(decls)) this.actions.set(name, action);
+	}
+	/**
+	* Where the pointer is, in CANVAS pixels (top-left origin), or null when it
+	* has never been over the canvas.
+	*
+	* This is what a click-driven game asks for. `pointerDelta()` answers "how far
+	* did the mouse move" — the mouse-look question — and for a whole class of
+	* genres that is the wrong question and the only one the engine could answer.
+	* Pair it with `renderer.pick(x, y)` to get the node under the cursor.
+	*/
+	pointerPosition() {
+		return this.pointerPos ? { ...this.pointerPos } : null;
+	}
+	/**
+	* @internal Feed a pointer position. `target` scales client → canvas pixels
+	* so a CSS-stretched canvas still reports coordinates its renderer can use.
+	*/
+	setPointerPosition(clientX, clientY, target) {
+		const rect = target?.getBoundingClientRect?.();
+		if (!rect || rect.width === 0 || rect.height === 0) {
+			this.pointerPos = {
+				x: clientX,
+				y: clientY
+			};
+			return;
+		}
+		this.pointerPos = {
+			x: clientX - rect.left,
+			y: clientY - rect.top
+		};
+	}
+	pointerPos = null;
+	/** Feed a key state change (code = KeyboardEvent.code, e.g. 'Space', 'KeyW'). */
+	handleKey(code, isDown) {
+		if (isDown) {
+			if (!this.down.has(code)) {
+				this.down.add(code);
+				this.pressedEdge.add(code);
+			}
+		} else if (this.down.has(code)) {
+			this.down.delete(code);
+			this.releasedEdge.add(code);
+		}
+	}
+	injectedDown = /* @__PURE__ */ new Set();
+	injectedPressed = /* @__PURE__ */ new Set();
+	injectedReleased = /* @__PURE__ */ new Set();
+	injectedVectors = /* @__PURE__ */ new Map();
+	/**
+	* Press a button ACTION directly — no key codes involved. This is how
+	* scripted gameplay tests and touch buttons drive the game by intent
+	* (`press('jump')`) instead of reverse-engineering keybinds.
+	*/
+	/**
+	* Every action this scene declared, with its kind.
+	*
+	* A scene states its own control vocabulary in `input{}`, which means a tool
+	* can drive a game it has never seen — the automated playtester's entire
+	* premise. Nothing else could ask: `actions` was private.
+	*/
+	declaredActions() {
+		const out = [];
+		for (const [name, def] of this.actions) out.push({
+			name,
+			type: def.type
+		});
+		return out;
+	}
+	pressAction(action) {
+		this.button(action);
+		if (!this.injectedDown.has(action)) {
+			this.injectedDown.add(action);
+			this.injectedPressed.add(action);
+		}
+	}
+	/** Release an injected button action (yields one justReleased frame). */
+	releaseAction(action) {
+		this.button(action);
+		if (this.injectedDown.delete(action)) this.injectedReleased.add(action);
+	}
+	/**
+	* Feed an analog direction for a vector2 ACTION — virtual joysticks and
+	* scripted runs. Persists until replaced; (0, 0) clears the injection.
+	* Combines with key state in getVector (clamped to unit length).
+	*/
+	setActionVector(action, x, y) {
+		if (this.get(action).type !== "vector2") throw new IncantoError("BAD_FORMAT", `Input action '${action}' is a button — use pressAction/releaseAction, not setActionVector.`);
+		if (!Number.isFinite(x) || !Number.isFinite(y)) throw new IncantoError("BAD_FORMAT", `setActionVector('${action}') needs finite numbers, got (${x}, ${y}).`);
+		if (x === 0 && y === 0) this.injectedVectors.delete(action);
+		else this.injectedVectors.set(action, {
+			x,
+			y
+		});
+	}
+	/**
+	* Actions the scene wants on-screen touch controls for, in declaration
+	* order (`"touch": "joystick"` on vector2, `"touch": "button"` on buttons).
+	* The touch overlay (core/touch.ts) renders these.
+	*/
+	touchControls() {
+		const out = [];
+		for (const [name, def] of this.actions) if (def.touch) out.push({
+			action: name,
+			kind: def.touch
+		});
+		return out;
+	}
+	/** Drop all injected action state (held buttons, vectors, pending edges). */
+	clearInjected() {
+		this.injectedDown.clear();
+		this.injectedPressed.clear();
+		this.injectedReleased.clear();
+		this.injectedVectors.clear();
+	}
+	dx = 0;
+	dy = 0;
+	wheel = 0;
+	/** Mouse buttons feed the same code space as keys: Mouse0/Mouse1/Mouse2. */
+	handleMouseButton(button, isDown) {
+		this.handleKey(`Mouse${button}`, isDown);
+	}
+	/** Accumulate look deltas (movementX/Y under pointer lock, else move deltas). */
+	handlePointerMove(dx, dy) {
+		this.dx += dx;
+		this.dy += dy;
+	}
+	handleWheel(deltaY) {
+		this.wheel += deltaY;
+	}
+	/** Drain the accumulated pointer delta (read once per frame). */
+	pointerDelta() {
+		const d = {
+			x: this.dx,
+			y: this.dy
+		};
+		this.dx = 0;
+		this.dy = 0;
+		return d;
+	}
+	/** Drain the accumulated wheel delta. */
+	wheelDelta() {
+		const w = this.wheel;
+		this.wheel = 0;
+		return w;
 	}
 	/**
 	* Wire browser pointer events on a canvas: buttons → Mouse0/1/2 codes,
@@ -867,567 +1252,182 @@ function captureBehaviors(root, source) {
 /** Every uid the scene FILE declares, in document order. */
 function authoredUids(source) {
 	const out = [];
-	const walk = (node) => {
-		if (typeof node !== "object" || node === null) return;
-		const n = node;
-		if (typeof n.uid === "string" && n.uid !== "") out.push(n.uid);
-		if (Array.isArray(n.children)) for (const child of n.children) walk(child);
-	};
-	walk(source.root);
-	return out;
-}
-/**
-* Hand each behavior its state back.
-*
-* Call this AFTER the scene has loaded and `onReady` has run: `onReady` is where
-* a behavior sets its starting values, so restoring first would be overwritten
-* by the fresh start.
-*
-* Never throws on a mismatch. A save from an older build of the game will name
-* uids that no longer exist, and refusing to load it would mean a patch that
-* moves one node deletes everyone's progress. It reports instead.
-*/
-function restoreBehaviors(root, state) {
-	const report = {
-		missing: [],
-		skipped: [],
-		restored: 0,
-		expected: captureBehaviors(root).saveable,
-		freed: 0
-	};
-	for (const [uid, value] of Object.entries(state)) {
-		if (uid === "#freed") {
-			for (const gone of value ?? []) {
-				const node = root.getNodeByUid(gone);
-				if (node) {
-					node.queueFree();
-					report.freed += 1;
-				}
-			}
-			continue;
-		}
-		const node = root.getNodeByUid(uid);
-		if (!node) {
-			report.missing.push(uid);
-			continue;
-		}
-		const behavior = node.behavior;
-		if (!behavior || typeof behavior.deserialize !== "function") {
-			report.skipped.push(uid);
-			continue;
-		}
-		try {
-			behavior.deserialize(value);
-			report.restored += 1;
-		} catch {
-			report.skipped.push(uid);
-		}
-	}
-	return report;
-}
-/** Slot ids, so a "3 save slots" menu is a list and not a naming convention. */
-const INDEX_KEY = "slots";
-/**
-* The slot layer: a named list of saves over the existing store.
-*
-* Slot ids are yours (`'auto'`, `'1'`, `'2'`, `'3'`) — the engine does not
-* decide how many you have or whether one of them autosaves.
-*/
-var SaveSlots = class {
-	store;
-	constructor(namespace = "saves", store) {
-		this.store = store ?? createSaveStore(namespace);
-	}
-	/** Slot ids that have a save, newest first. */
-	list() {
-		const rows = this.store.get(INDEX_KEY, []).map((id) => ({
-			id,
-			slot: this.read(id)
-		})).filter((row) => row.slot !== null);
-		rows.sort((a, b) => b.slot.savedAt - a.slot.savedAt);
-		return rows.map((row) => row.id);
-	}
-	/** Every slot with its contents — what a load menu actually renders. */
-	all() {
-		return this.list().map((id) => ({
-			id,
-			...this.read(id)
-		}));
-	}
-	read(id) {
-		const raw = this.store.get(key(id), null);
-		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
-		const slot = raw;
-		if (typeof slot.scene !== "string" || typeof slot.state !== "object" || slot.state === null) return null;
-		return {
-			scene: slot.scene,
-			state: slot.state,
-			label: typeof slot.label === "string" ? slot.label : "",
-			savedAt: typeof slot.savedAt === "number" ? slot.savedAt : 0,
-			playtime: typeof slot.playtime === "number" ? slot.playtime : 0,
-			data: slot.data ?? {}
-		};
-	}
-	/**
-	* Write a slot.
-	*
-	* `savedAt` is a parameter rather than `Date.now()` so a test can assert an
-	* ordering without sleeping, and so a game that wants server time can use it.
-	*/
-	write(id, slot) {
-		const full = {
-			scene: slot.scene,
-			state: slot.state,
-			label: slot.label ?? "",
-			savedAt: slot.savedAt ?? 0,
-			playtime: slot.playtime ?? 0,
-			data: slot.data ?? {}
-		};
-		this.store.set(key(id), full);
-		const ids = this.store.get(INDEX_KEY, []);
-		if (!ids.includes(id)) this.store.set(INDEX_KEY, [...ids, id]);
-	}
-	remove(id) {
-		this.store.remove(key(id));
-		this.store.set(INDEX_KEY, this.store.get(INDEX_KEY, []).filter((other) => other !== id));
-	}
-	/** Wipe every slot — a "delete all data" button, and test isolation. */
-	clear() {
-		for (const id of this.store.get(INDEX_KEY, [])) this.store.remove(key(id));
-		this.store.set(INDEX_KEY, []);
-	}
-};
-function key(id) {
-	return `slot:${id}`;
-}
-/**
-* Behaviors in this tree that hold state and cannot save it — the audit's
-* question, answerable before a player loses an hour.
-*
-* A behavior with props but no `serialize` is not necessarily wrong (an
-* `Oscillate` derives everything from time), so this reports rather than warns,
-* and the caller decides.
-*/
-function behaviorsWithoutSave(root) {
-	const out = [];
-	const walk = (node) => {
-		const behavior = node.behavior;
-		const name = node.script?.name;
-		if (behavior && typeof name === "string" && typeof behavior.serialize !== "function") {
-			if (Object.keys(behaviorSchema(name)).length > 0) out.push(`${node.getPath()} (${name})`);
-		}
-		for (const child of node.children) walk(child);
-	};
-	walk(root);
-	return out;
-}
-/**
-* Behaviors that DO save, on nodes with no uid to save them under — the state
-* that goes nowhere.
-*
-* `incanto-check` warns about the built-ins it can recognise from the JSON
-* (Health, ScoreKeeper, Collector), but a scene file cannot be asked whether
-* YOUR behavior has a `serialize`. This can: it walks the live tree, so a quest
-* log or a wallet of your own is named too.
-*
-* The pair to read before shipping: `behaviorsWithoutSave` is "did you forget
-* to write serialize", this is "did you forget the uid that makes it count".
-*/
-function savesWithoutUid(root) {
-	const out = [];
-	const walk = (node) => {
-		const behavior = node.behavior;
-		const name = node.script?.name;
-		if (behavior && typeof behavior.serialize === "function" && !node.uid) out.push(`${node.getPath()} (${name ?? "behavior"})`);
-		for (const child of node.children) walk(child);
+	const walk = (node) => {
+		if (typeof node !== "object" || node === null) return;
+		const n = node;
+		if (typeof n.uid === "string" && n.uid !== "") out.push(n.uid);
+		if (Array.isArray(n.children)) for (const child of n.children) walk(child);
 	};
-	walk(root);
+	walk(source.root);
 	return out;
 }
-//#endregion
-//#region src/core/node.ts
-function validateName(name) {
-	if (name === "" || name.includes("/") || name.includes("%")) throw new IncantoError("TREE_VIOLATION", `Invalid node name '${name}'. Names must be non-empty and must not contain '/' or '%'.`);
-}
 /**
-* Base class of everything in an Incanto scene (Godot's Node model).
+* Hand each behavior its state back.
 *
-* Pure data + tree structure: no rendering, no DOM, no three.js — renderer
-* adapters subscribe from the outside.
+* Call this AFTER the scene has loaded and `onReady` has run: `onReady` is where
+* a behavior sets its starting values, so restoring first would be overwritten
+* by the fresh start.
+*
+* Never throws on a mismatch. A save from an older build of the game will name
+* uids that no longer exist, and refusing to load it would mean a patch that
+* moves one node deletes everyone's progress. It reports instead.
 */
-var Node = class {
-	static typeName = "Node";
-	_name;
-	_parent = null;
-	_children = [];
-	_groups = /* @__PURE__ */ new Set();
-	_signals = /* @__PURE__ */ new Map();
-	_declared = null;
-	_tree = null;
-	_ready = false;
-	/**
-	* Optional STABLE identifier (scene JSON `uid`) — unlike names (unique only
-	* among siblings) a uid is unique across the whole scene, so scripts and
-	* tools can address a node no matter where it moves.
-	*/
-	uid = null;
-	/** Free-form JSON identity for game logic (e.g. `{kind: 'ITEM', value: 10}`). */
-	tags = {};
-	/** Behavior attachment blob from scene JSON (resolved by the loader). */
-	script = null;
-	/** The resolved behavior instance (set by the loader from `script`). */
-	behavior = null;
-	/** Replication config blob from scene JSON (interpreted in M6; preserved until then). */
-	network = null;
-	constructor(name) {
-		const ctor = this.constructor;
-		this._name = name ?? ctor.typeName;
-		validateName(this._name);
-	}
-	get name() {
-		return this._name;
-	}
-	set name(value) {
-		validateName(value);
-		const old = this._name;
-		if (this._parent) this._name = uniqueSiblingName(value, this._parent._children, this);
-		else this._name = value;
-		if (this._tree && this._name !== old) this._tree._reindexName(this, old);
-	}
-	get parent() {
-		return this._parent;
-	}
-	get children() {
-		return this._children;
-	}
-	get groups() {
-		return this._groups;
-	}
-	/** The SceneTree this node is attached to, or null while detached. */
-	get tree() {
-		return this._tree;
-	}
-	/** Whether onReady has run (it runs at most once per instance). */
-	get isReady() {
-		return this._ready;
-	}
-	addChild(child) {
-		if (child._parent !== null) throw new IncantoError("TREE_VIOLATION", `Cannot add '${child.name}': it already has parent '${child._parent.name}'. removeChild/reparent first.`);
-		for (let n = this; n; n = n._parent) if (n === child) throw new IncantoError("TREE_VIOLATION", `Cannot add '${child.name}' to '${this.name}': it is this node or an ancestor (cycle).`);
-		child._name = uniqueSiblingName(child._name, this._children, child);
-		child._parent = this;
-		this._children.push(child);
-		if (this._tree) {
-			child._propagateEnterTree(this._tree);
-			child._propagateReady();
-		}
-		return child;
-	}
-	removeChild(child) {
-		const i = this._children.indexOf(child);
-		if (i === -1) throw new IncantoError("TREE_VIOLATION", `'${child.name}' is not a child of '${this.name}'.`);
-		if (child._tree) child._propagateExitTree();
-		this._children.splice(i, 1);
-		child._parent = null;
-	}
-	reparent(newParent) {
-		this._parent?.removeChild(this);
-		newParent.addChild(this);
-	}
-	findChild(name, recursive = true) {
-		for (const c of this._children) if (c._name === name) return c;
-		if (recursive) for (const c of this._children) {
-			const found = c.findChild(name, true);
-			if (found) return found;
-		}
-		return null;
-	}
-	/** Topmost ancestor (the node itself when detached). */
-	getRoot() {
-		let n = this;
-		while (n._parent) n = n._parent;
-		return n;
-	}
-	/** Depth-first search of THIS subtree for the node carrying `uid`. */
-	getNodeByUid(uid) {
-		if (this.uid === uid) return this;
-		for (const child of this.children) {
-			const found = child.getNodeByUid(uid);
-			if (found) return found;
-		}
-		return null;
-	}
-	/** Every node in THIS subtree named `name` — names repeat, so a list. */
-	getNodesByName(name) {
-		if (this._tree && this._parent === null) {
-			const set = this._tree._nodesNamed(name);
-			return set ? [...set] : [];
-		}
-		const out = [];
-		const walk = (node) => {
-			if (node.name === name) out.push(node);
-			for (const child of node.children) walk(child);
-		};
-		walk(this);
-		return out;
-	}
-	getPath() {
-		const parts = [];
-		for (let n = this; n; n = n._parent) parts.unshift(n._name);
-		return `/${parts.join("/")}`;
-	}
-	getNode(path) {
-		const found = this.resolve(path);
-		if (found) return found;
-		throw new IncantoError("NODE_NOT_FOUND", `No node at '${path}' from '${this.getPath()}'. Children here: [${this._children.map((c) => c._name).join(", ")}].`);
-	}
-	getNodeOrNull(path) {
-		return this.resolve(path);
-	}
-	resolve(path) {
-		const parsed = parseNodePath(path);
-		if (parsed.kind === "unique") {
-			const tree = this._tree;
-			if (tree) {
-				const set = tree._nodesNamed(parsed.name);
-				if (!set || set.size === 0) return null;
-				if (set.size > 1) {
-					const paths = [];
-					for (const m of set) paths.push(m.getPath());
-					throw new IncantoError("DUPLICATE_UNIQUE_NAME", `'%${parsed.name}' is ambiguous: ${set.size} nodes named '${parsed.name}' (${paths.join(", ")}).`);
+function restoreBehaviors(root, state) {
+	const report = {
+		missing: [],
+		skipped: [],
+		restored: 0,
+		expected: captureBehaviors(root).saveable,
+		freed: 0
+	};
+	for (const [uid, value] of Object.entries(state)) {
+		if (uid === "#freed") {
+			for (const gone of value ?? []) {
+				const node = root.getNodeByUid(gone);
+				if (node) {
+					node.queueFree();
+					report.freed += 1;
 				}
-				for (const m of set) return m;
 			}
-			const matches = [];
-			collectByName(this.getRoot(), parsed.name, matches);
-			if (matches.length > 1) throw new IncantoError("DUPLICATE_UNIQUE_NAME", `'%${parsed.name}' is ambiguous: ${matches.length} nodes named '${parsed.name}' (${matches.map((m) => m.getPath()).join(", ")}).`);
-			return matches[0] ?? null;
+			continue;
 		}
-		let current;
-		let segments = parsed.segments;
-		if (parsed.kind === "absolute") {
-			const root = this.getRoot();
-			if (segments[0] !== root._name && segments[0] !== "root") return null;
-			current = root;
-			segments = segments.slice(1);
-		} else current = this;
-		for (const seg of segments) {
-			if (!current) return null;
-			if (seg === "..") {
-				current = current._parent;
-				continue;
-			}
-			current = current._children.find((c) => c._name === seg) ?? null;
+		const node = root.getNodeByUid(uid);
+		if (!node) {
+			report.missing.push(uid);
+			continue;
 		}
-		return current;
-	}
-	addToGroup(group) {
-		this._groups.add(group);
-	}
-	removeFromGroup(group) {
-		this._groups.delete(group);
-	}
-	isInGroup(group) {
-		return this._groups.has(group);
-	}
-	declaredSignals() {
-		if (!this._declared) {
-			this._declared = /* @__PURE__ */ new Set();
-			let ctor = this.constructor;
-			while (typeof ctor === "function") {
-				const own = ctor;
-				if (Object.hasOwn(ctor, "signals") && own.signals) for (const s of own.signals) this._declared.add(s);
-				ctor = Object.getPrototypeOf(ctor);
-			}
+		const behavior = node.behavior;
+		if (!behavior || typeof behavior.deserialize !== "function") {
+			report.skipped.push(uid);
+			continue;
 		}
-		return this._declared;
-	}
-	/** Declare an ad-hoc signal on THIS instance (static `signals` covers types). */
-	declareSignal(name) {
-		this.declaredSignals().add(name);
-	}
-	/** Every signal this instance may emit (static + behavior + ad-hoc). */
-	declaredSignalNames() {
-		return [...this.declaredSignals()];
-	}
-	assertDeclared(name) {
-		if (this.declaredSignals().has(name)) return;
-		const ctor = this.constructor;
-		const declared = [...this.declaredSignals()];
-		throw new IncantoError("UNKNOWN_SIGNAL", `Unknown signal '${name}' on '${this.getPath()}' (${ctor.typeName}). Declared signals: [${declared.join(", ")}]. Declare it with "static signals = ['${name}']" on the node class or its behavior, or call node.declareSignal('${name}').`, {
-			signal: name,
-			path: this.getPath(),
-			nodeType: ctor.typeName,
-			validOptions: declared
-		});
-	}
-	/** Get the named DECLARED signal (creating its Signal object on demand). */
-	signal(name) {
-		this.assertDeclared(name);
-		let sig = this._signals.get(name);
-		if (!sig) {
-			sig = new Signal();
-			this._signals.set(name, sig);
+		try {
+			behavior.deserialize(value);
+			report.restored += 1;
+		} catch {
+			report.skipped.push(uid);
 		}
-		return sig;
-	}
-	on(signal, fn, opts) {
-		return this.signal(signal).connect(fn, opts);
-	}
-	off(signal, fn) {
-		this._signals.get(signal)?.disconnect(fn);
-	}
-	emit(signal, ...args) {
-		this.assertDeclared(signal);
-		this._signals.get(signal)?.emit(...args);
-	}
-	/**
-	* Defer destruction to the end of the current update pass (flushed by the
-	* SceneTree). Frees immediately when detached from any tree.
-	*/
-	queueFree() {
-		if (this._tree) this._tree._queueFree(this);
-		else this.free();
-	}
-	/** Immediately detach and tear down this node and its children. */
-	free() {
-		const tree = this._tree;
-		for (const child of [...this._children]) child.free();
-		this._parent?.removeChild(this);
-		if (this._tree) this._propagateExitTree();
-		tree?._detachRoot(this);
-		for (const sig of this._signals.values()) sig.disconnectAll();
-		this._signals.clear();
-	}
-	/** @internal */
-	_propagateEnterTree(tree) {
-		this._tree = tree;
-		tree._indexName(this);
-		this.onEnterTree();
-		this.behavior?.onEnterTree?.();
-		for (const c of [...this._children]) if (c._tree !== tree) c._propagateEnterTree(tree);
 	}
-	/** @internal */
-	_propagateReady() {
-		for (const c of [...this._children]) if (c._tree) c._propagateReady();
-		if (!this._ready) {
-			this._ready = true;
-			this.onReady();
-			this.behavior?.onReady?.();
-		}
+	return report;
+}
+/** Slot ids, so a "3 save slots" menu is a list and not a naming convention. */
+const INDEX_KEY = "slots";
+/**
+* The slot layer: a named list of saves over the existing store.
+*
+* Slot ids are yours (`'auto'`, `'1'`, `'2'`, `'3'`) — the engine does not
+* decide how many you have or whether one of them autosaves.
+*/
+var SaveSlots = class {
+	store;
+	constructor(namespace = "saves", store) {
+		this.store = store ?? createSaveStore(namespace);
 	}
-	/** @internal */
-	_propagateExitTree() {
-		for (const c of [...this._children]) c._propagateExitTree();
-		this.onExitTree();
-		this.behavior?.onExitTree?.();
-		this._tree?._unindexName(this);
-		this._tree = null;
+	/** Slot ids that have a save, newest first. */
+	list() {
+		const rows = this.store.get(INDEX_KEY, []).map((id) => ({
+			id,
+			slot: this.read(id)
+		})).filter((row) => row.slot !== null);
+		rows.sort((a, b) => b.slot.savedAt - a.slot.savedAt);
+		return rows.map((row) => row.id);
 	}
-	/** @internal */
-	_propagateUpdate(dt) {
-		if (!this.errored) try {
-			this.update(dt);
-		} catch (error) {
-			this._quarantine("update", error, "node");
-		}
-		if (this.behavior && !this.behaviorErrored) try {
-			this.behavior.update?.(dt);
-		} catch (error) {
-			this._quarantine("update", error, "behavior");
-		}
-		const kids = this._children;
-		for (let i = 0, n = kids.length; i < n; i++) kids[i]?._propagateUpdate(dt);
+	/** Every slot with its contents — what a load menu actually renders. */
+	all() {
+		return this.list().map((id) => ({
+			id,
+			...this.read(id)
+		}));
 	}
-	/** @internal */
-	_propagateFixedUpdate(dt) {
-		if (!this.errored) try {
-			this.fixedUpdate(dt);
-		} catch (error) {
-			this._quarantine("fixedUpdate", error, "node");
-		}
-		if (this.behavior && !this.behaviorErrored) try {
-			this.behavior.fixedUpdate?.(dt);
-		} catch (error) {
-			this._quarantine("fixedUpdate", error, "behavior");
-		}
-		const kids = this._children;
-		for (let i = 0, n = kids.length; i < n; i++) kids[i]?._propagateFixedUpdate(dt);
+	read(id) {
+		const raw = this.store.get(key(id), null);
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+		const slot = raw;
+		if (typeof slot.scene !== "string" || typeof slot.state !== "object" || slot.state === null) return null;
+		return {
+			scene: slot.scene,
+			state: slot.state,
+			label: typeof slot.label === "string" ? slot.label : "",
+			savedAt: typeof slot.savedAt === "number" ? slot.savedAt : 0,
+			playtime: typeof slot.playtime === "number" ? slot.playtime : 0,
+			data: slot.data ?? {}
+		};
 	}
 	/**
-	* Report an engine-level problem about THIS node.
+	* Write a slot.
 	*
-	* Goes to `engine.log` (what the debug overlay, `runScript()` and any agent
-	* tool read) as well as the console. A `console.warn` alone is invisible to
-	* every channel except a human with devtools open.
+	* `savedAt` is a parameter rather than `Date.now()` so a test can assert an
+	* ordering without sleeping, and so a game that wants server time can use it.
 	*/
-	diagnose(level, ...parts) {
-		diagnose(this._tree?.engine ?? null, level, ...parts);
+	write(id, slot) {
+		const full = {
+			scene: slot.scene,
+			state: slot.state,
+			label: slot.label ?? "",
+			savedAt: slot.savedAt ?? 0,
+			playtime: slot.playtime ?? 0,
+			data: slot.data ?? {}
+		};
+		this.store.set(key(id), full);
+		const ids = this.store.get(INDEX_KEY, []);
+		if (!ids.includes(id)) this.store.set(INDEX_KEY, [...ids, id]);
 	}
-	/**
-	* This node threw and is being skipped. Its CHILDREN still run.
-	*
-	* The alternative is what used to happen: the exception escaped into the rAF
-	* callback, the loop was never rescheduled, and the game froze — permanently,
-	* silently, with `stats().running` still reporting true. In a vibe-coded
-	* project the least-tested code in the repo is a behavior's `update`, so this
-	* is not an edge case; it is Tuesday.
-	*
-	* Set it back to false to try the node again (the debug overlay's "resume").
-	*/
-	errored = false;
-	/**
-	* This node's SCRIPT threw and is being skipped — the node itself still runs.
-	*
-	* A behavior is your code; the node is the engine's. A typo in the first must
-	* not switch off the second, or breaking a sword script stops the character
-	* from walking.
-	*/
-	behaviorErrored = false;
-	/**
-	* Report ONCE and stop running this node's own update.
-	*
-	* Once, because a behavior that throws throws every frame: sixty identical
-	* stack traces a second buries the one line that matters and costs more than
-	* the game did.
-	*/
-	_quarantine(phase, error, what) {
-		const where = `${this.getPath()} (${this.constructor.typeName ?? "Node"})`;
-		let message;
-		if (what === "behavior") {
-			this.behaviorErrored = true;
-			message = `[incanto] behavior '${this.behavior?.constructor.name ?? "?"}' on ${where} threw in ${phase} — THE SCRIPT is now skipped; the node itself and the rest of the scene keep running.`;
-		} else {
-			this.errored = true;
-			message = `[incanto] ${where} threw in ${phase} — this node is now SKIPPED. Its children and the rest of the scene keep running.`;
-		}
-		const engine = this._tree?.engine;
-		engine?.log.error(message, error);
-		engine?._nodeErrored(this);
-		console.error(message, error);
+	remove(id) {
+		this.store.remove(key(id));
+		this.store.set(INDEX_KEY, this.store.get(INDEX_KEY, []).filter((other) => other !== id));
+	}
+	/** Wipe every slot — a "delete all data" button, and test isolation. */
+	clear() {
+		for (const id of this.store.get(INDEX_KEY, [])) this.store.remove(key(id));
+		this.store.set(INDEX_KEY, []);
 	}
-	onEnterTree() {}
-	onReady() {}
-	onExitTree() {}
-	update(_dt) {}
-	fixedUpdate(_dt) {}
 };
-function collectByName(node, name, out) {
-	if (node.name === name) out.push(node);
-	for (const c of node.children) collectByName(c, name, out);
+function key(id) {
+	return `slot:${id}`;
 }
 /**
-* Deterministic sibling auto-rename: keep the requested name when free,
-* otherwise increment its trailing number ('Enemy' → 'Enemy2', 'Enemy2' → 'Enemy3').
+* Behaviors in this tree that hold state and cannot save it — the audit's
+* question, answerable before a player loses an hour.
+*
+* A behavior with props but no `serialize` is not necessarily wrong (an
+* `Oscillate` derives everything from time), so this reports rather than warns,
+* and the caller decides.
 */
-function uniqueSiblingName(requested, siblings, self) {
-	const taken = new Set(siblings.filter((s) => s !== self).map((s) => s.name));
-	if (!taken.has(requested)) return requested;
-	const m = requested.match(/^(.*?)(\d+)$/);
-	const stem = m ? m[1] : requested;
-	let counter = m ? Number(m[2]) + 1 : 2;
-	while (taken.has(`${stem}${counter}`)) counter += 1;
-	return `${stem}${counter}`;
+function behaviorsWithoutSave(root) {
+	const out = [];
+	const walk = (node) => {
+		const behavior = node.behavior;
+		const name = node.script?.name;
+		if (behavior && typeof name === "string" && typeof behavior.serialize !== "function") {
+			if (Object.keys(behaviorSchema(name)).length > 0) out.push(`${node.getPath()} (${name})`);
+		}
+		for (const child of node.children) walk(child);
+	};
+	walk(root);
+	return out;
+}
+/**
+* Behaviors that DO save, on nodes with no uid to save them under — the state
+* that goes nowhere.
+*
+* `incanto-check` warns about the built-ins it can recognise from the JSON
+* (Health, ScoreKeeper, Collector), but a scene file cannot be asked whether
+* YOUR behavior has a `serialize`. This can: it walks the live tree, so a quest
+* log or a wallet of your own is named too.
+*
+* The pair to read before shipping: `behaviorsWithoutSave` is "did you forget
+* to write serialize", this is "did you forget the uid that makes it count".
+*/
+function savesWithoutUid(root) {
+	const out = [];
+	const walk = (node) => {
+		const behavior = node.behavior;
+		const name = node.script?.name;
+		if (behavior && typeof behavior.serialize === "function" && !node.uid) out.push(`${node.getPath()} (${name ?? "behavior"})`);
+		for (const child of node.children) walk(child);
+	};
+	walk(root);
+	return out;
 }
 //#endregion
 //#region src/core/scene/constants.ts
@@ -2066,4 +2066,4 @@ function validateUniqueUids(root) {
 	walk(root);
 }
 //#endregion
-export { registerBehavior as A, diagnose as C, behaviorSignals as D, behaviorSchema as E, Signal as M, clearBehaviors as O, InputMap as S, Behavior as T, savesWithoutUid as _, SCENE_FORMAT as a, effectiveOrder as b, SceneTree as c, resolveConstants as d, Node as f, restoreBehaviors as g, captureBehaviors as h, serializeNode as i, registeredBehaviors as j, getBehavior as k, CONST_REF_KEY as l, behaviorsWithoutSave as m, loadScene as n, computeViewport as o, SaveSlots as p, Scene as r, resolveViewport as s, buildNodeJson as t, isConstRef as u, createSaveStore as v, parseNodePath as w, resolveOrderGroups as x, ORDER_GROUP_BASE as y };
+export { registerBehavior as A, diagnose as C, behaviorSignals as D, behaviorSchema as E, Signal as M, clearBehaviors as O, Node as S, Behavior as T, createSaveStore as _, SCENE_FORMAT as a, resolveOrderGroups as b, SceneTree as c, resolveConstants as d, SaveSlots as f, savesWithoutUid as g, restoreBehaviors as h, serializeNode as i, registeredBehaviors as j, getBehavior as k, CONST_REF_KEY as l, captureBehaviors as m, loadScene as n, computeViewport as o, behaviorsWithoutSave as p, Scene as r, resolveViewport as s, buildNodeJson as t, isConstRef as u, ORDER_GROUP_BASE as v, parseNodePath as w, InputMap as x, effectiveOrder as y };