incanto 0.61.0 → 0.63.0

package/dist/{physics-3d-BTUfUSWO.js → physics-3d-BL_pFJ19.js}

@@ -1,10 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { k as diagnose } from "./loader-D7jTvDQv.js";
+import { k as diagnose } from "./loader-zDynoew_.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
-import { H as validateCollider3D, I as Area3D, L as CharacterBody3D, R as PhysicsBody3D, V as Node3D, z as RigidBody3D } from "./gameplay-Dtzd2itW.js";
+import { B as CharacterBody3D, G as validateCollider3D, H as RigidBody3D, V as PhysicsBody3D, W as Node3D, z as Area3D } from "./gameplay-CuqoHHUB.js";
 import { n as registerDebugSource } from "./debug-draw-BM3DsvtT.js";
 import { t as withoutRapierInitNoise } from "./quiet-rapier-BAJ4K94N.js";
-import { A as Terrain3D, F as InstancedMesh3D, L as buildMeshGeometry, P as Joint3D } from "./environment-presets-CNxCuhZF.js";
+import { A as Terrain3D, F as InstancedMesh3D, L as buildMeshGeometry, P as Joint3D } from "./environment-presets-QR7_75KJ.js";
 import { Euler, Matrix4, Quaternion, Vector3 } from "three";
 //#region src/3d/physics/collider-lines.ts
 /**
@@ -318,6 +318,9 @@ var Physics3D = class {
 					rot[0] = eulerScratch.x / DEG;
 					rot[1] = eulerScratch.y / DEG;
 					rot[2] = eulerScratch.z / DEG;
+					e.lastRot[0] = rot[0];
+					e.lastRot[1] = rot[1];
+					e.lastRot[2] = rot[2];
 				}
 				const lv = e.body.linvel();
 				const nv = node.linearVelocity;
@@ -381,6 +384,8 @@ var Physics3D = class {
 		if (node.stickToGround && vy <= 0) this.kcc.enableSnapToGround(.1);
 		else this.kcc.disableSnapToGround();
 		this.kcc.setMaxSlopeClimbAngle(node.slopeLimitDeg * DEG);
+		if (node.stepHeight > 0) this.kcc.enableAutostep(node.stepHeight, node.stepHeight / 2, false);
+		else this.kcc.disableAutostep();
 		let carryX = 0;
 		let carryY = 0;
 		let carryZ = 0;
@@ -644,6 +649,11 @@ var Physics3D = class {
 					wy,
 					wz
 				],
+				lastRot: [
+					node.rotation[0] ?? 0,
+					node.rotation[1] ?? 0,
+					node.rotation[2] ?? 0
+				],
 				lastV: [
 					0,
 					0,
@@ -679,6 +689,21 @@ var Physics3D = class {
 			e.last[2] = p[2];
 			node._interpPrev = node._interpCurr = null;
 		}
+		const rx = node.rotation[0] ?? 0;
+		const ry = node.rotation[1] ?? 0;
+		const rz = node.rotation[2] ?? 0;
+		if (rx !== e.lastRot[0] || ry !== e.lastRot[1] || rz !== e.lastRot[2]) {
+			quatScratch.setFromEuler(eulerScratch.set(rx * DEG, ry * DEG, rz * DEG, "XYZ"));
+			e.body.setRotation({
+				x: quatScratch.x,
+				y: quatScratch.y,
+				z: quatScratch.z,
+				w: quatScratch.w
+			}, true);
+			e.lastRot[0] = rx;
+			e.lastRot[1] = ry;
+			e.lastRot[2] = rz;
+		}
 		if (node instanceof RigidBody3D) {
 			const v = [
 				node.linearVelocity[0] ?? 0,
@@ -854,15 +879,20 @@ function collectBodies(node, out) {
 * 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;
+function meshShapedDesc(R, kind, size, scale, who) {
+	const sx = scale[0] ?? 1;
+	const sy = scale[1] ?? 1;
+	const sz = scale[2] ?? 1;
+	const x = (size[0] ?? 1) * sx;
+	const y = (size[1] ?? 1) * sy;
+	const z = (size[2] ?? 1) * sz;
+	const radial = Math.max(Math.abs(sx), Math.abs(sz));
+	if (who && kind !== "box" && kind !== "plane" && Math.abs(sx - sz) > 1e-6) console.warn(`[incanto] Collider on '${who}': shape 'auto' fits a ${kind} to a mesh scaled [${sx}, ${sy}, ${sz}]. A ${kind} has one radius, so the widest of x/z (${radial}) is used. Use a box, or scale x and z the same.`);
 	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 "sphere": return R.ColliderDesc.ball((size[0] ?? 1) * Math.max(radial, Math.abs(sy)));
+		case "capsule": return R.ColliderDesc.capsule(y / 2, (size[0] ?? 1) * radial);
+		case "cylinder": return R.ColliderDesc.cylinder(y / 2, (size[0] ?? 1) * radial);
 		case "plane": return R.ColliderDesc.cuboid(x / 2, .01, z / 2);
 		default: return R.ColliderDesc.convexHull(meshPoints(kind, [
 			x,
@@ -937,18 +967,79 @@ const TRIMESH_BUDGET = 2e4;
 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) {
+/**
+* Every mesh a body carries, itself first — `auto` shapes itself on one.
+*
+* The transform chain is composed on the way down because `auto` used to drop
+* it: the collector returned `{name, mesh, size}` and the `auto` branch built
+* the shape at the BODY's origin, at the authored size, scale hard-coded to 1.
+* The renderer applies all three every frame (`Node3D._syncObject3D`), so
+* measured on a body whose plank child sits at `[0, 3, 0]`:
+*
+* ```
+* drawn plank top y = 3.2
+* ray straight down from y=10 : HIT Deck — surface at y=0.200
+* ```
+*
+* and on one scaled 4×:
+*
+* ```
+* drawn crate top y = 2.0
+* ray straight down : HIT Crate — surface at y=0.500
+* ray down inside the DRAWN 4 m crate : MISS
+* ```
+*
+* You walk through the deck you can see and land on an invisible slab at ground
+* level — from the shape whose entire promise is that "a blocker can never
+* disagree with what the player sees". The sibling paths in this same file were
+* already right: `syncScatters` honours every scatter row's translation, yaw
+* and scale, and `modelTriangles` bakes a GLB's world matrices. Only the
+* primitive-mesh branch dropped it.
+*/
+function meshesUnder(node, out, models, at = [
+	0,
+	0,
+	0
+], turn = [
+	0,
+	0,
+	0
+], scale = [
+	1,
+	1,
+	1
+]) {
 	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
+			size: self.size,
+			at: [...at],
+			turn: [...turn],
+			scale: [...scale]
 		});
 	}
-	for (const child of node.children) meshesUnder(child, out, models);
+	for (const child of node.children) {
+		const t = child;
+		const p = Array.isArray(t.position) ? t.position : [];
+		const r = Array.isArray(t.rotation) ? t.rotation : [];
+		const c = Array.isArray(t.scale) ? t.scale : [];
+		meshesUnder(child, out, models, [
+			at[0] + (p[0] ?? 0) * scale[0],
+			at[1] + (p[1] ?? 0) * scale[1],
+			at[2] + (p[2] ?? 0) * scale[2]
+		], [
+			turn[0] + (r[0] ?? 0),
+			turn[1] + (r[1] ?? 0),
+			turn[2] + (r[2] ?? 0)
+		], [
+			scale[0] * (c[0] ?? 1),
+			scale[1] * (c[1] ?? 1),
+			scale[2] * (c[2] ?? 1)
+		]);
+	}
 }
 /** Every scatter field asking to be solid (see InstancedMesh3D.collider). */
 function collectScatters(node, out) {
@@ -1019,7 +1110,10 @@ function parseCollider3D(R, node) {
 	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);
+	if (Array.isArray(offset)) {
+		const at = desc.translation;
+		desc.setTranslation(at.x + (offset[0] ?? 0), at.y + (offset[1] ?? 0), at.z + (offset[2] ?? 0));
+	}
 	return desc;
 }
 /**
@@ -1070,8 +1164,20 @@ function buildColliderDesc3D(R, collider, nodeName, node) {
 		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;
+			const desc = meshShapedDesc(R, mesh.mesh, mesh.size, mesh.scale, nodeName);
+			if (desc) {
+				desc.setTranslation(mesh.at[0], mesh.at[1], mesh.at[2]);
+				if (mesh.turn[0] !== 0 || mesh.turn[1] !== 0 || mesh.turn[2] !== 0) {
+					quatScratch.setFromEuler(eulerScratch.set(mesh.turn[0] * DEG, mesh.turn[1] * DEG, mesh.turn[2] * DEG, "XYZ"));
+					desc.setRotation({
+						x: quatScratch.x,
+						y: quatScratch.y,
+						z: quatScratch.z,
+						w: quatScratch.w
+					});
+				}
+				return desc;
+			}
 		} else if (model && node) {
 			const tri = modelTriangles(node, model);
 			if (!tri) return null;

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-IX5lEH0P.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-DH7JI5xx.js").then((n) => n.n)).createGame2D(o)))(opts);
+			const next = await (_gameFactory ?? (mode === "3d" ? async (o) => (await import("./create-game-viBqXUoZ.js").then((n) => n.n)).createGame3D(o) : async (o) => (await import("./create-game-lLeITaZ5.js").then((n) => n.n)).createGame2D(o)))(opts);
 			if (disposed) {
 				next.dispose();
 				return;

package/dist/{register-DL3izw8j.js → register-1cKM8DEj.js}

@@ -1,9 +1,10 @@
-import { O as Node, k as diagnose, w as effectiveOrder } from "./loader-D7jTvDQv.js";
-import { I as translateOn, t as registerCoreNodes } from "./register-xuSRyD6b.js";
+import { O as Node, k as diagnose, w as effectiveOrder } from "./loader-zDynoew_.js";
+import { L as translateOn, t as registerCoreNodes } from "./register-Btm7_Emq.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { i as getNodeSchema, l as registerNode } from "./registry-CF70EArN.js";
 import { i as ParticleSim, n as resolveFrames, o as PARTICLE_PRESET_NAMES, r as validateAnimationAliases, s as applyParticlePreset, t as resolveAnimation } from "./sprite-animation-CY-mrr1L.js";
+import { N as localFromWorld, P as worldPosition } from "./gameplay-CuqoHHUB.js";
 import { t as checkSheetGrid } from "./sheet-grid-BT6N_Bjs.js";
 import { AdditiveBlending, BufferAttribute, BufferGeometry, CanvasTexture, Color, DynamicDrawUsage, Group, InstancedMesh, MathUtils, Matrix4, Mesh, MeshBasicMaterial, NearestFilter, NormalBlending, Object3D, PlaneGeometry, SRGBColorSpace } from "three";
 //#region src/2d/physics/collider-validate.ts
@@ -94,6 +95,30 @@ var Node2D = class extends Node {
 		return new Object3D();
 	}
 	/** @internal Push JSON props onto the backing object. Called every frame. */
+	/**
+	* Has this node produced the thing `static: true` is about to freeze?
+	*
+	* `static` latches after the first sync, and a textured node's first sync
+	* happens BEFORE its texture has decoded — `TextureLoader.load()` returns a
+	* `Texture` with `image === undefined` and fills it asynchronously, while
+	* `Renderer2D.render()` calls `assets.load()` and `syncTree2D()` in the same
+	* frame. So the state frozen was `visible = false`, forever. Measured on two
+	* identical sprites differing only in `static`:
+	*
+	* ```
+	* frame 1            Backdrop(static) visible: false   Control visible: false
+	* 600 frames later   Backdrop(static) visible: false width 1
+	*                    Control          visible: true  width 64
+	* ```
+	*
+	* Nothing throws: the texture loaded fine, so `assetErrors()` is empty,
+	* `stats().errors` is 0, and `framing` reads props rather than pixels and
+	* still calls the node on-screen. Overridden by the nodes that wait on an
+	* image; a node with nothing to wait for is ready by definition.
+	*/
+	_staticReady(_assets) {
+		return true;
+	}
 	_syncObject2D(_assets) {
 		const o = this._ensureObject2D();
 		o.position.set(this.position[0] ?? 0, -(this.position[1] ?? 0), 0);
@@ -393,6 +418,9 @@ var Sprite2D = class extends Node2D {
 			height: image.height
 		};
 	}
+	_staticReady(assets) {
+		return this.texture === "" || this.resolveTexture(assets) !== null;
+	}
 	_syncObject2D(assets) {
 		super._syncObject2D(assets);
 		const quad = this._quad();
@@ -577,18 +605,36 @@ var Camera2D = class extends Node2D {
 		if (!this.follow) return;
 		const target = this.getNodeOrNull(this.follow);
 		if (!(target instanceof Node2D)) return;
-		const tx = target.position[0] ?? 0;
-		const ty = target.position[1] ?? 0;
+		const [tx = 0, ty = 0] = worldPosition(target);
+		const [px = 0, py = 0] = worldPosition(this);
 		const s = Math.min(Math.max(this.smoothing, 0), .99);
 		const f = s <= 0 ? 1 : 1 - s ** (dt * 60);
-		const px = this.position[0] ?? 0;
-		const py = this.position[1] ?? 0;
-		this.position = [px + (tx - px) * f, py + (ty - py) * f];
+		const [lx = 0, ly = 0] = localFromWorld(this, [px + (tx - px) * f, py + (ty - py) * f]);
+		this.position = [lx, ly];
 	}
 	/** View center after clamping the (vw×vh)/zoom view rect inside `limits`. */
+	/**
+	* The view centre the renderer draws around, in WORLD space.
+	*
+	* It used to read `this.position` raw — the LOCAL prop — while every other
+	* 2D node gets its ancestors composed for free by the three scene graph. So a
+	* camera parented to the player, the Godot/Phaser idiom the authoring skill
+	* explicitly permits, framed the world origin:
+	*
+	* ```
+	* player world position : [1400, 900]
+	* renderer view centre  : {"x":0,"y":0}
+	* framing               : camera /Level/Player/Cam centred [1400, 900]
+	*                         1 in view, 0 outside it
+	* ```
+	*
+	* `framing` composes full world matrices, so the instrument the skills tell
+	* you to trust certified a view the renderer never drew.
+	*/
 	clampedCenter(vw, vh) {
-		let cx = this.position[0] ?? 0;
-		let cy = this.position[1] ?? 0;
+		const world = worldPosition(this);
+		let cx = world[0] ?? 0;
+		let cy = world[1] ?? 0;
 		if (this.limits.length !== 0 && this.limits.length !== 4) throw new IncantoError("BAD_FORMAT", `Camera2D '${this.name}' limits must be [] or [minX,minY,maxX,maxY], got length ${this.limits.length}.`);
 		if (this.limits.length === 4) {
 			const [minX, minY, maxX, maxY] = this.limits;
@@ -1435,6 +1481,11 @@ var TileMap2D = class extends Node2D {
 		}
 		return this.tileMesh;
 	}
+	_staticReady(assets) {
+		if (this.texture === "" || !assets) return this.texture === "";
+		const image = assets.getTexture(this.texture).image;
+		return Boolean(image?.width);
+	}
 	_syncObject2D(assets) {
 		super._syncObject2D(assets);
 		const mesh = this._mesh();

package/dist/{register-xuSRyD6b.js → register-Btm7_Emq.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { C as ORDER_GROUP_BASE, E as InputMap, O as Node, S as createSaveStore, T as resolveOrderGroups, V as Signal, b as restoreBehaviors, k as diagnose, y as captureBehaviors } from "./loader-D7jTvDQv.js";
+import { C as ORDER_GROUP_BASE, E as InputMap, O as Node, S as createSaveStore, T as resolveOrderGroups, V as Signal, b as restoreBehaviors, k as diagnose, y as captureBehaviors } from "./loader-zDynoew_.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { l as registerNode } from "./registry-CF70EArN.js";
@@ -3294,6 +3294,161 @@ var UiDialogue = class extends HudWidgetBase {
 	}
 };
 //#endregion
+//#region src/core/nodes/respawn.ts
+/** Out of the world, from the spawn: metres in 3D, pixels in 2D. */
+const AUTO_DROP_3D_M = 50;
+const AUTO_DROP_2D_PX = 1e3;
+/**
+* Catch whatever this node hangs off when it leaves the world, and put it back.
+*
+* Nothing in the engine did this. Not a node, not a behavior, not a scene
+* header — and the shipped examples prove what that costs: with the `plays`
+* rung finally counting defects, `basic-3d-sideview` fails 8 seeded runs out of
+* 8, `water-lake-3d` 7, `water-ocean-3d` 5, `water-pool-3d` 4,
+* `water-river-3d` 1. Every one of them the same way — the player walks off the
+* edge of the terrain and falls forever, and the only fix available was a
+* per-frame `y` check hand-written in TypeScript, which is exactly the kind of
+* thing this engine exists to keep out of TypeScript.
+*
+* A CHILD NODE rather than a Behavior, deliberately: a node holds one behavior
+* and the player's is already spoken for (`PlayerControl`, `Health`, the game's
+* own script). Children stack, the way `CharacterController3D` already hangs
+* off its body.
+*
+* ```jsonc
+* { "name": "Player", "type": "RigidBody3D", "props": { … },
+*   "children": [
+*     { "name": "Ctl", "type": "CharacterController3D" },
+*     { "name": "Catch", "type": "Respawn" }            // that is the whole thing
+*   ] }
+* ```
+*
+* With no props it guards its parent, uses the same line the playtest's fall
+* detector uses (50 m under the spawn in 3D, 1000 px in 2D), and puts the node
+* back where it started. `respawned` fires each time, so a life can be taken
+* off a `ScoreKeeper` or a `Health` with an ordinary connection — this node
+* does not decide what falling COSTS, which is a game-design question and not
+* a physics one.
+*/
+var Respawn = class extends Node {
+	static typeName = "Respawn";
+	static signals = ["respawned"];
+	static props = {
+		target: {
+			default: "..",
+			nodePath: true
+		},
+		below: { default: null },
+		to: { default: [] },
+		resetVelocity: { default: true }
+	};
+	/**
+	* Who is being caught. Defaults to the parent, which is the whole point of
+	* hanging this off the thing it guards.
+	*/
+	target = "..";
+	/**
+	* The line past which the target has left the world, in the scene's own
+	* down: 3D counts down (−y), 2D counts down the screen (+y).
+	*
+	* `null` is AUTO — the spawn position offset by the same distance the
+	* playtest's own fall detector uses, so "the level says it fell" and "the
+	* ladder says it fell" cannot disagree. Author a number when the level has a
+	* real floor to name; leave it alone otherwise.
+	*/
+	below = null;
+	/** Where to put it back. Empty = wherever it started. */
+	to = [];
+	/**
+	* Zero the body's velocity on the way back.
+	*
+	* On by default because the alternative is invisible: a body respawned with
+	* 40 m/s of accumulated fall still in it drops straight back through the
+	* line on the next frame, and the level flickers instead of resuming.
+	*/
+	resetVelocity = true;
+	/** How many times this has caught the target — for HUDs and tests. */
+	falls = 0;
+	home = [];
+	line = null;
+	/** +1 when "out" means y greater (2D screen-down), −1 when smaller (3D). */
+	down = -1;
+	onReady() {
+		const target = this.guarded();
+		this.home = this.to.length > 0 ? [...this.to] : [...positionOf(target)];
+		this.spawnY = worldY(target);
+	}
+	spawnY = 0;
+	/**
+	* Which way is out, and where the line is.
+	*
+	* Resolved on the first `update` rather than in `onReady`, because
+	* `onReady` runs inside `loadScene` — BEFORE `setScene` attaches the engine —
+	* so the scene's `dimension` is not readable there yet. Reading it there
+	* silently gives every 2D scene the 3D answer, and a line above a falling
+	* player fires on frame one, forever.
+	*
+	* Not called `resolve`: `Node` has a private method by that name and
+	* `getNodeOrNull` calls it, so a subclass method with the same name
+	* overrides it on the prototype — `private` is a TypeScript fiction that
+	* costs nothing at runtime — and every path lookup this node made returned a
+	* number. `node-method-shadowing.test.ts` refuses the whole family now.
+	*/
+	fallLine() {
+		if (this.line !== null) return this.line;
+		this.down = this.tree?.engine?.scene?.dimension === "2d" ? 1 : -1;
+		const drop = this.down > 0 ? AUTO_DROP_2D_PX : AUTO_DROP_3D_M;
+		this.line = this.below ?? this.spawnY + this.down * drop;
+		return this.line;
+	}
+	/** The node this guards, or itself if the path no longer resolves. */
+	guarded() {
+		return this.getNodeOrNull(this.target) ?? this;
+	}
+	update(_dt) {
+		const line = this.fallLine();
+		const target = this.guarded();
+		if (target === this) return;
+		const y = worldY(target);
+		if ((y - line) * this.down <= 0) return;
+		this.falls += 1;
+		setPosition(target, this.home);
+		if (this.resetVelocity) zeroVelocity(target);
+		this.emit("respawned", target, y);
+	}
+};
+function positionOf(node) {
+	const p = node.position;
+	return Array.isArray(p) ? p : [];
+}
+/** Sum of the `position[1]` of the node and every spatial ancestor. */
+function worldY(node) {
+	let y = 0;
+	let at = node;
+	while (at) {
+		y += positionOf(at)[1] ?? 0;
+		at = at.parent;
+	}
+	return y;
+}
+function setPosition(node, to) {
+	const slot = node;
+	if (!Array.isArray(slot.position)) return;
+	slot.position = slot.position.map((v, i) => to[i] ?? v);
+}
+/**
+* Stop whatever the fall built up.
+*
+* Both names are real: `RigidBody` calls it `linearVelocity` and
+* `CharacterBody` calls it `velocity`, and a respawn has to reach whichever
+* one this body has.
+*/
+function zeroVelocity(node) {
+	const body = node;
+	if (Array.isArray(body.linearVelocity)) body.linearVelocity = body.linearVelocity.map(() => 0);
+	if (Array.isArray(body.velocity)) body.velocity = body.velocity.map(() => 0);
+}
+//#endregion
 //#region src/core/nodes/timer.ts
 /**
 * The canonical serializable game clock — never `setTimeout` in game logic.
@@ -4021,6 +4176,7 @@ var UiMuteToggle = class extends UiToggle {
 function registerCoreNodes() {
 	registerNode(Node);
 	registerNode(Timer);
+	registerNode(Respawn);
 	registerNode(AudioPlayer);
 	registerNode(HudLayer);
 	registerNode(UiText);
@@ -4041,4 +4197,4 @@ function registerCoreNodes() {
 	registerNode(UiMuteToggle);
 }
 //#endregion
-export { UiBar as A, ROLLOFF_MODELS as B, readDeviceHints as C, HudLayer as D, EffectLog as E, suggestLocale as F, sfxDuration as G, spatialPan as H, translateOn as I, WebAudioMusicBackend as J, synthSfx as K, translationKey as L, BASE_LOCALE as M, Localization as N, HudWidgetBase as O, T_PREFIX as P, SfxEngine as R, qualityRendering as S, LogManager as T, SFX_PRESETS as U, spatialGain as V, SFX_PRESET_NAMES as W, fadeGain as X, crossfadeGains as Y, AudioBuses as Z, Engine as _, UiMuteToggle as a, qualityCaps as b, UiRenderScaleSelect as c, UiToggle as d, UiVolumeSlider as f, AudioPlayer as g, UiDialogue as h, UiLanguageSelect as i, UiText as j, UiBanner as k, UiSelect as l, UiButton as m, UiFrameCapSelect as n, UiPanel as o, Timer as p, MusicManager as q, UiImage as r, UiQualitySelect as s, registerCoreNodes as t, UiSlider as u, engine_exports as v, suggestQuality as w, qualityEnvironment as x, Settings as y, isAudioContextAvailable as z };
+export { UiBanner as A, isAudioContextAvailable as B, qualityRendering as C, EffectLog as D, LogManager as E, T_PREFIX as F, SFX_PRESET_NAMES as G, spatialGain as H, suggestLocale as I, MusicManager as J, sfxDuration as K, translateOn as L, UiText as M, BASE_LOCALE as N, HudLayer as O, Localization as P, AudioBuses as Q, translationKey as R, qualityEnvironment as S, suggestQuality as T, spatialPan as U, ROLLOFF_MODELS as V, SFX_PRESETS as W, crossfadeGains as X, WebAudioMusicBackend as Y, fadeGain as Z, AudioPlayer as _, UiMuteToggle as a, Settings as b, UiRenderScaleSelect as c, UiToggle as d, UiVolumeSlider as f, UiDialogue as g, UiButton as h, UiLanguageSelect as i, UiBar as j, HudWidgetBase as k, UiSelect as l, Respawn as m, UiFrameCapSelect as n, UiPanel as o, Timer as p, synthSfx as q, UiImage as r, UiQualitySelect as s, registerCoreNodes as t, UiSlider as u, Engine as v, readDeviceHints as w, qualityCaps as x, engine_exports as y, SfxEngine as z };

package/dist/{replay-D7-yle3s.js → replay-Bhdntkvq.js}

@@ -1,5 +1,5 @@
-import { D as handlerShadowWarnings, j as nodeRefWarnings } from "./loader-D7jTvDQv.js";
-import { L as translationKey, O as HudWidgetBase } from "./register-xuSRyD6b.js";
+import { D as handlerShadowWarnings, j as nodeRefWarnings } from "./loader-zDynoew_.js";
+import { R as translationKey, k as HudWidgetBase } from "./register-Btm7_Emq.js";
 import { o as getNodeType } from "./registry-CF70EArN.js";
 //#region src/core/audit.ts
 const ANIMATED_TYPES = new Set([
@@ -54,6 +54,18 @@ const LIGHT_TYPES = new Set([
 	"SpotLight3D"
 ]);
 /**
+* Nodes whose gameplay answer comes from a CPU twin built out of `size`.
+*
+* `Terrain3D.heightAt`, the heightfield collider and `Water3D._waterYAt` all
+* read `size` and compose ancestor POSITIONS only, so an ancestor that scales
+* or rotates them moves the picture and not the answer.
+*/
+const WORLD_QUERY_TYPES = new Set([
+	"Terrain3D",
+	"Water3D",
+	"River3D"
+]);
+/**
 * Built-ins that put something in a save. A save is keyed by node uid, so one
 * of these on a node without one is state that silently goes nowhere: the save
 * comes back `{}` and the load reports a clean bill, because "nothing was
@@ -121,6 +133,7 @@ function auditScene(scene, opts = {}) {
 		if (type === "CharacterController3D") cameraDrivers.push(path);
 		if (LIGHT_TYPES.has(type)) lights += 1;
 		if (BODY_TYPES.has(type) && transformed) warnings.push(`${path}: ${type} sits under '${transformed.path}', whose ${transformed.what} physics cannot compose — the collider will not line up with what is drawn. Keep body ancestors untransformed or translation-only, or put the body outside them.`);
+		if (WORLD_QUERY_TYPES.has(type) && transformed) warnings.push(`${path}: ${type} sits under '${transformed.path}', whose ${transformed.what} it cannot compose — the ground (or water) you can see would not be the ground you can stand on. Keep its ancestors untransformed or translation-only.`);
 		if (BODY_TYPES.has(type)) {
 			const collider = props.collider;
 			if (!collider || collider.shape === void 0) warnings.push(`${path}: ${type} has no collider — physics will skip it (add "collider": { "shape": ... }).`);

package/dist/{split-screen-5Ban4q4n.js → split-screen-Dx0LvzqS.js}

@@ -1,5 +1,5 @@
-import { O as Node, V as Signal, k as diagnose, n as loadScene, t as buildNodeJson } from "./loader-D7jTvDQv.js";
-import { _ as Engine, t as registerCoreNodes } from "./register-xuSRyD6b.js";
+import { O as Node, V as Signal, k as diagnose, n as loadScene, t as buildNodeJson } from "./loader-zDynoew_.js";
+import { t as registerCoreNodes, v as Engine } from "./register-Btm7_Emq.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { n as jsonEquals, t as jsonClone } from "./json-CwwhxQgb.js";
 import { l as registerNode } from "./registry-CF70EArN.js";

package/dist/{src-DozXvyZS.js → src-BlV9Sv4m.js}

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

package/dist/{teardown-B6rwJOyS.js → teardown-BwhkcNt8.js}

@@ -1,4 +1,4 @@
-import { g as AudioPlayer } from "./register-xuSRyD6b.js";
+import { _ as AudioPlayer } from "./register-Btm7_Emq.js";
 import { a as logReport, s as parseDrive } from "./touch-DESwnpOc.js";
 import { a as frameSignature, i as frameImage, o as frameStats } from "./frame-report-BSMny7oe.js";
 //#region src/core/audio-errors.ts