incanto 0.28.0 → 0.30.0

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

@@ -1,9 +1,206 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.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-DEG-TP7D.js";
-import { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
-import { A as Joint3D, E as Terrain3D } from "./register-6R75AC7-.js";
-import { Euler, Quaternion } from "three";
+import { F as PhysicsBody3D, I as RigidBody3D, N as Area3D, P as CharacterBody3D, R as Node3D, z as validateCollider3D } from "./gameplay-Cfr6aFZ1.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 { Euler, Matrix4, Quaternion, Vector3 } from "three";
+//#region src/3d/physics/collider-lines.ts
+/**
+* Wireframe segments for INDIVIDUAL colliders.
+*
+* Rapier's own `world.debugRender()` is all-or-nothing: it draws every collider
+* in the world, which on a real map means a terrain heightfield's grid drowning
+* the one shape you were actually looking at. Drawing a chosen few means
+* generating the outlines ourselves, from the same shape data the solver holds.
+*
+* Shapes are drawn at their true size — no bounding boxes standing in for real
+* geometry, since a box around a rotated shape is exactly the lie this view
+* exists to expose.
+*/
+const RING = 16;
+const point = new Vector3();
+const quat = new Quaternion();
+function transformer(collider, out) {
+	const t = collider.translation();
+	const r = collider.rotation();
+	quat.set(r.x, r.y, r.z, r.w);
+	const put = (x, y, z) => {
+		point.set(x, y, z).applyQuaternion(quat);
+		out.push(point.x + t.x, point.y + t.y, point.z + t.z);
+	};
+	return (ax, ay, az, bx, by, bz) => {
+		put(ax, ay, az);
+		put(bx, by, bz);
+	};
+}
+/** A circle in the plane spanned by two axes, at `offset` along the third. */
+function ring(push, radius, plane, offset, arc = Math.PI * 2, from = 0) {
+	const at = (a) => {
+		const c = Math.cos(a) * radius;
+		const s = Math.sin(a) * radius;
+		if (plane === "xy") return [
+			c,
+			s,
+			offset
+		];
+		if (plane === "xz") return [
+			c,
+			offset,
+			s
+		];
+		return [
+			offset,
+			c,
+			s
+		];
+	};
+	const steps = Math.max(3, Math.round(RING * arc / (Math.PI * 2)));
+	for (let i = 0; i < steps; i++) {
+		const [ax, ay, az] = at(from + arc * i / steps);
+		const [bx, by, bz] = at(from + arc * (i + 1) / steps);
+		push(ax, ay, az, bx, by, bz);
+	}
+}
+function triangleEdges(push, vertices, indices) {
+	const v = (i) => [
+		vertices[i * 3],
+		vertices[i * 3 + 1],
+		vertices[i * 3 + 2]
+	];
+	if (indices) {
+		for (let i = 0; i < indices.length; i += 3) {
+			const a = v(indices[i]);
+			const b = v(indices[i + 1]);
+			const c = v(indices[i + 2]);
+			push(...a, ...b);
+			push(...b, ...c);
+			push(...c, ...a);
+		}
+		return;
+	}
+	for (let i = 0; i + 5 < vertices.length; i += 9) {
+		const a = v(i / 3);
+		const b = v(i / 3 + 1);
+		const c = v(i / 3 + 2);
+		push(...a, ...b);
+		push(...b, ...c);
+		push(...c, ...a);
+	}
+}
+/** The heights grid, drawn as its own quad lines (column-major, like Rapier). */
+function heightfield(push, shape) {
+	const { nrows, ncols, heights, scale } = shape;
+	const rows = nrows + 1;
+	const cols = ncols + 1;
+	const at = (i, j) => [
+		(i / nrows - .5) * scale.x,
+		heights[j * rows + i] * scale.y,
+		(j / ncols - .5) * scale.z
+	];
+	for (let j = 0; j < cols; j++) for (let i = 0; i < rows; i++) {
+		if (i + 1 < rows) push(...at(i, j), ...at(i + 1, j));
+		if (j + 1 < cols) push(...at(i, j), ...at(i, j + 1));
+	}
+}
+/** Append one collider's wireframe to `out` (flat xyz, segment pairs). */
+function colliderLines3D(collider, out) {
+	const push = transformer(collider, out);
+	const shape = collider.shape;
+	switch (collider.shape.type) {
+		case 0: {
+			const r = shape.radius;
+			ring(push, r, "xy", 0);
+			ring(push, r, "xz", 0);
+			ring(push, r, "yz", 0);
+			return;
+		}
+		case 1: {
+			const h = shape.halfExtents;
+			for (const [sy, sz] of [
+				[-1, -1],
+				[-1, 1],
+				[1, -1],
+				[1, 1]
+			]) push(-h.x, sy * h.y, sz * h.z, h.x, sy * h.y, sz * h.z);
+			for (const [sx, sz] of [
+				[-1, -1],
+				[-1, 1],
+				[1, -1],
+				[1, 1]
+			]) push(sx * h.x, -h.y, sz * h.z, sx * h.x, h.y, sz * h.z);
+			for (const [sx, sy] of [
+				[-1, -1],
+				[-1, 1],
+				[1, -1],
+				[1, 1]
+			]) push(sx * h.x, sy * h.y, -h.z, sx * h.x, sy * h.y, h.z);
+			return;
+		}
+		case 2: {
+			const { radius, halfHeight } = shape;
+			for (const sign of [-1, 1]) {
+				ring(push, radius, "xz", sign * halfHeight);
+				for (const plane of ["xy", "yz"]) {
+					const from = sign > 0 ? 0 : Math.PI;
+					const cap = (ax, ay, az, bx, by, bz) => push(ax, ay + sign * halfHeight, az, bx, by + sign * halfHeight, bz);
+					ring(cap, radius, plane, 0, Math.PI, from);
+				}
+			}
+			for (const [x, z] of [
+				[1, 0],
+				[-1, 0],
+				[0, 1],
+				[0, -1]
+			]) push(x * radius, -halfHeight, z * radius, x * radius, halfHeight, z * radius);
+			return;
+		}
+		case 3: {
+			const seg = shape;
+			push(seg.a.x, seg.a.y, seg.a.z, seg.b.x, seg.b.y, seg.b.z);
+			return;
+		}
+		case 6:
+		case 9:
+		case 16: {
+			const mesh = shape;
+			triangleEdges(push, mesh.vertices, mesh.indices);
+			return;
+		}
+		case 7:
+			heightfield(push, shape);
+			return;
+		case 10:
+		case 14: {
+			const { radius, halfHeight } = shape;
+			ring(push, radius, "xz", -halfHeight);
+			ring(push, radius, "xz", halfHeight);
+			for (const [x, z] of [
+				[1, 0],
+				[-1, 0],
+				[0, 1],
+				[0, -1]
+			]) push(x * radius, -halfHeight, z * radius, x * radius, halfHeight, z * radius);
+			return;
+		}
+		case 11:
+		case 15: {
+			const { radius, halfHeight } = shape;
+			ring(push, radius, "xz", -halfHeight);
+			for (let i = 0; i < 4; i++) {
+				const a = i / 4 * Math.PI * 2;
+				push(Math.cos(a) * radius, -halfHeight, Math.sin(a) * radius, 0, halfHeight, 0);
+			}
+			return;
+		}
+		default:
+			if (collider.shape.type === 12 || collider.shape.type === 13) {
+				const h = shape.halfExtents;
+				if (h) push(-h.x, -h.y, -h.z, h.x, h.y, h.z);
+			}
+			return;
+	}
+}
+//#endregion
 //#region src/3d/physics/physics-3d.ts
 var physics_3d_exports = /* @__PURE__ */ __exportAll({
 	Physics3D: () => Physics3D,
@@ -26,6 +223,8 @@ var Physics3D = class {
 	engine;
 	/** Render collider outlines in the GAME view (renderers pick this up). */
 	debugDraw = false;
+	/** Narrow those outlines to one node's subtree (see DebugLineSource). */
+	debugScope = null;
 	dimension = "3d";
 	unregisterDebug;
 	warnedNoCollider = /* @__PURE__ */ new WeakSet();
@@ -42,6 +241,7 @@ var Physics3D = class {
 		this.R = R;
 		this.engine = engine;
 		this.optsGravity = opts?.gravity;
+		this.simulate = opts?.simulate ?? true;
 		this.lastScene = engine.scene;
 		const declared = engine.scene?.physics?.gravity;
 		const g = opts?.gravity ?? declared ?? [
@@ -60,9 +260,16 @@ var Physics3D = class {
 		this.disconnect = engine.fixedUpdated.connect((dt) => this.step(dt));
 		this.syncBodies();
 	}
+	/** Whether the solver runs at all. False = collider outlines only. */
+	simulate;
 	/** @internal Driven by engine.fixedUpdated. */
 	step(dt) {
 		this.lastDt = dt;
+		if (!this.simulate) {
+			this.syncBodies();
+			this.poseFromTree();
+			return;
+		}
 		if (this.engine.scene !== this.lastScene) {
 			this.lastScene = this.engine.scene;
 			if (!this.optsGravity) {
@@ -133,9 +340,37 @@ var Physics3D = class {
 			}
 		});
 	}
+	/**
+	* Move every body to its node's current transform.
+	*
+	* Only used in outline mode: normally physics owns the pose and writes it
+	* INTO the node, so nothing re-reads the tree. Deliberately computed the same
+	* way `ensureEntry` computes a body's initial pose — world position, node-local
+	* euler — so an outline in the editor is the outline the game will draw, right
+	* down to the places where that pair disagrees with a rotated parent.
+	*/
+	poseFromTree() {
+		for (const [node, e] of this.entries) {
+			const [wx, wy, wz] = worldPosition3D(node);
+			e.body.setTranslation({
+				x: wx,
+				y: wy,
+				z: wz
+			}, false);
+			quatScratch.setFromEuler(eulerScratch.set((node.rotation[0] ?? 0) * DEG, (node.rotation[1] ?? 0) * DEG, (node.rotation[2] ?? 0) * DEG, "XYZ"));
+			e.body.setRotation({
+				x: quatScratch.x,
+				y: quatScratch.y,
+				z: quatScratch.z,
+				w: quatScratch.w
+			}, false);
+		}
+		this.world.propagateModifiedBodyPositionsToColliders();
+	}
 	/** @internal Called by CharacterBody3D.moveAndSlide (during tree fixedUpdate). */
 	moveAndSlide(node) {
 		const e = this.ensureEntry(node);
+		if (!e) return;
 		const vy = node.velocity[1] ?? 0;
 		if (node.snapToGround && vy <= 0) this.kcc.enableSnapToGround(.1);
 		else this.kcc.disableSnapToGround();
@@ -158,7 +393,36 @@ var Physics3D = class {
 	/** Rapier debug segments (meters). Null while debugDraw is off. */
 	debugLines() {
 		if (!this.debugDraw) return null;
-		return this.world.debugRender().vertices;
+		const scope = this.debugScope;
+		if (!scope) return this.world.debugRender().vertices;
+		const bodies = this.scopedBodies(scope);
+		const out = [];
+		for (const body of bodies) for (let i = 0; i < body.numColliders(); i++) {
+			const collider = body.collider(i);
+			if (collider) colliderLines3D(collider, out);
+		}
+		return new Float32Array(out);
+	}
+	/**
+	* The Rapier bodies a selected node stands for: its own, its descendants',
+	* and — when it owns none — the nearest body ABOVE it, so clicking the visual
+	* mesh child of a StaticBody3D shows that body's collider rather than nothing.
+	*/
+	scopedBodies(node) {
+		const out = [];
+		const collect = (n) => {
+			const entry = this.entries.get(n);
+			if (entry) out.push(entry.body);
+			const scatter = this.scatterBodies.get(n);
+			if (scatter) out.push(scatter);
+			for (const child of n.children) collect(child);
+		};
+		collect(node);
+		for (let p = node.parent; p && out.length === 0; p = p.parent) {
+			const entry = this.entries.get(p);
+			if (entry) out.push(entry.body);
+		}
+		return out;
 	}
 	dispose() {
 		this.disconnect();
@@ -169,7 +433,63 @@ var Physics3D = class {
 	lastRoot = null;
 	jointSet = /* @__PURE__ */ new Set();
 	joints = /* @__PURE__ */ new Map();
+	/** One fixed body per solid scatter field, carrying a collider per row. */
+	scatterBodies = /* @__PURE__ */ new Map();
 	bodySet = /* @__PURE__ */ new Set();
+	/**
+	* Give every row of a scatter field its own static collider.
+	*
+	* A stone field is one node with fifty transforms in it, and a player walking
+	* through all fifty is what gives a world away as scenery. All of them hang
+	* off ONE fixed body — they never move, so there is nothing to step — and the
+	* whole set is rebuilt only when the tree's shape changes.
+	*/
+	syncScatters(root) {
+		for (const [, entry] of this.scatterBodies) this.world.removeRigidBody(entry);
+		this.scatterBodies.clear();
+		const fields = /* @__PURE__ */ new Set();
+		collectScatters(root, fields);
+		for (const field of fields) {
+			const spec = field.collider;
+			if (!spec) continue;
+			const [ox, oy, oz] = worldPosition3D(field);
+			const body = this.world.createRigidBody(this.R.RigidBodyDesc.fixed().setTranslation(0, 0, 0));
+			const [sx, sy, sz] = field.size;
+			let basePoints = null;
+			for (const row of field.transforms) {
+				const scale = row[4] ?? 1;
+				const x = ox + (row[0] ?? 0);
+				const y = oy + (row[1] ?? 0);
+				const z = oz + (row[2] ?? 0);
+				let desc = null;
+				if (spec.shape === "sphere") desc = this.R.ColliderDesc.ball(Math.max((spec.radius ?? Math.max(sx, sz) / 2) * scale, .01));
+				else if (spec.shape === "box") {
+					const ext = spec.size ?? [
+						sx,
+						sy,
+						sz
+					];
+					desc = this.R.ColliderDesc.cuboid(Math.max((ext[0] ?? 1) * scale / 2, .01), Math.max((ext[1] ?? 1) * scale / 2, .01), Math.max((ext[2] ?? 1) * scale / 2, .01));
+				} else {
+					basePoints ??= meshPoints(field.mesh, field.size);
+					const pts = new Float32Array(basePoints.length);
+					for (let i = 0; i < pts.length; i++) pts[i] = basePoints[i] * scale;
+					desc = this.R.ColliderDesc.convexHull(pts);
+				}
+				if (!desc) continue;
+				desc.setTranslation(x, y, z);
+				const yaw = (row[3] ?? 0) * Math.PI / 180;
+				if (yaw !== 0) desc.setRotation({
+					x: 0,
+					y: Math.sin(yaw / 2),
+					z: 0,
+					w: Math.cos(yaw / 2)
+				});
+				this.world.createCollider(desc, body);
+			}
+			this.scatterBodies.set(field, body);
+		}
+	}
 	syncBodies() {
 		const scene = this.engine.scene;
 		if (!scene) return;
@@ -184,6 +504,7 @@ var Physics3D = class {
 		if (structureChanged) {
 			this.jointSet.clear();
 			collectJoints(scene.root, this.jointSet);
+			this.syncScatters(scene.root);
 		}
 		const seen = this.bodySet;
 		for (const node of seen) {
@@ -223,10 +544,18 @@ var Physics3D = class {
 			}
 		}
 	}
+	/**
+	* Null while a `{"shape":"auto"}` body is waiting on its model — the shape
+	* lives in the model's triangles, and there is nothing honest to guess in the
+	* meantime. syncBodies runs every step, so the body appears the moment the
+	* download lands.
+	*/
 	ensureEntry(node) {
 		let e = this.entries.get(node);
 		const R = this.R;
 		if (!e) {
+			const colDesc = parseCollider3D(R, node);
+			if (!colDesc) return null;
 			let desc;
 			if (node instanceof RigidBody3D) desc = R.RigidBodyDesc.dynamic();
 			else if (node instanceof CharacterBody3D || node instanceof Area3D) desc = R.RigidBodyDesc.kinematicPositionBased();
@@ -246,7 +575,6 @@ var Physics3D = class {
 				if (node.fixedRotation) desc.lockRotations();
 			}
 			const body = this.world.createRigidBody(desc);
-			const colDesc = parseCollider3D(R, node);
 			colDesc.setActiveEvents(R.ActiveEvents.COLLISION_EVENTS);
 			colDesc.setActiveCollisionTypes(R.ActiveCollisionTypes.ALL);
 			if (node instanceof Area3D) colDesc.setSensor(true);
@@ -448,6 +776,120 @@ function collectBodies(node, out) {
 	for (const c of node.children) collectBodies(c, out);
 }
 /**
+* A collider shaped like the mesh actually being drawn.
+*
+* Hand-written extents drift from what the player sees — a box "around" a
+* bridge is wider than the bridge, a sphere "for" a stone is smaller than the
+* stone — and nobody notices until they walk into thin air. So the collider is
+* built from the SAME geometry factory the renderer draws with: box → cuboid,
+* sphere → ball, cylinder/capsule → their own shapes, and anything faceted
+* (the `gem` stone) → a convex hull of its real vertices.
+*
+* Convex, always: a hull is a few planes to test against, where a triangle
+* mesh is a tree of them, and nothing scattered across a map needs concavity.
+*/
+function meshShapedDesc(R, kind, size, scale) {
+	const x = (size[0] ?? 1) * scale;
+	const y = (size[1] ?? 1) * scale;
+	const z = (size[2] ?? 1) * scale;
+	switch (kind) {
+		case "box": return R.ColliderDesc.cuboid(x / 2, y / 2, z / 2);
+		case "sphere": return R.ColliderDesc.ball(x);
+		case "capsule": return R.ColliderDesc.capsule(y / 2, x);
+		case "cylinder": return R.ColliderDesc.cylinder(y / 2, x);
+		case "plane": return R.ColliderDesc.cuboid(x / 2, .01, z / 2);
+		default: return R.ColliderDesc.convexHull(meshPoints(kind, [
+			x,
+			y,
+			z
+		]));
+	}
+}
+/** The drawn geometry's vertices, flat xyz — the same mesh the player sees. */
+function meshPoints(kind, size) {
+	const geo = buildMeshGeometry(kind, size);
+	const pos = geo.getAttribute("position");
+	const points = new Float32Array(pos.count * 3);
+	for (let i = 0; i < pos.count; i++) {
+		points[i * 3] = pos.getX(i);
+		points[i * 3 + 1] = pos.getY(i);
+		points[i * 3 + 2] = pos.getZ(i);
+	}
+	geo.dispose();
+	return points;
+}
+function isMountedModel(node) {
+	return typeof node._mountedObject3D === "function";
+}
+const localMat = new Matrix4();
+const meshMat = new Matrix4();
+const vertScratch = new Vector3();
+/**
+* The triangles of a LOADED model, in the body's own frame.
+*
+* A GLB is not a primitive — its shape lives in its vertices, and those are the
+* only honest source for a collider around it. Every drawn mesh under the model
+* is baked through its own world matrix into the body's local space, so a model
+* that is offset, turned or fitted to `targetHeight` collides where it is drawn
+* rather than where it was authored.
+*
+* Null while the asset is still downloading — the caller retries next step.
+*/
+function modelTriangles(body, model) {
+	const mounted = model._mountedObject3D();
+	if (!mounted) return null;
+	const bodyObj = body._ensureObject3D();
+	bodyObj.updateWorldMatrix(true, true);
+	localMat.copy(bodyObj.matrixWorld).invert();
+	const verts = [];
+	const idx = [];
+	mounted.traverse((obj) => {
+		const mesh = obj;
+		if (!mesh.isMesh) return;
+		const pos = mesh.geometry?.getAttribute("position");
+		if (!pos) return;
+		meshMat.multiplyMatrices(localMat, mesh.matrixWorld);
+		const base = verts.length / 3;
+		for (let i = 0; i < pos.count; i++) {
+			vertScratch.set(pos.getX(i), pos.getY(i), pos.getZ(i)).applyMatrix4(meshMat);
+			verts.push(vertScratch.x, vertScratch.y, vertScratch.z);
+		}
+		const index = mesh.geometry.getIndex();
+		if (index) for (let i = 0; i < index.count; i++) idx.push(base + index.getX(i));
+		else for (let i = 0; i < pos.count; i++) idx.push(base + i);
+	});
+	if (idx.length < 3) return null;
+	return {
+		vertices: new Float32Array(verts),
+		indices: new Uint32Array(idx),
+		triangles: idx.length / 3
+	};
+}
+/** Past this, a trimesh is worth a word — level art is not collision art. */
+const TRIMESH_BUDGET = 2e4;
+/** A body Rapier will never move, so a hollow triangle mesh is safe on it. */
+function isStaticShape(node) {
+	return !(node instanceof RigidBody3D || node instanceof CharacterBody3D);
+}
+/** Every mesh a body carries, itself first — `auto` shapes itself on one. */
+function meshesUnder(node, out, models) {
+	if (isMountedModel(node)) models.push(node);
+	else {
+		const self = node;
+		if (typeof self.mesh === "string" && Array.isArray(self.size)) out.push({
+			name: node.name,
+			mesh: self.mesh,
+			size: self.size
+		});
+	}
+	for (const child of node.children) meshesUnder(child, out, models);
+}
+/** Every scatter field asking to be solid (see InstancedMesh3D.collider). */
+function collectScatters(node, out) {
+	if (node instanceof InstancedMesh3D && node.collider) out.add(node);
+	for (const c of node.children) collectScatters(c, out);
+}
+/**
 * Composed world position (translation only — ancestor rotation/scale are NOT
 * supported for physics bodies; keep body ancestors untransformed or offset-only).
 */
@@ -495,7 +937,8 @@ function parseCollider3D(R, node) {
 	const collider = node.collider;
 	validateCollider3D(collider, node.name);
 	if (collider.shape === "heightfield") return buildHeightfieldDesc3D(R, node);
-	const desc = buildColliderDesc3D(R, collider, node.name);
+	const desc = buildColliderDesc3D(R, collider, node.name, node);
+	if (!desc) return null;
 	const offset = collider.offset;
 	if (Array.isArray(offset)) desc.setTranslation(offset[0] ?? 0, offset[1] ?? 0, offset[2] ?? 0);
 	return desc;
@@ -522,7 +965,8 @@ function buildHeightfieldDesc3D(R, node) {
 	desc.setTranslation((terrain.position[0] ?? 0) + (offset[0] ?? 0), (terrain.position[1] ?? 0) + (offset[1] ?? 0), (terrain.position[2] ?? 0) + (offset[2] ?? 0));
 	return desc;
 }
-function buildColliderDesc3D(R, collider, nodeName) {
+/** Null means "not ready yet" (a model still downloading), never "no shape". */
+function buildColliderDesc3D(R, collider, nodeName, node) {
 	const shape = collider.shape;
 	if (shape === "box") {
 		const size = collider.size;
@@ -537,13 +981,35 @@ function buildColliderDesc3D(R, collider, nodeName) {
 		if (typeof collider.radius !== "number" || typeof collider.height !== "number") throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': capsule needs "radius" and "height".`);
 		return R.ColliderDesc.capsule(collider.height / 2, collider.radius);
 	}
+	if (shape === "auto") {
+		const meshes = [];
+		const models = [];
+		if (node) meshesUnder(node, meshes, models);
+		const mesh = meshes[0];
+		const model = models[0];
+		if (!mesh && !model) throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': shape 'auto' needs a MeshInstance3D or ModelInstance3D on the body (or as a child) to take its shape from.`);
+		const parts = meshes.length + models.length;
+		if (parts > 1) console.warn(`[incanto] Collider on '${nodeName}': shape 'auto' fits ONE mesh and took '${(mesh ?? model)?.name}'; ${parts - 1} other mesh(es) here are not solid. Give each part its own body.`);
+		if (mesh) {
+			const desc = meshShapedDesc(R, mesh.mesh, mesh.size, 1);
+			if (desc) return desc;
+		} else if (model && node) {
+			const tri = modelTriangles(node, model);
+			if (!tri) return null;
+			if (isStaticShape(node)) {
+				if (tri.triangles > TRIMESH_BUDGET) console.warn(`[incanto] Collider on '${nodeName}': shape 'auto' built a ${tri.triangles}-triangle mesh from '${model.name}'. Consider a low-poly collision model or an explicit box.`);
+				return R.ColliderDesc.trimesh(tri.vertices, tri.indices);
+			}
+			return R.ColliderDesc.convexHull(tri.vertices);
+		}
+	}
 	if (shape === "trimesh") {
 		const vertices = collider.vertices;
 		const indices = collider.indices;
 		if (!Array.isArray(vertices) || !Array.isArray(indices)) throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': trimesh needs "vertices" (flat xyz) and "indices" (triangles).`);
 		return R.ColliderDesc.trimesh(new Float32Array(vertices), new Uint32Array(indices));
 	}
-	throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': "shape" must be 'box', 'sphere', 'capsule', 'trimesh', or 'heightfield', got ${JSON.stringify(shape)}.`);
+	throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': "shape" must be 'auto', 'box', 'sphere', 'capsule', 'trimesh', or 'heightfield', got ${JSON.stringify(shape)}.`);
 }
 //#endregion
 export { enablePhysics3D as n, physics_3d_exports as r, Physics3D as t };

package/dist/react.d.ts

@@ -1,5 +1,5 @@
 import { c as JsonValue } from "./schema-CcoWb32N.js";
-import { n as BehaviorCtor, v as Engine, w as Scene } from "./behavior-CPibUfnH.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-BRgWpNsa.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-71TJjW1T.js").then((n) => n.n)).createGame2D(o)))(opts);
+			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);
 			if (disposed) {
 				next.dispose();
 				return;

package/dist/{register-nObreUQR.js → register-BTg0EM7s.js}

@@ -1432,6 +1432,16 @@ var Engine = class {
 	*  `engine.music.play(src)` / `crossfadeTo(src, secs)` / `stop(fadeOut)`;
 	*  routes through the music bus and is advanced each frame by the loop. */
 	music = new MusicManager(this.audio);
+	/**
+	* Where nodes that build DOM (HudLayer and its widgets) mount their elements.
+	*
+	* `null` — the default — means `document.body` with `position: fixed`, i.e. a
+	* game's HUD covers the window, which is what a game wants. A host that only
+	* OWNS PART of the page sets this to its own (positioned) container so the
+	* HUD stays inside it: the scene editor points it at the viewport pane, which
+	* is why an edited scene's HUD no longer floats over the inspector.
+	*/
+	uiHost = null;
 	fixedStep;
 	maxFixedSteps;
 	scheduler;
@@ -1566,7 +1576,7 @@ var Engine = class {
 			this.lastMs = nowMs;
 			return;
 		}
-		const rawDt = Math.min((nowMs - this.lastMs) / 1e3, MAX_DT_SECONDS);
+		const rawDt = Math.max(0, Math.min((nowMs - this.lastMs) / 1e3, MAX_DT_SECONDS));
 		const dt = rawDt * this.timeScale;
 		this._time += dt;
 		this._unscaledTime += rawDt;
@@ -1836,8 +1846,27 @@ var HudLayer = class extends Node {
 		const el = document.createElement("div");
 		el.dataset.incantoHud = this.name;
 		el.style.cssText = `position:fixed;inset:0;pointer-events:none;z-index:${this.zIndex};font:${FONT};`;
-		document.body.appendChild(el);
 		this._element = el;
+		this._mount();
+	}
+	/**
+	* Put the overlay where the page's owner says UI goes: `engine.uiHost`, or
+	* the window when nobody claims it (a game — a HUD covers the screen).
+	*
+	* Re-checked every frame because a scene's tree is BUILT before it is handed
+	* to an engine: at onEnterTree there is no engine to ask yet, so the first
+	* update is where the answer actually arrives. appendChild moves the element
+	* if it already landed somewhere else, so the HUD follows the host across a
+	* scene swap into a differently-hosted engine (game → editor) instead of
+	* being stranded on document.body over the inspector.
+	*/
+	_mount() {
+		const el = this._element;
+		if (!el) return;
+		const host = this.tree?.engine?.uiHost ?? document.body;
+		if (el.parentElement === host) return;
+		el.style.position = host === document.body ? "fixed" : "absolute";
+		host.appendChild(el);
 	}
 	onExitTree() {
 		this._element?.remove();
@@ -1845,7 +1874,10 @@ var HudLayer = class extends Node {
 		this.slots.clear();
 	}
 	update() {
-		if (this._element) this._element.style.display = this.visible ? "" : "none";
+		if (this._element) {
+			this._mount();
+			this._element.style.display = this.visible ? "" : "none";
+		}
 	}
 	/** @internal Widgets mount into per-anchor flex columns. */
 	_slot(anchor) {