incanto 0.30.0 → 0.32.0

package/dist/{loader-BZqOKfI2.js → loader-BlaRQGaA.js}

@@ -1,6 +1,6 @@
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
-import { c as mergeStaticSignals, i as getNodeSchema, r as createNode, s as mergeStaticProps, t as applySchemaProps } from "./registry-BVJ2HbCn.js";
+import { c as mergeStaticSignals, i as getNodeSchema, r as createNode, s as mergeStaticProps, t as applySchemaProps } from "./registry-CJdGpT2V.js";
 //#region src/core/signal.ts
 var Signal = class {
 	connections = [];
@@ -118,6 +118,402 @@ function createBehavior(name, props) {
 	return behavior;
 }
 //#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);
+	}
+	/** 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.
+	*/
+	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,
+	* movement → pointerDelta (movementX/Y so pointer lock just works),
+	* wheel → wheelDelta. `lockOnClick` requests pointer lock on mousedown
+	* (the FPS pattern).
+	*/
+	padAxesState = {
+		lx: 0,
+		ly: 0,
+		rx: 0,
+		ry: 0
+	};
+	padButtonsDown = 0;
+	/**
+	* Feed one polled gamepad snapshot (standard mapping). Buttons become
+	* codes `Pad0`..`Pad16` in the same space as keys — declare them in input
+	* actions like any key ("jump": ["Space", "Pad0"]). Axes land in
+	* `padAxes()` with a deadzone. Pass null when no pad is connected.
+	*/
+	pollGamepad(pad) {
+		const dead = .15;
+		const shape = (v) => Math.abs(v) < dead ? 0 : v;
+		if (!pad) {
+			for (let i = 0; i < 17; i++) if (this.padButtonsDown & 1 << i) this.handleKey(`Pad${i}`, false);
+			this.padButtonsDown = 0;
+			this.padAxesState.lx = 0;
+			this.padAxesState.ly = 0;
+			this.padAxesState.rx = 0;
+			this.padAxesState.ry = 0;
+			return;
+		}
+		for (let i = 0; i < Math.min(17, pad.buttons.length); i++) {
+			const down = pad.buttons[i]?.pressed === true;
+			if (down !== ((this.padButtonsDown & 1 << i) !== 0)) {
+				this.handleKey(`Pad${i}`, down);
+				this.padButtonsDown = down ? this.padButtonsDown | 1 << i : this.padButtonsDown & ~(1 << i);
+			}
+		}
+		this.padAxesState.lx = shape(pad.axes[0] ?? 0);
+		this.padAxesState.ly = shape(pad.axes[1] ?? 0);
+		this.padAxesState.rx = shape(pad.axes[2] ?? 0);
+		this.padAxesState.ry = shape(pad.axes[3] ?? 0);
+	}
+	/** Deadzoned analog sticks: 0 = left {x,y}, 1 = right. */
+	padAxes(stick = 0) {
+		return stick === 0 ? {
+			x: this.padAxesState.lx,
+			y: this.padAxesState.ly
+		} : {
+			x: this.padAxesState.rx,
+			y: this.padAxesState.ry
+		};
+	}
+	/**
+	* Poll the browser Gamepad API every frame (the first connected pad).
+	* Wire once at boot: `engine.input.attachGamepad(engine)`. Headless no-op.
+	*/
+	attachGamepad(engine) {
+		if (typeof navigator === "undefined" || typeof navigator.getGamepads !== "function") return () => {};
+		const disconnect = engine.updated.connect(() => {
+			const pads = navigator.getGamepads();
+			let pad = null;
+			for (const p of pads) if (p?.connected) {
+				pad = p;
+				break;
+			}
+			this.pollGamepad(pad);
+		});
+		const prev = this.detach;
+		this.detach = () => {
+			prev?.();
+			disconnect();
+		};
+		return disconnect;
+	}
+	attachPointer(target, opts) {
+		let buttonsHeld = 0;
+		const onDown = (e) => {
+			buttonsHeld++;
+			this.handleMouseButton(e.button, true);
+			if (opts?.lockOnClick && document.pointerLockElement !== target) target.requestPointerLock?.();
+		};
+		const onUp = (e) => {
+			buttonsHeld = Math.max(0, buttonsHeld - 1);
+			this.handleMouseButton(e.button, false);
+		};
+		const onMove = (e) => {
+			if (document.pointerLockElement === target || buttonsHeld > 0) this.handlePointerMove(e.movementX, e.movementY);
+		};
+		const onWheel = (e) => {
+			e.preventDefault();
+			this.handleWheel(e.deltaY);
+		};
+		const onContext = (e) => e.preventDefault();
+		target.addEventListener("mousedown", onDown);
+		window.addEventListener("mouseup", onUp);
+		window.addEventListener("mousemove", onMove);
+		target.addEventListener("wheel", onWheel, { passive: false });
+		target.addEventListener("contextmenu", onContext);
+		const detach = () => {
+			target.removeEventListener("mousedown", onDown);
+			window.removeEventListener("mouseup", onUp);
+			window.removeEventListener("mousemove", onMove);
+			target.removeEventListener("wheel", onWheel);
+			target.removeEventListener("contextmenu", onContext);
+		};
+		const prev = this.detach;
+		this.detach = () => {
+			prev?.();
+			detach();
+		};
+		return detach;
+	}
+	/**
+	* Wire browser keyboard events. Returns (and chains into dispose()) a detach
+	* function.
+	*
+	* By default the browser default is prevented for keys BOUND to a declared
+	* action — an embedded game must not scroll its host page on Space/arrows.
+	* Keys typed into editable elements (inputs, textareas, contenteditable)
+	* are ignored entirely so DOM UI overlays keep working.
+	*/
+	attachKeyboard(target, opts) {
+		const mode = opts?.preventDefault ?? "bound";
+		const onDown = (e) => {
+			if (isEditableTarget(e.target)) return;
+			if ((e.ctrlKey || e.metaKey) && !e.code.startsWith("Control") && !e.code.startsWith("Meta")) return;
+			if (mode === "bound" && this.codeIsBound(e.code)) e.preventDefault?.();
+			if (!e.repeat) this.handleKey(e.code, true);
+		};
+		const onUp = (e) => {
+			if (isEditableTarget(e.target)) return;
+			this.handleKey(e.code, false);
+		};
+		target.addEventListener("keydown", onDown);
+		target.addEventListener("keyup", onUp);
+		const detach = () => {
+			target.removeEventListener("keydown", onDown);
+			target.removeEventListener("keyup", onUp);
+		};
+		const prev = this.detach;
+		this.detach = () => {
+			prev?.();
+			detach();
+		};
+		return detach;
+	}
+	/** Whether any declared action binds this key code. */
+	codeIsBound(code) {
+		for (const action of this.actions.values()) if (action.type === "button") {
+			if (action.keys.includes(code)) return true;
+		} else {
+			const k = action.keys;
+			if (k.up.includes(code) || k.down.includes(code) || k.left.includes(code) || k.right.includes(code)) return true;
+		}
+		return false;
+	}
+	dispose() {
+		this.detach?.();
+		this.detach = null;
+	}
+	isPressed(action) {
+		return this.button(action).keys.some((k) => this.down.has(k)) || this.injectedDown.has(action);
+	}
+	justPressed(action) {
+		return this.button(action).keys.some((k) => this.pressedEdge.has(k)) || this.injectedPressed.has(action);
+	}
+	justReleased(action) {
+		return this.button(action).keys.some((k) => this.releasedEdge.has(k)) || this.injectedReleased.has(action);
+	}
+	/** Normalized direction for a vector2 action (y-down: up = -y). */
+	getVector(action) {
+		const def = this.get(action);
+		if (def.type !== "vector2") throw new IncantoError("BAD_FORMAT", `Input action '${action}' is a button — use isPressed/justPressed, not getVector.`);
+		const active = (codes) => codes.some((k) => this.down.has(k)) ? 1 : 0;
+		let x = active(def.keys.right) - active(def.keys.left);
+		let y = active(def.keys.down) - active(def.keys.up);
+		const injected = this.injectedVectors.get(action);
+		if (injected) {
+			x += injected.x;
+			y += injected.y;
+		}
+		const len = Math.hypot(x, y);
+		if (len > 1) {
+			x /= len;
+			y /= len;
+		}
+		return {
+			x,
+			y
+		};
+	}
+	/** Consume one-frame edges. The Engine calls this at the end of every tick. */
+	endFrame() {
+		this.pressedEdge.clear();
+		this.releasedEdge.clear();
+		this.injectedPressed.clear();
+		this.injectedReleased.clear();
+	}
+	/**
+	* Drop all action declarations and injected action state (physical key
+	* state is kept). The Engine calls this on setScene so keybinds never
+	* bleed between scenes.
+	*/
+	clear() {
+		this.actions.clear();
+		this.pressedEdge.clear();
+		this.releasedEdge.clear();
+		this.clearInjected();
+	}
+	get(action) {
+		const def = this.actions.get(action);
+		if (!def) throw new IncantoError("BAD_FORMAT", `Unknown input action '${action}'. Declared actions: [${[...this.actions.keys()].join(", ")}].`);
+		return def;
+	}
+	button(action) {
+		const def = this.get(action);
+		if (def.type !== "button") throw new IncantoError("BAD_FORMAT", `Input action '${action}' is a vector2 — use getVector, not button queries.`);
+		return def;
+	}
+};
+/**
+* Parse and HARD-VALIDATE a scene's `input{}` block.
+*
+* Standalone because validating it used to require an Engine: the only caller
+* was `setScene`, so `incanto-check` — the gate an agent runs after every edit —
+* never looked at `input` at all. A typo there ("keys": "KeyW" instead of
+* ["KeyW"]) passed the check and threw in the browser at boot.
+*/
+function parseInputDecls(decls) {
+	const out = /* @__PURE__ */ new Map();
+	for (const [name, raw] of Object.entries(decls)) {
+		const decl = raw;
+		if (decl.type === "button") {
+			const keys = decl.keys;
+			if (!Array.isArray(keys) || keys.some((k) => typeof k !== "string")) throw new IncantoError("BAD_FORMAT", `Input action '${name}': button "keys" must be an array of KeyboardEvent.code strings.`);
+			if (decl.touch !== void 0 && decl.touch !== "button") throw new IncantoError("BAD_FORMAT", `Input action '${name}': button "touch" must be 'button', got ${JSON.stringify(decl.touch)}.`);
+			out.set(name, {
+				type: "button",
+				keys: [...keys],
+				...decl.touch === "button" ? { touch: "button" } : {}
+			});
+		} else if (decl.type === "vector2") {
+			const dirs = decl.keys;
+			for (const dir of [
+				"up",
+				"down",
+				"left",
+				"right"
+			]) if (!Array.isArray(dirs?.[dir])) throw new IncantoError("BAD_FORMAT", `Input action '${name}': vector2 "keys" needs arrays for up/down/left/right.`);
+			if (decl.touch !== void 0 && decl.touch !== "joystick") throw new IncantoError("BAD_FORMAT", `Input action '${name}': vector2 "touch" must be 'joystick', got ${JSON.stringify(decl.touch)}.`);
+			const d = dirs;
+			out.set(name, {
+				type: "vector2",
+				keys: {
+					up: [...d.up],
+					down: [...d.down],
+					left: [...d.left],
+					right: [...d.right]
+				},
+				...decl.touch === "joystick" ? { touch: "joystick" } : {}
+			});
+		} else throw new IncantoError("BAD_FORMAT", `Input action '${name}': "type" must be 'button' or 'vector2', got ${JSON.stringify(decl.type)}.`);
+	}
+	return out;
+}
+//#endregion
+//#region src/core/diagnostics.ts
+function diagnose(engine, level, ...parts) {
+	engine?.log[level](...parts);
+	if (level === "error") console.error(...parts);
+	else if (level === "warn") console.warn(...parts);
+	else console.info(...parts);
+}
+//#endregion
 //#region src/core/node-path.ts
 function parseNodePath(path) {
 	if (path === "") throw new IncantoError("BAD_NODE_PATH", "Node path must not be empty.");
@@ -432,18 +828,86 @@ var Node = class {
 	}
 	/** @internal */
 	_propagateUpdate(dt) {
-		this.update(dt);
-		this.behavior?.update?.(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) {
-		this.fixedUpdate(dt);
-		this.behavior?.fixedUpdate?.(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() {}
@@ -841,6 +1305,18 @@ function validateHeader(json) {
 	if (json.dimension !== void 0 && json.dimension !== "2d" && json.dimension !== "3d") throw new IncantoError("BAD_FORMAT", `Scene "dimension" must be "2d" or "3d", got ${JSON.stringify(json.dimension)}.`);
 	if (typeof json.root !== "object" || json.root === null) throw new IncantoError("BAD_FORMAT", "Scene \"root\" must be a node object.");
 	resolveViewport(json.viewport);
+	if (json.input !== void 0) {
+		if (typeof json.input !== "object" || json.input === null || Array.isArray(json.input)) throw new IncantoError("BAD_FORMAT", "Scene \"input\" must be an object of action declarations.");
+		parseInputDecls(json.input);
+	}
+	if (json.assets !== void 0) {
+		if (typeof json.assets !== "object" || json.assets === null || Array.isArray(json.assets)) throw new IncantoError("BAD_FORMAT", "Scene \"assets\" must be an object of asset declarations.");
+		for (const [key, decl] of Object.entries(json.assets)) {
+			if (typeof decl !== "object" || decl === null || Array.isArray(decl)) throw new IncantoError("BAD_FORMAT", `Asset '${key}' must be an object, got ${JSON.stringify(decl)}.`);
+			const url = decl.url;
+			if (typeof url !== "string" || url === "") throw new IncantoError("BAD_FORMAT", `Asset '${key}' needs a non-empty "url" string.`);
+		}
+	}
 }
 /**
 * Re-raise a node-build error with the node's absolute scene path attached —
@@ -978,4 +1454,4 @@ function validateUniqueUids(root) {
 	walk(root);
 }
 //#endregion
-export { registerBehavior as _, SCENE_FORMAT as a, SceneTree as c, resolveConstants as d, Node as f, getBehavior as g, clearBehaviors as h, serializeNode as i, CONST_REF_KEY as l, Behavior as m, loadScene as n, computeViewport as o, parseNodePath as p, Scene as r, resolveViewport as s, buildNodeJson as t, isConstRef as u, registeredBehaviors as v, Signal as y };
+export { clearBehaviors as _, SCENE_FORMAT as a, registeredBehaviors as b, SceneTree as c, resolveConstants as d, Node as f, Behavior as g, InputMap as h, serializeNode as i, CONST_REF_KEY as l, diagnose as m, loadScene as n, computeViewport as o, parseNodePath as p, Scene as r, resolveViewport as s, buildNodeJson as t, isConstRef as u, getBehavior as v, Signal as x, registerBehavior as y };

package/dist/net.d.ts

@@ -1,5 +1,5 @@
+import { X as Node, l as PropSchema, nt as Signal, v as Engine } from "./behavior-D_jMpFh8.js";
 import { c as JsonValue, i as SceneJson, s as JsonObject } from "./schema-CcoWb32N.js";
-import { $ as Node, l as PropSchema, tt as Signal, v as Engine } from "./behavior-BAc0erXF.js";
 
 //#region src/net/types.d.ts
 type Unsubscribe = () => void;

package/dist/net.js

@@ -1,9 +1,9 @@
-import { n as loadScene } from "./loader-BZqOKfI2.js";
-import { u as Engine } from "./register-BTg0EM7s.js";
+import { n as loadScene } from "./loader-BlaRQGaA.js";
+import { u as Engine } from "./register-Dzkd6-os.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as jsonClone } from "./json-BLk7H2Qa.js";
 import { n as createAgent8Server } from "./agent8-CvsfVskX.js";
-import { i as applySyncPatch, n as NetworkSpawner, r as NetworkManager, t as registerNodesNet } from "./register-MelqEdza.js";
+import { i as applySyncPatch, n as NetworkSpawner, r as NetworkManager, t as registerNodesNet } from "./register-CUY284Is.js";
 //#region src/net/loopback.ts
 /**
 * In-memory multiplayer hub implementing the SAME kernel contract as

package/dist/{pathfinding-BwD974Ss.d.ts → pathfinding-BwhqPD3i.d.ts}

@@ -1,4 +1,4 @@
-import { $ as Node, P as Listener, l as PropSchema } from "./behavior-BAc0erXF.js";
+import { X as Node, j as Listener, l as PropSchema } from "./behavior-D_jMpFh8.js";
 
 //#region src/core/nodes/audio-player.d.ts
 /**

package/dist/{physics-2d-3kOQCtgd.js → physics-2d-D9wquBvK.js}

@@ -1,6 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { m as diagnose } from "./loader-BlaRQGaA.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, y as Node2D } from "./register-DWcWq4QG.js";
+import { _ as RigidBody2D, b as validateCollider2D, g as PhysicsBody2D, h as CharacterBody2D, m as Area2D, p as Joint2D, y as Node2D } from "./register-tkR_8tWg.js";
 import { n as registerDebugSource } from "./debug-draw-BM3DsvtT.js";
 //#region src/2d/physics/physics-2d.ts
 var physics_2d_exports = /* @__PURE__ */ __exportAll({
@@ -113,7 +114,7 @@ var Physics2D = class {
 				a.emit(sig, b);
 				b.emit(sig, a);
 			} catch (error) {
-				console.error(`incanto: error in a '${sig}' handler (${a.name} ↔ ${b.name}):`, error);
+				diagnose(this.engine, "error", `incanto: error in a '${sig}' handler (${a.name} ↔ ${b.name}):`, error);
 			}
 		});
 	}
@@ -346,7 +347,7 @@ var Physics2D = class {
 				}
 				if (!this.warnedNoCollider.has(node)) {
 					this.warnedNoCollider.add(node);
-					console.warn(`[incanto] '${node.name}' has no collider — physics skips it.`);
+					diagnose(this.engine, "warn", `[incanto] '${node.name}' has no collider — physics skips it.`);
 				}
 				continue;
 			}

package/dist/{physics-3d-CeRH-Ff_.js → physics-3d-CnPygVGo.js}

@@ -1,8 +1,9 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { m as diagnose } from "./loader-BlaRQGaA.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { F as PhysicsBody3D, I as RigidBody3D, N as Area3D, P as CharacterBody3D, R as Node3D, z as validateCollider3D } from "./gameplay-Cfr6aFZ1.js";
+import { F as PhysicsBody3D, I as RigidBody3D, N as Area3D, P as CharacterBody3D, R as Node3D, z as validateCollider3D } from "./gameplay-BftxM_It.js";
 import { n as registerDebugSource } from "./debug-draw-BM3DsvtT.js";
-import { I as buildMeshGeometry, N as Joint3D, P as InstancedMesh3D, k as Terrain3D } from "./register-DJ0SByQg.js";
+import { A as Terrain3D, F as InstancedMesh3D, L as buildMeshGeometry, P as Joint3D } from "./environment-presets--DigHNg4.js";
 import { Euler, Matrix4, Quaternion, Vector3 } from "three";
 //#region src/3d/physics/collider-lines.ts
 /**
@@ -336,7 +337,7 @@ var Physics3D = class {
 				a.emit(sig, b);
 				b.emit(sig, a);
 			} catch (error) {
-				console.error(`incanto: error in a '${sig}' handler (${a.name} ↔ ${b.name}):`, error);
+				diagnose(this.engine, "error", `incanto: error in a '${sig}' handler (${a.name} ↔ ${b.name}):`, error);
 			}
 		});
 	}
@@ -519,7 +520,7 @@ var Physics3D = class {
 				}
 				if (!this.warnedNoCollider.has(node)) {
 					this.warnedNoCollider.add(node);
-					console.warn(`[incanto] '${node.name}' has no collider — physics skips it.`);
+					diagnose(this.engine, "warn", `[incanto] '${node.name}' has no collider — physics skips it.`);
 				}
 				continue;
 			}

package/dist/react.d.ts

@@ -1,5 +1,5 @@
+import { n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-D_jMpFh8.js";
 import { c as JsonValue } from "./schema-CcoWb32N.js";
-import { n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-BAc0erXF.js";
 import { CSSProperties, ReactNode } from "react";
 
 //#region src/react/index.d.ts

package/dist/react.js

@@ -156,7 +156,7 @@ function IncantoCanvas(props) {
 				pointer: latest.pointer,
 				...keyboard !== void 0 ? { keyboard } : {}
 			};
-			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-DuBTv2zI.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-5z_QVtLx.js").then((n) => n.n)).createGame2D(o)))(opts);
+			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-gXI7PYl0.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-bKHgHcsZ.js").then((n) => n.n)).createGame2D(o)))(opts);
 			if (disposed) {
 				next.dispose();
 				return;

package/dist/{register-MelqEdza.js → register-CUY284Is.js}

@@ -1,8 +1,8 @@
-import { f as Node, t as buildNodeJson, y as Signal } from "./loader-BZqOKfI2.js";
-import { t as registerCoreNodes } from "./register-BTg0EM7s.js";
+import { f as Node, t as buildNodeJson, x as Signal } from "./loader-BlaRQGaA.js";
+import { t as registerCoreNodes } from "./register-Dzkd6-os.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { n as jsonEquals, t as jsonClone } from "./json-BLk7H2Qa.js";
-import { l as registerNode } from "./registry-BVJ2HbCn.js";
+import { l as registerNode } from "./registry-CJdGpT2V.js";
 //#region src/net/network-manager.ts
 const managers = /* @__PURE__ */ new WeakMap();
 /**