incanto 0.20.0 → 0.22.0

package/dist/{register-BWFgsGra.js → register-CHgVdSbp.js}

@@ -1,12 +1,12 @@
-import { f as Node } from "./loader-BZqOKfI2.js";
 import { t as registerCoreNodes } from "./register-nObreUQR.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-BVJ2HbCn.js";
 import { t as createNoise2D } from "./noise-CGUMx44x.js";
-import { i as applyParticlePreset, o as effectiveOrder, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-CyUU7HVU.js";
+import { i as applyParticlePreset, r as PARTICLE_PRESET_NAMES, t as ParticleSim } from "./particle-sim-Bw7hB93B.js";
+import { A as Water3D, B as colliderFootDrop, F as StaticBody3D, I as Node3D, M as CharacterBody3D, N as PhysicsBody3D, P as RigidBody3D, j as Area3D } from "./gameplay-Dib5mNFD.js";
 import { n as splatWeights, t as buildHeightmap } from "./heightmap-CRK0M4jT.js";
-import { AdditiveBlending, AnimationClip, AnimationMixer, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CapsuleGeometry, Color, ConeGeometry, CubeCamera, CylinderGeometry, DataTexture, DepthTexture, DirectionalLight, DoubleSide, DynamicDrawUsage, Euler, FloatType, Frustum, Group, HalfFloatType, IcosahedronGeometry, ImageBitmapLoader, InstancedBufferAttribute, InstancedMesh, LinearFilter, LinearMipmapLinearFilter, LoopOnce, LoopRepeat, MathUtils, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshPhysicalMaterial, MeshStandardMaterial, NearestFilter, NoBlending, NormalBlending, Object3D, PerspectiveCamera, Plane, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, QuaternionKeyframeTrack, RGBADepthPacking, RGBAFormat, RepeatWrapping, SRGBColorSpace, ShaderChunk, ShaderMaterial, Sphere, SphereGeometry, Texture, TextureLoader, UniformsLib, UniformsUtils, Vector2, Vector3, Vector4, VectorKeyframeTrack, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
+import { AdditiveBlending, AnimationClip, AnimationMixer, Box3, BoxGeometry, BufferAttribute, BufferGeometry, CanvasTexture, CapsuleGeometry, Color, ConeGeometry, CylinderGeometry, DataTexture, DirectionalLight, DoubleSide, DynamicDrawUsage, Euler, Group, IcosahedronGeometry, ImageBitmapLoader, InstancedBufferAttribute, InstancedMesh, LinearFilter, LoopOnce, LoopRepeat, Matrix4, Mesh, MeshBasicMaterial, MeshDepthMaterial, MeshPhysicalMaterial, MeshStandardMaterial, NearestFilter, NoBlending, NormalBlending, PerspectiveCamera, PlaneGeometry, PointLight, Points, PointsMaterial, Quaternion, QuaternionKeyframeTrack, RGBADepthPacking, RGBAFormat, RepeatWrapping, SRGBColorSpace, ShaderChunk, ShaderMaterial, SphereGeometry, Texture, TextureLoader, UniformsLib, UniformsUtils, Vector3, Vector4, VectorKeyframeTrack } from "three";
 import { clone } from "three/addons/utils/SkeletonUtils.js";
 //#region src/3d/camera-rig.ts
 const QUARTER_PITCH = Math.atan(1 / Math.SQRT2);
@@ -151,269 +151,6 @@ function movementState(grounded, intensity) {
 	return "fastRun";
 }
 //#endregion
-//#region src/3d/physics/collider-validate.ts
-/**
-* Hard-validate a 3D collider prop at LOAD time (see the 2D twin for rationale).
-* An EMPTY collider is allowed — a body without a collider is work in progress.
-*/
-function validateCollider3D(collider, nodeName) {
-	const shape = collider.shape;
-	if (shape === void 0) return;
-	if (shape === "box") {
-		const size = collider.size;
-		if (!Array.isArray(size) || size.length !== 3 || size.some((v) => typeof v !== "number")) throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': box needs "size": [x, y, z].`);
-		return;
-	}
-	if (shape === "sphere") {
-		if (typeof collider.radius !== "number") throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': sphere needs "radius".`);
-		return;
-	}
-	if (shape === "capsule") {
-		if (typeof collider.radius !== "number" || typeof collider.height !== "number") throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': capsule needs "radius" and "height".`);
-		return;
-	}
-	if (shape === "trimesh") {
-		const vertices = collider.vertices;
-		const indices = collider.indices;
-		if (!Array.isArray(vertices) || vertices.length % 3 !== 0 || !Array.isArray(indices) || indices.length % 3 !== 0) throw new IncantoError("BAD_FORMAT", `Collider on '${nodeName}': trimesh needs "vertices" (flat xyz floats) and "indices" (triangle triplets).`);
-		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)}.`);
-}
-//#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 {
-	static typeName = "Node3D";
-	static props = {
-		position: { default: [
-			0,
-			0,
-			0
-		] },
-		rotation: { default: [
-			0,
-			0,
-			0
-		] },
-		static: { default: false },
-		scale: { default: [
-			1,
-			1,
-			1
-		] },
-		visible: { default: true },
-		renderOrder: { default: 0 },
-		orderGroup: {
-			default: "default",
-			options: [
-				"background",
-				"terrain",
-				"default",
-				"characters",
-				"effects",
-				"overlay"
-			]
-		}
-	};
-	position = [
-		0,
-		0,
-		0
-	];
-	/** Euler XYZ in degrees. */
-	rotation = [
-		0,
-		0,
-		0
-	];
-	/**
-	* This subtree never changes after load: the renderer syncs it ONCE and
-	* skips it every frame after (transforms, materials, animations frozen).
-	* The per-frame walk is O(nodes) — marking terrain/buildings/decor static
-	* removes most of a big scene from it. Set `static = false` to resume
-	* live syncing. Do NOT mark animated nodes (Water3D, Particles3D,
-	* AnimatedSprite3D, ModelInstance3D with clips) or cameras static.
-	*/
-	static = false;
-	scale = [
-		1,
-		1,
-		1
-	];
-	visible = true;
-	/** Draw-order priority (higher = drawn later / on top). Only affects TRANSPARENT
-	* materials — three sorts the transparent pass by renderOrder, then depth.
-	* Pairs with named scene constants (e.g. `{"@const": "UI"}`) for sorting tiers. */
-	renderOrder = 0;
-	/** Named draw-order band; `renderOrder` is the fine offset inside it. */
-	orderGroup = "default";
-	/** What three actually sorts by: band base + renderOrder. */
-	get effectiveRenderOrder() {
-		return effectiveOrder(this.orderGroup, this.renderOrder);
-	}
-	_object3D = null;
-	/**
-	* @internal Fixed-step render interpolation. A physics body fills these with
-	* its previous and current fixed-step LOCAL positions; `_syncObject3D(alpha)`
-	* lerps the rendered transform between them so motion is smooth between fixed
-	* steps. `null` means "not physics-driven" — render `position` directly.
-	*/
-	_interpPrev = null;
-	_interpCurr = null;
-	/** @internal The backing three object (lazily created). */
-	_ensureObject3D() {
-		if (!this._object3D) {
-			this._object3D = this._createObject3D();
-			this._object3D.userData.incantoNode = this;
-		}
-		return this._object3D;
-	}
-	/** @internal Override point for subclasses (mesh, camera, light…). */
-	_createObject3D() {
-		return new Object3D();
-	}
-	/** @internal Push JSON props onto the backing object. Called every frame.
-	*  `alpha` (0..1) interpolates a physics body between its last two fixed-step
-	*  positions; non-physics nodes ignore it and render `position` directly. */
-	_syncObject3D(alpha = 1) {
-		const o = this._ensureObject3D();
-		const prev = this._interpPrev;
-		const curr = this._interpCurr;
-		if (prev && curr) o.position.set((prev[0] ?? 0) + ((curr[0] ?? 0) - (prev[0] ?? 0)) * alpha, (prev[1] ?? 0) + ((curr[1] ?? 0) - (prev[1] ?? 0)) * alpha, (prev[2] ?? 0) + ((curr[2] ?? 0) - (prev[2] ?? 0)) * alpha);
-		else o.position.set(this.position[0] ?? 0, this.position[1] ?? 0, this.position[2] ?? 0);
-		o.rotation.set(MathUtils.degToRad(this.rotation[0] ?? 0), MathUtils.degToRad(this.rotation[1] ?? 0), MathUtils.degToRad(this.rotation[2] ?? 0));
-		o.scale.set(this.scale[0] ?? 1, this.scale[1] ?? 1, this.scale[2] ?? 1);
-		o.visible = this.visible;
-		o.renderOrder = this.effectiveRenderOrder;
-	}
-	free() {
-		super.free();
-		this._object3D?.removeFromParent();
-		this._object3D = null;
-		this._interpPrev = null;
-		this._interpCurr = null;
-	}
-};
-//#endregion
-//#region src/3d/nodes/bodies-3d.ts
-/**
-* Shared base for physics-backed 3D nodes. Colliders are NODE PROPS:
-* `{shape:'box', size:[x,y,z]}` · `{shape:'sphere', radius}` ·
-* `{shape:'capsule', radius, height}` (meters, y-up).
-*/
-var PhysicsBody3D = class extends Node3D {
-	static props = { collider: { default: {} } };
-	/** The unified collision model: every collider participant can emit these. */
-	static signals = ["triggerEnter", "triggerExit"];
-	_collider = {};
-	/** @internal Physics resync flag — raised when `collider` is REPLACED. */
-	_colliderChanged = false;
-	/**
-	* Collider shape prop. Change it by REPLACING the object
-	* (`body.collider = { shape: 'box', size: [...] }`) — physics rebuilds the
-	* body on replacement; in-place mutation of the old object is not watched.
-	*/
-	get collider() {
-		return this._collider;
-	}
-	set collider(value) {
-		this._collider = value;
-		this._colliderChanged = true;
-	}
-	/** Loader hook: bad collider shapes fail at LOAD, not at physics start. */
-	static validateJson(node) {
-		const body = node;
-		validateCollider3D(body.collider, node.name);
-		if (body.collider.shape === "heightfield" && !(body instanceof StaticBody3D)) throw new IncantoError("BAD_FORMAT", `Collider on '${node.name}': heightfield is static terrain — put it on a StaticBody3D (with a Terrain3D child), not a ${body.constructor.typeName}.`, { prop: "collider" });
-	}
-	/** @internal Set by Physics3D when the body is created. */
-	_physics = null;
-};
-/** Immovable collider (ground, walls, platforms). */
-var StaticBody3D = class extends PhysicsBody3D {
-	static typeName = "StaticBody3D";
-};
-/** Sensor volume emitting `triggerEnter(other)` / `triggerExit(other)`. */
-var Area3D = class extends PhysicsBody3D {
-	static typeName = "Area3D";
-};
-/** Dynamic simulated body. */
-var RigidBody3D = class extends PhysicsBody3D {
-	static typeName = "RigidBody3D";
-	static props = {
-		mass: { default: 1 },
-		gravityScale: { default: 1 },
-		fixedRotation: { default: false },
-		friction: { default: .5 },
-		restitution: { default: 0 },
-		linearVelocity: { default: [
-			0,
-			0,
-			0
-		] }
-	};
-	mass = 1;
-	gravityScale = 1;
-	fixedRotation = false;
-	friction = .5;
-	restitution = 0;
-	/** m/s, y-up. Read back every step; write to launch. */
-	linearVelocity = [
-		0,
-		0,
-		0
-	];
-	/** @internal set by Physics3D */
-	_physics3d = null;
-	/** World-space impulse (kg·m/s) — the floating-capsule controller's verb. */
-	applyImpulse(impulse) {
-		this._physics3d?.applyImpulse(this, impulse);
-	}
-};
-/**
-* Kinematic capsule on Rapier's character controller. Gravity is NOT applied
-* automatically — integrate `velocity` yourself, then `moveAndSlide()` from
-* `fixedUpdate`.
-*/
-var CharacterBody3D = class extends PhysicsBody3D {
-	static typeName = "CharacterBody3D";
-	static props = {
-		velocity: { default: [
-			0,
-			0,
-			0
-		] },
-		snapToGround: { default: true },
-		slopeLimitDeg: { default: 45 }
-	};
-	/** m/s, y-up (up = +y). */
-	velocity = [
-		0,
-		0,
-		0
-	];
-	snapToGround = true;
-	/** Max climbable slope angle. */
-	slopeLimitDeg = 45;
-	/** @internal Updated by Physics3D.moveAndSlide. */
-	_grounded = false;
-	moveAndSlide() {
-		if (!this._physics) throw new IncantoError("TREE_VIOLATION", this.collider.shape === void 0 ? `CharacterBody3D '${this.name}' has no collider — set a collider prop (physics skips collider-less bodies).` : `CharacterBody3D '${this.name}' has no physics world — await enablePhysics3D(engine) first.`);
-		this._physics.moveAndSlide(this);
-	}
-	isOnFloor() {
-		return this._grounded;
-	}
-};
-//#endregion
 //#region src/3d/nodes/joint-3d.ts
 /**
 * A physics joint linking its PARENT body to `target` (a node path to the
@@ -6684,121 +6421,6 @@ function softSprite() {
 	return tex;
 }
 //#endregion
-//#region src/3d/water/interaction.ts
-/**
-* Water3D character interaction — pure functions, no three, node-env testable.
-*
-* The node samples physics bodies each update, detects waterline crossings
-* (`detectCrossings`), and converts them into ripple impulses in a FIXED-SIZE
-* ring buffer that mirrors the shader's `uRipples[8]` uniform array
-* (`pushRipple` / `ageRipples`). `rippleHeight` is the exact ring-wave shape
-* the vertex shader evaluates — `quality: 'simple'` runs it on the CPU.
-*/
-/** Ring-buffer capacity — MUST match `uRipples[8]` in the water shaders. */
-const WATER_MAX_RIPPLES = 8;
-/**
-* Distance from a body's ORIGIN down to its collider's lowest point. Water
-* interaction adds this to the waterline so a body counts as touching the water
-* when its FEET dip below the surface — not only when its centre does (a wading
-* character whose origin rides ~1 m above its feet would otherwise never splash).
-* 0 for a missing/empty/unsized collider (origin == feet).
-*/
-function colliderFootDrop(collider) {
-	if (!collider || typeof collider !== "object") return 0;
-	switch (collider.shape) {
-		case "capsule": return (collider.height ?? 0) / 2 + (collider.radius ?? 0);
-		case "sphere": return collider.radius ?? 0;
-		case "box": return (collider.size?.[1] ?? 0) / 2;
-		default: return 0;
-	}
-}
-/**
-* Foam strength (0..1) for a body ENTERING the water, from its DOWNWARD speed:
-* a gentle wade-in froths a little; a hard plunge froths fully. Clamped at
-* `FOAM_FULL_SPEED`.
-*/
-function entryFoam(fallSpeed) {
-	return .55 + .45 * (Math.min(Math.max(fallSpeed, 0), 12) / 12);
-}
-/**
-* Diff body positions against the waterline. A body enters when `y` drops
-* below its waterline and exits when it rises above `waterline + hysteresis`
-* (the band stops surface-bobbing bodies from flickering entered/exited).
-* Bodies missing from `samples` (despawned mid-water) are dropped WITHOUT an
-* `exited` event — their splash position no longer exists.
-*/
-function detectCrossings(prev, samples, hysteresis = 0) {
-	const entered = [];
-	const exited = [];
-	const inWater = /* @__PURE__ */ new Set();
-	for (const s of samples) {
-		const wasIn = prev.has(s.id);
-		if (wasIn ? s.y <= s.waterline + hysteresis : s.y < s.waterline) {
-			inWater.add(s.id);
-			if (!wasIn) entered.push(s);
-		} else if (wasIn) exited.push(s);
-	}
-	return {
-		entered,
-		exited,
-		inWater
-	};
-}
-/** Append a ripple at age 0; when the buffer is full, evict the OLDEST.
-* `foam` (0..1) tags how much surface froth the shaders paint around it. */
-function pushRipple(ripples, x, z, amp, foam = 0, max = 8) {
-	if (ripples.length >= max) {
-		let oldest = 0;
-		for (let i = 1; i < ripples.length; i++) if (ripples[i].age > ripples[oldest].age) oldest = i;
-		ripples.splice(oldest, 1);
-	}
-	ripples.push({
-		x,
-		z,
-		age: 0,
-		amp,
-		foam
-	});
-}
-/** Advance ages by `dt` and drop ripples decayed past `maxAge` (in place). */
-function ageRipples(ripples, dt, maxAge = 3) {
-	for (let i = ripples.length - 1; i >= 0; i--) {
-		const r = ripples[i];
-		r.age += dt;
-		if (r.age >= maxAge) ripples.splice(i, 1);
-	}
-}
-/** The ring-wave height contribution of one ripple at world (x, z). */
-function rippleHeight(x, z, ripple) {
-	const dx = x - ripple.x;
-	const dz = z - ripple.z;
-	const r = Math.sqrt(dx * dx + dz * dz);
-	return ripple.amp * Math.sin(6 * r - 8 * ripple.age) * Math.exp(-1.1 * ripple.age) * Math.exp(-.15 * r * r);
-}
-/** Sum of every live ripple's height at world (x, z) — the CPU water path. */
-function ripplesHeightAt(x, z, ripples) {
-	let h = 0;
-	for (const r of ripples) h += rippleHeight(x, z, r);
-	return h;
-}
-/**
-* Accumulate per-body bob timers for bodies floating IN water; returns the
-* ids due for a gentle bob impulse this update (timer wraps, cadence keeps).
-* Timers of bodies that left the water are forgotten.
-*/
-function stepBobTimers(timers, inWater, dt, interval) {
-	const due = [];
-	for (const id of timers.keys()) if (!inWater.has(id)) timers.delete(id);
-	for (const id of inWater) {
-		const t = (timers.get(id) ?? 0) + dt;
-		if (t >= interval) {
-			due.push(id);
-			timers.set(id, t - interval);
-		} else timers.set(id, t);
-	}
-	return due;
-}
-//#endregion
 //#region src/3d/water/river.ts
 /** Dense Catmull-Rom taps per control segment before arc-length resampling. */
 const SPLINE_TAPS = 24;
@@ -6910,15 +6532,17 @@ function buildRiverRings(opts) {
 		const raw = bed[i];
 		descending[i] = i === 0 ? raw : Math.min(raw, descending[i - 1]);
 	}
-	const smoothed = descending.map((_, i) => {
+	const keep = Math.max(.5, opts.depth * 1.5);
+	const smoothed = descending.map((center, i) => {
 		let sum = 0;
 		let n = 0;
 		for (let k = -3; k <= PROFILE_SMOOTH; k++) {
-			const j = Math.min(Math.max(i + k, 0), descending.length - 1);
-			sum += descending[j];
+			const h = descending[Math.min(Math.max(i + k, 0), descending.length - 1)];
+			if (Math.abs(h - center) > keep) continue;
+			sum += h;
 			n++;
 		}
-		return sum / n;
+		return n > 0 ? sum / n : center;
 	});
 	const profile = new Array(smoothed.length);
 	for (let i = 0; i < smoothed.length; i++) {
@@ -7079,6 +6703,39 @@ function hitFrom(a, b, t, x, z, capped) {
 	};
 }
 /**
+* Find the waterfalls in a course: maximal runs of steep stations, reported at
+* the station where the water lands. Callers hang spray on these, and the
+* shader aerates the curtain from the same grade the detector reads — one
+* source of truth for "this is falling, not flowing".
+*/
+function detectFalls(rings, opts = {}) {
+	const minGrade = opts.minGrade ?? .45;
+	const minDrop = opts.minDrop ?? 1.2;
+	const out = [];
+	let start = -1;
+	for (let i = 0; i <= rings.length; i++) {
+		const steep = i < rings.length && rings[i].slope >= minGrade;
+		if (steep && start < 0) start = i;
+		if (steep || start < 0) continue;
+		const lip = rings[Math.max(0, start - 1)];
+		const base = rings[Math.min(rings.length - 1, i)];
+		const drop = lip.surfaceY - base.surfaceY;
+		if (drop >= minDrop) out.push({
+			x: base.x,
+			z: base.z,
+			topY: lip.surfaceY,
+			baseY: base.surfaceY,
+			drop,
+			halfWidth: base.halfWidth,
+			dirX: base.tx,
+			dirZ: base.tz,
+			speed: base.speed
+		});
+		start = -1;
+	}
+	return out;
+}
+/**
 * Trace where water would actually run from a point: repeated steepest descent
 * with momentum, so the line follows a valley floor instead of rattling between
 * its walls. Ends when the ground goes flat (a pool), the trace leaves the play
@@ -7225,7 +6882,10 @@ void main() {
 
   // hydraulic jump: in a chute the wave train stands still in the world (phase
   // on the downstream coordinate, NEVER scrolled) and only breathes in time
-  float chute = smoothstep(0.035, 0.16, grade) * smoothstep(0.6, 2.4, speed);
+  // standing waves belong to a RAPID: past ~20° the water has left the bed and
+  // a wave train on a falling curtain reads as a rippling flag
+  float chute = smoothstep(0.035, 0.16, grade) * smoothstep(0.6, 2.4, speed) *
+                (1.0 - smoothstep(0.35, 0.7, grade));
   float standing =
     sin(aFlowUv.x * 1.9 + sin(uTime * 0.7) * 0.35) * 0.6 +
     sin(aFlowUv.x * 3.6 + sin(uTime * 0.9) * 0.5) * 0.4;
@@ -7329,8 +6989,11 @@ void main() {
   vec3 ripB = riverRipple(base - vec2(travel * pB, 0.0));
   vec3 ripple = mix(ripA, ripB, blend);
 
-  float streakA = riverStreak(base * 0.55 - vec2(travel * pA * 0.55, 0.0));
-  float streakB = riverStreak(base * 0.55 - vec2(travel * pB * 0.55, 0.0));
+  // on a curtain the pattern stretches into strands: the same field, sampled
+  // with the downstream axis squeezed hard, is what reads as falling water
+  float streakScale = mix(0.55, 0.16, smoothstep(0.35, 0.9, grade));
+  float streakA = riverStreak(base * streakScale - vec2(travel * pA * streakScale, 0.0));
+  float streakB = riverStreak(base * streakScale - vec2(travel * pB * streakScale, 0.0));
   float streak = mix(streakA, streakB, blend);
 
   // ripples flatten out where the water thins to a film over the bed
@@ -7356,14 +7019,25 @@ void main() {
   // shallow is RELATIVE to this river: a hand's depth is a riffle in a brook
   // and nothing at all in a millrace, so the thresholds ride uMaxDepth
   float shallowT = column / max(uMaxDepth, 0.05);
-  float riffle = (1.0 - smoothstep(0.12, 0.42, shallowT)) * smoothstep(0.7, 2.2, speed);
-  float drive = clamp(rapids * 1.0 + bankShear * 0.35 + riffle * 0.5, 0.0, 1.3) * uFoam;
+  // a riffle needs water to break OVER something — a centimetres-thin film on
+  // a drying bar is a wet rock, and painting it white is what turns the tail of
+  // a creek into a bright sheet
+  float riffle =
+    smoothstep(0.04, 0.13, column) *
+    (1.0 - smoothstep(0.12, 0.42, shallowT)) *
+    smoothstep(0.7, 2.2, speed);
+  // FALLING, not flowing: past ~20° the sheet leaves the bed, shatters and
+  // aerates. Aerated water is a white DIFFUSE body — it stops mirroring the
+  // sky (that is the tell that separates a waterfall from a steep chute).
+  float fall = smoothstep(0.35, 0.9, grade);
+  float drive = clamp(rapids * 1.0 + bankShear * 0.35 + riffle * 0.5 + fall * 1.6, 0.0, 2.0) * uFoam;
   // COVERAGE is the thing to be strict about: whitewater is where the surface
   // has actually broken, and a river that fizzes everywhere reads as milk
   float foam = smoothstep(0.74 - 0.45 * drive, 1.02 - 0.24 * drive, streak) * min(drive, 1.0);
   // crest froth: the tops of standing waves in a real rapid always carry white
   foam = max(foam, smoothstep(0.68, 0.96, ripple.x) * smoothstep(0.4, 1.0, rapids) * uFoam * 0.5);
-  foam = clamp(foam, 0.0, 1.0);
+  // froth can never be more present than the water carrying it
+  foam = clamp(foam, 0.0, 1.0) * smoothstep(0.02, 0.14, column);
 
   // ── body ────────────────────────────────────────────────────────────────
   float depthT = clamp(column / max(uMaxDepth, 0.01), 0.0, 1.0);
@@ -7413,10 +7087,16 @@ void main() {
   spec *= 0.45 + 0.55 * glint * uSparkle;
   spec *= 1.0 - foam * 0.85; // froth is rough — it kills the mirror
 
+  fresnel *= 1.0 - 0.85 * fall; // froth scatters; it does not reflect
   vec3 color = mix(body, sky, fresnel);
   color += uSunColor * spec * 1.6;
   color = mix(color, uFoamColor, foam * 0.88);
 
+  // the LIP reads glassy-dark for a moment before the sheet breaks — the
+  // contrast against the white curtain below is most of the drop's drama
+  float lip = smoothstep(0.12, 0.32, grade) * (1.0 - smoothstep(0.32, 0.55, grade));
+  color = mix(color, color * 0.72, lip * 0.6);
+
   // ── edges ───────────────────────────────────────────────────────────────
   // the ribbon is built wider than the channel; what makes its outline is the
   // water running out, so bars and boulders cut it exactly like the ground does
@@ -7521,7 +7201,8 @@ var River3D = class River3D extends Node3D {
 		sunColor: { default: "#fff6e0" },
 		sunIntensity: { default: 1 },
 		terrain: { default: "" },
-		flowForce: { default: 1 }
+		flowForce: { default: 1 },
+		spray: { default: 1 }
 	};
 	/** Centerline control points `[[x, z], …]` in the node's local frame. */
 	path = [];
@@ -7557,9 +7238,17 @@ var River3D = class River3D extends Node3D {
 	terrain = "";
 	/** How hard the current sweeps bodies downstream (0 = visual only). */
 	flowForce = 1;
+	/**
+	* Mist at the foot of every waterfall the course contains: the node finds
+	* the drops itself (see {@link detectFalls}) and hangs a Particles3D plume
+	* on each, sized by how far the water falls. 0 = off.
+	*/
+	spray = 1;
 	renderOrder = 1;
 	time = 0;
 	rings = [];
+	falls = [];
+	sprayKey = "";
 	courseKey = "";
 	bedAt = null;
 	world = [
@@ -7585,6 +7274,7 @@ var River3D = class River3D extends Node3D {
 			"foam",
 			"ripples",
 			"flowForce",
+			"spray",
 			"sunIntensity"
 		]) {
 			const v = r[key];
@@ -7604,6 +7294,7 @@ var River3D = class River3D extends Node3D {
 	update(dt) {
 		this.time += dt;
 		this.ensureCourse();
+		this.syncSpray();
 		if (this.flowForce > 0 && this.rings.length > 1) this.sweepBodies(dt);
 	}
 	_syncObject3D() {
@@ -7627,6 +7318,21 @@ var River3D = class River3D extends Node3D {
 			surfaceY: hit.surfaceY + wy
 		} : null;
 	}
+	/**
+	* The waterfalls on this course — where the water stops flowing and starts
+	* falling, with the drop height and the plunge point in WORLD coordinates.
+	* Hang your own effects (sound, a rainbow, a hidden cave) on these.
+	*/
+	fallsAt() {
+		this.ensureCourse();
+		const [wx, wy, wz] = this.world;
+		return this.falls.map((f) => ({
+			...f,
+			worldX: f.x + wx,
+			worldY: f.baseY + wy,
+			worldZ: f.z + wz
+		}));
+	}
 	/** @internal The derived centerline stations (surface, grade, current). */
 	_rings() {
 		return this.rings;
@@ -7677,6 +7383,7 @@ var River3D = class River3D extends Node3D {
 		this.bedAt = null;
 		if (this.path.length < 2) {
 			this.rings = [];
+			this.falls = [];
 			return true;
 		}
 		const [wx, wy, wz] = world;
@@ -7691,6 +7398,7 @@ var River3D = class River3D extends Node3D {
 			step: Math.min(Math.max(narrow * STEP_PER_WIDTH, STEP_MIN), STEP_MAX),
 			bedAt: this.bedAt
 		});
+		this.falls = detectFalls(this.rings);
 		return true;
 	}
 	rebuildIfNeeded(mesh) {
@@ -7790,6 +7498,48 @@ var River3D = class River3D extends Node3D {
 		set("uSparkle", this.ripples);
 	}
 	/**
+	* Hang a mist plume on every fall. Runtime children (`__spray*`), rebuilt
+	* only when the course or the dial changes — a plume is a Particles3D, so it
+	* carries its own budget, culling and editor visibility for free.
+	*/
+	syncSpray() {
+		const key = this.spray > 0 ? `${this.spray}|${JSON.stringify(this.falls)}` : "";
+		if (key === this.sprayKey) return;
+		this.sprayKey = key;
+		for (const child of [...this.children]) if (child.name.startsWith("__spray")) child.free();
+		if (this.spray <= 0) return;
+		this.falls.forEach((fall, i) => {
+			const plume = new Particles3D(`__spray${i}`);
+			plume.position = [
+				fall.x + fall.dirX * .6,
+				fall.baseY + .15,
+				fall.z + fall.dirZ * .6
+			];
+			const power = Math.min(1.6, .4 + fall.drop * .12) * this.spray;
+			plume.rate = Math.round(Math.min(46, 10 + fall.drop * 3) * this.spray);
+			plume.maxParticles = 160;
+			plume.lifetime = [1, 2.1];
+			plume.speed = [55 * power, 170 * power];
+			plume.directionDeg = -90;
+			plume.spreadDeg = 58;
+			plume.gravity = [
+				0,
+				-240,
+				0
+			];
+			plume.drag = 1.2;
+			plume.sizeStart = 16 * power;
+			plume.sizeEnd = 80 * power;
+			plume.colorStart = "#ffffff";
+			plume.colorEnd = "#dfe9ec";
+			plume.alphaStart = .2;
+			plume.alphaEnd = 0;
+			plume.blend = "normal";
+			plume.depthTest = true;
+			this.addChild(plume);
+		});
+	}
+	/**
 	* Drag every body floating in the channel toward the water's own velocity.
 	* Drag rather than thrust: a raft accelerates until it matches the current
 	* and then coasts, and a swimmer can still fight across a slow ford.
@@ -7799,7 +7549,7 @@ var River3D = class River3D extends Node3D {
 		while (top.parent) top = top.parent;
 		const bodies = this._bodies;
 		bodies.length = 0;
-		collectBodies$1(top, bodies);
+		collectBodies(top, bodies);
 		if (bodies.length === 0) return;
 		const [wx, wy, wz] = this.world;
 		for (const body of bodies) {
@@ -7810,7 +7560,7 @@ var River3D = class River3D extends Node3D {
 			const feet = p[1] - colliderFootDrop(body.collider);
 			if (feet > surfaceY + CURRENT_SURFACE_SLACK) continue;
 			if (feet < surfaceY - this.depth - CURRENT_UNDER_SLACK) continue;
-			const vel = bodyVelocity$1(body);
+			const vel = bodyVelocity(body);
 			if (!vel) continue;
 			const gain = Math.min(1, this.flowForce * CURRENT_DRAG * dt);
 			const dvx = (hit.dirX * hit.speed - (vel[0] ?? 0)) * gain;
@@ -7830,12 +7580,12 @@ var River3D = class River3D extends Node3D {
 	}
 };
 /** Bodies a current can carry: kinematic characters and dynamic rigid bodies. */
-function collectBodies$1(node, out) {
+function collectBodies(node, out) {
 	if (node instanceof CharacterBody3D || node instanceof RigidBody3D) out.push(node);
-	for (const child of node.children) collectBodies$1(child, out);
+	for (const child of node.children) collectBodies(child, out);
 }
 /** A body's velocity vector — kinematic `velocity` or dynamic `linearVelocity`. */
-function bodyVelocity$1(body) {
+function bodyVelocity(body) {
 	return body.velocity ?? body.linearVelocity;
 }
 //#endregion
@@ -10069,9 +9819,9 @@ function normalizeTint(color) {
 	const max = Math.max(tint.r, tint.g, tint.b);
 	if (max > 0) tint.multiplyScalar(1 / max);
 	else tint.setRGB(1, 1, 1);
-	return tint.lerp(WHITE$1, .18);
+	return tint.lerp(WHITE, .18);
 }
-const WHITE$1 = new Color(1, 1, 1);
+const WHITE = new Color(1, 1, 1);
 /** Bark tint for a customized trunkColor: keep the hue, normalize the
 * brightest channel to 1 — the color map keeps its own brightness. */
 function barkTint(color) {
@@ -11095,2749 +10845,6 @@ void main() {
 }
 `;
 //#endregion
-//#region src/3d/frustum.ts
-const scratchFrustum = new Frustum();
-const scratchMatrix = new Matrix4();
-const scratchSphere = new Sphere();
-/**
-* Is a world-space sphere inside the camera's view frustum?
-*
-* Used to skip per-frame work for things the camera can't see — e.g. Water3D's
-* fancy scene pre-pass + reflection cube, which otherwise re-render the whole
-* scene every frame for ponds that are off-screen. Uses shared scratch objects
-* (single-threaded engine), so it allocates nothing per call.
-*/
-function sphereInCameraFrustum(camera, center, radius) {
-	scratchMatrix.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
-	scratchFrustum.setFromProjectionMatrix(scratchMatrix);
-	scratchSphere.center.set(center.x, center.y, center.z);
-	scratchSphere.radius = radius;
-	return scratchFrustum.intersectsSphere(scratchSphere);
-}
-//#endregion
-//#region src/3d/water/lake.ts
-/**
-* The Water3D 'simple' quality lake shader — the CHEAP good-looking path.
-*
-* 'fancy' water is commercial-grade but pays for it: a CubeCamera reflection
-* plus a half-res scene depth/color pre-pass (and a depth-completion pass) —
-* 2–3 extra full-scene renders every frame, which drop a pond to ~30 fps. The
-* old 'simple' fallback was a plain lit MeshStandardMaterial over CPU-displaced
-* sine waves: cheap, but flat and lifeless (the "허접" playtest complaint).
-*
-* This lake shader keeps the cheap budget — ZERO scene re-renders, no cube map,
-* no depth texture — and still reads as real water by faking the three cues the
-* eye actually needs:
-*
-* - Fresnel sky reflection: a procedural horizon→zenith SKY TINT (uSkyColor),
-*   Schlick-mixed in by view angle. Steep view = water color, grazing = sky.
-*   No environment to sample — a lake reflects mostly sky anyway.
-* - Procedural ripple normals: two crossing animated simplex layers perturb the
-*   (CPU-computed) macro normal per pixel — the LIQUID micro-detail, texture-
-*   free, distance-faded (procedural noise has no mips → aliases at range).
-* - Sun glint: a tight Blinn-Phong spark + soft sheen off the rippled normal,
-*   weighted toward the sun's azimuth path (uSunDirection/Color/Intensity).
-* - Depth-free body: looking straight down reads the lighter surface tint
-*   (clearer shallows feel), grazing reads the darker deep base; grazing also
-*   reads more opaque/reflective. No depth buffer, all from the view angle.
-* - Soft edge fade: the rectangular plane's rim fades to zero alpha, so the
-*   surface melts into the shore instead of poking out as a hard rectangle
-*   (the "물 삐져나옴" complaint).
-*
-* The CPU still displaces the coarse vertex grid (macro swell + interaction
-* ring waves) and computes its normals — that path stays deterministic and
-* headless-testable; this shader only adds the per-pixel look on top.
-*
-* Atmosphere stage (marked below): the fragment ends with three's
-* tonemapping + colorspace + fog chunks in built-in-material order, and both
-* stages carry the standard fog chunks, so the lake tone-maps, sRGB-encodes
-* and fogs identically to the fancy water and the terrain.
-*/
-const LAKE_VERT = `
-precision highp float;
-
-// atmosphere: three's linear fog rides the standard chunks (compiled out
-// unless the scene declares fog — USE_FOG comes from material.fog)
-#include <fog_pars_vertex>
-
-varying vec3 vWorldPosition;
-varying vec3 vNormalW;
-
-void main() {
-  vec4 modelPosition = modelMatrix * vec4(position, 1.0);
-  vWorldPosition = modelPosition.xyz;
-  // The CPU computeVertexNormals() macro normal, lifted to world space. Water
-  // is laid axis-aligned on XZ (no parent rotation expected), so the plain
-  // model rotation is exact enough for the fresnel/glint cues.
-  vNormalW = normalize(mat3(modelMatrix) * normal);
-
-  vec4 mvPosition = viewMatrix * modelPosition;
-  gl_Position = projectionMatrix * mvPosition;
-
-  // atmosphere: fog depth from the displaced surface position
-  #include <fog_vertex>
-}
-`;
-const LAKE_FRAG = `
-precision highp float;
-
-// atmosphere: standard fog chunk (compiled out without scene fog)
-#include <fog_pars_fragment>
-
-uniform float uTime;
-uniform float uOpacity;
-uniform vec3 uColor;        // deep water base (derived from the single hue)
-uniform vec3 uSurfaceColor; // shallow/surface tint (the hue itself)
-uniform vec3 uSkyColor;     // fresnel reflection tint — NO cube map
-uniform vec3 uSunDirection;
-uniform vec3 uSunColor;
-uniform float uSunIntensity;
-uniform float uDetailStrength;
-uniform float uFresnelPower;
-uniform vec3 uScale;        // half extents (x, _, z) for the edge fade
-uniform vec3 uWaterCenter;
-
-// incanto: splash whitewater — the ripple buffer drives expanding surface foam
-// (entry "풍덩" + wake "물살"); uSplashFoam = the Water3D.splash gate.
-uniform vec4 uRipples[8];
-uniform float uRippleFoam[8];
-uniform float uSplashFoam;
-uniform vec3 uFoamColor;
-
-varying vec3 vWorldPosition;
-varying vec3 vNormalW;
-
-// Simplex 2D noise (Ian McEwan, Stefan Gustavson — https://github.com/stegu/webgl-noise, MIT)
-vec3 permute(vec3 x) { return mod(((x * 34.0) + 1.0) * x, 289.0); }
-
-float snoise(vec2 v) {
-  const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
-  vec2 i = floor(v + dot(v, C.yy));
-  vec2 x0 = v - i + dot(i, C.xx);
-  vec2 i1;
-  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
-  vec4 x12 = x0.xyxy + C.xxzz;
-  x12.xy -= i1;
-  i = mod(i, 289.0);
-  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
-  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
-  m = m * m;
-  m = m * m;
-  vec3 x = 2.0 * fract(p * C.www) - 1.0;
-  vec3 h = abs(x) - 0.5;
-  vec3 ox = floor(x + 0.5);
-  vec3 a0 = x - ox;
-  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
-  vec3 g;
-  g.x = a0.x * x0.x + h.x * x0.y;
-  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-  return 130.0 * dot(m, g);
-}
-
-// finite-difference gradient of the simplex height field
-vec2 noiseGrad(vec2 p) {
-  const float e = 0.06;
-  float h = snoise(p);
-  return vec2(snoise(p + vec2(e, 0.0)) - h, snoise(p + vec2(0.0, e)) - h) / e;
-}
-
-// incanto: splash WHITEWATER. A clean radial disc/ring read as a fake CG stamp;
-// real foam is irregular clumps that drift with the water and break apart at the
-// edges. A soft COVERAGE envelope (an expanding patch fading over FOAM_MAX_AGE —
-// the CPU twin rippleFoamAt, constants MIRRORED) THRESHOLDS a domain-warped
-// fractal noise: dense coverage → broad froth, thinning coverage raises the
-// threshold → it erodes into sparse bubbles. Warp + drift = advected, not stamped.
-float lnoise(vec2 p) { return 0.5 + 0.5 * snoise(p); }
-float foamFbm(vec2 p) {
-  float v = 0.0, a = 0.5;
-  for (int i = 0; i < 4; i++) { v += a * lnoise(p); p = p * 2.02 + 7.3; a *= 0.5; }
-  return v; // ~0..0.94
-}
-
-float rippleFoam(vec2 p) {
-  if (uSplashFoam < 0.5) return 0.0;
-  float cover = 0.0;
-  for (int i = 0; i < 8; i++) {
-    float foam = uRippleFoam[i];
-    if (foam <= 0.0) continue;
-    vec4 r = uRipples[i];
-    float age = r.z;
-    float life = 1.0 - age / 1.6; // FOAM_MAX_AGE
-    if (life <= 0.0) continue;
-    float d = distance(p, r.xy);
-    float radius = 0.4 + 1.15 * age; // FOAM_R0 + FOAM_SPREAD * age
-    cover = max(cover, (1.0 - smoothstep(radius * 0.7, radius, d)) * foam * life);
-  }
-  if (cover <= 0.001) return 0.0;
-  // FINE frequencies (premium foam = many small bubbles, not coarse blobs)
-  vec2 flow = vec2(uTime * 0.05, uTime * -0.04);
-  vec2 warp = vec2(foamFbm(p * 1.1 + flow), foamFbm(p * 1.1 + 4.2 - flow)) - 0.5;
-  float pattern = foamFbm(p * 2.6 + warp * 1.4 + flow);
-  // raised floor + wide band = sparser + softer = subtler/more refined
-  float thresh = mix(0.36, 0.96, 1.0 - cover);
-  float foamHere = smoothstep(thresh, thresh + 0.26, pattern);
-  return clamp(foamHere * (0.4 + 0.5 * cover), 0.0, 1.0);
-}
-
-// Two crossing animated ripple layers perturb the macro normal. Each fades out
-// with distance (procedural noise has no mips — past its range it aliases into
-// white speckle), so far water relaxes back to the smooth swell.
-vec3 detailNormal(vec3 n, vec2 worldXZ, float strength, float camDist) {
-  float fadeMid  = 1.0 - smoothstep(45.0, 170.0, camDist);
-  float fadeFine = 1.0 - smoothstep(14.0, 70.0, camDist);
-  // Three FINE isotropic ripple fields drifting in crossing directions — a
-  // calm lake's surface is many small wavelets, not a few big swells, so the
-  // frequencies are high (≈1.4 m / ≈0.8 m / ≈0.5 m) and the amplitudes small.
-  // Each gradient is multiplied by its own frequency: noiseGrad returns the
-  // slope in NOISE space, so without this the coarsest layer over-amplifies
-  // into the foil-blob look. Net perturbation stays a gentle few degrees.
-  vec2 dMid  = normalize(vec2(0.72, 0.50));
-  vec2 dFine = normalize(vec2(-0.42, 0.91));
-  vec2 dMicro = normalize(vec2(0.34, -0.94));
-  vec2 slope =
-      noiseGrad(worldXZ * 0.70 + dMid * uTime * 0.14) * (0.70 * 0.085 * fadeMid)
-    + noiseGrad(worldXZ * 1.30 + dFine * uTime * 0.20) * (1.30 * 0.060 * fadeFine)
-    + noiseGrad(worldXZ * 2.10 - dMicro * uTime * 0.26) * (2.10 * 0.040 * fadeFine);
-  slope *= strength;
-  return normalize(vec3(n.x - slope.x, n.y, n.z - slope.y));
-}
-
-void main() {
-  vec3 viewDir = normalize(vWorldPosition - cameraPosition);
-  float camDist = length(vWorldPosition - cameraPosition);
-
-  // Flatten the macro normal with distance so far ripples don't strobe into
-  // sky-reflection sequins against the bright horizon.
-  float geoFlat = 1.0 - 0.85 * smoothstep(140.0, 520.0, camDist);
-  vec3 geoN = normalize(mix(vec3(0.0, 1.0, 0.0), normalize(vNormalW), geoFlat));
-  vec3 normal = detailNormal(geoN, vWorldPosition.xz, uDetailStrength, camDist);
-
-  // Schlick fresnel: 2% normal-incidence floor (water's real F0), 98% at
-  // grazing. Steep view → water color, grazing → sky tint.
-  float fresnel = 0.02 + 0.98 * pow(1.0 - clamp(dot(-viewDir, normal), 0.0, 1.0), uFresnelPower);
-
-  // Depth-free body color from the view angle: straight down sees the lighter
-  // surface (clearer shallows feel), grazing sees the deeper base.
-  float viewUp = clamp(dot(-viewDir, vec3(0.0, 1.0, 0.0)), 0.0, 1.0);
-  vec3 body = mix(uColor, uSurfaceColor, viewUp);
-
-  // Sky reflection WITHOUT a cube map: a soft horizon→zenith gradient sampled
-  // by the reflected ray. The horizon is paler/brighter (atmospheric haze),
-  // the zenith deeper — convincing for a lake, which reflects mostly sky.
-  vec3 refl = reflect(viewDir, normal);
-  float up = clamp(refl.y, 0.0, 1.0);
-  vec3 skyTint = mix(uSkyColor * 1.08, uSkyColor * 0.82, up);
-
-  // cap the sky mix below a full mirror (that reads as white foil — the old
-  // goop look) but high enough that the grazing far field catches believable
-  // sky instead of going flat grey
-  vec3 color = mix(body, skyTint, clamp(fresnel, 0.0, 0.62));
-
-  // Sun glint: a tight spark + soft sheen off the rippled normal, weighted to
-  // the sun's azimuth path so crests sparkle ALONG the light and the rest of
-  // the surface stays calm color (not an all-over glossy speckle).
-  vec3 sunL = normalize(uSunDirection);
-  vec3 halfway = normalize(sunL - viewDir); // -viewDir = surface→camera
-  float specAngle = max(dot(normal, halfway), 0.0);
-  vec2 toFrag = normalize(vWorldPosition.xz - cameraPosition.xz);
-  float sunPath = pow(clamp(dot(toFrag, normalize(sunL.xz)), 0.0, 1.0), 4.0);
-  float glintFade = 1.0 - smoothstep(70.0, 240.0, camDist);
-  float glint = pow(specAngle, 380.0) * (0.25 + 0.9 * sunPath) * glintFade;
-  float sheen = pow(specAngle, 36.0) * 0.05 * sunPath;
-  color += uSunColor * min(uSunIntensity * (glint * 0.7 + sheen), 0.8);
-
-  // splash froth where bodies enter / wade — a PALE foam tint (not pure white,
-  // which floats on top as a jarring decal); the water still reads through
-  float splashFoam = rippleFoam(vWorldPosition.xz);
-  color = mix(color, mix(uFoamColor, vec3(1.0), 0.3), splashFoam * 0.58);
-
-  // Soft edge fade — the rectangular rim melts into the shore. Normalized
-  // distance from the node center to its half extents; the last ~18% fades to
-  // zero alpha (no hard "물 삐져나옴" rectangle).
-  vec2 nrm = (vWorldPosition.xz - uWaterCenter.xz) / vec2(uScale.x, uScale.z);
-  float edge = 1.0 - smoothstep(0.82, 1.0, length(nrm));
-
-  // Grazing angles look more opaque/reflective; straight-down looks clearer.
-  float alpha = mix(uOpacity * 0.7, min(uOpacity + 0.25, 1.0), fresnel);
-  alpha *= edge;
-  // foam reads even looking straight down — lift froth opacity, but only part
-  // way so the disturbed water still shows through (translucent froth)
-  alpha = max(alpha, splashFoam * 0.7 * edge);
-
-  gl_FragColor = vec4(color, alpha);
-
-  // atmosphere: join three's output pipeline — ACES tone map + working→output
-  // colorspace encode + linear fog, in the SAME order as the built-in
-  // materials so the lake fogs/grades identically to the terrain.
-  #include <tonemapping_fragment>
-  #include <colorspace_fragment>
-  #include <fog_fragment>
-}
-`;
-//#endregion
-//#region src/3d/water/caustics.ts
-/**
-* Underwater caustics — the dancing refracted-light pattern the water surface
-* throws onto everything below it. The engine has no post-processing pipeline,
-* so the renderer does this as ONE depth-aware composite pass, and ONLY while
-* the camera is genuinely underwater (so normal above-water rendering — even
-* standing at the water's edge — is completely untouched):
-*
-*   1. render the scene to an offscreen target (color + depth)
-*   2. draw this fullscreen material, which reconstructs each pixel's WORLD
-*      position from the depth buffer and adds an animated caustic highlight
-*      wherever that world point sits below the water surface
-*
-* Because the pattern is keyed to reconstructed world XZ, it STICKS to the
-* floor/walls/props (it isn't a flat screen overlay) and fades with depth +
-* view distance so it melts into the underwater fog.
-*/
-/** Fullscreen triangle/quad — the vertex stage ignores the camera entirely. */
-const CAUSTICS_VERT = `
-varying vec2 vUv;
-void main() {
-  vUv = uv;
-  gl_Position = vec4(position.xy, 0.0, 1.0);
-}
-`;
-/**
-* The classic animated caustic pattern (layered moving cells), 0..1 — SHARED
-* between the underwater composite and Water3D's above-water caustics (the
-* refracted bottom shimmer), so both views of the same water agree.
-*/
-const CAUSTIC_GLSL = `
-float caustic(vec2 uv, float t) {
-  vec2 p = mod(uv * 6.28318, 6.28318) - 250.0;
-  vec2 i = p;
-  float c = 1.0;
-  float inten = 0.005;
-  for (int n = 0; n < 5; n++) {
-    float ti = t * (1.0 - (3.5 / float(n + 1)));
-    i = p + vec2(cos(ti - i.x) + sin(ti + i.y), sin(ti - i.y) + cos(ti + i.x));
-    c += 1.0 / length(vec2(p.x / (sin(i.x + ti) / inten), p.y / (cos(i.y + ti) / inten)));
-  }
-  c /= 5.0;
-  c = 1.17 - pow(c, 1.4);
-  return clamp(pow(abs(c), 8.0), 0.0, 1.0);
-}
-`;
-const CAUSTICS_FRAG = `
-precision highp float;
-varying vec2 vUv;
-uniform sampler2D tColor;
-uniform sampler2D tDepth;
-uniform mat4 uInvViewProj;
-uniform vec3 uCameraPos;
-uniform float uWaterLevel;
-uniform float uTime;
-uniform vec3 uCausticColor;
-uniform float uCausticIntensity;
-uniform float uCausticScale;
-uniform float uMaxDist;
-
-${CAUSTIC_GLSL}
-
-void main() {
-  vec4 color = texture2D(tColor, vUv);
-  float depth = texture2D(tDepth, vUv).x;
-  // depth == 1 is the far plane (sky/background) — nothing to light there
-  if (depth < 1.0) {
-    vec4 ndc = vec4(vUv * 2.0 - 1.0, depth * 2.0 - 1.0, 1.0);
-    vec4 world = uInvViewProj * ndc;
-    world.xyz /= world.w;
-    float below = uWaterLevel - world.y;
-    if (below > 0.0) {
-      float dist = distance(world.xyz, uCameraPos);
-      // caustics — fade with distance (melt into the fog) + a touch with depth
-      float distFade = 1.0 - clamp(dist / uMaxDist, 0.0, 1.0);
-      float depthFade = 1.0 - clamp(below / (uMaxDist * 0.5), 0.0, 0.6);
-      // two octaves at offset speeds = the shimmering interference of real caustics
-      float c =
-        caustic(world.xz * uCausticScale, uTime) * 0.65 +
-        caustic(world.xz * uCausticScale * 1.7 + 30.0, uTime * 0.8) * 0.35;
-      color.rgb += uCausticColor * (c * uCausticIntensity * distFade * distFade * depthFade);
-    }
-  }
-  gl_FragColor = color;
-}
-`;
-/** Build the fullscreen composite mesh (a 2×2 clip-space quad). */
-function createCausticsQuad() {
-	const material = new ShaderMaterial({
-		vertexShader: CAUSTICS_VERT,
-		fragmentShader: CAUSTICS_FRAG,
-		depthTest: false,
-		depthWrite: false,
-		uniforms: {
-			tColor: { value: null },
-			tDepth: { value: null },
-			uInvViewProj: { value: new Matrix4() },
-			uCameraPos: { value: new Vector3() },
-			uWaterLevel: { value: 0 },
-			uTime: { value: 0 },
-			uCausticColor: { value: new Color("#cdeeff") },
-			uCausticIntensity: { value: .55 },
-			uCausticScale: { value: .32 },
-			uMaxDist: { value: 22 }
-		}
-	});
-	const mesh = new Mesh(new PlaneGeometry(2, 2), material);
-	mesh.frustumCulled = false;
-	return {
-		mesh,
-		uniforms: material.uniforms
-	};
-}
-//#endregion
-//#region src/3d/water/shaders.ts
-/**
-* The Water3D 'fancy' shaders — ported VERBATIM from
-* vibe-starter-3d-environment `src/components/water/shader/water.{vert,frag}.glsl`
-* (9-iteration simplex-2D FBM displacement with analytic finite-difference
-* normals and an 85→98% edge-fade ring; trough/surface/peak elevation ramp,
-* fresnel-mixed cube-map reflection, optional depth-texture shoreline foam
-* with hard above-water discard). Incanto deviations, each marked inline:
-*
-* - `uWaterCenter` (NEW): the source normalized world positions by the raw
-*   scale, which only works for water sitting at the world origin — we
-*   subtract the node's world center so positioned/parented water keeps its
-*   edge fade and color ramp. `uScale` carries HALF extents (x=w/2, y=d/2,
-*   z=d/2) so the shader text stays unchanged.
-* - `uRipples[8]` + `getRippleHeight` (NEW): character-interaction ring waves
-*   (see ./interaction.ts — constants mirrored there). Displacement AND
-*   normals include them via `getHeight`.
-* - `uUseEnvironmentMap` gate: the source declared it but never read it; we
-*   multiply it into the fresnel mix so water without a live reflection
-*   (headless, `reflection: false`, first frame) shades flat instead of black.
-* - Fresnel FIX: the source's `dot(viewDirection, normal)` (camera→surface vs
-*   up normal) is negative at every above-water angle, pinning fresnel at max
-*   — the surface was a constant 3/4 mirror, so the cube map smeared across
-*   everything. We dot the negated view direction (true Schlick shape) and
-*   clamp reflectivity to 0.75 so grazing angles keep some water colour.
-* - Reflection sampling FIXES: no `.x` flip (only LOADED cube textures need
-*   it; CubeCamera targets sample with three's flipEnvMap=+1 convention), and
-*   rays are folded above the horizon (`max(abs(y), 0.1)`) because the lower
-*   hemisphere of a water-centered cube map is parallax garbage.
-* - World-space `vNormal` FIX: the source ran the world-space analytic normal
-*   through `normalMatrix` (a VIEW-space transform) and then dotted it against
-*   world-space view/sun vectors — approximately right only for a level
-*   camera. We pass the world normal straight through; fresnel and the new
-*   sun glint stay put when the camera rolls.
-*
-* Water v2 additions (each marked `incanto v2` inline):
-* - Sun specular: tight Blinn-Phong glint + broad soft sheen off the
-*   detail-perturbed normal vs `uSunDirection` — the sparkling light path.
-* - Animated detail normals: two procedural high-frequency simplex gradient
-*   layers (different scales/directions/speeds, finite-differenced — no
-*   texture asset) perturb the analytic vertex normal, `uDetailStrength`.
-* - Beer's-law absorption: `exp(-uAbsorption · waterViewDepth)` blends the
-*   refracted scene into the ramp color — clear turquoise shallows, dark
-*   depths. Depth comes from the always-on (when rendered) scene pre-pass,
-*   gated by `uUseSceneDepth` so headless/first-frame shading stays flat.
-* - Screen-space refraction: the same pre-pass' color target (`uSceneColor`)
-*   sampled with a detail-normal offset — submerged geometry shimmers.
-*
-* Atmosphere additions (marked `incanto atmosphere`): the fragment ends with
-* three's `tonemapping_fragment` + `colorspace_fragment` + `fog_fragment`
-* chunks (the SAME output stage the built-in materials run), and both stages
-* carry the standard fog pars/vertex chunks — so ACES tone mapping,
-* sRGB output and `environment.fog` hit water exactly like the terrain.
-*/
-const WATER_VERT = `
-precision highp float;
-
-// incanto atmosphere: three's linear fog rides the standard chunks (compiled
-// out unless the scene declares fog — USE_FOG comes from material.fog)
-#include <fog_pars_vertex>
-
-const float WAVE_WORLD_REF = 128.0;
-
-uniform float uTime;
-
-uniform float uWavesAmplitude;
-uniform float uWavesSpeed;
-uniform float uWavesFrequency;
-uniform float uWavesPersistence;
-uniform float uWavesLacunarity;
-uniform float uWavesIterations;
-uniform vec3 uScale;
-// incanto: world-anchor + interaction ripples (x, z, age, amplitude)
-uniform vec3 uWaterCenter;
-uniform vec4 uRipples[8];
-// incanto swell: directional traveling wave trains (0 = off — legacy look).
-// uSwellDir is a unit XZ vector; amplitude in meters; wavelength in meters.
-uniform float uSwellAmplitude;
-uniform vec2 uSwellDir;
-uniform float uSwellWavelength;
-// incanto shore: the SWASH SURGE shares the shore-waves dial — a very long
-// slow bulge marching shoreward; ±9 cm of water height walks the waterline
-// meters up and down a gentle beach (the lapping runup).
-uniform float uShoreWaves;
-// incanto presets: the edge-fade ring exists to melt BIG water into terrain
-// shores — inside an exact-walled basin (pool/pond) it carves a visible
-// elliptical cliff instead, so those presets turn it off.
-uniform float uEdgeFadeOn;
-
-varying vec3 vNormal;
-varying vec3 vWorldPosition;
-varying vec4 vScreenPosition;
-
-//	Simplex 3D Noise
-//	by Ian McEwan, Stefan Gustavson (https://github.com/stegu/webgl-noise)
-//
-vec4 permute(vec4 x) {
-  return mod(((x * 34.0) + 1.0) * x, 289.0);
-}
-vec4 taylorInvSqrt(vec4 r) {
-  return 1.79284291400159 - 0.85373472095314 * r;
-}
-
-// Simplex 2D noise
-//
-vec3 permute(vec3 x) {
-  return mod(((x * 34.0) + 1.0) * x, 289.0);
-}
-
-float snoise(vec2 v) {
-  const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
-  vec2 i = floor(v + dot(v, C.yy));
-  vec2 x0 = v - i + dot(i, C.xx);
-  vec2 i1;
-  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
-  vec4 x12 = x0.xyxy + C.xxzz;
-  x12.xy -= i1;
-  i = mod(i, 289.0);
-  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
-  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
-  m = m * m;
-  m = m * m;
-  vec3 x = 2.0 * fract(p * C.www) - 1.0;
-  vec3 h = abs(x) - 0.5;
-  vec3 ox = floor(x + 0.5);
-  vec3 a0 = x - ox;
-  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
-  vec3 g;
-  g.x = a0.x * x0.x + h.x * x0.y;
-  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-  return 130.0 * dot(m, g);
-}
-
-// Helper function to calculate elevation at any point
-float getElevation(float x, float z) {
-  // World-metre wavelength: the source normalized by the water's own size,
-  // which shrinks wavelengths on small pools into storm spikes. A fixed
-  // 128 m reference reproduces the source's look (256 m lake) at ANY size.
-  vec2 pos = vec2(x / WAVE_WORLD_REF, z / WAVE_WORLD_REF);
-
-  float elevation = 0.0;
-  float amplitude = 1.0;
-  float frequency = uWavesFrequency;
-  vec2 p = pos.xy;
-
-  for(float i = 0.0; i < uWavesIterations; i++) {
-    float noiseValue = snoise(p * frequency + uTime * uWavesSpeed);
-    elevation += amplitude * noiseValue;
-    amplitude *= uWavesPersistence;
-    frequency *= uWavesLacunarity;
-  }
-
-  elevation *= uWavesAmplitude;
-
-  return elevation;
-}
-
-// incanto: expanding character-interaction rings — constants mirror
-// RIPPLE_K/W/DECAY/SPREAD in src/3d/water/interaction.ts (keep in sync).
-float getRippleHeight(vec2 p) {
-  float h = 0.0;
-  for (int i = 0; i < 8; i++) {
-    vec4 r = uRipples[i];
-    if (r.w <= 0.0) continue;
-    float d = distance(p, r.xy);
-    h += r.w * sin(6.0 * d - 8.0 * r.z) * exp(-1.1 * r.z) * exp(-0.15 * d * d);
-  }
-  return h;
-}
-
-// incanto swell: one peaked traveling wave train. Deep-water dispersion
-// (c = sqrt(g/k)) gives each wavelength its REAL speed, so short chop
-// overtakes long swell exactly like the open sea. The pow-shaped profile
-// sharpens crests and flattens troughs (a height-only Gerstner stand-in —
-// no XZ pinch, so the analytic finite-difference normals stay exact).
-float swellWave(vec2 p, vec2 dir, float lambda, float amp, float sharp) {
-  float k = 6.2831853 / max(lambda, 1.0);
-  float c = sqrt(9.8 / k);
-  float s = 0.5 + 0.5 * sin(dot(p, dir) * k - uTime * c * k);
-  return amp * (pow(s, sharp) * 2.0 - 1.0);
-}
-
-// incanto swell: three trains — the primary + two shorter crossing sets
-// (+25° / −19°) so crest lines stay broken and organic, never a zebra field.
-float getSwell(vec2 p) {
-  if (uSwellAmplitude <= 0.0) return 0.0;
-  vec2 d1 = uSwellDir;
-  vec2 d2 = normalize(vec2(d1.x * 0.906 - d1.y * 0.423, d1.x * 0.423 + d1.y * 0.906));
-  vec2 d3 = normalize(vec2(d1.x * 0.946 + d1.y * 0.326, -d1.x * 0.326 + d1.y * 0.946));
-  return swellWave(p, d1, uSwellWavelength,        uSwellAmplitude * 0.60, 2.6)
-       + swellWave(p, d2, uSwellWavelength * 0.53, uSwellAmplitude * 0.27, 2.2)
-       + swellWave(p, d3, uSwellWavelength * 0.31, uSwellAmplitude * 0.16, 1.8);
-}
-
-// incanto: waves + swell + ripples — used for displacement AND the normal
-// samples so every layer catches the light like real waves.
-// incanto shore: two incommensurate long surges — the waterline breathes in
-// wave-sets instead of a metronome tide
-float getSwash(vec2 p) {
-  if (uShoreWaves <= 0.0) return 0.0;
-  float along = dot(p, uSwellDir);
-  return uShoreWaves *
-    (0.06 * sin(along * 0.045 - uTime * 0.42) + 0.045 * sin(along * 0.11 - uTime * 0.71 + 1.3));
-}
-
-float getHeight(float x, float z) {
-  return getElevation(x, z) + getSwell(vec2(x, z)) + getSwash(vec2(x, z)) +
-    getRippleHeight(vec2(x, z));
-}
-
-void main() {
-  vec4 modelPosition = modelMatrix * vec4(position, 1.0);
-
-  float elevation = getHeight(modelPosition.x, modelPosition.z);
-  modelPosition.y += elevation;
-
-  // Height adjustment to smooth water edges
-  // Lower water height as it approaches scale boundaries
-  // incanto: measured from the node's center, not the world origin
-  vec2 normalizedPos = (modelPosition.xz - uWaterCenter.xz) / vec2(uScale.x, uScale.z);
-  float distanceFromCenter = length(normalizedPos);
-
-  // Gradually lower water height near edges
-  float edgeFadeStart = 0.85; // Start fade from 85% point
-  float edgeFadeEnd = 0.98;   // Completely lowered at 98% point
-
-  if (uEdgeFadeOn > 0.5 && distanceFromCenter >= edgeFadeStart) {
-    float fadeAmount = smoothstep(edgeFadeStart, edgeFadeEnd, distanceFromCenter);
-    float heightReduction = fadeAmount * 0.5; // Lower up to 0.5 units maximum
-    modelPosition.y -= heightReduction;
-  }
-
-  // Adjust appropriate eps value according to scale
-  float eps = 0.001 * max(uScale.x, uScale.z);
-
-  // Calculate normal using partial derivatives with scaled eps
-  vec3 tangent = normalize(vec3(eps, getHeight(modelPosition.x + eps, modelPosition.z) - elevation, 0.0));
-  vec3 bitangent = normalize(vec3(0.0, getHeight(modelPosition.x, modelPosition.z + eps) - elevation, eps));
-  vec3 objectNormal = normalize(cross(bitangent, tangent));
-
-  // incanto: tangent/bitangent above are WORLD-space — pass the world normal
-  // straight through (the source's normalMatrix mapped it into VIEW space and
-  // then dotted it against world vectors in the fragment shader).
-  vNormal = objectNormal;
-  vWorldPosition = modelPosition.xyz;
-
-  gl_Position = projectionMatrix * viewMatrix * modelPosition;
-  vScreenPosition = gl_Position;
-
-  // incanto atmosphere: fog depth from the displaced surface position
-  vec4 mvPosition = viewMatrix * modelPosition;
-  #include <fog_vertex>
-}
-`;
-const WATER_FRAG = `
-precision highp float;
-
-// incanto atmosphere: standard fog chunk (compiled out without scene fog)
-#include <fog_pars_fragment>
-
-uniform float uOpacity;
-
-uniform vec3 uTroughColor;
-uniform vec3 uSurfaceColor;
-uniform vec3 uPeakColor;
-
-uniform float uPeakThreshold;
-uniform float uPeakTransition;
-uniform float uTroughThreshold;
-uniform float uTroughTransition;
-
-uniform float uFresnelScale;
-uniform float uFresnelPower;
-uniform vec3 uScale;
-// incanto: world-anchor (the color ramp is relative to the waterline)
-uniform vec3 uWaterCenter;
-// incanto: 0 until the first cube render — the source declared but never read it
-uniform float uUseEnvironmentMap;
-
-// incanto v2: sun specular (glint + sheen) off the detail-perturbed normal
-uniform vec3 uSunDirection;
-uniform vec3 uSunColor;
-uniform float uSunIntensity;
-// incanto v2: animated procedural detail-normal strength
-uniform float uDetailStrength;
-// incanto v2: Beer's-law absorption (per meter of water along the view ray)
-uniform float uAbsorption;
-// incanto v2: scene pre-pass gates — 0 headless / before the first render
-uniform float uUseSceneDepth;
-uniform float uUseRefraction;
-// incanto v2: half-res scene color grab (the refracted underwater view).
-// grab-clip: Water3D renders this pass clipped at the waterline, so it holds
-// ONLY underwater geometry — refraction may sample it freely (the halo
-// guards this freed us from lived here; see _onRender3D). uDepthTexture is
-// NOT clipped (a depth-only completion pass restores the above-water scene),
-// so depth always means the true nearest occluder — 'no sample' never gets
-// mistaken for 'open water' (ref-26's shoreline seam).
-uniform sampler2D uSceneColor;
-
-// Uniforms for foam effects
-uniform float uEnableFoam;
-uniform vec3 uFoamColor;
-uniform float uFoamIntensity;
-uniform float uFoamRange;
-uniform float uFoamScale;
-uniform sampler2D uDepthTexture;
-uniform float uCameraNear;
-uniform float uCameraFar;
-uniform float uTime;
-
-// incanto: splash WHITEWATER — the ripple buffer (also bound in the vertex
-// shader) drives expanding foam on the surface; uSplashFoam = Water3D.splash.
-uniform vec4 uRipples[8];
-uniform float uRippleFoam[8];
-uniform float uSplashFoam;
-
-// incanto swell: open-water WHITECAPS — foam breaking on the highest crests,
-// independent of the shoreline depth mask. uWaveEnvelope is the JS-computed
-// total wave amplitude (FBM + swell) so the crest mask normalizes by the
-// actual sea state, not the surface's extent. uSwellAmplitude gates the
-// swell-only color work (crest banding + wave-face shading).
-uniform float uWhitecaps;
-uniform float uWaveEnvelope;
-uniform float uSwellAmplitude;
-// incanto shore: BREAKERS — foam fronts marching down the depth gradient
-// toward the beach. Phase rides the VERTICAL water depth, so the fronts hug
-// the shore's depth contours automatically and roll shoreward with time.
-uniform float uShoreWaves;
-
-// incanto presets: above-water CAUSTICS — the dancing light web on the
-// submerged bottom, seen THROUGH the surface (the pool/shallow-sea look).
-// Intensity 0 = off. The pattern fn is shared with the underwater composite.
-uniform float uCausticsAbove;
-// incanto presets: per-preset reflection ceiling (the old hard 0.6) — lakes
-// push toward mirror, pools stay glassy-clear.
-uniform float uReflectivityMax;
-
-${CAUSTIC_GLSL}
-
-// 🎨 Contact surface color customization uniforms
-uniform vec3 uEdgeColor;
-uniform float uEdgeIntensity;
-uniform float uEdgeWidth;
-
-varying vec3 vNormal;
-varying vec3 vWorldPosition;
-varying vec4 vScreenPosition;
-
-uniform samplerCube uEnvironmentMap;
-// incanto MIRROR: a planar reflection rendered from the camera mirrored across
-// the water plane. A water-centered cube map can only carry DISTANT content —
-// the shoreline trees, the boat, the player standing at the edge are exactly
-// what a still lake is supposed to show, and only a planar pass has them.
-// uMirrorMatrix projects a world position into that render's UV, so the sample
-// is self-consistent no matter where the fragment sits on the surface.
-uniform sampler2D uMirrorMap;
-uniform mat4 uMirrorMatrix;
-uniform float uUseMirror;
-uniform float uMirrorDistort;
-
-// Noise function (for foam patterns)
-float hash(vec2 p) {
-  return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453);
-}
-
-float noise(vec2 p) {
-  vec2 i = floor(p);
-  vec2 f = fract(p);
-  f = f * f * (3.0 - 2.0 * f);
-
-  float a = hash(i);
-  float b = hash(i + vec2(1.0, 0.0));
-  float c = hash(i + vec2(0.0, 1.0));
-  float d = hash(i + vec2(1.0, 1.0));
-
-  return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
-}
-
-// incanto v2: the SAME simplex the vertex waves use (Ian McEwan, Stefan
-// Gustavson — https://github.com/stegu/webgl-noise), here feeding the
-// procedural detail normals so the package stays texture-free.
-vec3 permute(vec3 x) {
-  return mod(((x * 34.0) + 1.0) * x, 289.0);
-}
-
-float snoise(vec2 v) {
-  const vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
-  vec2 i = floor(v + dot(v, C.yy));
-  vec2 x0 = v - i + dot(i, C.xx);
-  vec2 i1;
-  i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
-  vec4 x12 = x0.xyxy + C.xxzz;
-  x12.xy -= i1;
-  i = mod(i, 289.0);
-  vec3 p = permute(permute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
-  vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), 0.0);
-  m = m * m;
-  m = m * m;
-  vec3 x = 2.0 * fract(p * C.www) - 1.0;
-  vec3 h = abs(x) - 0.5;
-  vec3 ox = floor(x + 0.5);
-  vec3 a0 = x - ox;
-  m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
-  vec3 g;
-  g.x = a0.x * x0.x + h.x * x0.y;
-  g.yz = a0.yz * x12.xz + h.yz * x12.yw;
-  return 130.0 * dot(m, g);
-}
-
-// refinement pass: Beer's law per CHANNEL — red is absorbed first, blue/green
-// linger, so a sandy bottom turns turquoise long before it turns deep blue
-// (the wide turquoise→blue gradient of a real tropical shallows). The scalar
-// uAbsorption prop scales this fixed spectral shape.
-const vec3 ABSORB_TINT = vec3(2.4, 0.7, 0.5);
-
-// incanto v2: finite-difference gradient of the simplex height field
-vec2 noiseGrad(vec2 p) {
-  const float e = 0.06;
-  float h = snoise(p);
-  return vec2(snoise(p + vec2(e, 0.0)) - h, snoise(p + vec2(0.0, e)) - h) / e;
-}
-
-// incanto v2: animated detail-normal layers — the high-frequency perturbation
-// that makes the surface feel LIQUID up close (the vertex FBM is far too
-// coarse to catch light per-pixel). Per-layer distance fades stay (procedural
-// noise has no mips — past its range a layer aliases into white speckle).
-//
-// refinement pass 3: ANISOTROPIC wind-stretched ripple. The old isotropic
-// simplex layers perturbed the normal in soft round BLOBS — under the sun
-// they read as sticky slime / 액체괴물, never as water. Real wind ripple is
-// (a) stretched ALONG the wind, (b) much finer than swell, and (c) crisper
-// than smooth lumps. So: the noise domain is compressed along a wind
-// direction and the two fine layers run in CROSSING directions (±~25° off
-// the wind). dapple pass (ref-27): full ridge sharpening (1-|n|) at 2.8×
-// stretch folded the field into LONG PARALLEL CREASES — fabric wrinkles,
-// not water. Stretch comes down to 1.7×, the ridge transform is BLENDED
-// ~half toward plain simplex (soft short crests, no continuous fold lines),
-// the mid layer's frequency rises so features shorten, and the two crossing
-// layers sit close in weight so no single direction dominates. One coarse
-// smooth layer keeps long-swell coherence underneath. The line this walks:
-// PR-J's isotropic goop ←→ the crease field this replaces.
-// ============ the WATER-FEEL rewrite (the syrup fix) ============
-// The old detail layers had two viscosity bugs that made every surface read
-// as 꿀렁꿀렁한 gel instead of water:
-//   1. WRONG SPEED: each ripple layer drifted ~10× slower than a real wave
-//      of its wavelength. Deep-water dispersion says a λ-meter wave travels
-//      at c = sqrt(gλ/2π) — a 40 cm ripple crosses ITSELF ~2.7× per second.
-//      Slow fine ripples are exactly what honey looks like.
-//   2. PATTERN SLIDING: a translated noise field reads as one sticker being
-//      dragged (cellophane). Real ripple CHURNS — crests appear, interfere
-//      and die. The fine octaves are therefore INTERFERENCE PAIRS: the same
-//      wavelength read twice in slightly split directions and speeds; their
-//      sum morphs continuously instead of sliding.
-// Four octaves, each advected at its REAL phase speed (in noise-space,
-// phase = c/λ per second — short waves flicker fast, the tell of thin
-// mobile water):  λ 6.0 m → 0.51/s · 2.2 m → 0.84/s · 0.9 m → 1.31/s ·
-// 0.38 m → 2.02/s.
-const vec2 WIND_DIR = vec2(0.8192, 0.5735);
-
-vec2 octaveSlope(vec2 p, vec2 dir, float lambda, float t) {
-  // advect ALONG the octave's travel direction at the dispersion speed
-  float phase = sqrt(1.56 / lambda) * t; // c/λ = sqrt(g/(2πλ)) · … ≈ sqrt(1.56/λ)
-  return noiseGrad(p / lambda + dir * phase);
-}
-// interference pair: same wavelength, directions split ±14°, speeds split
-// ±12% — the sum churns (crests are born and die) instead of sliding.
-vec2 octavePair(vec2 p, vec2 dir, float lambda, float t) {
-  vec2 dA = normalize(dir + 0.25 * vec2(-dir.y, dir.x));
-  vec2 dB = normalize(dir - 0.25 * vec2(-dir.y, dir.x));
-  float phase = sqrt(1.56 / lambda) * t;
-  return noiseGrad(p / lambda + dA * (phase * 1.12))
-       + noiseGrad(p / lambda * 1.07 + dB * (phase * 0.88) + 17.0);
-}
-
-vec3 detailNormal(vec3 n, vec2 worldXZ, float strength, float camDist) {
-  float fadeCoarse = 1.0 - smoothstep(90.0, 420.0, camDist);
-  float fadeMid    = 1.0 - smoothstep(40.0, 170.0, camDist);
-  float fadeFine   = 1.0 - smoothstep(18.0, 80.0, camDist);
-  float fadeMicro  = 1.0 - smoothstep(8.0, 34.0, camDist);
-  vec2 dMid = normalize(vec2(0.62, 0.78));
-  vec2 slope =
-      octaveSlope(worldXZ, WIND_DIR, 6.0, uTime) * (0.085 * fadeCoarse)
-    + octaveSlope(worldXZ, dMid,     2.2, uTime) * (0.10  * fadeMid)
-    + octavePair(worldXZ, WIND_DIR,  0.9, uTime) * (0.055 * fadeFine)
-    + octavePair(worldXZ, dMid,      0.38, uTime) * (0.042 * fadeMicro);
-  slope *= strength * 3.0; // spectrum norm: default strength 0.26 ≈ calm-lively
-  return normalize(vec3(n.x - slope.x, n.y, n.z - slope.y));
-}
-
-// The GLOSS normal — what fresnel, the reflection and the refraction offset
-// read. Only the two long octaves: a mirror the size of a pixel integrates
-// micro-ripple away, so reflections stay smooth and ROUNDED (the glassy
-// pool-reference surface); the fast fine churn lives in the sun glitter and
-// the body shading, never as reflection speckle.
-vec3 glossNormal(vec3 n, vec2 worldXZ, float strength, float camDist) {
-  float fadeCoarse = 1.0 - smoothstep(90.0, 420.0, camDist);
-  float fadeMid    = 1.0 - smoothstep(40.0, 170.0, camDist);
-  vec2 dMid = normalize(vec2(0.62, 0.78));
-  vec2 slope =
-      octaveSlope(worldXZ, WIND_DIR, 6.0, uTime) * (0.085 * fadeCoarse)
-    + octaveSlope(worldXZ, dMid,     2.2, uTime) * (0.075 * fadeMid);
-  slope *= strength * 3.0;
-  return normalize(vec3(n.x - slope.x, n.y, n.z - slope.y));
-}
-
-// Linear depth conversion
-float linearizeDepth(float depth, float near, float far) {
-  float z = depth * 2.0 - 1.0;
-  return (2.0 * near * far) / (far + near - z * (far - near));
-}
-
-// incanto: splash WHITEWATER. The look that read as FAKE was a clean radial
-// disc/ring × speckle. Real foam is irregular clumps + tendrils that drift with
-// the water and break apart at the edges. So: a soft COVERAGE envelope (where
-// foam can be — an expanding patch that fades over FOAM_MAX_AGE; this is the
-// CPU twin rippleFoamAt, constants MIRRORED) THRESHOLDS a domain-warped
-// fractal noise. Dense coverage → broad froth; thinning coverage (edges / old)
-// raises the threshold → only the noise peaks survive → it erodes into sparse
-// bubbles. The warp + slow drift make it look advected, not stamped.
-float foamFbm(vec2 p) {
-  float v = 0.0, a = 0.5;
-  for (int i = 0; i < 4; i++) { v += a * noise(p); p = p * 2.02 + 7.3; a *= 0.5; }
-  return v; // ~0..0.94
-}
-
-float rippleFoam(vec2 p) {
-  if (uSplashFoam < 0.5) return 0.0;
-  float cover = 0.0;
-  for (int i = 0; i < 8; i++) {
-    float foam = uRippleFoam[i];
-    if (foam <= 0.0) continue;
-    vec4 r = uRipples[i];
-    float age = r.z;
-    float life = 1.0 - age / 1.6; // FOAM_MAX_AGE
-    if (life <= 0.0) continue;
-    float d = distance(p, r.xy);
-    float radius = 0.4 + 1.15 * age; // FOAM_R0 + FOAM_SPREAD * age
-    cover = max(cover, (1.0 - smoothstep(radius * 0.7, radius, d)) * foam * life);
-  }
-  if (cover <= 0.001) return 0.0;
-  // organic clumps: domain-warp the fbm (swirl) + slow drift = advected foam.
-  // FINE frequencies (premium foam is many small bubbles, not coarse blobs).
-  vec2 flow = vec2(uTime * 0.05, uTime * -0.04);
-  vec2 warp = vec2(foamFbm(p * 1.1 + flow), foamFbm(p * 1.1 + 4.2 - flow)) - 0.5;
-  float pattern = foamFbm(p * 2.6 + warp * 1.4 + flow);
-  // erode: high coverage → low threshold (denser foam); low coverage → high
-  // threshold (only the peaks survive → delicate lacy bubbles, soft edges).
-  // Raised floor + wide band = sparser + softer = subtler/more refined.
-  float thresh = mix(0.36, 0.96, 1.0 - cover);
-  float foamHere = smoothstep(thresh, thresh + 0.26, pattern);
-  return clamp(foamHere * (0.4 + 0.5 * cover), 0.0, 1.0);
-}
-
-// Enhanced depth-based foam effect calculation
-float calculateFoam() {
-  // incanto v2: foam rides the always-on scene depth pass — both gates
-  if (uEnableFoam < 0.5 || uUseSceneDepth < 0.5) return 0.0;
-
-  // 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);
-  float linearWaterDepth = linearizeDepth(waterDepth, uCameraNear, uCameraFar);
-
-  // Calculate depth difference (distance between water and other objects)
-  float depthDiff = abs(linearSceneDepth - linearWaterDepth);
-
-  // Generate foam - stronger in wider range
-  float foamFactor = 1.0 - smoothstep(0.0, uFoamRange, depthDiff);
-  foamFactor = pow(foamFactor, 0.5); // Softer decay
-
-  // Generate strong foam patterns with multi-layer noise
-  vec2 foamUV = vWorldPosition.xz * uFoamScale + uTime * 0.2;
-  float foamNoise = 0.0;
-
-  // Large pattern
-  foamNoise += noise(foamUV) * 0.6;
-  // Medium pattern
-  foamNoise += noise(foamUV * 3.0 + uTime * 0.5) * 0.4;
-  // Fine pattern
-  foamNoise += noise(foamUV * 8.0 + uTime * 1.0) * 0.3;
-  // Micro pattern
-  foamNoise += noise(foamUV * 20.0 + uTime * 1.5) * 0.2;
-
-  // Normalize noise
-  foamNoise /= 1.5;
-
-  // refinement pass: WISPY foam — a wide soft ramp instead of the old hard
-  // contrast boost, and the constant edge band cut way down so shallows read
-  // as noise-broken patches (the reference's channel foam), not a painted rim.
-  float foam = foamFactor * foamNoise * uFoamIntensity;
-  foam = smoothstep(0.12, 0.95, foam);
-
-  // Additional foam layer - edge enhancement (kept faint, noise-broken — a
-  // constant term veiled whole shallow ponds in flat white)
-  float edgeFoam = foamFactor * foamFactor * 0.18 * (0.35 + 0.65 * foamNoise);
-  foam = max(foam, edgeFoam);
-
-  // incanto v2: wave/ripple crests breaking NEAR shores kick up extra foam —
-  // the elevation ramp's peak factor masked by the shoreline depth factor.
-  float crest = smoothstep(uPeakThreshold, uPeakThreshold + uPeakTransition * 2.0,
-                           (vWorldPosition.y - uWaterCenter.y) / uScale.y);
-  foam = max(foam, foamFactor * crest * (0.5 + 0.5 * foamNoise));
-
-  return clamp(foam, 0.0, 1.0);
-}
-
-// Calculate smooth color blending at contact surfaces
-float calculateEdgeBlending() {
-  // Contact surface effects are part of foam effects (enableFoam is required)
-  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 linearWaterDepth = linearizeDepth(waterDepth, uCameraNear, uCameraFar);
-
-  float depthDiff = abs(linearSceneDepth - linearWaterDepth);
-
-  // User-defined range for color blending at contact surfaces
-  float blendRange = uFoamRange * uEdgeWidth; // Use user-defined range
-  float blendFactor = 1.0 - smoothstep(0.0, blendRange, depthDiff);
-
-  return blendFactor; // 0.0 (no effect) ~ 1.0 (maximum blending)
-}
-
-void main() {
-  // 🔥 Fundamental solution: Handle overlapping parts with objects
-  float depthMask = 1.0; // Default: fully render
-
-  // incanto v2: the scene depth pass is always-on for fancy when rendered —
-  // the mask (and the water view depth for Beer's law below) now ride
-  // uUseSceneDepth instead of the foam toggle.
-  vec2 screenUV = vScreenPosition.xy / vScreenPosition.w * 0.5 + 0.5;
-  float linearWaterDepth = linearizeDepth(gl_FragCoord.z, uCameraNear, uCameraFar);
-  // incanto v2: meters of water along the view ray; -1 = depth unavailable
-  float waterViewDepth = -1.0;
-  // shoreline-seam fix: hoisted — the refraction block reconstructs the scene
-  // sample's world height from it (grab validity, see below)
-  float linearSceneDepth = uCameraFar;
-
-  if (uUseSceneDepth > 0.5) {
-    float sceneDepth = texture2D(uDepthTexture, screenUV).r;
-    linearSceneDepth = linearizeDepth(sceneDepth, uCameraNear, uCameraFar);
-
-    float depthDiff = linearWaterDepth - linearSceneDepth;
-    waterViewDepth = max(-depthDiff, 0.0);
-
-    // 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
-    // notches along the swash edge — jitter the boundary with world noise and
-    // the seam breaks organic. Two octaves at LOW amplitude: a flat slope
-    // multiplies vertical jitter into horizontal metres, so a single strong
-    // octave carved angular value-noise chunks (the diced-radish waterline bug).
-    float seamJitter =
-      (noise(vWorldPosition.xz * 3.1) * 0.65 + noise(vWorldPosition.xz * 8.7) * 0.35 - 0.5) * 0.035;
-
-    // 🎯 Two-step approach
-    // Step 1: Discard completely overlapping parts
-    float hardDiscardThreshold = 0.1 + seamJitter;
-    if (depthDiff > hardDiscardThreshold) {
-      discard; // Completely remove definitively overlapping pixels
-    }
-
-    // Step 2: Gradual transparency for border parts
-    float softDiscardStart = -0.05 + seamJitter; // Start fade slightly ahead
-    float softDiscardEnd = hardDiscardThreshold;
-
-    if (depthDiff > softDiscardStart) {
-      depthMask = 1.0 - smoothstep(softDiscardStart, softDiscardEnd, depthDiff);
-      // At border: 0 (fully transparent) ~ 1 (fully opaque)
-    }
-  }
-
-  // Calculate vector from camera to the vertex
-  vec3 viewDirection = normalize(vWorldPosition - cameraPosition);
-  // incanto v2: perturb the analytic vertex normal with the animated detail
-  // layers — fresnel, reflection, refraction and the sun glint all read it.
-  // refinement pass: the per-LAYER distance fades live inside detailNormal,
-  // and fresnel/reflection read a distance-SMOOTHED normal — a pixel at range
-  // integrates many ripples, so its fresnel must converge to the swell's, not
-  // flicker per ripple (the old per-pixel fresnel turned the whole mid-field
-  // into white sky-reflection sequins). The sun glint keeps the full detail
-  // normal: distant glitter is real and reads as sparkle, not noise.
-  float camDist = length(vWorldPosition - cameraPosition);
-  vec3 geoNormal = normalize(vNormal);
-  vec3 normal = detailNormal(geoNormal, vWorldPosition.xz, uDetailStrength, camDist);
-  // refinement pass 3: the GEO normal must flatten with distance too — the
-  // per-vertex FBM normal varies per pixel near the horizon (its features go
-  // subpixel), and against the bright sun-side sky every flicker becomes a
-  // white sequin. A pixel at range integrates whole wave trains: its normal
-  // converges to flat-up, so fresnel/reflection/streak read exactly that.
-  float geoFlat = 1.0 - 0.9 * smoothstep(150.0, 600.0, camDist);
-  vec3 geoSmooth = normalize(mix(vec3(0.0, 1.0, 0.0), geoNormal, geoFlat));
-  float fresnelDetail = 1.0 - 0.85 * smoothstep(20.0, 120.0, camDist);
-  // eztree-parity pass: hoisted — fresnel AND the refraction offset read it.
-  // crisp-water fix: NEAR the camera the reflection must read the FULL
-  // ripple spectrum (sky reflections shatter into crisp shards at arm's
-  // length — reading only the smooth octaves rendered soft lava-lamp blobs);
-  // with distance it hands over to the smooth gloss so the far field never
-  // speckles against the HDR sky.
-  vec3 gloss = glossNormal(geoNormal, vWorldPosition.xz, uDetailStrength, camDist);
-  vec3 crisp = mix(normal, gloss, smoothstep(6.0, 26.0, camDist));
-  vec3 fresnelNormal = normalize(mix(geoSmooth, crisp, fresnelDetail));
-  vec3 reflectedDirection = reflect(viewDirection, fresnelNormal);
-  // incanto: the source flipped .x here — correct for cube textures LOADED
-  // from images, but a left/right mirror for CubeCamera render targets
-  // (three samples those with flipEnvMap = +1). Verified live: a marker
-  // object's reflection appeared on the opposite side with the flip.
-  // incanto: fold reflection rays above the horizon — the lower hemisphere
-  // of a water-centered cube map is parallax garbage (the ground under and
-  // around the pool) and painted ink-black wavelet patches at grazing angles;
-  // the +y bias keeps samples off the smeared horizon seam. refinement pass:
-  // 0.1 → 0.15 — the physical sky's brightest haze hugs the horizon, and
-  // grazing water sampled it into a blown-white band; a touch higher samples
-  // believable pale blue instead.
-  reflectedDirection.y = max(abs(reflectedDirection.y), 0.15);
-
-  // Sample environment map to get the reflected color
-  // refinement pass 3: soft-cap the HDR radiance — the physical sky's
-  // horizon haze runs ≫1 and a single bright reflection pixel reads as a
-  // white sequin after ACES; 2.5 still tone-maps near-white for real sky
-  // reflections without letting one texel blow out.
-  vec4 reflectionColor = textureCube(uEnvironmentMap, reflectedDirection);
-  reflectionColor.rgb = min(reflectionColor.rgb, vec3(2.5));
-
-  // incanto MIRROR: where the planar pass has data it REPLACES the cube — it
-  // is the same sky plus everything the cube map is blind to. Rays that leave
-  // the screen have no mirror sample, so the border fade hands those back to
-  // the cube instead of clamping a stretched edge texel across the surface.
-  if (uUseMirror > 0.5) {
-    vec4 mirrorClip = uMirrorMatrix * vec4(vWorldPosition, 1.0);
-    vec2 mirrorUv = mirrorClip.xy / max(mirrorClip.w, 1e-4);
-    // the ripple tilt bends the reflected ray: offset the sample by how far
-    // the wavelet normal leans off flat, damped with distance so the far field
-    // (many wavelets per pixel) stays a clean mirror instead of a jitter field
-    vec2 lean = (fresnelNormal.xz - geoNormal.xz) * uMirrorDistort;
-    mirrorUv += lean * (1.0 - smoothstep(20.0, 90.0, camDist));
-    vec2 edge = smoothstep(vec2(0.0), vec2(0.06), mirrorUv) *
-                (1.0 - smoothstep(vec2(0.94), vec2(1.0), mirrorUv));
-    float valid = edge.x * edge.y * step(0.0, mirrorClip.w);
-    if (valid > 0.0) {
-      vec3 mirrored = min(texture2D(uMirrorMap, mirrorUv).rgb, vec3(2.5));
-      reflectionColor.rgb = mix(reflectionColor.rgb, mirrored, valid);
-    }
-  }
-
-  // Calculate fresnel effect
-  // incanto: the source dotted the camera→surface direction against the
-  // up-facing normal — NEGATIVE at every above-water angle, so the clamp
-  // pinned fresnel at its maximum and the whole surface was a constant-ratio
-  // mirror. Negate it (surface→camera) for real angle-dependent fresnel:
-  // steep view = water color, grazing view = sky mirror.
-  // incanto atmosphere: full Schlick — the F0 floor (2%, water's real normal-
-  // incidence reflectance) keeps a whisper of sky at steep angles while the
-  // default exponent 5 stops the HDR sky from whitewashing the whole surface.
-  float fresnel = uFresnelScale * (0.02 + 0.98 * pow(1.0 - clamp(dot(-viewDirection, fresnelNormal), 0.0, 1.0), uFresnelPower));
-
-  // Calculate scale-normalized height value
-  // incanto: relative to the waterline, not absolute world y
-  float normalizedElevation = (vWorldPosition.y - uWaterCenter.y) / uScale.y;
-
-  // Calculate transition factors using smoothstep
-  float peakFactor = smoothstep(uPeakThreshold - uPeakTransition, uPeakThreshold + uPeakTransition, normalizedElevation);
-  float troughFactor = smoothstep(uTroughThreshold - uTroughTransition, uTroughThreshold + uTroughTransition, normalizedElevation);
-
-  // Mix between trough and surface colors based on trough transition
-  vec3 mixedColor1 = mix(uTroughColor, uSurfaceColor, troughFactor);
-
-  // Mix between surface and peak colors based on peak transition
-  vec3 mixedColor2 = mix(mixedColor1, uPeakColor, peakFactor);
-
-  // incanto swell: the legacy ramp normalizes elevation by the surface's
-  // HALF-EXTENT — on a real ocean plane that's hundreds of meters, so the
-  // ramp never sees a wave. When swell is on, re-read the crest height
-  // against the actual sea state (uWaveEnvelope) and (a) lighten crest tops
-  // toward the peak color, (b) shade the wave FACES with a gentle N·L off
-  // the distance-smoothed geometry normal — the lit/shadow lanes are what
-  // make open-ocean swell READ at any distance. Both gated: swell 0 keeps
-  // the legacy look byte-identical.
-  if (uSwellAmplitude > 0.0) {
-    float crestBand = smoothstep(0.3, 0.9,
-      (vWorldPosition.y - uWaterCenter.y) / max(uWaveEnvelope, 0.001));
-    mixedColor2 = mix(mixedColor2, uPeakColor, crestBand * 0.45);
-    float faceShade = clamp(dot(normalize(mix(vec3(0.0, 1.0, 0.0), normalize(vNormal),
-      1.0 - 0.9 * smoothstep(150.0, 600.0, length(vWorldPosition - cameraPosition)))),
-      normalize(uSunDirection)), 0.0, 1.0);
-    mixedColor2 *= 0.80 + 0.32 * faceShade;
-  }
-
-  // incanto v2: Beer's-law depth absorption + screen-space refraction.
-  // Shallow water transmits the (refracted) scene almost untouched; depth
-  // exponentially absorbs it into the ramp color — clear turquoise edges,
-  // dark depths. Headless / first frame: waterViewDepth stays -1 → flat ramp.
-  vec3 bodyColor = mixedColor2;
-  float bodyOpacity = uOpacity;
-  if (waterViewDepth >= 0.0) {
-    // refinement pass: per-channel transmittance (see ABSORB_TINT) — the
-    // turquoise→deep-blue gradient comes from red dying first, not from a
-    // hand-painted band.
-    vec3 transmittance = exp(-uAbsorption * ABSORB_TINT * waterViewDepth);
-    if (uUseRefraction > 0.5) {
-      // eztree-parity pass: the offset reads ONLY the SMOOTH gloss normal —
-      // the ridge-sharpened detail normal flips sign across every crest line
-      // and combed the submerged scene into jaggy scratch streaks (빗살무늬);
-      // even a 15% share re-speckled bright submerged objects.
-      vec2 refrSlope = crisp.xz;
-      // thickness-scaled parallax: the bottom image's refraction displacement
-      // grows with the water column's depth (thin film ≈ no shift, deep water
-      // ≈ full shimmer) — zero AT an object's contact line, so a partially
-      // submerged object's image stays glued to the surface (the old fixed
-      // contact damp), and strongly reduced in knee-deep ponds, where the old
-      // distance-only offset flung the pale submerged column into a ragged
-      // star splat around its own base (ref-23's waterline blob).
-      float contactDamp = clamp(waterViewDepth * 0.5, 0.0, 1.0);
-      vec2 refractionOffset = refrSlope * contactDamp * (0.35 / max(linearWaterDepth, 4.0));
-      vec2 refractedUV = clamp(screenUV + refractionOffset, vec2(0.001), vec2(0.999));
-      // grab-clip: the grab COLOR holds ONLY underwater geometry (Water3D
-      // clips that pass at the waterline), so there is no above-water color
-      // to bleed and no halo to guard — the PR-K soft reject and PR-L probe
-      // ring (whose boundaries became ref-23's silhouette outlines) are gone.
-      // One cheap sanity tap remains: an offset landing on geometry in FRONT
-      // of this water fragment (the thin waterline band the clip slack keeps,
-      // grazing self-overlaps) snaps back to the straight grab pixel…
-      float refractedSceneDepth =
-        linearizeDepth(texture2D(uDepthTexture, refractedUV).r, uCameraNear, uCameraFar);
-      float offsetReject = smoothstep(0.0, 0.05, linearWaterDepth - refractedSceneDepth);
-      // …or on an ABOVE-water sample: the depth-completion pass restored its
-      // true depth, but the clipped grab has no color there (clear-color
-      // texel) — reconstruct its world height along the view ray (view depth
-      // is linear in ray distance: t = camDist · sceneDepth/waterDepth) and
-      // snap those offsets back too.
-      float refrT = camDist * (refractedSceneDepth / max(linearWaterDepth, 1e-4));
-      offsetReject = max(offsetReject, smoothstep(0.02, 0.25,
-        cameraPosition.y + viewDirection.y * refrT - uWaterCenter.y));
-      refractedUV = mix(refractedUV, screenUV, offsetReject);
-      // mip-biased grab read: the pre-pass target carries mips (see
-      // Water3D._onRender3D) — biasing ~1.75 levels samples a pre-blurred
-      // underwater scene. Real water blurs what it refracts; the crisp
-      // half-res grab pixel-speckled at every silhouette and ripple edge.
-      vec3 sceneColor = texture2D(uSceneColor, refractedUV, 1.75).rgb;
-      // incanto presets: above-water caustics — reconstruct the sampled
-      // bottom's world position along the view ray and light it with the
-      // shared caustic web. Needs a focusing column of water (a centimeters-
-      // deep swash film shows no web) and a close viewer: past ~30m each
-      // pixel integrates many caustic cells and the additive web averages
-      // into a solid white sheet over any flat shallow (aerial sandbar bug).
-      if (uCausticsAbove > 0.0) {
-        vec3 bottomWorld = cameraPosition + viewDirection * refrT;
-        float below = uWaterCenter.y - bottomWorld.y;
-        if (below > 0.05) {
-          float reach = smoothstep(0.05, 0.5, below) * (1.0 - smoothstep(0.2, 9.0, below));
-          float causticFade = 1.0 - smoothstep(28.0, 90.0, camDist);
-          float cw = caustic(bottomWorld.xz * 0.42, uTime * 0.7) * 0.65
-                   + caustic(bottomWorld.xz * 0.72 + 30.0, uTime * 0.55) * 0.35;
-          sceneColor += vec3(0.87, 0.96, 1.0) * (cw * uCausticsAbove * reach * causticFade);
-        }
-      }
-      // opacity keeps its dial under in-shader compositing: it scales how
-      // strongly the water body hides the Beer-attenuated scene behind it —
-      // per channel, so the shallows tint instead of fading uniformly
-      vec3 body = clamp(uOpacity * (1.0 - transmittance) * 1.4, 0.0, 1.0);
-      // refinement pass 3: crystal shallows (photo reference) — where the
-      // water column is thin you SEE THE BOTTOM, ripple-distorted by the
-      // detail normals; the body color barely tints it. Clarity ramps the
-      // refracted scene up to ~88% inside the first ~1.5 m of water path and
-      // hands over to absorption beyond — depth still darkens the bottom.
-      float clarity = 0.88 * (1.0 - smoothstep(0.2, 1.5, waterViewDepth));
-      body *= 1.0 - clarity;
-      // shoreline-seam fallback: when the STRAIGHT sample itself sits above
-      // the waterline (beach rising behind a shoreline crest, a piercing
-      // object's dry half) the grab texel is clear-color, not the occluder —
-      // hand those pixels to the alpha path. The main framebuffer already
-      // shows the occluder behind this fragment, so a translucent ramp tint
-      // over it is the honest shallow-water look; compositing the clipped
-      // grab instead painted ref-26's background-colored band.
-      float sceneT = camDist * (linearSceneDepth / max(linearWaterDepth, 1e-4));
-      float sceneAbove = smoothstep(0.02, 0.25,
-        cameraPosition.y + viewDirection.y * sceneT - uWaterCenter.y);
-      float meanAbsorbed = 1.0 - dot(transmittance, vec3(0.299, 0.587, 0.114));
-      float alphaOpacity = mix(uOpacity * 0.45, max(uOpacity, 0.95), meanAbsorbed);
-      bodyColor = mix(mix(sceneColor, mixedColor2, body), mixedColor2, sceneAbove);
-      // in-shader compositing (opacity 1) for valid grab pixels; alpha blend
-      // over the main framebuffer for above-water-occluder pixels
-      bodyOpacity = mix(1.0, alphaOpacity, sceneAbove);
-    } else {
-      // no grab pass: alpha does the work — clear shallows, opaque depths
-      float meanAbsorbed = 1.0 - dot(transmittance, vec3(0.299, 0.587, 0.114));
-      bodyOpacity = mix(uOpacity * 0.45, max(uOpacity, 0.95), meanAbsorbed);
-    }
-  }
-
-  // Mix the final color with the reflection color
-  // incanto: gated on uUseEnvironmentMap so an unbound cube map reads flat
-  // clamp so grazing angles keep some water colour instead of going pure
-  // mirror (dark scenes otherwise paint the near edge black). refinement
-  // pass: 0.75 → 0.6 — the reference sea stays teal even at range; an HDR
-  // sky at 3/4 mirror washed the whole far field toward white.
-  float reflectivity = clamp(fresnel, 0.0, uReflectivityMax) * uUseEnvironmentMap;
-  vec3 finalColor = mix(bodyColor, reflectionColor.rgb, reflectivity);
-
-  // incanto v2: sun specular off the detail-perturbed normal.
-  // refinement pass 3: glints are SPARSE micro-facets. The old 320-power
-  // glint + everywhere-sheen flashed on half the ripples in view — the whole
-  // sea read as dense white speckle (글로시 슬라임). Now: extreme shininess
-  // (1400) so only facets aligned within a fraction of a degree flash, and
-  // both terms are weighted toward the sun's AZIMUTH path — crests sparkle
-  // along the light path, the rest of the surface stays broad calm color
-  // fields (the reference look). The sheen survives only as a soft halo on
-  // that path, near-zero elsewhere.
-  vec3 sunL = normalize(uSunDirection);
-  vec3 halfway = normalize(sunL - viewDirection); // -viewDirection = surface→camera
-  float specAngle = max(dot(normal, halfway), 0.0);
-  vec2 toFrag = normalize(vWorldPosition.xz - cameraPosition.xz);
-  float sunPath = pow(clamp(dot(toFrag, normalize(sunL.xz)), 0.0, 1.0), 5.0);
-  // micro-facet glints are a NEAR-field phenomenon on screen: past ~200 m a
-  // pixel integrates whole wave trains and per-pixel glints alias back into
-  // the old speckle — fade them out and hand the sun path to a SMOOTH streak
-  // off the distance-smoothed normal (a real sea's far sun path is a soft
-  // continuous band, not glitter).
-  // …and a VIEW-angle phenomenon: looking straight down (the photo-ref
-  // clarity framing) a real surface shows almost no sparkle — glints live at
-  // grazing angles. Weight by a Schlick-like grazing term so steep views
-  // stay calm, clear water instead of speckling.
-  float grazing = pow(1.0 - clamp(dot(-viewDirection, vec3(0.0, 1.0, 0.0)), 0.0, 1.0), 2.0);
-  // water-feel rewrite: NO artificial gate — the micro-ripple spectrum's
-  // fast churn makes each facet align with the sun for only a flash, so the
-  // glitter is naturally granular AND flickers at ripple speed (the old
-  // slow-noise gate was another piece of the syrup feel).
-  float glintFade = 1.0 - smoothstep(60.0, 240.0, camDist);
-  float glint = pow(specAngle, 900.0) * (0.15 + 0.85 * sunPath) * glintFade
-              * (0.1 + 0.9 * grazing);
-  float farAngle = max(dot(fresnelNormal, halfway), 0.0);
-  float streak = pow(farAngle, 240.0) * 0.45 * sunPath * (1.0 - glintFade);
-  float sheen = pow(specAngle, 64.0) * 0.05 * sunPath;
-  finalColor += uSunColor * min(uSunIntensity * (glint + streak + sheen), 0.85);
-
-  // Calculate and apply foam effects (only when enableFoam is true)
-  float foamAmount = 0.0;
-  if (uEnableFoam > 0.5) {
-    foamAmount = calculateFoam();
-  }
-  // incanto shore: traveling BREAKERS. The leading edge is sharp (the
-  // collapsing face), the tail is a long noisy wash that dissolves seaward
-  // of the beach; the whole system lives in the 0.1–3.2 m depth band where
-  // real waves shoal and break. Because phase = f(vertical depth), a front
-  // is always parallel to the local shoreline — bays curve it, points wrap
-  // it, no per-scene wiring.
-  if (uShoreWaves > 0.0 && uUseSceneDepth > 0.5 && waterViewDepth >= 0.0) {
-    float sceneT2 = camDist * (linearSceneDepth / max(linearWaterDepth, 1e-4));
-    float bottomY = cameraPosition.y + viewDirection.y * sceneT2;
-    float vertDepth = max(uWaterCenter.y - bottomY, 0.0);
-    if (vertDepth > 0.02 && vertDepth < 3.4) {
-      // DITHER the depth before phasing: the half-res depth texture
-      // quantizes on gentle slopes, and un-dithered fronts render as hard
-      // parallel terraces with visible pixel columns.
-      float dither = (noise(vWorldPosition.xz * 1.7) - 0.5) * 0.35
-                   + (noise(vWorldPosition.xz * 6.3 + 11.0) - 0.5) * 0.12;
-      float dd = max(vertDepth + dither, 0.0);
-      // ONE front per ~1.3 m of depth (the old 0.53 m stacked 3-4 terraces
-      // in view at once), soft leading edge, long dissolving wash
-      float phase = dd * 0.75 - uTime * 0.4;
-      float f = fract(phase);
-      float front = smoothstep(0.0, 0.14, f) * (1.0 - smoothstep(0.14, 0.85, f));
-      // waves arrive in SETS: a slow alongshore envelope gates whole fronts
-      // in and out so the surf breathes instead of ticking like a metronome
-      float sets = smoothstep(0.2, 0.75, noise(vWorldPosition.xz * 0.045 + uTime * vec2(0.025, 0.014)));
-      float breakup = noise(vWorldPosition.xz * 0.3 + uTime * vec2(0.06, 0.04));
-      float lace = noise(vWorldPosition.xz * 2.2 - uTime * vec2(0.18, 0.1));
-      front *= (0.45 + 0.55 * breakup) * (0.55 + 0.45 * lace) * (0.35 + 0.65 * sets);
-      // no fronts in the centimeters-deep SHEET-FLOW film (an enclosed flat
-      // fizzed solid white from the air) — breakers need ~knee depth to form
-      float zone = smoothstep(3.4, 1.2, vertDepth) * smoothstep(0.12, 0.38, vertDepth);
-      foamAmount = max(foamAmount, clamp(uShoreWaves * front * zone * 1.5, 0.0, 1.0));
-      // waterline LACE — fizzing bubbles where the runup meets sand. On a
-      // near-FLAT bar the 0–30 cm depth band is tens of meters wide, so an
-      // ungated lace carpeted whole flats in white — a slow patch gate keeps
-      // it as drifting foam streaks instead (real tidal-flat scum lines).
-      float lacePatch = smoothstep(0.4, 0.8, noise(vWorldPosition.xz * 0.5 + uTime * vec2(0.06, 0.045)));
-      float lace2 = smoothstep(0.24, 0.02, vertDepth) *
-        (0.35 + 0.65 * noise(vWorldPosition.xz * 3.1 + uTime * vec2(0.5, 0.35)));
-      foamAmount = max(foamAmount, clamp(uShoreWaves * lace2 * lacePatch * 0.4, 0.0, 1.0));
-    }
-  }
-  // incanto swell: whitecaps — foam eats the TOPS of the tallest crests in
-  // open water. The crest mask normalizes elevation by the real wave envelope
-  // (uScale.y is the surface's half-extent — useless as a sea-state yardstick
-  // on a big ocean plane), and a two-octave noise breaks the caps into
-  // patches that live and die with the crests. Distance-faded: far whitecaps
-  // subtend under a pixel and would alias into horizon speckle.
-  if (uWhitecaps > 0.0 && uWaveEnvelope > 0.001) {
-    float crestN = (vWorldPosition.y - uWaterCenter.y) / uWaveEnvelope;
-    float cap = smoothstep(0.5, 0.85, crestN);
-    vec2 capUV = vWorldPosition.xz * 0.3;
-    float capNoise = noise(capUV * 2.2 + uTime * vec2(0.10, 0.06)) * 0.65
-                   + noise(capUV * 6.5 - uTime * vec2(0.05, 0.14)) * 0.35;
-    float capFade = 1.0 - smoothstep(220.0, 640.0, camDist);
-    float whitecap = uWhitecaps * cap * smoothstep(0.42, 0.78, capNoise) * capFade;
-    foamAmount = max(foamAmount, whitecap);
-  }
-  // incanto: splash/wake whitewater rides the ripple buffer, INDEPENDENT of the
-  // depth-foam gate so it works even on shallow ponds / before the first pre-pass
-  float splashFoam = rippleFoam(vWorldPosition.xz);
-
-  // 🎨 Calculate contact surface color blending (part of foam effects)
-  if (uEnableFoam > 0.5 && uEdgeIntensity > 0.0) {
-    float edgeBlend = calculateEdgeBlending();
-
-    // Blend water color with user-defined color at contact surfaces
-    vec3 blendedWaterColor = mix(finalColor, uEdgeColor, edgeBlend * uEdgeIntensity);
-
-    // Slightly darken at contact surfaces (shadow effect)
-    float shadowIntensity = uEdgeIntensity * 0.5; // Link shadow intensity to user settings
-    float shadowFactor = 1.0 - edgeBlend * shadowIntensity;
-    finalColor = blendedWaterColor * shadowFactor;
-  }
-
-  // Apply foam effects (only when foamAmount is greater than 0)
-  // refinement pass: low-contrast blend, no additive brightness kick — foam
-  // is bubbles ON the water, slightly lighter, never glowing white.
-  if (foamAmount > 0.0) {
-    finalColor = mix(finalColor, uFoamColor, foamAmount * 0.55);
-  }
-  // splash froth: pale foam tint (NOT pure white — that floats on top as a
-  // jarring decal), the water still reads through, so a plunge/wake looks like
-  // disturbed water rather than painted-on white
-  if (splashFoam > 0.0) {
-    vec3 froth = mix(uFoamColor, vec3(1.0), 0.3); // pale, not stark white
-    finalColor = mix(finalColor, froth, splashFoam * 0.58); // subtle, water reads through
-  }
-
-  // 🎨 Adjust transparency at contact surfaces (part of foam effects)
-  // incanto v2: starts from bodyOpacity (Beer's-law depth-shaped alpha)
-  float baseOpacity = bodyOpacity;
-  if (uEnableFoam > 0.5 && uEdgeIntensity > 0.0) {
-    float edgeBlend = calculateEdgeBlending();
-    float transparencyEffect = uEdgeIntensity * 0.4; // Maximum 40% transparency increase
-    float edgeTransparency = mix(1.0, 1.0 - transparencyEffect, edgeBlend);
-    baseOpacity = bodyOpacity * edgeTransparency;
-  }
-
-  // Make areas with foam more opaque — shoreline foam firm, splash froth gentler
-  // (a lighter opacity bump keeps the splash translucent, not a solid white cap)
-  float foamOpacity = baseOpacity;
-  if (foamAmount > 0.0) {
-    foamOpacity = mix(baseOpacity, min(baseOpacity + 0.5, 1.0), foamAmount);
-  }
-  if (splashFoam > 0.0) {
-    foamOpacity = max(foamOpacity, mix(baseOpacity, min(baseOpacity + 0.3, 1.0), splashFoam));
-  }
-
-  // 🔥 Final fundamental solution: Apply depth mask
-  float finalOpacity = foamOpacity * depthMask;
-
-  gl_FragColor = vec4(finalColor, finalOpacity);
-
-  // incanto atmosphere: join three's output pipeline — ACES tone mapping +
-  // working→output colorspace encode + linear fog, in the SAME order as the
-  // built-in materials so water fogs/grades identically to the terrain.
-  #include <tonemapping_fragment>
-  #include <colorspace_fragment>
-  #include <fog_fragment>
-}
-`;
-//#endregion
-//#region src/3d/water/underwater.ts
-/**
-* True when the camera EYE sits below the water surface and inside its
-* (margin-expanded) XZ footprint — i.e. genuinely underwater. The tie at exactly
-* the surface height counts as above water (no flicker as you break the surface).
-* The underwater look is deliberately gated to this (not "near" the surface), so
-* wading with the camera above the water never tints the view. `marginXZ` lets it
-* engage a touch past the rim so swimming to the edge doesn't pop.
-*/
-function isCameraUnderwater(camX, camY, camZ, s, marginXZ = 0) {
-	if (camY >= s.centerY) return false;
-	return Math.abs(camX - s.centerX) <= s.halfW + marginXZ && Math.abs(camZ - s.centerZ) <= s.halfD + marginXZ;
-}
-/** Default visibility (fog far, meters) when the prop doesn't specify one. */
-const DEFAULT_VISIBILITY = 22;
-const DEFAULT_CAUSTICS = {
-	enabled: true,
-	color: "#cdeeff",
-	intensity: .55,
-	scale: .32,
-	speed: 1
-};
-/**
-* Resolve the `underwater` prop (`false` | `true` | `{color?, visibility?,
-* caustics?}`) into concrete values. With no explicit color the murk is DERIVED
-* from the water's own hue — darkened and pulled a touch toward deep blue so
-* being submerged reads as "inside THIS water", brighter water → brighter murk.
-*/
-function resolveUnderwater(prop, waterColor) {
-	if (prop === false) return {
-		enabled: false,
-		color: deriveMurk(waterColor),
-		visibility: DEFAULT_VISIBILITY,
-		caustics: DEFAULT_CAUSTICS
-	};
-	const obj = prop && typeof prop === "object" ? prop : {};
-	return {
-		enabled: true,
-		color: obj.color ?? deriveMurk(waterColor),
-		visibility: obj.visibility ?? DEFAULT_VISIBILITY,
-		caustics: resolveCaustics(obj.caustics)
-	};
-}
-function resolveCaustics(prop) {
-	if (prop === false) return {
-		...DEFAULT_CAUSTICS,
-		enabled: false
-	};
-	const obj = prop && typeof prop === "object" ? prop : {};
-	return {
-		enabled: true,
-		color: typeof obj.color === "string" ? obj.color : DEFAULT_CAUSTICS.color,
-		intensity: typeof obj.intensity === "number" ? obj.intensity : DEFAULT_CAUSTICS.intensity,
-		scale: typeof obj.scale === "number" ? obj.scale : DEFAULT_CAUSTICS.scale,
-		speed: typeof obj.speed === "number" ? obj.speed : DEFAULT_CAUSTICS.speed
-	};
-}
-/**
-* Darken a hex color toward a deep blue-green — the look of light absorbed by a
-* column of water (red dies first, blue lingers). Pure hex math so the parser
-* stays three-free.
-*/
-function deriveMurk(hex) {
-	const { r, g, b } = parseHex(hex);
-	const mix = (c, target, t) => Math.round(c * (1 - t) + target * t);
-	return toHex(Math.round(mix(r, 6, .45) * .7), Math.round(mix(g, 40, .4) * .78), Math.round(mix(b, 70, .35) * .82));
-}
-function parseHex(hex) {
-	const h = hex.replace("#", "");
-	const n = h.length === 3 ? h.split("").map((c) => c + c).join("") : h;
-	return {
-		r: Number.parseInt(n.slice(0, 2), 16) || 0,
-		g: Number.parseInt(n.slice(2, 4), 16) || 0,
-		b: Number.parseInt(n.slice(4, 6), 16) || 0
-	};
-}
-function toHex(r, g, b) {
-	const c = (v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, "0");
-	return `#${c(r)}${c(g)}${c(b)}`;
-}
-//#endregion
-//#region src/3d/water/waves.ts
-/**
-* CPU twin of the Water3D vertex-shader wave field — pure math, no three.
-*
-* `waveElevation` ports the shader's 2D-simplex FBM (`getElevation`) exactly
-* (same constants, same iteration scheme) so character-interaction code can
-* sample the waterline a body is crossing WITHOUT reading the GPU back.
-* `simpleWaveHeight` is the legacy crossed-sines displacement used by
-* `quality: 'simple'`.
-*/
-/** The ported shader's FBM constants (vibe-starter-3d-environment water). */
-const FANCY_WAVE = {
-	frequency: 6.7,
-	persistence: .3,
-	lacunarity: 2.18,
-	iterations: 9,
-	speed: .5
-};
-/** The source shader's reference amplitude… */
-const REFERENCE_AMPLITUDE = .525;
-/** …which the legacy `waveHeight` default maps onto (0.08 → 0.525). */
-const REFERENCE_WAVE_HEIGHT = .08;
-/** Legacy crossed-sine constants (`quality: 'simple'`). */
-const SIMPLE_WAVE = {
-	freqX: .7,
-	freqZ: .5,
-	cross: .6
-};
-/** GLSL `mod` (sign of divisor, unlike JS `%`). */
-function glslMod(a, n) {
-	return a - Math.floor(a / n) * n;
-}
-function fract(x) {
-	return x - Math.floor(x);
-}
-/** GLSL `permute`: mod(((x*34)+1)*x, 289). */
-function permute(x) {
-	return glslMod((x * 34 + 1) * x, 289);
-}
-const C_X = .211324865405187;
-const C_Y = .366025403784439;
-const C_Z = -.577350269189626;
-const C_W = .024390243902439;
-function snoise2(vx, vy) {
-	let ix = Math.floor(vx + (vx + vy) * C_Y);
-	let iy = Math.floor(vy + (vx + vy) * C_Y);
-	const x0x = vx - ix + (ix + iy) * C_X;
-	const x0y = vy - iy + (ix + iy) * C_X;
-	const i1x = x0x > x0y ? 1 : 0;
-	const i1y = x0x > x0y ? 0 : 1;
-	const x12x = x0x + C_X - i1x;
-	const x12y = x0y + C_X - i1y;
-	const x12z = x0x + C_Z;
-	const x12w = x0y + C_Z;
-	ix = glslMod(ix, 289);
-	iy = glslMod(iy, 289);
-	const p0 = permute(permute(iy) + ix);
-	const p1 = permute(permute(iy + i1y) + ix + i1x);
-	const p2 = permute(permute(iy + 1) + ix + 1);
-	let m0 = Math.max(.5 - (x0x * x0x + x0y * x0y), 0);
-	let m1 = Math.max(.5 - (x12x * x12x + x12y * x12y), 0);
-	let m2 = Math.max(.5 - (x12z * x12z + x12w * x12w), 0);
-	m0 = m0 * m0;
-	m0 = m0 * m0;
-	m1 = m1 * m1;
-	m1 = m1 * m1;
-	m2 = m2 * m2;
-	m2 = m2 * m2;
-	const g0x = 2 * fract(p0 * C_W) - 1;
-	const g1x = 2 * fract(p1 * C_W) - 1;
-	const g2x = 2 * fract(p2 * C_W) - 1;
-	const h0 = Math.abs(g0x) - .5;
-	const h1 = Math.abs(g1x) - .5;
-	const h2 = Math.abs(g2x) - .5;
-	const a0 = g0x - Math.floor(g0x + .5);
-	const a1 = g1x - Math.floor(g1x + .5);
-	const a2 = g2x - Math.floor(g2x + .5);
-	m0 *= 1.79284291400159 - .85373472095314 * (a0 * a0 + h0 * h0);
-	m1 *= 1.79284291400159 - .85373472095314 * (a1 * a1 + h1 * h1);
-	m2 *= 1.79284291400159 - .85373472095314 * (a2 * a2 + h2 * h2);
-	const g0 = a0 * x0x + h0 * x0y;
-	const g1 = a1 * x12x + h1 * x12y;
-	const g2 = a2 * x12z + h2 * x12w;
-	return 130 * (m0 * g0 + m1 * g1 + m2 * g2);
-}
-/**
-* Wave elevation at world (x, z) at `time` — the shader's `getElevation`.
-* Deterministic; bounded by `amplitude · (1 − persistence^n) / (1 − persistence)`.
-*/
-function waveElevation(x, z, time, p) {
-	const norm = Math.max(p.scaleNorm, 1e-6);
-	const px = x / norm;
-	const pz = z / norm;
-	let elevation = 0;
-	let amplitude = 1;
-	let frequency = p.frequency;
-	const phase = time * p.speed;
-	for (let i = 0; i < p.iterations; i++) {
-		elevation += amplitude * snoise2(px * frequency + phase, pz * frequency + phase);
-		amplitude *= p.persistence;
-		frequency *= p.lacunarity;
-	}
-	return elevation * p.amplitude;
-}
-/** The legacy two-crossed-sines height at LOCAL (x, z) — `quality: 'simple'`. */
-function simpleWaveHeight(x, z, time, waveHeight) {
-	return waveHeight * (Math.sin(x * SIMPLE_WAVE.freqX + time) + SIMPLE_WAVE.cross * Math.sin(z * SIMPLE_WAVE.freqZ + time * 1.3));
-}
-//#endregion
-//#region src/3d/nodes/water-3d.ts
-const WATER_QUALITIES = ["fancy", "simple"];
-const COLOR_KEYS = [
-	"trough",
-	"surface",
-	"peak"
-];
-const WATER_PRESET_NAMES = [
-	"custom",
-	"ocean",
-	"pool",
-	"lake",
-	"pond"
-];
-/**
-* The four curated water types — `preset: 'ocean' | 'pool' | 'lake' | 'pond'`
-* is THE one-choice dial: each bundle sets every wave/color/clarity/caustics
-* knob to a hand-tuned sea state. A preset value applies ONLY while the prop
-* still sits at its schema default (same convention as the env-sun handoff),
-* so any explicitly authored prop wins — pick the type, then override details
-* to taste.
-*
-* - ocean: traveling swell + whitecaps, wide turquoise→deep-blue absorption
-* - pool:  near-flat crystal water, strong above-water caustics on the floor
-* - lake:  calm mirror — high reflectivity, murkier green-teal depths
-* - pond:  still, mossy, opaque quickly — the garden pond
-*/
-const WATER_PRESETS = {
-	ocean: {
-		waveHeight: .045,
-		swell: .34,
-		swellWavelength: 52,
-		whitecaps: .15,
-		absorption: .17,
-		opacity: .85,
-		detailStrength: .17,
-		sunIntensity: .85,
-		colors: {
-			trough: "#175360",
-			surface: "#2f8792",
-			peak: "#9bd8d2"
-		},
-		color: "#2f8792",
-		causticsAbove: .3,
-		shoreWaves: .7,
-		reflectionInterval: 400,
-		_look: {
-			fresnelScale: 1.15,
-			reflectivityMax: .93,
-			foamRangeScale: .35,
-			foamIntensity: .55
-		}
-	},
-	pool: {
-		waveHeight: .006,
-		swell: 0,
-		whitecaps: 0,
-		absorption: .3,
-		opacity: .5,
-		detailStrength: .16,
-		sunIntensity: 1.25,
-		colors: {
-			trough: "#1e8dbe",
-			surface: "#3fb6dc",
-			peak: "#bdeef7"
-		},
-		color: "#3fb6dc",
-		causticsAbove: 1,
-		reflectionInterval: 600,
-		_look: {
-			fresnelScale: .85,
-			reflectivityMax: .5,
-			edgeFade: false
-		}
-	},
-	lake: {
-		waveHeight: .028,
-		swell: .14,
-		swellWavelength: 24,
-		whitecaps: 0,
-		absorption: .5,
-		opacity: .88,
-		detailStrength: .3,
-		colors: {
-			trough: "#12343a",
-			surface: "#25565c",
-			peak: "#7fb2ab"
-		},
-		color: "#25565c",
-		causticsAbove: .15,
-		reflectionInterval: 300,
-		_look: {
-			fresnelScale: 1.25,
-			reflectivityMax: .78
-		}
-	},
-	pond: {
-		waveHeight: .012,
-		swell: 0,
-		whitecaps: 0,
-		absorption: .55,
-		opacity: .88,
-		detailStrength: .2,
-		sunIntensity: .9,
-		colors: {
-			trough: "#24402a",
-			surface: "#436b4d",
-			peak: "#8fae8e"
-		},
-		color: "#436b4d",
-		causticsAbove: 0,
-		reflectionInterval: 800,
-		_look: {
-			fresnelScale: 1.1,
-			reflectivityMax: .68,
-			edgeFade: false
-		}
-	}
-};
-/** Refinement-pass palette — teal-leaning sea blues sampled off the reference
-* calm sea (deep open water ≈ #2b7993, mid teal ≈ #16878a). The old ported
-* palette (#1f5b8a/#52a0d0/#aee3ff) read as saturated pool blue. */
-const FANCY_COLORS = {
-	trough: "#135a72",
-	surface: "#2a86a0",
-	peak: "#a5ddd6"
-};
-/** Color-ramp constants ported as-is; fresnel RETUNED for the atmosphere
-* stage: the source's scale 1.5 / power 0.8 made the surface a ~75% mirror at
-* every angle — invisible against its LDR backdrop, but a milk-white sea once
-* the reflection cube carries the HDR physical sky. Schlick's real exponent
-* (5) with unit scale keeps steep views water-colored and grazing views sky. */
-const FANCY_LOOK = {
-	peakThreshold: .08,
-	peakTransition: .05,
-	troughThreshold: -.01,
-	troughTransition: .15,
-	fresnelScale: 1,
-	fresnelPower: 5
-};
-/** Foam/contact constants. Refinement-pass retune: `range` scales with the
-* water's extent (see foamRangeFor) — SEAS get wide wispy channel foam like
-* the reference, ponds keep a shoreline KISS (a flat 1.4 m range painted a
-* 0.45 m-deep pond white wall-to-wall — the exact v2 regression, relearned).
-* `intensity` drops and the fragment ramp softens — wispy patches, never a
-* bright band. `edgeIntensity` 2 → 0.6: the contact line is a hint. */
-const FOAM_LOOK = {
-	color: "#dcebe8",
-	intensity: .32,
-	rangeMin: .45,
-	rangeMax: 1.4,
-	scale: .35,
-	edgeColor: "#ffffff",
-	edgeIntensity: .6,
-	edgeWidth: .5
-};
-/** Foam depth-range in meters, scaled by the surface's smaller extent: a
-* garden pond (≤ ~37 m) keeps the tight 0.45 m contact band, open water
-* ramps to 1.4 m so foam spreads across whole shallow channels. */
-function foamRangeFor(w, d) {
-	return Math.min(FOAM_LOOK.rangeMax, Math.max(FOAM_LOOK.rangeMin, Math.min(w, d) * .012));
-}
-/** `waveHeight` keeps its role as THE wave dial: the legacy default (0.08)
-* reproduces the source's reference amplitude (0.525) exactly. */
-const WAVE_WORLD_REF = 128;
-const AMPLITUDE_PER_WAVE_HEIGHT = REFERENCE_AMPLITUDE / REFERENCE_WAVE_HEIGHT;
-/** Cube-map reflection resolution (source: reflectionQuality = 256). */
-const REFLECTION_RESOLUTION = 256;
-/** Planar-mirror target size cap (per side) — half the drawing buffer, clamped. */
-const MIRROR_PASS_MAX = 1024;
-/** How far a wavelet's tilt slides the mirror sample, in UV per unit of normal lean. */
-const MIRROR_DISTORT = .06;
-/** Scene pre-pass (depth for absorption/foam + color grab for refraction):
-* half the drawing buffer, clamped — ONE extra scene render per frame. */
-const SCENE_PASS_MAX = 1024;
-/** Grab-clip tolerance above the waterline (meters) — covers depth-buffer
-* precision at the clip plane, nothing more. Deliberately NO wave-height
-* slack: clipping at crest height instead kept each piercing object's
-* [waterline..crest] slice in the grab, and that pale band re-bled through
-* the mip-biased read and the ripple-wiggled offsets as silhouette scribbles
-* — a miniature of the halo disease the clip exists to kill. The cost is
-* crests refracting a hair short at an object's contact (invisible: the
-* object's own deeper column fills the gap with near-identical color). */
-const WATERLINE_CLIP_SLACK = .02;
-/** Fancy vertex density: the FBM displaces per vertex, so density scales with
-* extent (the source's formula degenerated to always-256; ours ramps to it). */
-const FANCY_SEGMENTS_PER_M = 4;
-const FANCY_SEGMENTS_MIN = 32;
-const FANCY_SEGMENTS_MAX = 256;
-/** Simple quality: coarse enough to animate every vertex on the CPU. */
-const SIMPLE_SEGMENTS = 32;
-/** Bodies must rise this far above the waterline to 'exit' (no surface flicker). */
-const SURFACE_HYSTERESIS = .05;
-/** Entry splash amplitude: base + per-(m/s of |vy|), capped. */
-const ENTER_AMP_BASE = .08;
-const ENTER_AMP_PER_VY = .02;
-const ENTER_AMP_MAX = .18;
-/** Leaving the water drags a smaller ring out with you. */
-const EXIT_AMP = .04;
-/** Bodies floating IN water bob a gentle ring every interval (seconds). */
-const BOB_INTERVAL = 1.4;
-const BOB_AMP = .04;
-/** A body striding through water trails a WAKE: a ripple every this-many metres. */
-const WAKE_STEP = .45;
-const WAKE_AMP = .08;
-/** Splash FOAM strengths (0..1) the shaders paint as surface whitewater.
-* Entry foam scales with fall speed (see `entryFoam`); these tag the rest. */
-const EXIT_FOAM = .4;
-/** Wake foam tracks how fast you stride through the water (the "물살"). */
-const WAKE_FOAM_BASE = .22;
-const WAKE_FOAM_PER_SPEED = .09;
-const WAKE_FOAM_MAX = .85;
-/**
-* A water surface on XZ. `quality: 'fancy'` (default) is a commercial-grade
-* water shader — 9-iteration simplex FBM displacement with analytic normals,
-* two animated procedural detail-normal layers (`detailStrength`), a sun
-* specular glint+sheen (`sunDirection`/`sunColor`/`sunIntensity`), Beer's-law
-* depth `absorption` (clear shallows → dark depths), screen-space
-* `refraction` of the submerged scene, depth-texture shoreline `foam` (on by
-* default), a trough/surface/peak color ramp and fresnel-mixed CubeCamera
-* reflections (re-rendered every `reflectionInterval` ms). `quality:
-* 'simple'` is the cheap CPU sine-wave material (low-end fallback; also the
-* deterministic headless path).
-*
-* Per-frame GPU budget for fancy (beyond drawing the surface): ONE half-res
-* scene pre-pass that feeds depth (absorption/foam/soft intersections) AND
-* the refraction color grab; the cube reflection stays on its `1000 ms`
-* throttle.
-*
-* Character interaction (`interaction: true`): each update the node scans the
-* tree for CharacterBody3D/RigidBody3D, compares their world y against the
-* waterline at their xz (wave offset included, CPU twin of the shader), emits
-* `entered`/`exited` with the body node, and pushes ripple impulses into a
-* fixed 8-slot ring buffer both shaders turn into expanding ring waves. The
-* surface has no bottom — anything below the waterline inside the XZ
-* footprint counts as in-water (pair with `Area3D` for volumetric gameplay).
-*
-* GPU-only features (reflection/foam) run through the renderer's
-* `_onRender3D` hand-off — headless runs simply never invoke it.
-*/
-var Water3D = class Water3D extends Node3D {
-	static typeName = "Water3D";
-	static signals = ["entered", "exited"];
-	static props = {
-		size: { default: [40, 40] },
-		color: { default: "#2a6fbe" },
-		opacity: { default: .8 },
-		renderOrder: { default: 1 },
-		waveHeight: { default: .04 },
-		waveSpeed: { default: 1 },
-		quality: {
-			default: "fancy",
-			options: WATER_QUALITIES
-		},
-		colors: { default: {} },
-		reflection: { default: true },
-		reflectionInterval: { default: 1e3 },
-		mirror: { default: false },
-		foam: { default: true },
-		interaction: { default: true },
-		splash: { default: true },
-		sunDirection: { default: [
-			.5,
-			.8,
-			.3
-		] },
-		sunColor: { default: "#fff5d6" },
-		sunIntensity: { default: 1 },
-		detailStrength: { default: .26 },
-		absorption: { default: .15 },
-		refraction: { default: true },
-		underwater: { default: true },
-		swell: { default: 0 },
-		swellDirectionDeg: { default: 0 },
-		swellWavelength: { default: 30 },
-		whitecaps: { default: 0 },
-		preset: {
-			default: "custom",
-			options: WATER_PRESET_NAMES
-		},
-		causticsAbove: { default: 0 },
-		shoreWaves: { default: 0 }
-	};
-	/** [width, depth] in meters (the surface lies on XZ). */
-	size = [40, 40];
-	/** Legacy single hue: simple-quality color; tints the fancy ramp when set. */
-	color = "#2a6fbe";
-	opacity = .8;
-	/** Draw after opaque geometry (overrides Node3D's 0 default). */
-	renderOrder = 1;
-	/** Wave intensity dial, meters-ish. 0 = mirror-flat; 0.04 (default) reads
-	* as a calm sea; 0.08 = the noisier ported-source look. */
-	waveHeight = .04;
-	waveSpeed = 1;
-	/** 'fancy' shader water (default) | 'simple' cheap CPU sine material. */
-	quality = "fancy";
-	/** Fancy ramp overrides: `{trough?, surface?, peak?}` hex strings. */
-	colors = {};
-	/** CubeCamera reflections (fancy only; needs a live renderer). */
-	reflection = true;
-	/**
-	* TRUE planar reflection: the scene re-rendered from the camera mirrored
-	* across this surface, sampled per fragment. A cube map can only carry
-	* distant content — the shoreline trees, the moored boat, the player at the
-	* water's edge only appear in the water with this on. Costs one extra scene
-	* render per frame, so it is off by default; a still lake earns it.
-	*/
-	mirror = false;
-	/** ms between reflection (and foam depth) re-renders. */
-	reflectionInterval = 1e3;
-	/** Depth-texture shoreline foam — rides the always-on fancy scene pass. */
-	foam = true;
-	/** Bodies crossing the surface emit signals and raise ripples. */
-	interaction = true;
-	/** Splash WHITEWATER: the shaders paint expanding surface foam where bodies
-	* interact — a "풍덩" froth bloom on entry (scaled by fall speed) and a foam
-	* trail ("물살") behind a body wading/running through. Needs `interaction`. */
-	splash = true;
-	/** Fixed sun for the specular glint — match the scene's key light. */
-	sunDirection = [
-		.5,
-		.8,
-		.3
-	];
-	/** Sun glint/sheen tint. */
-	sunColor = "#fff5d6";
-	/** Sun glint/sheen strength — 0 disables the specular entirely. */
-	sunIntensity = 1;
-	/** Animated detail-normal strength — the close-up liquid feel (0 = off). */
-	detailStrength = .26;
-	/** Beer's-law absorption per meter of water depth (0 = no depth tinting).
-	* Per-channel under the hood: red dies ~3× faster than blue, so shallows
-	* over a bright bottom read turquoise before fading to deep blue. */
-	absorption = .15;
-	/** Screen-space refraction of the submerged scene (fancy only). */
-	refraction = true;
-	/**
-	* Submerged-camera look: when the camera dips below this surface (inside its
-	* XZ footprint) the scene switches to an underwater fog + tint for that frame
-	* — the murky, limited-visibility feel of being underwater. `true` (default)
-	* derives the murk from `color`; `false` disables it; an object
-	* `{ color?, visibility? }` overrides the fog hue / view distance (meters).
-	*/
-	underwater = true;
-	/**
-	* Directional traveling SWELL amplitude in meters (fancy only; 0 = off, the
-	* legacy isotropic look). Three peaked wave trains march across the surface
-	* at real deep-water speeds — THE open-ocean dial: 0.15 = lively lake chop,
-	* 0.4 = coastal sea, 0.8 = heavy weather. Crests feed the color ramp,
-	* `whitecaps` and the shore foam automatically.
-	*/
-	swell = 0;
-	/** Compass direction the swell TRAVELS toward, degrees (0 = +z, 90 = +x). */
-	swellDirectionDeg = 0;
-	/** Primary swell wavelength in meters (the two crossing trains derive). */
-	swellWavelength = 30;
-	/** Open-water whitecap foam on the tallest crests, 0–1 (fancy only). Works
-	* best with `swell` — the caps ride the swell's crest lines. */
-	whitecaps = 0;
-	/**
-	* THE one-choice water type: 'ocean' | 'pool' | 'lake' | 'pond' bundles
-	* every wave/color/clarity/caustics knob into a hand-tuned sea state
-	* ('custom', the default, changes nothing). A preset value applies ONLY
-	* where a prop still sits at its schema default — set the type first, then
-	* override any detail prop to taste and your value wins.
-	*/
-	preset = "custom";
-	/**
-	* Above-water CAUSTICS intensity (0 = off): the dancing light web on the
-	* submerged bottom, seen THROUGH the surface — the pool / tropical-shallows
-	* look. Needs `refraction` (fancy quality). Presets set it; override freely.
-	*/
-	causticsAbove = 0;
-	/**
-	* Traveling SHORE BREAKERS, 0–1 (fancy + depth pre-pass only): foam fronts
-	* that roll down the depth gradient and break toward every beach — the
-	* fronts follow the shore's depth contours automatically. Presets: ocean
-	* ships 0.7; 0 (default) = off.
-	*/
-	shoreWaves = 0;
-	/** Preset-layered prop read (see {@link WATER_PRESETS}): the preset value
-	* applies only while the prop sits at its schema default. */
-	rp(key) {
-		const bundle = WATER_PRESETS[this.preset];
-		const self = this;
-		if (bundle && key in bundle) {
-			const def = Water3D.props[key]?.default;
-			const cur = self[key];
-			if (typeof cur === "object" && cur !== null ? JSON.stringify(cur) === JSON.stringify(def) : cur === def) return bundle[key];
-		}
-		return self[key];
-	}
-	/** Per-preset internal look constants (fresnel curve, reflection ceiling). */
-	presetLook() {
-		const look = WATER_PRESETS[this.preset]?._look;
-		return {
-			fresnelScale: look?.fresnelScale ?? FANCY_LOOK.fresnelScale,
-			reflectivityMax: look?.reflectivityMax ?? .6,
-			edgeFade: look?.edgeFade ?? true,
-			foamRangeScale: look?.foamRangeScale ?? 1,
-			foamIntensity: look?.foamIntensity ?? FOAM_LOOK.intensity
-		};
-	}
-	/** Loader hook: degenerate planes and bad enums fail at LOAD, not at render. */
-	static validateJson(node) {
-		const w = node;
-		if (!((w.size[0] ?? 0) > 0) || !((w.size[1] ?? 0) > 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' size must be positive [width, depth] meters, got ${JSON.stringify(w.size)}.`, { prop: "size" });
-		if (!WATER_QUALITIES.includes(w.quality)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' quality must be one of [${WATER_QUALITIES.join(", ")}], got '${w.quality}'.`, {
-			prop: "quality",
-			validOptions: WATER_QUALITIES
-		});
-		for (const [key, value] of Object.entries(w.colors)) {
-			if (!COLOR_KEYS.includes(key)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' colors has unknown key '${key}'. Valid keys: [${COLOR_KEYS.join(", ")}].`, {
-				prop: "colors",
-				validOptions: COLOR_KEYS
-			});
-			if (typeof value !== "string") throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' colors.${key} must be a hex color string, got ${JSON.stringify(value)}.`, { prop: "colors" });
-		}
-		if (!(w.reflectionInterval > 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' reflectionInterval must be > 0 ms, got ${w.reflectionInterval}.`, { prop: "reflectionInterval" });
-		const sun = w.sunDirection;
-		if (!Array.isArray(sun) || sun.length !== 3 || !sun.every((v) => Number.isFinite(v)) || Math.hypot(sun[0] ?? 0, sun[1] ?? 0, sun[2] ?? 0) === 0) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' sunDirection must be a non-zero [x, y, z] vector, got ${JSON.stringify(sun)}.`, { prop: "sunDirection" });
-		if (!(w.sunIntensity >= 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' sunIntensity must be >= 0, got ${w.sunIntensity}.`, { prop: "sunIntensity" });
-		if (!(w.detailStrength >= 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' detailStrength must be >= 0, got ${w.detailStrength}.`, { prop: "detailStrength" });
-		if (!(w.absorption >= 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' absorption must be >= 0 (per-meter Beer's-law constant), got ${w.absorption}.`, { prop: "absorption" });
-		if (!(w.swell >= 0) || !Number.isFinite(w.swell)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' swell must be >= 0 meters (0 = off), got ${JSON.stringify(w.swell)}.`, { prop: "swell" });
-		if (!(w.swellWavelength >= 2)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' swellWavelength must be >= 2 meters, got ${JSON.stringify(w.swellWavelength)}.`, { prop: "swellWavelength" });
-		if (!(w.whitecaps >= 0) || !(w.whitecaps <= 1)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' whitecaps must be in [0, 1], got ${JSON.stringify(w.whitecaps)}.`, { prop: "whitecaps" });
-		if (!WATER_PRESET_NAMES.includes(w.preset)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' preset must be one of [${WATER_PRESET_NAMES.join(", ")}], got '${w.preset}'.`, {
-			prop: "preset",
-			validOptions: WATER_PRESET_NAMES
-		});
-		if (!(w.shoreWaves >= 0) || !(w.shoreWaves <= 1)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' shoreWaves must be in [0, 1] (0 = off), got ${JSON.stringify(w.shoreWaves)}.`, { prop: "shoreWaves" });
-		if (!(w.causticsAbove >= 0) || !(w.causticsAbove <= 3)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' causticsAbove must be in [0, 3] (0 = off), got ${JSON.stringify(w.causticsAbove)}.`, { prop: "causticsAbove" });
-		const uw = w.underwater;
-		if (typeof uw !== "boolean") {
-			if (typeof uw !== "object" || uw === null || Array.isArray(uw)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' underwater must be true, false or an object ({ color?, visibility? }), got ${JSON.stringify(uw)}.`, { prop: "underwater" });
-			const o = uw;
-			if (o.color !== void 0 && typeof o.color !== "string") throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' underwater.color must be a hex color string, got ${JSON.stringify(o.color)}.`, { prop: "underwater" });
-			if (o.visibility !== void 0 && !(o.visibility > 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' underwater.visibility must be > 0 meters, got ${JSON.stringify(o.visibility)}.`, { prop: "underwater" });
-		}
-	}
-	time = 0;
-	surfaceKey = "";
-	/** @internal Live ripple ring buffer (≤8) — tests and tools read this. */
-	_ripples = [];
-	inWater = /* @__PURE__ */ new Set();
-	bobTimers = /* @__PURE__ */ new Map();
-	/** Last position a wake ripple was dropped, per in-water body (for the trail). */
-	wadeAnchors = /* @__PURE__ */ new Map();
-	_scratchA = {
-		x: 0,
-		y: 0,
-		z: 0
-	};
-	_scratchB = {
-		x: 0,
-		y: 0,
-		z: 0
-	};
-	_bodies = [];
-	cubeTarget = null;
-	cubeCamera = null;
-	/** Reflection near plane (max half extent) — recreate the camera on resize. */
-	reflectionNear = 0;
-	lastReflectionAt = 0;
-	/** Per-frame scene pre-pass: depth (absorption/foam) + color grab (refraction). */
-	scenePassTarget = null;
-	mirrorTarget = null;
-	mirrorCamera = new PerspectiveCamera();
-	mirrorMatrix = new Matrix4();
-	_createObject3D() {
-		return new Mesh();
-	}
-	update(dt) {
-		this.time += dt * this.waveSpeed;
-		ageRipples(this._ripples, dt);
-		if (this.interaction) this.stepInteraction(dt);
-	}
-	_syncObject3D() {
-		super._syncObject3D();
-		const mesh = this._ensureObject3D();
-		this.rebuildSurfaceIfNeeded(mesh);
-		if (this.quality === "simple") this.syncSimple(mesh);
-		else this.syncFancy(mesh);
-	}
-	/**
-	* @internal Renderer hand-off (see {@link RenderContext3D}): re-render the
-	* CubeCamera reflection every `reflectionInterval` ms, plus ONE per-frame
-	* half-res scene pre-pass whose depth texture drives Beer's-law absorption,
-	* shoreline foam and soft intersections, and whose color texture is the
-	* refraction grab — one extra render feeds all three.
-	*/
-	_onRender3D(ctx) {
-		const mesh = this._ensureObject3D();
-		const material = mesh.material;
-		ctx.camera.updateWorldMatrix(true, false);
-		ctx.camera.getWorldPosition(underwaterCamScratch);
-		if (this.underwaterAt(underwaterCamScratch.x, underwaterCamScratch.y, underwaterCamScratch.z)) {
-			if (material.isShaderMaterial) {
-				const u = material.uniforms;
-				if (u.uUseSceneDepth) u.uUseSceneDepth.value = 0;
-				if (u.uUseRefraction) u.uUseRefraction.value = 0;
-				if (u.uUseMirror) u.uUseMirror.value = 0;
-			}
-			return;
-		}
-		if (this.quality !== "fancy" || !material.isShaderMaterial) return;
-		const halfDiagonal = Math.hypot((this.size[0] ?? 1) / 2, (this.size[1] ?? 1) / 2);
-		if (!sphereInCameraFrustum(ctx.camera, worldTranslationOf(this), halfDiagonal + 1)) return;
-		const u = material.uniforms;
-		const now = Date.now();
-		if (this.reflection) {
-			if (!this.cubeTarget) this.cubeTarget = new WebGLCubeRenderTarget(REFLECTION_RESOLUTION, {
-				generateMipmaps: true,
-				minFilter: LinearMipmapLinearFilter,
-				type: HalfFloatType
-			});
-			const near = Math.max((this.size[0] ?? 1) / 2, (this.size[1] ?? 1) / 2);
-			if (!this.cubeCamera || this.reflectionNear !== near) {
-				this.reflectionNear = near;
-				this.cubeCamera = new CubeCamera(near, 1e3, this.cubeTarget);
-				this.lastReflectionAt = 0;
-			}
-			if (this.lastReflectionAt === 0 || now - this.lastReflectionAt >= this.rp("reflectionInterval")) {
-				this.lastReflectionAt = now;
-				const center = worldTranslationOf(this);
-				const cam = this.cubeCamera;
-				cam.position.set(center.x, center.y + .1, center.z);
-				const wasVisible = mesh.visible;
-				mesh.visible = false;
-				cam.update(ctx.gl, ctx.scene);
-				mesh.visible = wasVisible;
-			}
-			if (u.uEnvironmentMap && u.uUseEnvironmentMap) {
-				u.uEnvironmentMap.value = this.cubeTarget.texture;
-				u.uUseEnvironmentMap.value = 1;
-			}
-		}
-		if (this.mirror && u.uMirrorMap && u.uMirrorMatrix && u.uUseMirror) {
-			ctx.gl.getDrawingBufferSize(drawingBufferScratch);
-			const mirrorW = Math.max(1, Math.min(Math.round(drawingBufferScratch.x / 2), MIRROR_PASS_MAX));
-			const mirrorH = Math.max(1, Math.min(Math.round(drawingBufferScratch.y / 2), MIRROR_PASS_MAX));
-			if (this.mirrorTarget && (this.mirrorTarget.width !== mirrorW || this.mirrorTarget.height !== mirrorH)) {
-				this.mirrorTarget.dispose();
-				this.mirrorTarget = null;
-			}
-			if (!this.mirrorTarget) this.mirrorTarget = new WebGLRenderTarget(mirrorW, mirrorH, {
-				depthBuffer: true,
-				stencilBuffer: false,
-				type: HalfFloatType
-			});
-			const surfaceY = worldTranslationOf(this).y;
-			const cam = ctx.camera;
-			cam.getWorldPosition(mirrorEyeScratch);
-			cam.getWorldQuaternion(mirrorQuatScratch);
-			mirrorTargetScratch.set(0, 0, -1).applyQuaternion(mirrorQuatScratch).add(mirrorEyeScratch);
-			mirrorUpScratch.set(0, 1, 0).applyQuaternion(mirrorQuatScratch);
-			mirrorEyeScratch.y = 2 * surfaceY - mirrorEyeScratch.y;
-			mirrorTargetScratch.y = 2 * surfaceY - mirrorTargetScratch.y;
-			mirrorUpScratch.y = -mirrorUpScratch.y;
-			const mirrorCam = this.mirrorCamera;
-			mirrorCam.fov = cam.fov ?? 50;
-			mirrorCam.aspect = cam.aspect ?? mirrorW / mirrorH;
-			mirrorCam.near = cam.near ?? .1;
-			mirrorCam.far = cam.far ?? 1e3;
-			mirrorCam.position.copy(mirrorEyeScratch);
-			mirrorCam.up.copy(mirrorUpScratch);
-			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);
-			const prevMirrorTarget = ctx.gl.getRenderTarget();
-			const prevMirrorClip = ctx.gl.clippingPlanes;
-			const wasMirrorVisible = mesh.visible;
-			mesh.visible = false;
-			mirrorClipPlane.constant = -(surfaceY - WATERLINE_CLIP_SLACK);
-			ctx.gl.clippingPlanes = mirrorClipPlanes;
-			ctx.gl.setRenderTarget(this.mirrorTarget);
-			ctx.gl.clear(true, true, false);
-			ctx.gl.render(ctx.scene, mirrorCam);
-			ctx.gl.setRenderTarget(prevMirrorTarget);
-			ctx.gl.clippingPlanes = prevMirrorClip;
-			mesh.visible = wasMirrorVisible;
-			u.uMirrorMap.value = this.mirrorTarget.texture;
-			u.uMirrorMatrix.value.copy(this.mirrorMatrix);
-			u.uUseMirror.value = 1;
-		} else if (u.uUseMirror) u.uUseMirror.value = 0;
-		ctx.gl.getDrawingBufferSize(drawingBufferScratch);
-		const passW = Math.max(1, Math.min(Math.round(drawingBufferScratch.x / 2), SCENE_PASS_MAX));
-		const passH = Math.max(1, Math.min(Math.round(drawingBufferScratch.y / 2), SCENE_PASS_MAX));
-		if (this.scenePassTarget && (this.scenePassTarget.width !== passW || this.scenePassTarget.height !== passH)) {
-			this.scenePassTarget.depthTexture?.dispose();
-			this.scenePassTarget.dispose();
-			this.scenePassTarget = null;
-		}
-		if (!this.scenePassTarget) {
-			const depthTexture = new DepthTexture(passW, passH);
-			depthTexture.type = FloatType;
-			this.scenePassTarget = new WebGLRenderTarget(passW, passH, {
-				depthTexture,
-				depthBuffer: true,
-				stencilBuffer: false,
-				generateMipmaps: true,
-				minFilter: LinearMipmapLinearFilter
-			});
-		}
-		const prevTarget = ctx.gl.getRenderTarget();
-		const prevAutoClear = ctx.gl.autoClear;
-		const prevClippingPlanes = ctx.gl.clippingPlanes;
-		const wasVisible = mesh.visible;
-		mesh.visible = false;
-		const waterY = worldTranslationOf(this).y;
-		grabClipPlane.constant = waterY + WATERLINE_CLIP_SLACK;
-		ctx.gl.clippingPlanes = grabClipPlanes;
-		ctx.gl.setRenderTarget(this.scenePassTarget);
-		ctx.gl.autoClear = true;
-		ctx.gl.clear(true, true, false);
-		ctx.gl.render(ctx.scene, ctx.camera);
-		depthOnlyClipPlane.constant = -(waterY - WATERLINE_CLIP_SLACK);
-		ctx.gl.clippingPlanes = depthOnlyClipPlanes;
-		const prevOverride = ctx.scene.overrideMaterial;
-		const prevBackground = ctx.scene.background;
-		ctx.scene.overrideMaterial = depthOnlyMaterial;
-		ctx.scene.background = null;
-		ctx.gl.autoClear = false;
-		ctx.gl.render(ctx.scene, ctx.camera);
-		ctx.scene.overrideMaterial = prevOverride;
-		ctx.scene.background = prevBackground;
-		ctx.gl.setRenderTarget(prevTarget);
-		ctx.gl.autoClear = prevAutoClear;
-		ctx.gl.clippingPlanes = prevClippingPlanes;
-		mesh.visible = wasVisible;
-		if (u.uDepthTexture && u.uSceneColor && u.uCameraNear && u.uCameraFar && u.uUseSceneDepth) {
-			u.uDepthTexture.value = this.scenePassTarget.depthTexture;
-			u.uSceneColor.value = this.scenePassTarget.texture;
-			u.uCameraNear.value = ctx.camera.near;
-			u.uCameraFar.value = ctx.camera.far;
-			u.uUseSceneDepth.value = 1;
-			if (u.uUseRefraction) u.uUseRefraction.value = this.refraction ? 1 : 0;
-			if (u.uEnableFoam) u.uEnableFoam.value = this.foam ? 1 : 0;
-		}
-	}
-	/**
-	* Camera-submersion query (the renderer asks every water node each frame): the
-	* resolved underwater look + this surface's Y when the camera EYE is below
-	* THIS surface inside its XZ footprint, else null. Deliberately gated to the
-	* eye being underwater (not merely near the surface) so wading with the camera
-	* above the water never tints the view. Cheap above water (geometric test first).
-	*/
-	underwaterAt(camX, camY, camZ) {
-		if (this.underwater === false) return null;
-		const center = worldTranslationOf(this, this._scratchA);
-		if (!isCameraUnderwater(camX, camY, camZ, {
-			centerX: center.x,
-			centerY: center.y,
-			centerZ: center.z,
-			halfW: (this.size[0] ?? 1) / 2,
-			halfD: (this.size[1] ?? 1) / 2
-		}, UNDERWATER_MARGIN)) return null;
-		const cfg = resolveUnderwater(this.underwater, this.rp("color"));
-		return cfg.enabled ? {
-			...cfg,
-			surfaceY: center.y
-		} : null;
-	}
-	free() {
-		const mesh = this._ensureObject3D();
-		mesh.geometry?.dispose();
-		mesh.material?.dispose?.();
-		this.cubeTarget?.dispose();
-		this.cubeTarget = null;
-		this.cubeCamera = null;
-		this.scenePassTarget?.depthTexture?.dispose();
-		this.scenePassTarget?.dispose();
-		this.scenePassTarget = null;
-		this.mirrorTarget?.dispose();
-		this.mirrorTarget = null;
-		super.free();
-	}
-	/** Swap geometry+material only when a surface-shaping prop changed. */
-	rebuildSurfaceIfNeeded(mesh) {
-		const key = JSON.stringify([this.size, this.quality]);
-		if (key === this.surfaceKey && mesh.geometry.getAttribute("position")) return;
-		this.surfaceKey = key;
-		mesh.geometry?.dispose();
-		mesh.material?.dispose?.();
-		const w = this.size[0] ?? 1;
-		const d = this.size[1] ?? 1;
-		if (this.quality === "simple") {
-			mesh.geometry = buildWaterGeometry(w, d, SIMPLE_SEGMENTS);
-			mesh.material = this.buildLakeMaterial();
-		} else {
-			mesh.geometry = buildWaterGeometry(w, d, Math.min(Math.max(Math.round(Math.max(w, d) * FANCY_SEGMENTS_PER_M), FANCY_SEGMENTS_MIN), FANCY_SEGMENTS_MAX));
-			mesh.material = this.buildFancyMaterial();
-		}
-	}
-	buildFancyMaterial() {
-		return new ShaderMaterial({
-			vertexShader: WATER_VERT,
-			fragmentShader: WATER_FRAG,
-			fog: true,
-			uniforms: {
-				fogColor: { value: new Color("#ffffff") },
-				fogNear: { value: 1 },
-				fogFar: { value: 1e3 },
-				fogDensity: { value: 25e-5 },
-				uTime: { value: 0 },
-				uOpacity: { value: this.rp("opacity") },
-				uEnvironmentMap: { value: null },
-				uUseEnvironmentMap: { value: 0 },
-				uMirrorMap: { value: null },
-				uMirrorMatrix: { value: new Matrix4() },
-				uUseMirror: { value: 0 },
-				uMirrorDistort: { value: MIRROR_DISTORT },
-				uWavesAmplitude: { value: this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT },
-				uWavesSpeed: { value: FANCY_WAVE.speed },
-				uWavesFrequency: { value: FANCY_WAVE.frequency },
-				uWavesPersistence: { value: FANCY_WAVE.persistence },
-				uWavesLacunarity: { value: FANCY_WAVE.lacunarity },
-				uWavesIterations: { value: FANCY_WAVE.iterations },
-				uTroughColor: { value: new Color(FANCY_COLORS.trough) },
-				uSurfaceColor: { value: new Color(FANCY_COLORS.surface) },
-				uPeakColor: { value: new Color(FANCY_COLORS.peak) },
-				uPeakThreshold: { value: FANCY_LOOK.peakThreshold },
-				uPeakTransition: { value: FANCY_LOOK.peakTransition },
-				uTroughThreshold: { value: FANCY_LOOK.troughThreshold },
-				uTroughTransition: { value: FANCY_LOOK.troughTransition },
-				uFresnelScale: { value: FANCY_LOOK.fresnelScale },
-				uFresnelPower: { value: FANCY_LOOK.fresnelPower },
-				uScale: { value: new Vector3(1, 1, 1) },
-				uWaterCenter: { value: new Vector3() },
-				uRipples: { value: Array.from({ length: 8 }, () => new Vector4()) },
-				uRippleFoam: { value: Array.from({ length: 8 }, () => 0) },
-				uSplashFoam: { value: this.splash ? 1 : 0 },
-				uSunDirection: { value: new Vector3(.5, .8, .3) },
-				uSunColor: { value: new Color(this.sunColor) },
-				uSunIntensity: { value: this.rp("sunIntensity") },
-				uDetailStrength: { value: this.rp("detailStrength") },
-				uAbsorption: { value: this.rp("absorption") },
-				uUseSceneDepth: { value: 0 },
-				uUseRefraction: { value: 0 },
-				uSceneColor: { value: null },
-				uEnableFoam: { value: 0 },
-				uFoamColor: { value: new Color(FOAM_LOOK.color) },
-				uFoamIntensity: { value: FOAM_LOOK.intensity },
-				uFoamRange: { value: foamRangeFor(this.size[0] ?? 1, this.size[1] ?? 1) },
-				uFoamScale: { value: FOAM_LOOK.scale },
-				uDepthTexture: { value: null },
-				uCameraNear: { value: .1 },
-				uCameraFar: { value: 1e3 },
-				uEdgeColor: { value: new Color(FOAM_LOOK.edgeColor) },
-				uEdgeIntensity: { value: FOAM_LOOK.edgeIntensity },
-				uEdgeWidth: { value: FOAM_LOOK.edgeWidth },
-				uSwellAmplitude: { value: this.rp("swell") },
-				uSwellDir: { value: new Vector2(0, 1) },
-				uSwellWavelength: { value: this.rp("swellWavelength") },
-				uWhitecaps: { value: this.rp("whitecaps") },
-				uWaveEnvelope: { value: 0 },
-				uCausticsAbove: { value: this.rp("causticsAbove") },
-				uShoreWaves: { value: this.rp("shoreWaves") },
-				uReflectivityMax: { value: .6 },
-				uEdgeFadeOn: { value: 1 }
-			},
-			transparent: true,
-			depthTest: true,
-			depthWrite: true,
-			side: DoubleSide
-		});
-	}
-	/** The cheap lake ShaderMaterial — fresnel sky tint + ripple normals + sun
-	* glint + edge fade, NO scene re-renders (see lake.ts). */
-	buildLakeMaterial() {
-		return new ShaderMaterial({
-			vertexShader: LAKE_VERT,
-			fragmentShader: LAKE_FRAG,
-			fog: true,
-			uniforms: {
-				fogColor: { value: new Color("#ffffff") },
-				fogNear: { value: 1 },
-				fogFar: { value: 1e3 },
-				fogDensity: { value: 25e-5 },
-				uTime: { value: 0 },
-				uOpacity: { value: this.rp("opacity") },
-				uColor: { value: new Color(this.rp("color")) },
-				uSurfaceColor: { value: new Color(this.rp("color")) },
-				uSkyColor: { value: new Color(this.rp("color")) },
-				uSunDirection: { value: new Vector3(.5, .8, .3).normalize() },
-				uSunColor: { value: new Color(this.sunColor) },
-				uSunIntensity: { value: this.rp("sunIntensity") },
-				uDetailStrength: { value: this.rp("detailStrength") },
-				uFresnelPower: { value: FANCY_LOOK.fresnelPower },
-				uScale: { value: new Vector3(1, 1, 1) },
-				uWaterCenter: { value: new Vector3() },
-				uRipples: { value: Array.from({ length: 8 }, () => new Vector4()) },
-				uRippleFoam: { value: Array.from({ length: 8 }, () => 0) },
-				uSplashFoam: { value: this.splash ? 1 : 0 },
-				uFoamColor: { value: new Color(FOAM_LOOK.color) }
-			},
-			transparent: true,
-			depthTest: true,
-			depthWrite: false,
-			side: DoubleSide
-		});
-	}
-	syncFancy(mesh) {
-		const u = mesh.material.uniforms;
-		const w = this.size[0] ?? 1;
-		const d = this.size[1] ?? 1;
-		const center = worldTranslationOf(this);
-		if (u.uTime) u.uTime.value = this.time;
-		if (u.uOpacity) u.uOpacity.value = this.rp("opacity");
-		if (u.uWavesAmplitude) u.uWavesAmplitude.value = this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT;
-		(u.uScale?.value)?.set(w / 2, d / 2, d / 2);
-		(u.uWaterCenter?.value)?.set(center.x, center.y, center.z);
-		const palette = this.resolvePalette();
-		(u.uTroughColor?.value)?.copy(palette.trough);
-		(u.uSurfaceColor?.value)?.copy(palette.surface);
-		(u.uPeakColor?.value)?.copy(palette.peak);
-		(u.uSunDirection?.value)?.set(this.sunDirection[0] ?? 0, this.sunDirection[1] ?? 1, this.sunDirection[2] ?? 0).normalize();
-		(u.uSunColor?.value)?.set(this.sunColor);
-		if (u.uSunIntensity) u.uSunIntensity.value = this.rp("sunIntensity");
-		if (u.uDetailStrength) u.uDetailStrength.value = this.rp("detailStrength");
-		if (u.uAbsorption) u.uAbsorption.value = this.rp("absorption");
-		if (u.uSwellAmplitude) u.uSwellAmplitude.value = this.rp("swell");
-		if (u.uSwellWavelength) u.uSwellWavelength.value = this.rp("swellWavelength");
-		if (u.uWhitecaps) u.uWhitecaps.value = this.rp("whitecaps");
-		if (u.uCausticsAbove) u.uCausticsAbove.value = this.rp("causticsAbove");
-		if (u.uShoreWaves) u.uShoreWaves.value = this.rp("shoreWaves");
-		const look = this.presetLook();
-		if (u.uFresnelScale) u.uFresnelScale.value = look.fresnelScale;
-		if (u.uReflectivityMax) u.uReflectivityMax.value = look.reflectivityMax;
-		if (u.uEdgeFadeOn) u.uEdgeFadeOn.value = look.edgeFade ? 1 : 0;
-		if (u.uFoamRange) u.uFoamRange.value = foamRangeFor(w, d) * look.foamRangeScale;
-		if (u.uFoamIntensity) u.uFoamIntensity.value = look.foamIntensity;
-		const swellRad = this.swellDirectionDeg * Math.PI / 180;
-		(u.uSwellDir?.value)?.set(Math.sin(swellRad), Math.cos(swellRad));
-		if (u.uWaveEnvelope) u.uWaveEnvelope.value = this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT * 1.5 + this.rp("swell") * 1.03;
-		if (!this.reflection && u.uUseEnvironmentMap) u.uUseEnvironmentMap.value = 0;
-		if (!this.foam && u.uEnableFoam) u.uEnableFoam.value = 0;
-		if (!this.refraction && u.uUseRefraction) u.uUseRefraction.value = 0;
-		if (u.uSplashFoam) u.uSplashFoam.value = this.splash ? 1 : 0;
-		const ripples = u.uRipples?.value;
-		const foam = u.uRippleFoam?.value;
-		if (ripples) for (let i = 0; i < ripples.length; i++) {
-			const r = this._ripples[i];
-			if (r) ripples[i].set(r.x, r.z, r.age, r.amp);
-			else ripples[i].set(0, 0, 0, 0);
-			if (foam) foam[i] = r ? r.foam ?? 0 : 0;
-		}
-	}
-	/**
-	* @internal Environment-sky sun hand-off (see {@link SunConsumer3D}): the
-	* sky's sun drives the glint ONLY while the `sunDirection` prop sits at its
-	* schema default — an explicitly authored prop always wins. Runs right
-	* after `_syncObject3D` (which wrote the prop value), overwriting the
-	* uniform for this frame.
-	*/
-	_applySunDirection(dir) {
-		const def = Water3D.props.sunDirection?.default;
-		if (!this.sunDirection.every((v, i) => v === def[i])) return;
-		(this._ensureObject3D().material.uniforms?.uSunDirection?.value)?.set(dir[0], dir[1], dir[2]);
-	}
-	/** The fancy three-color ramp; a customized legacy `color` tints it. */
-	resolvePalette() {
-		const overrides = this.rp("colors");
-		const tint = this.rp("color");
-		const legacyTint = tint !== Water3D.props.color?.default ? tint : null;
-		const surface = overrides.surface ?? legacyTint ?? FANCY_COLORS.surface;
-		paletteScratch.surface.set(surface);
-		if (overrides.trough) paletteScratch.trough.set(overrides.trough);
-		else if (legacyTint) paletteScratch.trough.set(legacyTint).lerp(BLACK, .45);
-		else paletteScratch.trough.set(FANCY_COLORS.trough);
-		if (overrides.peak) paletteScratch.peak.set(overrides.peak);
-		else if (legacyTint) paletteScratch.peak.set(legacyTint).lerp(WHITE, .3);
-		else paletteScratch.peak.set(FANCY_COLORS.peak);
-		return paletteScratch;
-	}
-	syncSimple(mesh) {
-		const mat = mesh.material;
-		mat.opacity = this.rp("opacity");
-		const u = mat.uniforms;
-		const w = this.size[0] ?? 1;
-		const d = this.size[1] ?? 1;
-		const center = worldTranslationOf(this, this._scratchA);
-		if (u.uTime) u.uTime.value = this.time;
-		if (u.uOpacity) u.uOpacity.value = this.rp("opacity");
-		(u.uSurfaceColor?.value)?.set(this.rp("color")).lerp(WHITE, .12);
-		(u.uColor?.value)?.set(this.rp("color")).lerp(BLACK, .4);
-		(u.uSkyColor?.value)?.set(this.rp("color")).lerp(SKY_PALE, .82);
-		(u.uScale?.value)?.set(w / 2, d / 2, d / 2);
-		(u.uWaterCenter?.value)?.set(center.x, center.y, center.z);
-		(u.uSunDirection?.value)?.set(this.sunDirection[0] ?? 0, this.sunDirection[1] ?? 1, this.sunDirection[2] ?? 0).normalize();
-		(u.uSunColor?.value)?.set(this.sunColor);
-		if (u.uSunIntensity) u.uSunIntensity.value = this.rp("sunIntensity");
-		if (u.uDetailStrength) u.uDetailStrength.value = this.rp("detailStrength");
-		if (u.uSplashFoam) u.uSplashFoam.value = this.splash ? 1 : 0;
-		const uRip = u.uRipples?.value;
-		const uFoam = u.uRippleFoam?.value;
-		if (uRip) for (let i = 0; i < uRip.length; i++) {
-			const r = this._ripples[i];
-			if (r) uRip[i].set(r.x, r.z, r.age, r.amp);
-			else uRip[i].set(0, 0, 0, 0);
-			if (uFoam) uFoam[i] = r ? r.foam ?? 0 : 0;
-		}
-		const geo = mesh.geometry;
-		const pos = geo.getAttribute("position");
-		const norm = geo.getAttribute("normal");
-		const t = this.time;
-		const wh = this.rp("waveHeight");
-		const cx = center.x;
-		const cz = center.z;
-		const ripples = this._ripples;
-		const eps = .5;
-		for (let i = 0; i < pos.count; i++) {
-			const x = pos.getX(i);
-			const z = pos.getZ(i);
-			const h = simpleWaveHeight(x, z, t, wh) + ripplesHeightAt(x + cx, z + cz, ripples);
-			pos.setY(i, h);
-			const hX = simpleWaveHeight(x + eps, z, t, wh) + ripplesHeightAt(x + cx + eps, z + cz, ripples);
-			const hZ = simpleWaveHeight(x, z + eps, t, wh) + ripplesHeightAt(x + cx, z + cz + eps, ripples);
-			const nx = (h - hX) / eps;
-			const nz = (h - hZ) / eps;
-			const inv = 1 / Math.hypot(nx, 1, nz);
-			norm.setXYZ(i, nx * inv, inv, nz * inv);
-		}
-		pos.needsUpdate = true;
-		norm.needsUpdate = true;
-	}
-	stepInteraction(dt) {
-		let top = this;
-		while (top.parent) top = top.parent;
-		const bodies = this._bodies;
-		bodies.length = 0;
-		collectBodies(top, bodies);
-		const center = worldTranslationOf(this, this._scratchA);
-		const halfW = (this.size[0] ?? 0) / 2;
-		const halfD = (this.size[1] ?? 0) / 2;
-		const samples = [];
-		for (const body of bodies) {
-			const p = worldTranslationOf(body, this._scratchB);
-			if (Math.abs(p.x - center.x) > halfW || Math.abs(p.z - center.z) > halfD) continue;
-			const footDrop = colliderFootDrop(body.collider);
-			samples.push({
-				id: body,
-				x: p.x,
-				y: p.y,
-				z: p.z,
-				waterline: center.y + this.waveOffsetAt(p.x, p.z, center) + footDrop
-			});
-		}
-		const { entered, exited, inWater } = detectCrossings(this.inWater, samples, SURFACE_HYSTERESIS);
-		this.inWater = inWater;
-		const splashFoam = this.splash;
-		for (const s of entered) {
-			const vy = Math.abs(bodyVelocity(s.id)?.[1] ?? 0);
-			pushRipple(this._ripples, s.x, s.z, entrySplashAmp(s.id), splashFoam ? entryFoam(vy) : 0);
-			this.emit("entered", s.id);
-		}
-		for (const s of exited) {
-			pushRipple(this._ripples, s.x, s.z, EXIT_AMP, splashFoam ? EXIT_FOAM : 0);
-			this.emit("exited", s.id);
-		}
-		for (const body of stepBobTimers(this.bobTimers, inWater, dt, BOB_INTERVAL)) {
-			const p = worldTranslationOf(body, this._scratchB);
-			pushRipple(this._ripples, p.x, p.z, BOB_AMP);
-		}
-		for (const body of inWater) {
-			const p = worldTranslationOf(body, this._scratchB);
-			const a = this.wadeAnchors.get(body);
-			if (!a) {
-				this.wadeAnchors.set(body, {
-					x: p.x,
-					z: p.z
-				});
-				continue;
-			}
-			const dx = p.x - a.x;
-			const dz = p.z - a.z;
-			if (dx * dx + dz * dz >= WAKE_STEP * WAKE_STEP) {
-				const v = bodyVelocity(body);
-				const speed = Math.hypot(v?.[0] ?? 0, v?.[2] ?? 0);
-				const wakeFoam = splashFoam ? Math.min(WAKE_FOAM_BASE + WAKE_FOAM_PER_SPEED * speed, WAKE_FOAM_MAX) : 0;
-				pushRipple(this._ripples, p.x, p.z, WAKE_AMP, wakeFoam);
-				a.x = p.x;
-				a.z = p.z;
-			}
-		}
-		for (const body of this.wadeAnchors.keys()) if (!inWater.has(body)) this.wadeAnchors.delete(body);
-	}
-	/** 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) {
-		if (this.quality === "simple") return simpleWaveHeight(x - center.x, z - center.z, this.time, this.rp("waveHeight"));
-		return waveElevation(x, z, this.time, {
-			amplitude: this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT,
-			frequency: FANCY_WAVE.frequency,
-			persistence: FANCY_WAVE.persistence,
-			lacunarity: FANCY_WAVE.lacunarity,
-			iterations: FANCY_WAVE.iterations,
-			speed: FANCY_WAVE.speed,
-			scaleNorm: WAVE_WORLD_REF
-		});
-	}
-};
-/** Bodies that can splash: kinematic characters and dynamic rigid bodies. */
-function collectBodies(node, out) {
-	if (node instanceof CharacterBody3D || node instanceof RigidBody3D) out.push(node);
-	for (const child of node.children) collectBodies(child, out);
-}
-/**
-* World position approximation: the sum of `position` props up the Node3D
-* ancestor chain. Ancestor ROTATION/SCALE are deliberately ignored — water
-* interaction assumes world-aligned layouts (the overwhelmingly common case);
-* it runs in update(), before the renderer refreshes any matrixWorld.
-*/
-function worldTranslationOf(node, out = {
-	x: 0,
-	y: 0,
-	z: 0
-}) {
-	let x = 0;
-	let y = 0;
-	let z = 0;
-	let current = node;
-	while (current) {
-		if (current instanceof Node3D) {
-			x += current.position[0] ?? 0;
-			y += current.position[1] ?? 0;
-			z += current.position[2] ?? 0;
-		}
-		current = current.parent;
-	}
-	out.x = x;
-	out.y = y;
-	out.z = z;
-	return out;
-}
-/** A body's velocity vector — kinematic `velocity` or dynamic `linearVelocity`. */
-function bodyVelocity(body) {
-	return body.velocity ?? body.linearVelocity;
-}
-/** Entry splash amplitude — faster falls splash harder. */
-function entrySplashAmp(body) {
-	const vy = Math.abs(bodyVelocity(body)?.[1] ?? 0);
-	return Math.min(ENTER_AMP_BASE + ENTER_AMP_PER_VY * vy, ENTER_AMP_MAX);
-}
-function buildWaterGeometry(width, depth, segments) {
-	const geo = new PlaneGeometry(width, depth, segments, segments);
-	geo.rotateX(-Math.PI / 2);
-	return geo;
-}
-const BLACK = new Color("#000000");
-const WHITE = new Color("#ffffff");
-/** Pale sky-blue the lake's single hue is lifted toward for its fresnel
-* reflection tint (no cube map to sample — see lake.ts). */
-const SKY_PALE = new Color("#cfe3f0");
-const paletteScratch = {
-	trough: new Color(),
-	surface: new Color(),
-	peak: new Color()
-};
-const drawingBufferScratch = new Vector2();
-/** Reused camera world-position scratch for the submersion test (zero alloc). */
-const underwaterCamScratch = new Vector3();
-/** XZ slack (m) so the underwater look persists a touch past the water's rim. */
-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 mirrorTargetScratch = new Vector3();
-const mirrorUpScratch = new Vector3();
-const mirrorQuatScratch = new Quaternion();
-/** Mirror pass: keep only what is ABOVE the waterline. */
-const mirrorClipPlane = new Plane(new Vector3(0, 1, 0), 0);
-const mirrorClipPlanes = [mirrorClipPlane];
-const grabClipPlane = new Plane(new Vector3(0, -1, 0), 0);
-const grabClipPlanes = [grabClipPlane];
-/** Keep-above twin for the depth-completion pass: normal (0,1,0) keeps
-* y > −constant — set per render to waterY − slack (overlapping the grab). */
-const depthOnlyClipPlane = new Plane(new Vector3(0, 1, 0), 0);
-const depthOnlyClipPlanes = [depthOnlyClipPlane];
-/** Shared override for the depth-completion pass — writes depth, never color. */
-const depthOnlyMaterial = new MeshDepthMaterial();
-depthOnlyMaterial.colorWrite = false;
-//#endregion
 //#region src/3d/register.ts
 /**
 * Register the 3D node taxonomy (and the core nodes). Call once in your game
@@ -13875,4 +10882,4 @@ function registerNodes3D() {
 	registerNode(CharacterBody3D);
 }
 //#endregion
-export { TERRAIN_THEMES as A, QUARTER_PITCH as B, CharacterController3D as C, Billboard3D as D, BoneAttachment3D as E, PhysicsBody3D as F, keyboardIntensity as H, RigidBody3D as I, StaticBody3D as L, Joint3D as M, Area3D as N, Terrain3D as O, CharacterBody3D as P, Node3D as R, FLOWER_VARIETIES as S, BoneLookAt3D as T, movementState as U, cameraRelative as V, rigPose as W, MeshInstance3D as _, VoxelGrid3D as a, Flowers3D as b, River3D as c, Particles3D as d, ModelInstance3D as f, InstancedMesh3D as g, OmniLight3D as h, VOXEL_PALETTE as i, terrainThemeLayers as j, DEFAULT_TERRAIN_TEXTURE_BASE as k, traceDownhillPath as l, DirectionalLight3D as m, Water3D as n, Tree3D as o, LoftMesh3D as p, createCausticsQuad as r, Trail3D as s, registerNodes3D as t, WATER_MAX_RIPPLES as u, Foliage3D as v, Camera3D as w, resolveFlowerDensity as x, DENSITY_PRESETS as y, validateCollider3D as z };
+export { QUARTER_PITCH as A, BoneAttachment3D as C, TERRAIN_THEMES as D, DEFAULT_TERRAIN_TEXTURE_BASE as E, keyboardIntensity as M, movementState as N, terrainThemeLayers as O, rigPose as P, BoneLookAt3D as S, Terrain3D as T, Flowers3D as _, Trail3D as a, CharacterController3D as b, Particles3D as c, DirectionalLight3D as d, OmniLight3D as f, DENSITY_PRESETS as g, Foliage3D as h, Tree3D as i, cameraRelative as j, Joint3D as k, ModelInstance3D as l, MeshInstance3D as m, VOXEL_PALETTE as n, River3D as o, InstancedMesh3D as p, VoxelGrid3D as r, traceDownhillPath as s, registerNodes3D as t, LoftMesh3D as u, resolveFlowerDensity as v, Billboard3D as w, Camera3D as x, FLOWER_VARIETIES as y };