incanto 0.27.0 → 0.29.0

package/dist/{gameplay-Ddk13pQ6.js → gameplay-L05WgWd1.js}

@@ -413,6 +413,13 @@ void main() {
 * Foliage/flowers additionally BELONG out of the depth pass: alpha-cutout
 * quads depth-write their full rectangle and wind-displaced blades render
 * unposed, so their depth was always a lie the foam mask had to survive.
+*
+* Individual OBJECTS opt out the same way by setting
+* `userData.incantoWaterPassSkip = true` — for a node that is only PARTLY
+* unfit, like a tree whose trunk is honest geometry but whose leaves are the
+* same alpha-cutout lie (a depth-only override drops both their alphaTest and
+* their wind displacement, so every leaf card stamps a solid unposed
+* rectangle; a canopy became a wall of near-depth over the water behind it).
 */
 const SKIPPED_IN_WATER_PASSES = new Set([
 	"Foliage3D",
@@ -430,6 +437,11 @@ function hideForWaterPass(root, out) {
 	if (typeof root?.traverse !== "function") return out;
 	root.traverse((obj) => {
 		if (!obj.visible) return;
+		if (obj.userData?.incantoWaterPassSkip === true) {
+			obj.visible = false;
+			out.push(obj);
+			return;
+		}
 		const type = (obj.userData?.incantoNode)?.constructor?.typeName;
 		if (type && SKIPPED_IN_WATER_PASSES.has(type)) {
 			obj.visible = false;
@@ -1280,6 +1292,24 @@ float rippleFoam(vec2 p) {
 }
 
 // Enhanced depth-based foam effect calculation
+/**
+ * Linear scene depth at uv, cross-filtered over the pre-pass' own texels.
+ * The pre-pass runs at HALF resolution: a single tap quantises the shoreline
+ * to half-res steps, and any camera motion — even sub-pixel — reshuffles which
+ * texel wins, so every depth-driven band (foam, contact line) BOILS while you
+ * move. Averaging the 4-neighbour cross moves smoothly instead. The shoreline
+ * fade has filtered this way all along (waterColumnAt callers); the foam and
+ * edge bands were still on one tap each.
+ */
+float filteredSceneDepth(vec2 uv) {
+  float c = linearizeDepth(texture2D(uDepthTexture, uv).r, uCameraNear, uCameraFar);
+  float l = linearizeDepth(texture2D(uDepthTexture, uv - vec2(uScenePassTexel.x, 0.0)).r, uCameraNear, uCameraFar);
+  float r = linearizeDepth(texture2D(uDepthTexture, uv + vec2(uScenePassTexel.x, 0.0)).r, uCameraNear, uCameraFar);
+  float d = linearizeDepth(texture2D(uDepthTexture, uv - vec2(0.0, uScenePassTexel.y)).r, uCameraNear, uCameraFar);
+  float u = linearizeDepth(texture2D(uDepthTexture, uv + vec2(0.0, uScenePassTexel.y)).r, uCameraNear, uCameraFar);
+  return c * 0.4 + (l + r + d + u) * 0.15;
+}
+
 float calculateFoam() {
   // incanto v2: foam rides the always-on scene depth pass — both gates
   if (uEnableFoam < 0.5 || uUseSceneDepth < 0.5) return 0.0;
@@ -1287,12 +1317,10 @@ float calculateFoam() {
   // Convert screen coordinates to texture coordinates
   vec2 screenUV = vScreenPosition.xy / vScreenPosition.w * 0.5 + 0.5;
 
-  // Sample scene depth value from depth texture
-  float sceneDepth = texture2D(uDepthTexture, screenUV).r;
   float waterDepth = gl_FragCoord.z;
 
-  // Convert to linear depth
-  float linearSceneDepth = linearizeDepth(sceneDepth, uCameraNear, uCameraFar);
+  // Convert to linear depth (scene side cross-filtered, see above)
+  float linearSceneDepth = filteredSceneDepth(screenUV);
   float linearWaterDepth = linearizeDepth(waterDepth, uCameraNear, uCameraFar);
 
   // Calculate depth difference (distance between water and other objects)
@@ -1344,10 +1372,9 @@ float calculateEdgeBlending() {
   if (uEnableFoam < 0.5 || uUseSceneDepth < 0.5 || uEdgeIntensity <= 0.0) return 0.0;
 
   vec2 screenUV = vScreenPosition.xy / vScreenPosition.w * 0.5 + 0.5;
-  float sceneDepth = texture2D(uDepthTexture, screenUV).r;
   float waterDepth = gl_FragCoord.z;
 
-  float linearSceneDepth = linearizeDepth(sceneDepth, uCameraNear, uCameraFar);
+  float linearSceneDepth = filteredSceneDepth(screenUV); // cross-filtered — one tap boils
   float linearWaterDepth = linearizeDepth(waterDepth, uCameraNear, uCameraFar);
 
   float depthDiff = abs(linearSceneDepth - linearWaterDepth);
@@ -1379,7 +1406,24 @@ void main() {
     linearSceneDepth = linearizeDepth(sceneDepth, uCameraNear, uCameraFar);
 
     float depthDiff = linearWaterDepth - linearSceneDepth;
-    waterViewDepth = max(-depthDiff, 0.0);
+
+    // The depth texture DELIBERATELY holds above-water geometry too (the
+    // depth-completion pass, for cutouts) — so a sample NEARER than this
+    // fragment cannot be a bed, and treating it as "column 0" rendered the
+    // water as clear glass over the bare bed. Behind a tree the half-res
+    // pre-pass smears the canopy across the gaps between its own leaves, and
+    // whole stretches of pond turned to glass — "the water isn't drawn". The
+    // column reads the DEEPEST of the 5-tap neighborhood instead; when even
+    // that is contaminated, depth is UNKNOWN (-1) and the flat-ramp fallback
+    // paints honest murk.
+    float seamL = linearizeDepth(texture2D(uDepthTexture, screenUV - vec2(uScenePassTexel.x, 0.0)).r, uCameraNear, uCameraFar);
+    float seamR = linearizeDepth(texture2D(uDepthTexture, screenUV + vec2(uScenePassTexel.x, 0.0)).r, uCameraNear, uCameraFar);
+    float seamD = linearizeDepth(texture2D(uDepthTexture, screenUV - vec2(0.0, uScenePassTexel.y)).r, uCameraNear, uCameraFar);
+    float seamU = linearizeDepth(texture2D(uDepthTexture, screenUV + vec2(0.0, uScenePassTexel.y)).r, uCameraNear, uCameraFar);
+    float seamFarthest = max(max(seamL, seamR), max(seamD, max(seamU, linearSceneDepth)));
+    if (seamFarthest > linearWaterDepth + 0.02) {
+      waterViewDepth = seamFarthest - linearWaterDepth;
+    }
 
     // waterline dither: on a near-flat beach one half-res depth texel spans a
     // wide screen block at grazing view, so these thresholds cut staircase
@@ -1390,10 +1434,21 @@ void main() {
     float seamJitter =
       (noise(vWorldPosition.xz * 3.1) * 0.65 + noise(vWorldPosition.xz * 8.7) * 0.35 - 0.5) * 0.035;
 
+    // This discard exists for ONE thing: dithering the waterline seam — an
+    // organic jittered edge in the few centimetres where half-res depth
+    // quantisation would carve staircase notches. TRUE occlusion is the
+    // hardware depth test's job (depthTest is on, and anything opaque wrote
+    // full-res depth): a water fragment that reached this shader is, by the
+    // full-res buffer's word, VISIBLE. So a pre-pass sample far in front of it
+    // can only be the half-res lie — a tree canopy smearing near-depth across
+    // the gaps between its own leaves — and acting on it erased the whole pond
+    // when viewed through or past a tree. Only the seam band may discard.
+    bool seamEligible = depthDiff < 0.45;
+
     // 🎯 Two-step approach
     // Step 1: Discard completely overlapping parts
     float hardDiscardThreshold = 0.1 + seamJitter;
-    if (depthDiff > hardDiscardThreshold) {
+    if (seamEligible && depthDiff > hardDiscardThreshold) {
       discard; // Completely remove definitively overlapping pixels
     }
 
@@ -1401,7 +1456,7 @@ void main() {
     float softDiscardStart = -0.05 + seamJitter; // Start fade slightly ahead
     float softDiscardEnd = hardDiscardThreshold;
 
-    if (depthDiff > softDiscardStart) {
+    if (seamEligible && depthDiff > softDiscardStart) {
       depthMask = 1.0 - smoothstep(softDiscardStart, softDiscardEnd, depthDiff);
       // At border: 0 (fully transparent) ~ 1 (fully opaque)
     }
@@ -2160,18 +2215,22 @@ function validateCollider3D(collider, nodeName) {
 		return;
 	}
 	if (shape === "heightfield") return;
-	throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': "shape" must be 'box', 'sphere', 'capsule', 'trimesh', or 'heightfield', got ${JSON.stringify(shape)}.`);
+	if (shape === "auto") return;
+	throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': "shape" must be 'auto', 'box', 'sphere', 'capsule', 'trimesh', or 'heightfield', got ${JSON.stringify(shape)}.`);
 }
 //#endregion
 //#region src/3d/nodes/node-3d.ts
-/**
-* Base of every 3D node: a JSON-prop transform backed by a `THREE.Object3D`.
-*
-* Props stay plain JSON (registry/serializer compatible); the renderer layer
-* pushes them onto the backing object once per frame (`_syncObject3D`).
-* Rotation is in DEGREES in JSON — friendlier for agents and humans.
-*/
-var Node3D = class extends Node {
+/** The first ground-answering node in the tree, searched depth-first. */
+function firstGroundIn(root) {
+	const probe = root;
+	if (probe.constructor?.typeName === "Terrain3D" && typeof probe.heightAt === "function") return root;
+	for (const child of root.children) {
+		const found = firstGroundIn(child);
+		if (found) return found;
+	}
+	return null;
+}
+var Node3D = class Node3D extends Node {
 	static typeName = "Node3D";
 	static props = {
 		position: { default: [
@@ -2202,7 +2261,8 @@ var Node3D = class extends Node {
 				"effects",
 				"overlay"
 			]
-		}
+		},
+		snapToGround: { default: null }
 	};
 	position = [
 		0,
@@ -2236,6 +2296,23 @@ var Node3D = class extends Node {
 	renderOrder = 0;
 	/** Named draw-order band; `renderOrder` is the fine offset inside it. */
 	orderGroup = "default";
+	/**
+	* PUT THIS ON THE GROUND. `true` sets the node's Y from the terrain under it
+	* at load; a number does the same and lifts it by that many metres (a post
+	* whose origin sits at its middle wants half its height).
+	*
+	* Computing a Y by hand is the single most repeated mistake in scene
+	* authoring, and it is not a careless one: the number is right when it is
+	* written and wrong the moment anything reshapes the ground — a river carving
+	* its bed, a basin, a different seed, a generator that mirrors the carve
+	* slightly differently. Every "floating boulder", "buried player" and
+	* "bridge posts in mid-air" in this engine's history is that drift.
+	*
+	* With this the ground is asked at load, in the same frame the terrain is
+	* built, and there is nothing to drift from. `null` (default) leaves `y`
+	* exactly as authored — for anything that genuinely hangs in the air.
+	*/
+	snapToGround = null;
 	/** What three actually sorts by: band base + renderOrder. */
 	get effectiveRenderOrder() {
 		return effectiveOrder(this.orderGroup, this.renderOrder);
@@ -2249,6 +2326,47 @@ var Node3D = class extends Node {
 	*/
 	_interpPrev = null;
 	_interpCurr = null;
+	onReady() {
+		this.applyGroundSnap();
+	}
+	/**
+	* Resolve {@link snapToGround} against the terrain under this node.
+	*
+	* Ancestor transforms are translation-only here, the same contract heightAt
+	* and the physics heightfield already follow, so the world height converts
+	* back to a local Y by subtracting the parents' offset.
+	*/
+	applyGroundSnap() {
+		if (this.snapToGround === null || this.snapToGround === false) return;
+		const lift = this.snapToGround === true ? 0 : this.snapToGround;
+		const terrain = firstGroundIn(this.getRoot());
+		if (!terrain) return;
+		let ox = this.position[0] ?? 0;
+		let oy = 0;
+		let oz = this.position[2] ?? 0;
+		for (let n = this.parent; n; n = n.parent) {
+			if (!(n instanceof Node3D)) continue;
+			const yaw = (n.rotation[1] ?? 0) * Math.PI / 180;
+			if (yaw !== 0) {
+				const c = Math.cos(yaw);
+				const sn = Math.sin(yaw);
+				const rx = ox * c + oz * sn;
+				const rz = -ox * sn + oz * c;
+				ox = rx;
+				oz = rz;
+			}
+			ox += n.position[0] ?? 0;
+			oy += n.position[1] ?? 0;
+			oz += n.position[2] ?? 0;
+		}
+		const worldX = ox;
+		const worldZ = oz;
+		this.position = [
+			this.position[0] ?? 0,
+			terrain.heightAt(worldX, worldZ) + lift - oy,
+			this.position[2] ?? 0
+		];
+	}
 	/** @internal The backing three object (lazily created). */
 	_ensureObject3D() {
 		if (!this._object3D) {
@@ -2291,7 +2409,38 @@ var Node3D = class extends Node {
 * `{shape:'capsule', radius, height}` (meters, y-up).
 */
 var PhysicsBody3D = class extends Node3D {
-	static props = { collider: { default: {} } };
+	static props = { collider: {
+		default: {},
+		variants: {
+			tag: "shape",
+			byTag: {
+				auto: { shape: "auto" },
+				box: {
+					shape: "box",
+					size: [
+						1,
+						1,
+						1
+					]
+				},
+				sphere: {
+					shape: "sphere",
+					radius: .5
+				},
+				capsule: {
+					shape: "capsule",
+					radius: .35,
+					height: 1
+				},
+				trimesh: {
+					shape: "trimesh",
+					vertices: [],
+					indices: []
+				},
+				heightfield: { shape: "heightfield" }
+			}
+		}
+	} };
 	/** The unified collision model: every collider participant can emit these. */
 	static signals = ["triggerEnter", "triggerExit"];
 	_collider = {};
@@ -2561,24 +2710,24 @@ const WATER_PRESETS = {
 		}
 	},
 	pond: {
-		waveHeight: .012,
+		waveHeight: .006,
 		swell: 0,
 		whitecaps: 0,
-		absorption: .55,
-		opacity: .88,
-		detailStrength: .2,
-		sunIntensity: .9,
+		absorption: .85,
+		opacity: .93,
+		detailStrength: .14,
+		sunIntensity: .7,
 		colors: {
-			trough: "#24402a",
-			surface: "#436b4d",
-			peak: "#8fae8e"
+			trough: "#1c2e1e",
+			surface: "#39543c",
+			peak: "#6f8a68"
 		},
-		color: "#436b4d",
+		color: "#39543c",
 		causticsAbove: 0,
 		reflectionInterval: 800,
 		_look: {
-			fresnelScale: 1.1,
-			reflectivityMax: .68,
+			fresnelScale: 1.05,
+			reflectivityMax: .78,
 			edgeFade: false
 		}
 	}
@@ -2731,6 +2880,7 @@ var Water3D = class Water3D extends Node3D {
 		mirrorInterval: { default: 33 },
 		swellSteepness: { default: .35 },
 		foam: { default: true },
+		reflectivity: { default: null },
 		interaction: { default: true },
 		splash: { default: true },
 		sunDirection: { default: [
@@ -2790,6 +2940,16 @@ var Water3D = class Water3D extends Node3D {
 	reflectionInterval = 1e3;
 	/** Depth-texture shoreline foam — rides the always-on fancy scene pass. */
 	foam = true;
+	/**
+	* How much sky the surface throws back at grazing angles, 0..1 — `null`
+	* keeps the preset's own ceiling.
+	*
+	* Turn it DOWN when the sky is blown out: a bright overcast reflected at 0.78
+	* is a sheet of white, and a pool doing that next to a River3D (which paints
+	* an AUTHORED sky palette and so never blows out) reads as two unrelated
+	* materials meeting at a line. Turn it up for a mirror-calm lake.
+	*/
+	reflectivity = null;
 	/** Bodies crossing the surface emit signals and raise ripples. */
 	interaction = true;
 	/** Splash WHITEWATER: the shaders paint expanding surface foam where bodies
@@ -2880,9 +3040,10 @@ var Water3D = class Water3D extends Node3D {
 	/** Per-preset internal look constants (fresnel curve, reflection ceiling). */
 	presetLook() {
 		const look = WATER_PRESETS[this.preset]?._look;
+		const asked = this.rp("reflectivity");
 		return {
 			fresnelScale: look?.fresnelScale ?? FANCY_LOOK.fresnelScale,
-			reflectivityMax: look?.reflectivityMax ?? .6,
+			reflectivityMax: typeof asked === "number" ? Math.min(Math.max(asked, 0), 1) : look?.reflectivityMax ?? .6,
 			edgeFade: look?.edgeFade ?? true,
 			foamRangeScale: look?.foamRangeScale ?? 1,
 			foamIntensity: look?.foamIntensity ?? FOAM_LOOK.intensity
@@ -2962,6 +3123,9 @@ var Water3D = class Water3D extends Node3D {
 	mirrorCamera = new PerspectiveCamera();
 	mirrorMatrix = new Matrix4();
 	lastMirrorAt = 0;
+	/** Camera pose the current mirror image was rendered from (see redraw). */
+	lastMirrorEye = new Vector3(Infinity, Infinity, Infinity);
+	lastMirrorQuat = new Quaternion();
 	_createObject3D() {
 		return new Mesh();
 	}
@@ -3044,7 +3208,8 @@ var Water3D = class Water3D extends Node3D {
 			if (!this.mirrorTarget) this.mirrorTarget = new WebGLRenderTarget(mirrorW, mirrorH, {
 				depthBuffer: true,
 				stencilBuffer: false,
-				type: HalfFloatType
+				type: HalfFloatType,
+				samples: 4
 			});
 			const surfaceY = worldTranslationOf(this).y;
 			const cam = ctx.camera;
@@ -3065,11 +3230,15 @@ var Water3D = class Water3D extends Node3D {
 			mirrorCam.lookAt(mirrorTargetScratch);
 			mirrorCam.updateMatrixWorld(true);
 			mirrorCam.updateProjectionMatrix();
-			this.mirrorMatrix.set(.5, 0, 0, .5, 0, .5, 0, .5, 0, 0, .5, .5, 0, 0, 0, 1);
-			this.mirrorMatrix.multiply(mirrorCam.projectionMatrix);
-			this.mirrorMatrix.multiply(mirrorCam.matrixWorldInverse);
-			if (this.lastMirrorAt === 0 || now - this.lastMirrorAt >= this.rp("mirrorInterval")) {
+			cam.getWorldPosition(mirrorPrevEyeCheck);
+			const moved = mirrorPrevEyeCheck.distanceToSquared(this.lastMirrorEye) > 1e-6 || Math.abs(mirrorQuatScratch.dot(this.lastMirrorQuat)) < .9999995;
+			if (this.lastMirrorAt === 0 || moved || now - this.lastMirrorAt >= this.rp("mirrorInterval")) {
 				this.lastMirrorAt = now;
+				this.lastMirrorEye.copy(mirrorPrevEyeCheck);
+				this.lastMirrorQuat.copy(mirrorQuatScratch);
+				this.mirrorMatrix.set(.5, 0, 0, .5, 0, .5, 0, .5, 0, 0, .5, .5, 0, 0, 0, 1);
+				this.mirrorMatrix.multiply(mirrorCam.projectionMatrix);
+				this.mirrorMatrix.multiply(mirrorCam.matrixWorldInverse);
 				const prevMirrorTarget = ctx.gl.getRenderTarget();
 				const prevMirrorClip = ctx.gl.clippingPlanes;
 				const wasMirrorVisible = mesh.visible;
@@ -3565,6 +3734,19 @@ var Water3D = class Water3D extends Node3D {
 		const center = worldTranslationOf(this, this._scratchA);
 		return center.y + this.waveOffsetAt(x, z, center);
 	}
+	/**
+	* @internal Water surface height over a world point, or null outside this
+	* surface's footprint — what scattered vegetation asks before it plants a
+	* blade (see {@link WetSurface}). The STILL level, not the wave: grass does
+	* not come and go with the swash.
+	*/
+	_waterYAt(x, z) {
+		const center = worldTranslationOf(this, this._scratchA);
+		const halfX = (this.size[0] ?? 0) / 2;
+		const halfZ = (this.size[1] ?? 0) / 2;
+		if (Math.abs(x - center.x) > halfX || Math.abs(z - center.z) > halfZ) return null;
+		return center.y;
+	}
 	/** Base wave height at world (x, z) — the CPU twin of the active shader.
 	* Ripples are excluded on purpose: a splash must not re-trigger itself. */
 	waveOffsetAt(x, z, center) {
@@ -3684,6 +3866,7 @@ const UNDERWATER_MARGIN = 3;
 /** Keep-below clip plane for the scene pre-pass (constant set per render):
 * normal (0,−1,0) keeps y < constant — see the grab-clip note in _onRender3D. */
 const mirrorEyeScratch = new Vector3();
+const mirrorPrevEyeCheck = new Vector3();
 const mirrorTargetScratch = new Vector3();
 const mirrorUpScratch = new Vector3();
 const mirrorQuatScratch = new Quaternion();

package/dist/gameplay.d.ts

@@ -1,5 +1,5 @@
 import { c as JsonValue, s as JsonObject } from "./schema-CcoWb32N.js";
-import { $ as Node, l as PropSchema, n as BehaviorCtor, t as Behavior, v as Engine } from "./behavior-CPibUfnH.js";
+import { $ as Node, l as PropSchema, n as BehaviorCtor, t as Behavior, v as Engine } from "./behavior-BAc0erXF.js";
 
 //#region src/gameplay/chase.d.ts
 /**

package/dist/gameplay.js

@@ -1,2 +1,2 @@
-import { C as FollowCamera, D as Health, E as DamageOnContact, O as Collector, S as restartScene, T as phaseOf, _ as hitStop, a as Wander, b as GameFlow, c as Projectile, d as PathFollow, f as Oscillate, g as Cooldown, h as CameraShake, i as WaveSpawner, k as Chase, l as Pickup, m as Lifetime, n as registerGameplayBehaviors, o as Spawner, p as MoveTo, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Patrol, v as screenFlash, w as DayNight, x as goToScene, y as Interactable } from "./gameplay-Ddk13pQ6.js";
+import { C as FollowCamera, D as Health, E as DamageOnContact, O as Collector, S as restartScene, T as phaseOf, _ as hitStop, a as Wander, b as GameFlow, c as Projectile, d as PathFollow, f as Oscillate, g as Cooldown, h as CameraShake, i as WaveSpawner, k as Chase, l as Pickup, m as Lifetime, n as registerGameplayBehaviors, o as Spawner, p as MoveTo, r as ZombieAI, s as ScoreKeeper, t as GAMEPLAY_BEHAVIORS, u as Patrol, v as screenFlash, w as DayNight, x as goToScene, y as Interactable } from "./gameplay-L05WgWd1.js";
 export { CameraShake, Chase, Collector, Cooldown, DamageOnContact, DayNight, FollowCamera, GAMEPLAY_BEHAVIORS, GameFlow, Health, Interactable, Lifetime, MoveTo, Oscillate, PathFollow, Patrol, Pickup, Projectile, ScoreKeeper, Spawner, Wander, WaveSpawner, ZombieAI, goToScene, hitStop, phaseOf, registerGameplayBehaviors, restartScene, screenFlash };

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { a as Rng, c as JsonValue, d as jsonKind, i as SceneJson, l as jsonClone, n as NodeJson, o as JsonKind, r as SCENE_FORMAT, s as JsonObject, t as ConnectionJson, u as jsonEquals } from "./schema-CcoWb32N.js";
-import { $ as Node, A as SfxPlayOptions, B as spatialPan, C as RendererStats, D as LogManager, E as LogLevel, F as ROLLOFF_MODELS, G as SynthOptions, H as SFX_PRESET_NAMES, I as RolloffModel, J as MusicManager, K as synthSfx, L as SpatialParams, M as Voice, N as VoicePreset, O as InputMap, P as Listener, Q as BusName, R as Vec3, S as GameStats, T as LogEntry, U as SfxParams, V as SFX_PRESETS, W as SfxWave, X as PlayMusicOptions, Y as MusicTrack, Z as AudioBuses, _ as registeredTypes, a as registerBehavior, b as Scheduler, c as PropDef, d as createNode, et as NodeLifecycle, f as getNodeSchema, g as registerNode, h as mergeStaticSignals, i as getBehavior, j as isAudioContextAvailable, k as SfxEngine, l as PropSchema, m as getNodeType, n as BehaviorCtor, nt as SignalListener, o as registeredBehaviors, p as getNodeSignals, q as MusicBackend, r as clearBehaviors, rt as SceneTree, s as NodeCtor, t as Behavior, tt as Signal, u as clearRegistry, v as Engine, w as Scene, x as EngineStats, y as EngineOptions, z as spatialGain } from "./behavior-CPibUfnH.js";
-import { n as loadScene, t as LoadSceneOptions } from "./loader-DILt9PGC.js";
+import { $ as Node, A as SfxPlayOptions, B as spatialPan, C as RendererStats, D as LogManager, E as LogLevel, F as ROLLOFF_MODELS, G as SynthOptions, H as SFX_PRESET_NAMES, I as RolloffModel, J as MusicManager, K as synthSfx, L as SpatialParams, M as Voice, N as VoicePreset, O as InputMap, P as Listener, Q as BusName, R as Vec3, S as GameStats, T as LogEntry, U as SfxParams, V as SFX_PRESETS, W as SfxWave, X as PlayMusicOptions, Y as MusicTrack, Z as AudioBuses, _ as registeredTypes, a as registerBehavior, b as Scheduler, c as PropDef, d as createNode, et as NodeLifecycle, f as getNodeSchema, g as registerNode, h as mergeStaticSignals, i as getBehavior, j as isAudioContextAvailable, k as SfxEngine, l as PropSchema, m as getNodeType, n as BehaviorCtor, nt as SignalListener, o as registeredBehaviors, p as getNodeSignals, q as MusicBackend, r as clearBehaviors, rt as SceneTree, s as NodeCtor, t as Behavior, tt as Signal, u as clearRegistry, v as Engine, w as Scene, x as EngineStats, y as EngineOptions, z as spatialGain } from "./behavior-BAc0erXF.js";
+import { n as loadScene, t as LoadSceneOptions } from "./loader-B242FF6N.js";
 import { n as ParticleSimConfig, r as ParticleView, t as ParticleSim } from "./particle-sim-CwJ5rI_P.js";
-import { a as AudioElementLike, i as gridFromRows, n as PathGrid, o as AudioPlayer, r as findPath, t as FindPathOptions } from "./pathfinding-RWYkNKx9.js";
+import { a as AudioElementLike, i as gridFromRows, n as PathGrid, o as AudioPlayer, r as findPath, t as FindPathOptions } from "./pathfinding-BwD974Ss.js";
 import { i as auditScene, n as IncantoErrorCode, r as IncantoErrorDetails, t as IncantoError } from "./errors-1dXlIwoR.js";
 
 //#region src/core/audio/crossfade.d.ts
@@ -49,6 +49,13 @@ interface DebugLineSource {
   readonly dimension: "2d" | "3d";
   /** Toggle at runtime: `physics.debugDraw = true`. */
   debugDraw: boolean;
+  /**
+  * Draw only the colliders under this node (its subtree, or the nearest body
+  * above it when the node itself carries none). Null draws every collider in
+  * the world — which on a real map is a terrain grid burying the one shape you
+  * meant to look at.
+  */
+  debugScope: object | null;
   /** Flat segment vertices (xy pairs in 2D px, xyz triples in 3D meters), or null while off. */
   debugLines(): Float32Array | null;
 }
@@ -108,6 +115,18 @@ declare class HudLayer extends Node {
   _element: HTMLElement | null;
   private readonly slots;
   override onEnterTree(): void;
+  /**
+  * 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.
+  */
+  private _mount;
   override onExitTree(): void;
   override update(): void;
   /** @internal Widgets mount into per-anchor flex columns. */

package/dist/index.js

@@ -1,5 +1,5 @@
 import { _ as registerBehavior, a as SCENE_FORMAT, c as SceneTree, d as resolveConstants, f as Node, g as getBehavior, h as clearBehaviors, i as serializeNode, l as CONST_REF_KEY, m as Behavior, n as loadScene, o as computeViewport, p as parseNodePath, r as Scene, s as resolveViewport, u as isConstRef, v as registeredBehaviors, y as Signal } from "./loader-BZqOKfI2.js";
-import { C as crossfadeGains, S as WebAudioMusicBackend, T as AudioBuses, _ as spatialPan, a as HudLayer, b as synthSfx, c as UiText, d as LogManager, f as InputMap, g as spatialGain, h as ROLLOFF_MODELS, i as UiDialogue, l as AudioPlayer, m as isAudioContextAvailable, n as Timer, o as UiBanner, p as SfxEngine, r as UiButton, s as UiBar, t as registerCoreNodes, u as Engine, v as SFX_PRESETS, w as fadeGain, x as MusicManager, y as SFX_PRESET_NAMES } from "./register-nObreUQR.js";
+import { C as crossfadeGains, S as WebAudioMusicBackend, T as AudioBuses, _ as spatialPan, a as HudLayer, b as synthSfx, c as UiText, d as LogManager, f as InputMap, g as spatialGain, h as ROLLOFF_MODELS, i as UiDialogue, l as AudioPlayer, m as isAudioContextAvailable, n as Timer, o as UiBanner, p as SfxEngine, r as UiButton, s as UiBar, t as registerCoreNodes, u as Engine, v as SFX_PRESETS, w as fadeGain, x as MusicManager, y as SFX_PRESET_NAMES } from "./register-BTg0EM7s.js";
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-DP-SR7eg.js";
 import { t as auditScene } from "./audit-C6rMyict.js";
@@ -295,6 +295,6 @@ function newUid() {
 //#endregion
 //#region src/index.ts
 /** Engine version. Kept in sync with package.json by the release pipeline. */
-const VERSION = "0.27.0";
+const VERSION = "0.29.0";
 //#endregion
 export { AudioBuses, AudioPlayer, Behavior, CONST_REF_KEY, Engine, HudLayer, IncantoError, InputMap, LogManager, MusicManager, Node, ORDER_GROUP_BASE, PARTICLE_PRESETS, PARTICLE_PRESET_NAMES, ParticleSim, ROLLOFF_MODELS, Rng, SCENE_FORMAT, SFX_PRESETS, SFX_PRESET_NAMES, Scene, SceneTree, SfxEngine, Signal, Timer, TouchControls, UiBanner, UiBar, UiButton, UiDialogue, UiText, VERSION, WebAudioMusicBackend, applyParticlePreset, assetUrls, attachTouchControls, auditScene, clearBehaviors, clearRegistry, computeViewport, createNode, createNoise2D, createSaveStore, crossfadeGains, duplicateNode, effectiveOrder, fadeGain, findPath, getBehavior, getNodeSchema, getNodeSignals, getNodeType, gridFromRows, isAudioContextAvailable, isConstRef, joystickVector, jsonClone, jsonEquals, jsonKind, loadScene, mergeStaticSignals, newUid, parseNodePath, preloadUrls, registerBehavior, registerCoreNodes, registerNode, registeredBehaviors, registeredTypes, replay, resolveConstants, resolveRendering, resolveViewport, serializeNode, spatialGain, spatialPan, startRecording, synthSfx };

package/dist/{loader-DILt9PGC.d.ts → loader-B242FF6N.d.ts}

@@ -1,5 +1,5 @@
 import { i as SceneJson } from "./schema-CcoWb32N.js";
-import { v as Engine, w as Scene } from "./behavior-CPibUfnH.js";
+import { v as Engine, w as Scene } from "./behavior-BAc0erXF.js";
 
 //#region src/core/scene/loader.d.ts
 interface LoadSceneOptions {

package/dist/net.d.ts

@@ -1,5 +1,5 @@
 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-CPibUfnH.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-nObreUQR.js";
+import { u as Engine } from "./register-BTg0EM7s.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-BFFE1Mh1.js";
+import { i as applySyncPatch, n as NetworkSpawner, r as NetworkManager, t as registerNodesNet } from "./register-MelqEdza.js";
 //#region src/net/loopback.ts
 /**
 * In-memory multiplayer hub implementing the SAME kernel contract as

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

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

package/dist/{physics-2d-DiVFFlH3.js → physics-2d-CCVTrKOd.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.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-CvpSUU3O.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 { n as registerDebugSource } from "./debug-draw-CZmOYjL2.js";
 //#region src/2d/physics/physics-2d.ts
 var physics_2d_exports = /* @__PURE__ */ __exportAll({
@@ -28,6 +28,8 @@ var Physics2D = 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 = "2d";
 	unregisterDebug;
 	warnedNoCollider = /* @__PURE__ */ new WeakSet();
@@ -157,11 +159,69 @@ var Physics2D = class {
 	/** Rapier debug segments, scaled back to pixels. Null while debugDraw is off. */
 	debugLines() {
 		if (!this.debugDraw) return null;
-		const raw = this.world.debugRender().vertices;
+		const raw = this.debugScope ? this.scopedLines(this.debugScope) : this.world.debugRender().vertices;
 		const px = new Float32Array(raw.length);
 		for (let i = 0; i < raw.length; i++) px[i] = raw[i] * SCALE;
 		return px;
 	}
+	/**
+	* Only the selected node's colliders (meters — the caller scales to pixels).
+	* Rapier draws the whole world or nothing, so a chosen few are outlined from
+	* the same shape data the solver holds. 2D colliders are rect/circle/capsule,
+	* which is the whole switch.
+	*/
+	scopedLines(node) {
+		const out = [];
+		const bodies = [];
+		const collect = (n) => {
+			const entry = this.entries.get(n);
+			if (entry) bodies.push(entry.body);
+			for (const child of n.children) collect(child);
+		};
+		collect(node);
+		for (let p = node.parent; p && bodies.length === 0; p = p.parent) {
+			const entry = this.entries.get(p);
+			if (entry) bodies.push(entry.body);
+		}
+		const RING = 24;
+		for (const body of bodies) for (let i = 0; i < body.numColliders(); i++) {
+			const collider = body.collider(i);
+			if (!collider) continue;
+			const t = collider.translation();
+			const angle = collider.rotation();
+			const cos = Math.cos(angle);
+			const sin = Math.sin(angle);
+			const put = (x, y) => {
+				out.push(t.x + x * cos - y * sin, t.y + x * sin + y * cos);
+			};
+			const seg = (ax, ay, bx, by) => {
+				put(ax, ay);
+				put(bx, by);
+			};
+			const shape = collider.shape;
+			if (shape.halfExtents) {
+				const { x, y } = shape.halfExtents;
+				seg(-x, -y, x, -y);
+				seg(x, -y, x, y);
+				seg(x, y, -x, y);
+				seg(-x, y, -x, -y);
+			} else if (shape.radius !== void 0) {
+				const r = shape.radius;
+				const half = shape.halfHeight ?? 0;
+				for (let k = 0; k < RING; k++) {
+					const a = k / RING * Math.PI * 2;
+					const b = (k + 1) / RING * Math.PI * 2;
+					const lift = (v) => v >= 0 ? half : -half;
+					seg(Math.cos(a) * r, Math.sin(a) * r + lift(Math.sin(a)), Math.cos(b) * r, Math.sin(b) * r + lift(Math.sin(b)));
+				}
+				if (half > 0) {
+					seg(-r, -half, -r, half);
+					seg(r, -half, r, half);
+				}
+			}
+		}
+		return new Float32Array(out);
+	}
 	/** Create newly-arrived joints; tear down departed ones. */
 	syncJoints(structureChanged) {
 		const R = this.R;