incanto 0.75.0 → 0.77.0

package/dist/{gameplay-D-JuGura.js → gameplay-Bfff_beb.js}

@@ -3,7 +3,7 @@ import { $ as Node, G as HudLayer, Z as requireNumber, at as Behavior, b as load
 import { t as IncantoError } from "./errors-BpWbnbb_.js";
 import { t as Rng } from "./rng-CDOMybym.js";
 import { h as didYouMean } from "./touch-CioTZB-y.js";
-import { Color, CubeCamera, DepthTexture, DoubleSide, Euler, FloatType, Frustum, HalfFloatType, LinearMipmapLinearFilter, MathUtils, Matrix4, Mesh, MeshDepthMaterial, Object3D, PerspectiveCamera, Plane, PlaneGeometry, Quaternion, ShaderMaterial, Sphere, Vector2, Vector3, Vector4, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
+import { Color, CubeCamera, DataTexture, DataUtils, DepthTexture, DoubleSide, Euler, FloatType, Frustum, GLSL3, HalfFloatType, InstancedBufferAttribute, InstancedBufferGeometry, LinearFilter, LinearMipmapLinearFilter, MathUtils, Matrix4, Mesh, MeshDepthMaterial, NearestFilter, NormalBlending, Object3D, OrthographicCamera, PerspectiveCamera, Plane, PlaneGeometry, Quaternion, RGBAFormat, RepeatWrapping, Scene, ShaderMaterial, Sphere, Vector2, Vector3, Vector4, WebGLCubeRenderTarget, WebGLRenderTarget } from "three";
 //#region src/gameplay/spatial.ts
 /** Duck-type test: every spatial node (Node2D/Node3D) exposes `position: number[]`. */
 function hasPosition$1(node) {
@@ -736,6 +736,615 @@ function sphereInCameraFrustum(camera, center, radius) {
 	return scratchFrustum.intersectsSphere(scratchSphere);
 }
 //#endregion
+//#region src/3d/water/fft.ts
+/**
+* The FFT sea — the CPU half. Pure math, no three.
+*
+* A real sea is not a sum of a few sine trains; it is a SPECTRUM — thousands of
+* waves at every wavelength and heading, each moving at the speed deep water
+* gives its wavelength, with the energy shaped by the wind (JONSWAP: a peaked
+* hump at the wind's dominant period, a k^-4 tail of chop above it, a fast
+* roll-off below). Tessendorf's method builds that spectrum once, spins every
+* mode by its own frequency each frame, and inverse-FFTs the lot into a tiling
+* height + horizontal-displacement patch. The GPU does the inverse FFT
+* (`fft-gpu.ts`, 256² in ~35 tiny passes); THIS file builds the spectrum the GPU
+* uploads, and evaluates the SAME spectrum on the CPU for everything headless —
+* buoyancy, the waterline a wader crosses, the playtest's idea of where the
+* surface is — by summing the strongest modes directly.
+*
+* Two halves, one contract, pinned by `fft.test.ts`:
+*   - the spectrum is deterministic per seed and Hermitian (the surface is real)
+*   - k lives in the texture in FFT order (index 0 = DC, upper half negative)
+*   - the truncated CPU sum tracks the full sum to within a few percent of the
+*     rms height, and is exact when every mode is kept
+*
+* The horizontal (choppy) displacement is GPU-only: the CPU answers the height
+* at the undisplaced grid point, which differs from the displaced surface by
+* displacement × slope — centimetres, well under what buoyancy can feel.
+*/
+const SEA_GRAVITY = 9.81;
+const DEFAULT_FETCH = 1e5;
+const DEFAULT_MODES = 2048;
+const JONSWAP_GAMMA = 3.3;
+/** cos^(2s) directional spread — 8 is a sea with a clear heading and real cross-chop. */
+const SPREAD_S = 8;
+/** Share of energy that ignores the wind entirely (old swell, reflections). */
+const SPREAD_ISOTROPIC = .06;
+/** Wavenumber of texture index `i` (FFT order: DC first, negatives in the upper half). */
+function fftIndexToK(i, n, patch) {
+	const m = i < n / 2 ? i : i - n;
+	return 2 * Math.PI * m / patch;
+}
+/** JONSWAP S(ω): energy density per unit angular frequency. */
+function jonswap(omega, omegaPeak, alpha) {
+	if (omega <= 0) return 0;
+	const sigma = omega <= omegaPeak ? .07 : .09;
+	const r = Math.exp(-((omega - omegaPeak) ** 2) / (2 * sigma * sigma * omegaPeak * omegaPeak));
+	return alpha * (SEA_GRAVITY * SEA_GRAVITY) / omega ** 5 * Math.exp(-1.25 * (omegaPeak / omega) ** 4) * JONSWAP_GAMMA ** r;
+}
+/** Directional spreading, normalized so ∫D dθ = 1. */
+function spreading(theta, thetaWind, norm) {
+	const lobe = Math.cos((theta - thetaWind) / 2) ** (2 * SPREAD_S) / norm;
+	return (1 - SPREAD_ISOTROPIC) * lobe + SPREAD_ISOTROPIC / (2 * Math.PI);
+}
+function spreadingNorm() {
+	const steps = 720;
+	let acc = 0;
+	for (let i = 0; i < steps; i++) {
+		const th = (i + .5) / steps * 2 * Math.PI;
+		acc += Math.cos(th / 2) ** (2 * SPREAD_S);
+	}
+	return acc * (2 * Math.PI / steps);
+}
+function gaussianPair(rng) {
+	const u1 = Math.max(rng.next(), 1e-12);
+	const u2 = rng.next();
+	const r = Math.sqrt(-2 * Math.log(u1));
+	return [r * Math.cos(2 * Math.PI * u2), r * Math.sin(2 * Math.PI * u2)];
+}
+function buildSeaSpectrum(params) {
+	const n = params.size;
+	if (!(Number.isInteger(n) && n >= 4 && (n & n - 1) === 0)) throw new Error(`sea spectrum size must be a power of two >= 4, got ${n}`);
+	const patch = params.patch;
+	const wind = Math.max(params.wind, 0);
+	const fetch = params.fetch ?? DEFAULT_FETCH;
+	const choppiness = params.choppiness ?? .85;
+	const modeBudget = params.modes ?? DEFAULT_MODES;
+	const rng = new Rng(params.seed);
+	const h0 = new Float32Array(n * n * 4);
+	const spec = {
+		size: n,
+		patch,
+		wind,
+		choppiness,
+		h0,
+		modes: new Float64Array(0),
+		modeCount: 0,
+		significantHeight: 0,
+		rmsSlope: 0
+	};
+	if (wind <= 0) return spec;
+	const g = SEA_GRAVITY;
+	const omegaPeak = 22 * (g * g / (wind * fetch)) ** (1 / 3);
+	const alpha = .076 * (wind * wind / (fetch * g)) ** .22;
+	const thetaWind = params.windDirectionDeg * Math.PI / 180;
+	const norm = spreadingNorm();
+	const dk = 2 * Math.PI / patch;
+	const cut = patch / n * .9;
+	const psi = new Float64Array(n * n);
+	let m0 = 0;
+	for (let j = 0; j < n; j++) {
+		const kz = fftIndexToK(j, n, patch);
+		for (let i = 0; i < n; i++) {
+			const kx = fftIndexToK(i, n, patch);
+			const k = Math.hypot(kx, kz);
+			if (k < 1e-9) continue;
+			const omega = Math.sqrt(g * k);
+			const dOmegaDk = g / (2 * omega);
+			const theta = Math.atan2(kx, kz);
+			const p = jonswap(omega, omegaPeak, alpha) * spreading(theta, thetaWind, norm) * dOmegaDk / k * Math.exp(-k * k * cut * cut) * dk * dk;
+			psi[j * n + i] = p;
+			m0 += p;
+		}
+	}
+	const re = new Float64Array(n * n);
+	const im = new Float64Array(n * n);
+	for (let idx = 0; idx < n * n; idx++) {
+		const [gr, gi] = gaussianPair(rng);
+		const a = Math.sqrt(psi[idx] / 2);
+		re[idx] = gr * a;
+		im[idx] = gi * a;
+	}
+	let realized = 0;
+	for (let j = 0; j < n; j++) for (let i = 0; i < n; i++) {
+		const idx = j * n + i;
+		const mi = (n - i) % n;
+		const midx = (n - j) % n * n + mi;
+		const hr = re[idx] + re[midx];
+		const hi = im[idx] - im[midx];
+		realized += hr * hr + hi * hi;
+	}
+	const scale = realized > 0 ? Math.sqrt(m0 / realized) : 0;
+	let slope2 = 0;
+	for (let j = 0; j < n; j++) for (let i = 0; i < n; i++) {
+		const idx = j * n + i;
+		const mi = (n - i) % n;
+		const midx = (n - j) % n * n + mi;
+		const o = idx * 4;
+		h0[o] = re[idx] * scale;
+		h0[o + 1] = im[idx] * scale;
+		h0[o + 2] = re[midx] * scale;
+		h0[o + 3] = -im[midx] * scale;
+		const hr = h0[o] + h0[o + 2];
+		const hi = h0[o + 1] + h0[o + 3];
+		const kx = fftIndexToK(i, n, patch);
+		const kz = fftIndexToK(j, n, patch);
+		slope2 += (hr * hr + hi * hi) * (kx * kx + kz * kz);
+	}
+	spec.significantHeight = 4 * Math.sqrt(m0);
+	spec.rmsSlope = Math.sqrt(slope2);
+	const strength = [];
+	for (let j = 0; j < n; j++) for (let i = 0; i < n; i++) {
+		const idx = j * n + i;
+		const o = idx * 4;
+		const hr = h0[o] + h0[o + 2];
+		const hi = h0[o + 1] + h0[o + 3];
+		strength.push({
+			idx,
+			s: hr * hr + hi * hi
+		});
+	}
+	strength.sort((a, b) => b.s - a.s || a.idx - b.idx);
+	const chosen = /* @__PURE__ */ new Set();
+	for (const { idx } of strength) {
+		if (chosen.size >= modeBudget) break;
+		if (chosen.has(idx)) continue;
+		const i = idx % n;
+		const midx = (n - (idx - i) / n) % n * n + (n - i) % n;
+		chosen.add(idx);
+		chosen.add(midx);
+	}
+	const modes = new Float64Array(chosen.size * 7);
+	let m = 0;
+	for (const idx of chosen) {
+		const i = idx % n;
+		const j = (idx - i) / n;
+		const kx = fftIndexToK(i, n, patch);
+		const kz = fftIndexToK(j, n, patch);
+		const o = idx * 4;
+		const b = m * 7;
+		modes[b] = kx;
+		modes[b + 1] = kz;
+		modes[b + 2] = Math.sqrt(g * Math.hypot(kx, kz));
+		modes[b + 3] = h0[o];
+		modes[b + 4] = h0[o + 1];
+		modes[b + 5] = h0[o + 2];
+		modes[b + 6] = h0[o + 3];
+		m++;
+	}
+	spec.modes = modes;
+	spec.modeCount = m;
+	return spec;
+}
+/**
+* One mode's contribution at (x, z, t): Re[ h̃(k,t) · e^{i k·x} ] with
+* h̃ = h0 e^{iωt} + conj(h0(-k)) e^{-iωt} — the exact term the GPU sums.
+*/
+function modeTerm(kx, kz, omega, h0r, h0i, hmr, hmi, x, z, t) {
+	const wt = omega * t;
+	const cw = Math.cos(wt);
+	const sw = Math.sin(wt);
+	const hr = h0r * cw - h0i * sw + (hmr * cw + hmi * sw);
+	const hi = h0r * sw + h0i * cw + (hmi * cw - hmr * sw);
+	const ph = kx * x + kz * z;
+	return hr * Math.cos(ph) - hi * Math.sin(ph);
+}
+/** Height of the sea at world (x, z) and time t — the strongest modes only. */
+function seaElevation(spec, x, z, t) {
+	const m = spec.modes;
+	let h = 0;
+	for (let i = 0; i < spec.modeCount; i++) {
+		const b = i * 7;
+		h += modeTerm(m[b], m[b + 1], m[b + 2], m[b + 3], m[b + 4], m[b + 5], m[b + 6], x, z, t);
+	}
+	return h;
+}
+//#endregion
+//#region src/3d/water/fft-shaders.ts
+/**
+* GLSL for the FFT sea (see `fft.ts` for the spectrum, `fft-gpu.ts` for the
+* pass schedule). All GLSL3, all `texelFetch` — an FFT reads exact texels,
+* never filtered ones.
+*
+* Every pass is a fullscreen quad over an N×N target; `gl_FragCoord` is the
+* texel. Complex numbers ride as vec2 (re, im); a texel carries TWO of them
+* (xy, zw) so one butterfly chain transforms two signals for the price of one.
+*/
+const COMPLEX = `
+vec2 cmul(vec2 a, vec2 b) {
+  return vec2(a.x * b.x - a.y * b.y, a.x * b.y + a.y * b.x);
+}
+`;
+const FFT_FULLSCREEN_VERT = `
+void main() {
+  gl_Position = vec4(position.xy, 0.0, 1.0);
+}
+`;
+/**
+* Spin the spectrum to time t. Slot 0 writes (h̃, D̃x), slot 1 writes (D̃z, 0):
+*   h̃(k,t) = h0(k) e^{iωt} + conj(h0(-k)) e^{-iωt},   ω = sqrt(g|k|)
+*   D̃ = -i (k/|k|) h̃ · choppiness            (Tessendorf's choppy displacement)
+*/
+const FFT_SPECTRUM_FRAG = `
+precision highp float;
+uniform sampler2D uH0;
+uniform float uTime;
+uniform int uSize;
+uniform float uPatch;
+uniform float uChoppiness;
+uniform int uSlot;
+out vec4 outColor;
+${COMPLEX}
+float kOf(int i) {
+  int m = i < uSize / 2 ? i : i - uSize;
+  return 6.28318530718 * float(m) / uPatch;
+}
+void main() {
+  ivec2 ij = ivec2(gl_FragCoord.xy);
+  vec4 h0 = texelFetch(uH0, ij, 0);
+  float kx = kOf(ij.x);
+  float kz = kOf(ij.y);
+  float k = length(vec2(kx, kz));
+  float omega = sqrt(9.81 * k);
+  float wt = omega * uTime;
+  vec2 e = vec2(cos(wt), sin(wt));
+  vec2 h = cmul(h0.xy, e) + cmul(h0.zw, vec2(e.x, -e.y));
+  // -i·h = (h.y, -h.x)
+  vec2 mih = vec2(h.y, -h.x);
+  float inv = k > 1e-6 ? 1.0 / k : 0.0;
+  vec2 dx = mih * (kx * inv) * uChoppiness;
+  vec2 dz = mih * (kz * inv) * uChoppiness;
+  outColor = uSlot == 0 ? vec4(h, dx) : vec4(dz, 0.0, 0.0);
+}
+`;
+/**
+* One radix-2 butterfly stage over both packed complex signals. The table
+* (`butterflyTable` in fft-gpu.ts) holds, per stage and index: the twiddle and
+* the two source indices — bit-reversal folded into stage 0.
+*/
+const FFT_BUTTERFLY_FRAG = `
+precision highp float;
+uniform sampler2D uButterfly;
+uniform sampler2D uInput;
+uniform int uStage;
+uniform int uHorizontal;
+out vec4 outColor;
+${COMPLEX}
+void main() {
+  ivec2 ij = ivec2(gl_FragCoord.xy);
+  int along = uHorizontal == 1 ? ij.x : ij.y;
+  vec4 b = texelFetch(uButterfly, ivec2(along, uStage), 0);
+  ivec2 pIdx = uHorizontal == 1 ? ivec2(int(b.z), ij.y) : ivec2(ij.x, int(b.z));
+  ivec2 qIdx = uHorizontal == 1 ? ivec2(int(b.w), ij.y) : ivec2(ij.x, int(b.w));
+  vec4 p = texelFetch(uInput, pIdx, 0);
+  vec4 q = texelFetch(uInput, qIdx, 0);
+  vec2 w = b.xy;
+  outColor = vec4(p.xy + cmul(w, q.xy), p.zw + cmul(w, q.zw));
+}
+`;
+/** Gather the transformed signals into the displacement texture (Dx, h, Dz, 0). */
+const FFT_DISPLACE_FRAG = `
+precision highp float;
+uniform sampler2D uA;
+uniform sampler2D uB;
+out vec4 outColor;
+void main() {
+  ivec2 ij = ivec2(gl_FragCoord.xy);
+  vec4 a = texelFetch(uA, ij, 0);
+  vec4 b = texelFetch(uB, ij, 0);
+  outColor = vec4(a.z, a.x, b.x, 0.0);
+}
+`;
+/**
+* Slopes, the Jacobian and the foam memory, from the displaced grid:
+*   sx = Δh / (Δx + ΔDx)   — the slope of the surface as it actually sits
+*   J  = (1+∂Dx/∂x)(1+∂Dz/∂z) − ∂Dx/∂z·∂Dz/∂x — folds where it collapses
+*   foam = max(previous · decay, saturate((J₀ − J) · gain)) — whitecaps are
+*          born where the surface folds and die over a few seconds
+* Output: (sx, sz, foam, sx²+sz²) — the last is what a mip of this texture
+* turns into slope VARIANCE (E[s²] − E[s]²), the roughness a far pixel sees.
+*/
+const FFT_NORMAL_FRAG = `
+precision highp float;
+uniform sampler2D uDisp;
+uniform sampler2D uPrev;
+uniform int uSize;
+uniform float uPatch;
+uniform float uFoamDecay;
+uniform float uFoamThreshold;
+uniform float uFoamGain;
+out vec4 outColor;
+vec4 at(ivec2 ij) {
+  return texelFetch(uDisp, ivec2((ij.x + uSize) % uSize, (ij.y + uSize) % uSize), 0);
+}
+void main() {
+  ivec2 ij = ivec2(gl_FragCoord.xy);
+  float texel = uPatch / float(uSize);
+  vec4 l = at(ij + ivec2(-1, 0));
+  vec4 r = at(ij + ivec2(1, 0));
+  vec4 d = at(ij + ivec2(0, -1));
+  vec4 u = at(ij + ivec2(0, 1));
+  float dxdx = (r.x - l.x) / (2.0 * texel);
+  float dzdz = (u.z - d.z) / (2.0 * texel);
+  float dxdz = (u.x - d.x) / (2.0 * texel);
+  float dzdx = (r.z - l.z) / (2.0 * texel);
+  float sx = (r.y - l.y) / max(2.0 * texel + (r.x - l.x), 0.05 * texel);
+  float sz = (u.y - d.y) / max(2.0 * texel + (u.z - d.z), 0.05 * texel);
+  float jac = (1.0 + dxdx) * (1.0 + dzdz) - dxdz * dzdx;
+  float prev = texelFetch(uPrev, ij, 0).z;
+  float born = clamp((uFoamThreshold - jac) * uFoamGain, 0.0, 1.0);
+  float foam = max(prev * uFoamDecay, born);
+  outColor = vec4(sx, sz, foam, sx * sx + sz * sz);
+}
+`;
+//#endregion
+//#region src/3d/water/fft-gpu.ts
+/**
+* The FFT sea — the GPU half (three.js). `fft.ts` builds the spectrum; this
+* file inverse-FFTs it every frame into two tiling textures the water shaders
+* read:
+*
+*   displacement  (Dx, h, Dz, 0)          — where the surface IS
+*   normal        (sx, sz, foam, sx²+sz²) — which way it faces, where it has
+*                                           folded into whitecaps, and how
+*                                           rough it is once a pixel
+*                                           integrates it (the mip chain)
+*
+* Schedule per frame, all N×N fullscreen passes: 2 spectrum spins (two packed
+* complex signals each), 2·log2 N butterfly stages per chain, one gather, one
+* slope/foam pass. At 256² that is 37 draws of 65 k fragments — less than a
+* single shadow cascade.
+*
+* `butterflyTable` and `runButterflyCpu` are exported for the test that runs
+* the SAME table on the CPU against the direct spectrum sum — the one way to
+* prove an FFT schedule headless.
+*/
+const SEA_FOAM_DEFAULT = {
+	decay: .985,
+	threshold: .8,
+	gain: 4
+};
+function bitReverse(x, bits) {
+	let r = 0;
+	for (let b = 0; b < bits; b++) r = r << 1 | x >> b & 1;
+	return r;
+}
+/**
+* The radix-2 DIT butterfly table for an INVERSE transform of size n:
+* `log2 n` rows of n texels, each (twiddle.re, twiddle.im, index p, index q)
+* so that out[x] = in[p] + twiddle · in[q]. Stage 0 folds the bit-reversal
+* into its indices; the bottom wing's twiddle carries the minus sign through
+* k + n/2, so one formula serves both wings.
+*/
+function butterflyTable(n) {
+	const stages = Math.round(Math.log2(n));
+	if (1 << stages !== n) throw new Error(`FFT size must be a power of two, got ${n}`);
+	const table = new Float32Array(stages * n * 4);
+	for (let s = 0; s < stages; s++) {
+		const span = 1 << s;
+		for (let x = 0; x < n; x++) {
+			const top = x % (span * 2) < span;
+			const k = x * (n >> s + 1) % n;
+			const ang = 2 * Math.PI * k / n;
+			let p;
+			let q;
+			if (s === 0) {
+				p = top ? bitReverse(x, stages) : bitReverse(x - 1, stages);
+				q = top ? bitReverse(x + 1, stages) : bitReverse(x, stages);
+			} else {
+				p = top ? x : x - span;
+				q = top ? x + span : x;
+			}
+			const o = (s * n + x) * 4;
+			table[o] = Math.cos(ang);
+			table[o + 1] = Math.sin(ang);
+			table[o + 2] = p;
+			table[o + 3] = q;
+		}
+	}
+	return table;
+}
+function chainTarget(n) {
+	return new WebGLRenderTarget(n, n, {
+		type: FloatType,
+		format: RGBAFormat,
+		minFilter: NearestFilter,
+		magFilter: NearestFilter,
+		depthBuffer: false,
+		stencilBuffer: false,
+		generateMipmaps: false
+	});
+}
+function surfaceTarget(n) {
+	return new WebGLRenderTarget(n, n, {
+		type: HalfFloatType,
+		format: RGBAFormat,
+		minFilter: LinearMipmapLinearFilter,
+		magFilter: LinearFilter,
+		wrapS: RepeatWrapping,
+		wrapT: RepeatWrapping,
+		depthBuffer: false,
+		stencilBuffer: false,
+		generateMipmaps: true
+	});
+}
+/** Does this context render to float targets at all? (Every WebGL2 desktop and iOS 15+ does.) */
+function seaFftSupported(gl) {
+	const ext = gl.extensions;
+	return typeof ext?.has === "function" && ext.has("EXT_color_buffer_float") === true;
+}
+var SeaFft = class {
+	size;
+	patch;
+	scene = new Scene();
+	camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+	quad;
+	spectrumMat;
+	butterflyMat;
+	displaceMat;
+	normalMat;
+	uSpec = {
+		uH0: { value: null },
+		uTime: { value: 0 },
+		uSize: { value: 0 },
+		uPatch: { value: 0 },
+		uChoppiness: { value: .85 },
+		uSlot: { value: 0 }
+	};
+	uButter = {
+		uButterfly: { value: null },
+		uInput: { value: null },
+		uStage: { value: 0 },
+		uHorizontal: { value: 1 }
+	};
+	uDisplace = {
+		uA: { value: null },
+		uB: { value: null }
+	};
+	uNormal = {
+		uDisp: { value: null },
+		uPrev: { value: null },
+		uSize: { value: 0 },
+		uPatch: { value: 0 },
+		uFoamDecay: { value: SEA_FOAM_DEFAULT.decay },
+		uFoamThreshold: { value: SEA_FOAM_DEFAULT.threshold },
+		uFoamGain: { value: SEA_FOAM_DEFAULT.gain }
+	};
+	butterfly;
+	h0 = null;
+	a;
+	b;
+	disp;
+	norm;
+	normIndex = 0;
+	stages;
+	constructor(size, patch) {
+		this.size = size;
+		this.patch = patch;
+		this.stages = Math.round(Math.log2(size));
+		const table = butterflyTable(size);
+		this.butterfly = new DataTexture(table, size, this.stages, RGBAFormat, FloatType);
+		this.butterfly.minFilter = NearestFilter;
+		this.butterfly.magFilter = NearestFilter;
+		this.butterfly.needsUpdate = true;
+		this.uSpec.uSize.value = size;
+		this.uSpec.uPatch.value = patch;
+		this.uButter.uButterfly.value = this.butterfly;
+		this.uNormal.uSize.value = size;
+		this.uNormal.uPatch.value = patch;
+		const pass = (fragmentShader, uniforms) => new ShaderMaterial({
+			glslVersion: GLSL3,
+			vertexShader: FFT_FULLSCREEN_VERT,
+			fragmentShader,
+			uniforms,
+			depthTest: false,
+			depthWrite: false
+		});
+		this.spectrumMat = pass(FFT_SPECTRUM_FRAG, this.uSpec);
+		this.butterflyMat = pass(FFT_BUTTERFLY_FRAG, this.uButter);
+		this.displaceMat = pass(FFT_DISPLACE_FRAG, this.uDisplace);
+		this.normalMat = pass(FFT_NORMAL_FRAG, this.uNormal);
+		this.quad = new Mesh(new PlaneGeometry(2, 2), this.spectrumMat);
+		this.quad.frustumCulled = false;
+		this.scene.add(this.quad);
+		this.a = [chainTarget(size), chainTarget(size)];
+		this.b = [chainTarget(size), chainTarget(size)];
+		this.disp = surfaceTarget(size);
+		this.norm = [surfaceTarget(size), surfaceTarget(size)];
+	}
+	/** Upload a (new) spectrum. Cheap to call with the same one — it is keyed by the caller. */
+	setSpectrum(spec) {
+		if (spec.size !== this.size) throw new Error(`spectrum size ${spec.size} ≠ FFT size ${this.size}`);
+		this.h0?.dispose();
+		this.h0 = new DataTexture(spec.h0, this.size, this.size, RGBAFormat, FloatType);
+		this.h0.minFilter = NearestFilter;
+		this.h0.magFilter = NearestFilter;
+		this.h0.needsUpdate = true;
+		this.uSpec.uH0.value = this.h0;
+		this.uSpec.uChoppiness.value = spec.choppiness;
+	}
+	get displacement() {
+		return this.disp.texture;
+	}
+	get normal() {
+		return (this.normIndex === 0 ? this.norm[0] : this.norm[1]).texture;
+	}
+	draw(gl, mat, target) {
+		this.quad.material = mat;
+		gl.setRenderTarget(target);
+		gl.render(this.scene, this.camera);
+	}
+	/** Run one chain (spectrum slot → log2N horizontal + log2N vertical stages). Returns the target holding the result. */
+	chain(gl, slot, pair) {
+		this.uSpec.uSlot.value = slot;
+		this.draw(gl, this.spectrumMat, pair[0]);
+		let src = 0;
+		const bu = this.uButter;
+		for (let pass = 0; pass < 2; pass++) {
+			bu.uHorizontal.value = pass === 0 ? 1 : 0;
+			for (let s = 0; s < this.stages; s++) {
+				bu.uStage.value = s;
+				bu.uInput.value = (src === 0 ? pair[0] : pair[1]).texture;
+				this.draw(gl, this.butterflyMat, src === 0 ? pair[1] : pair[0]);
+				src = src === 0 ? 1 : 0;
+			}
+		}
+		return src === 0 ? pair[0] : pair[1];
+	}
+	/** Advance the sea to `time` (seconds). Restores the caller's render target. */
+	update(gl, time, foam = SEA_FOAM_DEFAULT) {
+		if (!this.h0) return;
+		const prevTarget = gl.getRenderTarget();
+		const prevAutoClear = gl.autoClear;
+		gl.autoClear = false;
+		this.uSpec.uTime.value = time;
+		const outA = this.chain(gl, 0, this.a);
+		const outB = this.chain(gl, 1, this.b);
+		this.uDisplace.uA.value = outA.texture;
+		this.uDisplace.uB.value = outB.texture;
+		this.draw(gl, this.displaceMat, this.disp);
+		const nu = this.uNormal;
+		const current = this.normIndex === 0 ? this.norm[0] : this.norm[1];
+		const next = this.normIndex === 0 ? this.norm[1] : this.norm[0];
+		nu.uDisp.value = this.disp.texture;
+		nu.uPrev.value = current.texture;
+		nu.uFoamDecay.value = foam.decay;
+		nu.uFoamThreshold.value = foam.threshold;
+		nu.uFoamGain.value = foam.gain;
+		this.draw(gl, this.normalMat, next);
+		this.normIndex = this.normIndex === 0 ? 1 : 0;
+		gl.setRenderTarget(prevTarget);
+		gl.autoClear = prevAutoClear;
+	}
+	dispose() {
+		for (const rt of [
+			...this.a,
+			...this.b,
+			this.disp,
+			...this.norm
+		]) rt.dispose();
+		this.butterfly.dispose();
+		this.h0?.dispose();
+		this.quad.geometry.dispose();
+		for (const m of [
+			this.spectrumMat,
+			this.butterflyMat,
+			this.displaceMat,
+			this.normalMat
+		]) m.dispose();
+	}
+};
+//#endregion
 //#region src/3d/water/interaction.ts
 /**
 * Water3D character interaction — pure functions, no three, node-env testable.
@@ -1445,6 +2054,26 @@ uniform float uShoreWaves;
 // shores — inside an exact-walled basin (pool/pond) it carves a visible
 // elliptical cliff instead, so those presets turn it off.
 uniform float uEdgeFadeOn;
+// the FFT sea (wind > 0): a tiling displacement patch the vertex reads at the
+// mip whose texel matches its own spacing — see fft-gpu.ts
+uniform float uFftOn;
+uniform sampler2D uFftDisp;
+uniform float uFftPatch;
+uniform float uFftLod;
+varying vec2 vFftUv;
+// the bed (Water3D.bed): a depth grid over a terrain's footprint, so the
+// swell trains shoal, peak and break where the bottom comes up
+uniform float uBedOn;
+uniform sampler2D uBedDepth;
+uniform vec4 uBedRect; // minX, minZ, 1/width, 1/depth
+uniform float uBedDeep;
+varying float vBreak;
+float bedDepthAt(vec2 xz) {
+  if (uBedOn < 0.5) return uBedDeep;
+  vec2 uv = (xz - uBedRect.xy) * uBedRect.zw;
+  if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return uBedDeep;
+  return textureLod(uBedDepth, uv, 0.0).r;
+}
 
 varying vec3 vNormal;
 varying vec3 vWorldPosition;
@@ -1494,6 +2123,8 @@ float snoise(vec2 v) {
 
 // Helper function to calculate elevation at any point
 float getElevation(float x, float z) {
+  // the FFT sea IS the wave field — the noise would only fight its statistics
+  if (uFftOn > 0.5) return 0.0;
   // 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.
@@ -1538,7 +2169,27 @@ 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);
+  // shoaling (shore.ts is the CPU copy of this rule): once the water is
+  // shallower than a quarter wavelength the wave RISES as depth^-1/4 (Green's
+  // law, capped at 2×) and its crest peaks; at 0.78× the depth it breaks —
+  // the height is capped there, and vBreak (below) says so to the fragment
+  float d = max(bedDepthAt(p), 0.05);
+  float ks = pow(clamp(lambda * 0.25 / d, 1.0, 16.0), 0.25);
+  float a = min(amp * ks, 0.39 * d);
+  float peak = sharp * mix(1.0, 2.2, clamp(ks - 1.0, 0.0, 1.0));
+  return a * (pow(s, peak) * 2.0 - 1.0);
+}
+
+// how far past breaking the primary swell is here (0 = not breaking)
+float getShoalBreak(vec2 p) {
+  if (uSwellAmplitude <= 0.0 || uBedOn < 0.5) return 0.0;
+  float d = max(bedDepthAt(p), 0.05);
+  float lambda = uSwellWavelength;
+  float ks = pow(clamp(lambda * 0.25 / d, 1.0, 16.0), 0.25);
+  float shoaled = uSwellAmplitude * 0.6 * ks;
+  // 1 as the shoaled height meets the cap, fading out where the film is a
+  // few centimetres (there is nothing left to break)
+  return smoothstep(0.8, 1.05, shoaled / (0.39 * d)) * smoothstep(0.05, 0.25, d);
 }
 
 // incanto swell: three trains — the primary + two shorter crossing sets
@@ -1610,14 +2261,43 @@ void main() {
   vec4 modelPosition = modelMatrix * vec4(position, 1.0);
 
   float elevation = getHeight(modelPosition.x, modelPosition.z);
-  modelPosition.y += elevation;
+  // the FFT sea's height and horizontal drag, read at the grid's own mip so a
+  // wave shorter than the vertex spacing never aliases into the mesh (the
+  // fragment adds its slope back at full detail). Sampled at the UNDISPLACED
+  // position, which is the texture's own coordinate.
+  vec2 fftUv = modelPosition.xz / uFftPatch;
+  vFftUv = fftUv;
+  vec3 fftD = vec3(0.0);
+  float fftBreak = 0.0;
+  if (uFftOn > 0.5) {
+    fftD = textureLod(uFftDisp, fftUv, uFftLod).xyz;
+    // the spectrum cannot shoal mode by mode, so its whole field rises by
+    // Green's law for its typical ~20 m wave as the bed comes up, and breaks
+    // at the same 0.78·depth the swell does — the beach reads in the chop too
+    if (uBedOn > 0.5) {
+      // the SURF zone only: a whole lagoon two metres deep would otherwise
+      // shoal and cap every wave in it (measured: the sea went flat and
+      // blotchy out to the reef) — the rise fades in over the last 2.6 m
+      float d = max(bedDepthAt(modelPosition.xz), 0.05);
+      float surf = 1.0 - smoothstep(1.2, 2.6, d);
+      float ks = mix(1.0, pow(clamp(5.0 / d, 1.0, 16.0), 0.25), surf);
+      float cap = 0.39 * d;
+      float h = fftD.y * ks;
+      float over = max(abs(h) - cap, 0.0) * surf;
+      fftBreak = smoothstep(0.8, 1.05, abs(h) / cap) * smoothstep(0.05, 0.25, d) * surf;
+      fftD.y = sign(h) * (abs(h) - over);
+      fftD.xz *= mix(1.0, 0.5, fftBreak); // a broken wave has spent its drag
+    }
+  }
+  modelPosition.y += elevation + fftD.y;
   // Gerstner pinch: the height field is sampled at the UNDISPLACED position
   // (so the analytic finite-difference normals below stay consistent), then
   // the surface is dragged horizontally toward its crests. At the steepness
   // this ships the normal error is far under the detail-normal layers.
   vec3 pinch = getSwellPinch(modelPosition.xz);
-  modelPosition.xz += pinch.xy;
+  modelPosition.xz += pinch.xy + fftD.xz;
   vFold = pinch.z;
+  vBreak = max(getShoalBreak(modelPosition.xz), fftBreak);
 
   // Height adjustment to smooth water edges
   // Lower water height as it approaches scale boundaries
@@ -1739,6 +2419,32 @@ 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;
+// screen-space reflections: the scene above the waterline, shaded, at half
+// res, and the camera's view-projection to walk a world ray through it
+uniform float uUseSsr;
+uniform sampler2D uAboveColor;
+uniform sampler2D uAboveDepth;
+uniform mat4 uSsrViewProj;
+// the FFT sea's slopes (xy), whitecap memory (z) and slope energy (w) — see
+// fft-gpu.ts; the vertex reads its displacement, this reads its facing
+uniform float uFftOn;
+uniform sampler2D uFftNormal;
+uniform float uFftPatch;
+varying vec2 vFftUv;
+// the live RIPPLE layer (fft-gpu.ts at 6 m): the wind ripple every fancy
+// surface wears, read twice so its tile never shows — as is, and turned a
+// quarter and scaled 0.71× (the second read's slope turns and scales with it)
+uniform float uRippleOn;
+uniform sampler2D uRippleNormal;
+uniform float uRipplePatch;
+uniform float uRippleGain;
+// the vertex's word on whether the shoaled swell is breaking here (Water3D.bed)
+varying float vBreak;
+vec2 rippleSlope(vec2 worldXZ, float bias) {
+  vec2 r1 = texture2D(uRippleNormal, worldXZ / uRipplePatch, bias).xy;
+  vec2 r2 = texture2D(uRippleNormal, worldXZ.yx * 0.71 / uRipplePatch + 0.37, bias).xy;
+  return r1 * 0.72 + r2.yx * (0.28 * 0.71);
+}
 // incanto: the scene pre-pass runs at HALF resolution, so everything read from
 // its depth texture arrives quantised to those texels. Derivatives of a
 // quantised signal are garbage (they alternate between ~0 inside a texel and a
@@ -1911,12 +2617,32 @@ vec3 detailNormal(vec3 n, vec2 worldXZ, float strength, float camDist) {
   // them by zero. Branch instead. camDist barely varies across a quad, so
   // these are warp-coherent: distant water genuinely skips the work, and the
   // near look is bit-identical because a skipped layer was contributing < 1%.
+  // water-that-reads-as-water: the spectrum's ENERGY sat in the two long
+  // octaves — the fine ones tilted the normal by a degree or two, so under a
+  // 50°-high sun nothing ever faced it (no glitter, ever) and every
+  // reflection was a smooth wobble (the gel). A wind-roughened surface holds
+  // most of its SLOPE in the short waves (Cox-Munk: rms slope ~0.1-0.2 at a
+  // breeze), so the fine octaves carry more, and a fifth 16 cm "spark"
+  // octave lives inside arm's reach — the facets the sun flashes off.
+  float fadeSpark  = 1.0 - smoothstep(3.0, 14.0, camDist);
+  // under the FFT sea the two long octaves overlap the spectrum's own band —
+  // keep a whisper for texture, not a second sea on top of the first
+  float longW = uFftOn > 0.5 ? 0.3 : 1.0;
   vec2 slope = vec2(0.0);
-  if (fadeCoarse > 0.01) slope += octaveSlope(worldXZ, WIND_DIR, 6.0, uTime) * (0.085 * fadeCoarse);
-  if (fadeMid > 0.01) slope += octaveSlope(worldXZ, dMid, 2.2, uTime) * (0.10 * fadeMid);
-  if (fadeFine > 0.01) slope += octavePair(worldXZ, WIND_DIR, 0.9, uTime) * (0.055 * fadeFine);
-  if (fadeMicro > 0.01) slope += octavePair(worldXZ, dMid, 0.38, uTime) * (0.042 * fadeMicro);
+  if (fadeCoarse > 0.01) slope += octaveSlope(worldXZ, WIND_DIR, 6.0, uTime) * (0.085 * fadeCoarse * longW);
+  if (fadeMid > 0.01) slope += octaveSlope(worldXZ, dMid, 2.2, uTime) * (0.10 * fadeMid * longW);
+  // the three short octaves are the RIPPLE band. The live ripple FFT carries
+  // its STRUCTURE (real churn, a mip chain for distance); these stay on under
+  // it at reduced weight for the one thing a filtered texture cannot give —
+  // the sub-pixel facets that flash. Evaluated per pixel and never filtered,
+  // their aliasing IS the glitter; measured: with them off the sun collapsed
+  // into one soft lobe and the sea read as satin.
+  float shortW = uRippleOn > 0.5 ? 0.6 : 1.0;
+  if (fadeFine > 0.01) slope += octavePair(worldXZ, WIND_DIR, 0.9, uTime) * (0.08 * fadeFine * shortW);
+  if (fadeMicro > 0.01) slope += octavePair(worldXZ, dMid, 0.38, uTime) * (0.07 * fadeMicro * shortW);
+  if (fadeSpark > 0.01) slope += octavePair(worldXZ, WIND_DIR, 0.16, uTime) * (0.05 * fadeSpark * shortW);
   slope *= strength * 3.0; // spectrum norm: default strength 0.26 ≈ calm-lively
+  if (uRippleOn > 0.5) slope += rippleSlope(worldXZ, -1.0) * uRippleGain;
   return normalize(vec3(n.x - slope.x, n.y, n.z - slope.y));
 }
 
@@ -1928,20 +2654,112 @@ vec3 detailNormal(vec3 n, vec2 worldXZ, float strength, float camDist) {
 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);
+  float fadeFine   = 1.0 - smoothstep(18.0, 80.0, camDist);
   vec2 dMid = normalize(vec2(0.62, 0.78));
+  float longW = uFftOn > 0.5 ? 0.3 : 1.0;
   vec2 slope = vec2(0.0);
-  if (fadeCoarse > 0.01) slope += octaveSlope(worldXZ, WIND_DIR, 6.0, uTime) * (0.085 * fadeCoarse);
-  if (fadeMid > 0.01) slope += octaveSlope(worldXZ, dMid, 2.2, uTime) * (0.075 * fadeMid);
+  if (fadeCoarse > 0.01) slope += octaveSlope(worldXZ, WIND_DIR, 6.0, uTime) * (0.085 * fadeCoarse * longW);
+  if (fadeMid > 0.01) slope += octaveSlope(worldXZ, dMid, 2.2, uTime) * (0.075 * fadeMid * longW);
+  // water-that-reads-as-water: a share of the 0.9 m octave — a reflection
+  // read only off the long swell is a lava lamp; real sky reflections break
+  // into short vertical shards on the wind ripple, out to mid range
+  if (uRippleOn < 0.5 && fadeFine > 0.01)
+    slope += octavePair(worldXZ, WIND_DIR, 0.9, uTime) * (0.035 * fadeFine);
   slope *= strength * 3.0;
+  // the reflection reads the ripple a mip and a half softer, and weaker — a
+  // mirror the size of a pixel integrates most of it away
+  if (uRippleOn > 0.5) slope += rippleSlope(worldXZ, 1.5) * (uRippleGain * 0.6);
   return normalize(vec3(n.x - slope.x, n.y, n.z - slope.y));
 }
 
+// ============ the SEA-STATE fresnel (why the sea is darker than its sky) ============
+// Smooth-surface Schlick says grazing water is a perfect mirror, and a
+// flat-Schlick sea therefore whites out into its own horizon haze — the
+// milky far field. A real sea is a field of tilted facets: at range a pixel
+// integrates thousands, and the ones tilted toward the viewer reflect a
+// steeper, darker patch of sky at a less grazing angle. Integrated, the
+// reflectance at the horizon of a wind-roughened sea is ~0.5-0.6, not 1.0 —
+// the ocean is always a darker band under its sky. This is Karis' analytic
+// fit of the split-sum environment BRDF: (scale, bias) with
+// F_rough = F0 * scale + bias.
+vec2 envBRDFApprox(float roughness, float NoV) {
+  const vec4 c0 = vec4(-1.0, -0.0275, -0.572, 0.022);
+  const vec4 c1 = vec4(1.0, 0.0425, 1.04, -0.04);
+  vec4 r = roughness * c0 + c1;
+  float a004 = min(r.x * r.x, exp2(-9.28 * NoV)) * r.x + r.y;
+  return vec2(-1.04, 1.04) * a004 + r.zw;
+}
+// The sea state as a microfacet roughness. Near the camera the detail
+// octaves are RESOLVED (each facet is pixels wide — glitter); with distance
+// a pixel integrates them, and what it integrates is exactly a rough mirror.
+// The fresnel, the horizon sky sample and the sun highlight all read it.
+float seaRoughness(float strength, float camDist) {
+  float far = smoothstep(15.0, 320.0, camDist);
+  // near: a resolved facet is GLASSY — the lobe must be tight or every
+  // ripple flank glows (the soft-blob glitter of the first pass); far: the
+  // integrated field of a breeze-roughened sea, rms slope ~0.15
+  return clamp(0.02 + strength * (0.2 + 1.5 * far), 0.02, 0.4);
+}
+
 // 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));
 }
 
+// ============ screen-space reflections ============
+// Walk the reflected ray through the above-water image: project each step,
+// read the scene's depth there, and call it a hit where the ray has passed
+// behind the surface by less than a step's worth (the "thickness"). Steps
+// grow geometrically so a 16-step walk reaches ~120 m while still resolving
+// the first metre — a wader's legs at the waterline and a headland alike.
+// Three bisection steps then pin the crossing. Returns the hit colour with
+// its confidence in .a: 0 where the ray left the screen or never crossed,
+// fading toward the screen edge so a reflection never ends on a hard line.
+vec4 ssrTrace(vec3 origin, vec3 dir) {
+  vec3 p = origin;
+  float stepLen = 0.35;
+  float prevDelta = 0.0;
+  vec3 prevP = origin;
+  bool hit = false;
+  vec2 hitUv = vec2(0.0);
+  for (int i = 0; i < 16; i++) {
+    prevP = p;
+    p += dir * stepLen;
+    vec4 clip = uSsrViewProj * vec4(p, 1.0);
+    if (clip.w <= 0.0) return vec4(0.0);
+    vec2 uv = clip.xy / clip.w * 0.5 + 0.5;
+    if (uv.x < 0.0 || uv.x > 1.0 || uv.y < 0.0 || uv.y > 1.0) return vec4(0.0);
+    float sceneD = linearizeDepth(texture2D(uAboveDepth, uv).r, uCameraNear, uCameraFar);
+    float delta = clip.w - sceneD; // > 0: the ray point is behind the scene surface
+    if (delta > 0.0 && delta < stepLen * 2.0 + 0.5) {
+      // bisect between prevP (in front) and p (behind)
+      vec3 a = prevP;
+      vec3 b = p;
+      for (int k = 0; k < 3; k++) {
+        vec3 m = (a + b) * 0.5;
+        vec4 mc = uSsrViewProj * vec4(m, 1.0);
+        vec2 muv = mc.xy / mc.w * 0.5 + 0.5;
+        float md = linearizeDepth(texture2D(uAboveDepth, muv).r, uCameraNear, uCameraFar);
+        if (mc.w - md > 0.0) b = m; else a = m;
+      }
+      vec4 hc = uSsrViewProj * vec4(b, 1.0);
+      hitUv = hc.xy / hc.w * 0.5 + 0.5;
+      hit = true;
+      break;
+    }
+    prevDelta = delta;
+    stepLen *= 1.45;
+  }
+  if (!hit) return vec4(0.0);
+  vec2 edge = smoothstep(vec2(0.0), vec2(0.08), hitUv) * (1.0 - smoothstep(vec2(0.92), vec2(1.0), hitUv));
+  float conf = edge.x * edge.y;
+  // a whisper of blur: the half-res image read a mip down is what a rippled
+  // surface would show of it anyway
+  vec3 col = texture2D(uAboveColor, hitUv, 1.0).rgb;
+  return vec4(min(col, vec3(2.5)), conf);
+}
+
 /**
  * Vertical water column under a screen point, reconstructed from the scene
  * depth along the view ray. Split out so the shoreline can sample it in a
@@ -2204,7 +3022,32 @@ void main() {
   // normal: distant glitter is real and reads as sparkle, not noise.
   float camDist = length(vWorldPosition - cameraPosition);
   vec3 geoNormal = normalize(vNormal);
+  // the FFT sea's facing, per PIXEL: the vertex only carried the waves its
+  // grid could hold, the texture holds all of them, and its mip chain hands a
+  // far pixel the MEAN slope plus (w − |xy|²) the slope VARIANCE it integrated
+  // — the roughness a distant sea really has, instead of a guessed ramp
+  float fftFoam = 0.0;
+  float fftVar = 0.0;
+  if (uFftOn > 0.5) {
+    vec4 fn = texture2D(uFftNormal, vFftUv);
+    geoNormal = normalize(vec3(geoNormal.x - fn.x, geoNormal.y, geoNormal.z - fn.y));
+    fftFoam = fn.z;
+    fftVar = max(fn.w - dot(fn.xy, fn.xy), 0.0);
+  }
+  if (uRippleOn > 0.5) {
+    // the ripple's own integrated variance, scaled the way its slopes are
+    vec4 rr = texture2D(uRippleNormal, vWorldPosition.xz / uRipplePatch);
+    fftVar += max(rr.w - dot(rr.xy, rr.xy), 0.0) * uRippleGain * uRippleGain;
+  }
   vec3 normal = detailNormal(geoNormal, vWorldPosition.xz, uDetailStrength, camDist);
+  // the SHADING normal keeps sub-pixel structure the mip chain would have
+  // averaged away: glitter is facets a pixel can only just resolve, and a
+  // fully filtered normal hands the sun one soft lobe where a sea sparkles.
+  // The fresnel/reflection normal and the variance stay filtered.
+  if (uFftOn > 0.5) {
+    vec2 crispSlope = texture2D(uFftNormal, vFftUv, -1.0).xy - texture2D(uFftNormal, vFftUv).xy;
+    normal = normalize(vec3(normal.x - crispSlope.x, normal.y, normal.z - crispSlope.y));
+  }
   // 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
@@ -2220,8 +3063,15 @@ void main() {
   // 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));
+  // water-that-reads-as-water: the handover used to finish at 26 m, so past
+  // a boat-length every reflection was the smooth gloss wobble; the shards
+  // now survive out to where the eye stops resolving ripple
+  vec3 crisp = mix(normal, gloss, smoothstep(10.0, 60.0, camDist));
   vec3 fresnelNormal = normalize(mix(geoSmooth, crisp, fresnelDetail));
+  float rough = seaRoughness(uDetailStrength, camDist);
+  // measured, not guessed: the spectrum's integrated slope variance widens
+  // the lobe exactly where a pixel spans more wave
+  rough = clamp(sqrt(rough * rough + 0.35 * fftVar), 0.02, 0.5);
   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
@@ -2234,7 +3084,10 @@ void main() {
   // 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);
+  // water-that-reads-as-water: a rough sea's MEAN reflected ray points
+  // higher than the mirror ray (the facets tilt it up), so far water samples
+  // the bluer sky above the haze band instead of the white haze itself
+  reflectedDirection.y = max(abs(reflectedDirection.y), 0.15 + 0.4 * rough);
 
   // Sample environment map to get the reflected color
   // refinement pass 3: soft-cap the HDR radiance — the physical sky's
@@ -2244,6 +3097,19 @@ void main() {
   vec4 reflectionColor = textureCube(uEnvironmentMap, reflectedDirection);
   reflectionColor.rgb = min(reflectionColor.rgb, vec3(2.5));
 
+  // SSR: what the screen can see standing above the water — a rock, a pier,
+  // a wader — replaces the cube's sky where its reflected ray lands on it.
+  // Walked with the UNCLAMPED reflection (a shore reflects at a grazing ray
+  // the horizon clamp above would have lifted off it), only where it is
+  // resolvable: past ~150 m the reflection of anything is under a pixel.
+  if (uUseSsr > 0.5 && camDist < 150.0) {
+    vec3 ssrDir = reflect(viewDirection, fresnelNormal);
+    if (ssrDir.y > 0.005) {
+      vec4 ssr = ssrTrace(vWorldPosition, ssrDir);
+      reflectionColor.rgb = mix(reflectionColor.rgb, ssr.rgb, ssr.a * (1.0 - smoothstep(90.0, 150.0, camDist)));
+    }
+  }
+
   // 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
@@ -2275,6 +3141,17 @@ void main() {
   // 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));
+  // water-that-reads-as-water: scale the smooth Schlick by the ratio a
+  // ROUGH surface reflects at this angle (see envBRDFApprox) — near, calm
+  // water is untouched; the far, wind-roughened field stops mirroring the
+  // haze at 100% and keeps its own colour under the sky
+  {
+    float NoV = clamp(dot(-viewDirection, fresnelNormal), 0.0, 1.0);
+    vec2 fRough = envBRDFApprox(rough, NoV);
+    vec2 fSmooth = envBRDFApprox(0.02, NoV);
+    float roughRatio = (0.02 * fRough.x + fRough.y) / max(0.02 * fSmooth.x + fSmooth.y, 1e-3);
+    fresnel *= clamp(roughRatio, 0.0, 1.35);
+  }
 
   // Calculate scale-normalized height value
   // incanto: relative to the waterline, not absolute world y
@@ -2301,11 +3178,25 @@ void main() {
   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);
+    mixedColor2 = mix(mixedColor2, uPeakColor, crestBand * 0.3);
     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;
+    // ============ light THROUGH the crest (the turquoise glow) ============
+    // Sunlight entering the back of a wave scatters forward through the thin
+    // crest and leaves its face toward the viewer — the translucent
+    // turquoise a real crest lights up with when you look toward the sun.
+    // It is the cue that says the surface is lit from INSIDE (water), not
+    // painted on lumps (gel). Strongest looking into the sun through the
+    // highest crests; the trough is thick water and stays dark.
+    vec3 sssL = normalize(uSunDirection);
+    vec3 sssH = normalize(sssL + geoSmooth * 0.35);
+    float sssView = pow(clamp(dot(viewDirection, sssH), 0.0, 1.0), 3.0);
+    float crestThin = smoothstep(0.1, 0.9,
+      (vWorldPosition.y - uWaterCenter.y) / max(uWaveEnvelope, 0.001));
+    vec3 sssColor = mix(uSurfaceColor, uPeakColor, 0.5) * vec3(0.75, 1.15, 1.05);
+    mixedColor2 += sssColor * (sssView * crestThin * 0.9);
   }
 
   // incanto v2: Beer's-law depth absorption + screen-space refraction.
@@ -2440,41 +3331,45 @@ void main() {
   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.
+  // ============ the SUN as a microfacet highlight (the glitter road) ============
+  // The old glint/streak/sheen trio was three hand-shaped powers gated by the
+  // sun's azimuth, and it could not put light where a real sea puts it: a
+  // 900-power lobe over ripple that tilts 3° never reaches a 50°-high sun,
+  // so most views had no sparkle at all, the few that did flashed uniform
+  // white, and everything was capped at 0.85 — below the bloom threshold,
+  // so the brightest thing in any seascape never bloomed. One GGX lobe over
+  // the shading normal does the whole thing: near the camera the per-pixel
+  // facet churn IS the glitter; with distance the roughness grows (a pixel
+  // integrates more facets) and the same lobe widens into the continuous
+  // sun path a far sea shows. HDR on purpose — the sun's reflection is
+  // meant to pass 1.0, and the bloom pass reads exactly that.
+  // SUN_RADIANCE: the sun is ~1e5× the sky's radiance and the scene's
+  // directional light carries none of that range, so the specular sun is
+  // scaled relative to the unit sky the cube map holds.
+  const float SUN_RADIANCE = 40.0;
   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);
+  vec3 toCam = -viewDirection;
+  vec3 halfway = normalize(sunL + toCam);
+  float NoL = clamp(dot(normal, sunL), 0.0, 1.0);
+  float NoVs = max(dot(normal, toCam), 1e-3);
+  float NoH = clamp(dot(normal, halfway), 0.0, 1.0);
+  float LoH = clamp(dot(sunL, halfway), 0.0, 1.0);
+  // the sun is a disc, not a point: a floor on the lobe width so a glassy
+  // pool shows a soft-edged sun, never a one-pixel dot
+  float a = max(rough, 0.035);
+  float a2 = a * a;
+  float dD = NoH * NoH * (a2 - 1.0) + 1.0;
+  float D = a2 / (3.14159265 * dD * dD);
+  float gV = NoL * sqrt(NoVs * NoVs * (1.0 - a2) + a2);
+  float gL = NoVs * sqrt(NoL * NoL * (1.0 - a2) + a2);
+  float Vis = 0.5 / max(gV + gL, 1e-4);
+  float Fh = 0.02 + 0.98 * pow(1.0 - LoH, 5.0);
+  float sunSpec = D * Vis * Fh * NoL * SUN_RADIANCE;
+  // a facet that spans less than a pixel aliases into a lone flash — the
+  // roughness ramp has already widened the lobe out there, so the cap only
+  // catches the last isolated ones
+  float glintCap = mix(6.0, 1.5, smoothstep(40.0, 260.0, camDist));
+  finalColor += uSunColor * (uSunIntensity * min(sunSpec, glintCap));
 
   // Calculate and apply foam effects (only when enableFoam is true)
   float foamAmount = 0.0;
@@ -2535,18 +3430,38 @@ void main() {
     float capFade = 1.0 - smoothstep(220.0, 640.0, camDist);
     // LOD: no cap, no distance, no noise — the patch field is two octaves
     float capNoise = 0.0;
-    if (capFade > 0.01 && max(cap, vFold) > 0.001) {
-      vec2 capUV = vWorldPosition.xz * 0.3;
-      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;
+    // the FFT sea's whitecaps are its Jacobian's memory — born where the
+    // surface actually folded, fading over seconds (fft-gpu.ts)
+    float fold = max(vFold, fftFoam);
+    if (capFade > 0.01 && max(cap, fold) > 0.001) {
+      // water-that-reads-as-water: finer patches with a harder edge — a
+      // whitecap is a torn streak of bubbles, not a soft white smudge
+      vec2 capUV = vWorldPosition.xz * 0.5;
+      capNoise = noise(capUV * 2.2 + uTime * vec2(0.16, 0.09)) * 0.55
+               + noise(capUV * 7.5 - uTime * vec2(0.08, 0.22)) * 0.45;
     }
     // height says WHERE the crest is; the Jacobian says where it is actually
     // breaking. Taking the max keeps the tuned height-based caps and adds the
     // ones physics insists on — the pinched crest faces about to spill.
-    cap = max(cap, vFold);
-    float whitecap = uWhitecaps * cap * smoothstep(0.42, 0.78, capNoise) * capFade;
+    cap = max(cap, fold);
+    float whitecap = uWhitecaps * cap * smoothstep(0.50, 0.64, capNoise) * capFade;
     foamAmount = max(foamAmount, whitecap);
   }
+  // the BREAKER: where the bed made the swell break, its crest is whitewater
+  // — torn by a fast fine noise, riding the crest band only, and independent
+  // of the whitecaps dial (a shore breaks in a dead calm sea state too)
+  if (vBreak > 0.001 && uWaveEnvelope > 0.001) {
+    // a broken crest sits LOW (its height was capped at 0.78·depth), so the
+    // crest band starts near the mean line, not at the deep-water crest
+    float crestB = smoothstep(0.02, 0.35, (vWorldPosition.y - uWaterCenter.y) / uWaveEnvelope);
+    // TORN, not smudged: two fast fine octaves thresholded hard — a soft
+    // low-frequency mask painted the surf as pale blotches (the gel again)
+    float tearN = noise(vWorldPosition.xz * 5.5 - uTime * vec2(0.5, 0.3)) * 0.6 +
+                  noise(vWorldPosition.xz * 13.0 + uTime * vec2(0.3, 0.5)) * 0.4;
+    float tear = smoothstep(0.38, 0.62, tearN);
+    float nearFade = 1.0 - smoothstep(40.0, 120.0, camDist);
+    foamAmount = max(foamAmount, vBreak * crestB * tear * nearFade);
+  }
   // 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);
@@ -2705,6 +3620,179 @@ void main() {
 }
 `;
 //#endregion
+//#region src/3d/water/shore.ts
+/**
+* The shore — pure math, no three.
+*
+* A wave that reaches a beach does three things a deep-water wave never does:
+* it slows and rises as the bottom comes up (shoaling, Green's law: amplitude
+* grows as depth^-1/4 once the water is shallower than a quarter wavelength),
+* its crest peaks up, and when the height reaches ~0.78 of the depth it
+* BREAKS. None of that can happen without the surface knowing where the
+* bottom is — which is what `Water3D.bed` supplies: a Terrain3D whose heights
+* are sampled once into a depth grid the vertex shader reads.
+*
+* `bedDepthGrid` builds that grid; `sprayPoints` picks the places in the
+* breaking band where the spray sprites live; `shoalFactor` is the CPU copy
+* of the vertex shader's amplitude rule, kept here so the two cannot drift.
+*/
+/** Depth of the water column over a grid of `n × n` samples of the bed. */
+function bedDepthGrid(heightAt, waterY, rect, n) {
+	const grid = new Float32Array(n * n);
+	for (let j = 0; j < n; j++) {
+		const z = rect.minZ + (j + .5) / n * rect.depth;
+		for (let i = 0; i < n; i++) {
+			const x = rect.minX + (i + .5) / n * rect.width;
+			grid[j * n + i] = waterY - heightAt(x, z);
+		}
+	}
+	return grid;
+}
+/**
+* Where spray lives: grid cells whose water column sits in the breaking band
+* (`minDepth`..`maxDepth`), thinned to at most `count` points by a seeded
+* draw so the set is the same on every client. Each point carries the
+* column it stands over (its front phase) and a seed (its own timing).
+*/
+function sprayPoints(grid, n, rect, count, seed, minDepth = .25, maxDepth = 1.3) {
+	const candidates = [];
+	for (let idx = 0; idx < n * n; idx++) {
+		const d = grid[idx];
+		if (d >= minDepth && d <= maxDepth) candidates.push(idx);
+	}
+	const rng = new Rng(seed);
+	const picked = [];
+	const take = Math.min(count, candidates.length);
+	for (let k = 0; k < take; k++) {
+		const r = k + Math.floor(rng.next() * (candidates.length - k));
+		const t = candidates[k];
+		candidates[k] = candidates[r];
+		candidates[r] = t;
+		const idx = candidates[k];
+		const i = idx % n;
+		const j = (idx - i) / n;
+		picked.push({
+			x: rect.minX + (i + rng.next()) / n * rect.width,
+			z: rect.minZ + (j + rng.next()) / n * rect.depth,
+			depth: grid[idx],
+			seed: rng.next()
+		});
+	}
+	return picked;
+}
+//#endregion
+//#region src/3d/water/spray.ts
+/**
+* Shore spray (three): camera-facing sprites in the breaking band, each
+* bursting when the shader's own foam front passes its column — the same
+* `phase = depth · 0.75 − t · 0.4` the fragment marches (shaders.ts, the
+* shore-breaker block), so the spray and the whitewater are one event. A
+* sprite rises on a parabola, grows, and fades over the front's period; a
+* per-sprite seed staggers the burst so a set of breakers never fires as a
+* row of identical puffs.
+*
+* Instanced: a few hundred quads, one draw. Hung under the water's own mesh,
+* so every pass that hides the water (the grab, the mirror, the sky cube)
+* hides the spray with it.
+*/
+const SPRAY_VERT = `
+attribute vec3 aSpot;   // x, z, water column (m)
+attribute float aSeed;
+uniform float uTime;
+uniform float uWaterY;
+uniform float uStrength;
+varying vec2 vUv;
+varying float vAlpha;
+void main() {
+  // the front's phase over this column — the fragment shader's rule
+  float phase = aSpot.z * 0.75 - uTime * 0.4 + aSeed * 0.35;
+  float life = fract(phase);
+  // sets: a breaker only every so often, per sprite
+  // sparse on purpose: a breaker throws spray on a few strokes, not every
+  // one, and never in a row of identical puffs — two slow envelopes per
+  // sprite, both must be up
+  float sets = smoothstep(0.55, 0.9, 0.5 + 0.5 * sin(uTime * 0.31 + aSeed * 6.2831853));
+  float sets2 = smoothstep(0.4, 0.8, 0.5 + 0.5 * sin(uTime * 0.17 + aSeed * 19.7));
+  float size = (0.35 + 0.9 * life) * (0.7 + 0.5 * aSeed);
+  float rise = 2.4 * life * (1.0 - life) * (0.9 + 0.6 * aSeed);
+  vAlpha = (1.0 - life) * (1.0 - life) * sets * sets2 * uStrength * 0.45;
+  vUv = uv;
+  vec3 centre = vec3(aSpot.x, uWaterY + 0.1 + rise, aSpot.y);
+  // camera-facing: the view matrix's rows are the camera's axes in world space
+  vec3 right = vec3(viewMatrix[0][0], viewMatrix[1][0], viewMatrix[2][0]);
+  vec3 up = vec3(viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);
+  vec3 world = centre + right * (position.x * size) + up * (position.y * size);
+  gl_Position = projectionMatrix * viewMatrix * vec4(world, 1.0);
+}
+`;
+const SPRAY_FRAG = `
+precision highp float;
+varying vec2 vUv;
+varying float vAlpha;
+float hash(vec2 p) {
+  p = fract(p * vec2(127.31, 311.7));
+  p += dot(p, p + 34.23);
+  return fract(p.x * p.y);
+}
+void main() {
+  vec2 c = vUv - 0.5;
+  float r = length(c);
+  // a torn puff: a soft disc broken by a coarse hash so no two look alike
+  float disc = 1.0 - smoothstep(0.18, 0.5, r);
+  float grain = 0.55 + 0.45 * hash(floor(vUv * 6.0));
+  float a = disc * grain * vAlpha;
+  if (a < 0.01) discard;
+  gl_FragColor = vec4(vec3(0.96, 0.98, 1.0), a);
+  #include <tonemapping_fragment>
+  #include <colorspace_fragment>
+}
+`;
+function createSprayMesh(points) {
+	const quad = new PlaneGeometry(1, 1);
+	const geometry = new InstancedBufferGeometry();
+	geometry.index = quad.index;
+	geometry.setAttribute("position", quad.getAttribute("position"));
+	geometry.setAttribute("uv", quad.getAttribute("uv"));
+	const spots = new Float32Array(points.length * 3);
+	const seeds = new Float32Array(points.length);
+	points.forEach((p, i) => {
+		spots[i * 3] = p.x;
+		spots[i * 3 + 1] = p.z;
+		spots[i * 3 + 2] = p.depth;
+		seeds[i] = p.seed;
+	});
+	geometry.setAttribute("aSpot", new InstancedBufferAttribute(spots, 3));
+	geometry.setAttribute("aSeed", new InstancedBufferAttribute(seeds, 1));
+	geometry.instanceCount = points.length;
+	const uniforms = {
+		uTime: { value: 0 },
+		uWaterY: { value: 0 },
+		uStrength: { value: 1 }
+	};
+	const material = new ShaderMaterial({
+		vertexShader: SPRAY_VERT,
+		fragmentShader: SPRAY_FRAG,
+		uniforms,
+		transparent: true,
+		depthWrite: false,
+		depthTest: true,
+		blending: NormalBlending,
+		side: DoubleSide
+	});
+	const mesh = new Mesh(geometry, material);
+	mesh.frustumCulled = false;
+	mesh.renderOrder = 3;
+	return {
+		mesh,
+		uniforms,
+		dispose() {
+			geometry.dispose();
+			quad.dispose();
+			material.dispose();
+		}
+	};
+}
+//#endregion
 //#region src/3d/water/underwater.ts
 /**
 * True when the camera EYE sits below the water surface and inside its
@@ -3739,9 +4827,11 @@ const WATER_PRESET_NAMES = [
 const WATER_PRESETS = {
 	ocean: {
 		waveHeight: .045,
-		swell: .34,
+		wind: 6.5,
+		choppiness: .9,
+		swell: .2,
 		swellWavelength: 52,
-		whitecaps: .15,
+		whitecaps: .4,
 		absorption: .17,
 		opacity: .85,
 		detailStrength: .17,
@@ -3786,8 +4876,8 @@ const WATER_PRESETS = {
 	},
 	lake: {
 		waveHeight: .028,
-		swell: .14,
-		swellWavelength: 24,
+		swell: .03,
+		swellWavelength: 9,
 		whitecaps: 0,
 		absorption: .5,
 		opacity: .88,
@@ -3877,6 +4967,30 @@ 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;
+/** The FFT sea: texels per side of the tiling patch, and the patch in metres
+* (0.78 m texels — the shortest wave the spectrum resolves is ~1.6 m; the
+* procedural ripple octaves carry everything finer). */
+const SEA_FFT_SIZE = 256;
+const SEA_FFT_PATCH = 200;
+/** One sea per seed: every client of a multiplayer game sees the same waves. */
+const SEA_FFT_SEED = 1337;
+/** The RIPPLE layer: a second, live FFT over a 6 m patch (4.7 cm texels) —
+* the wind ripple every fancy surface wears, replacing the procedural fine
+* octaves: real churn instead of noise, and a mip chain instead of hand-tuned
+* distance fades. A short fetch puts the spectrum's peak inside the patch. */
+const RIPPLE_FFT_SIZE = 128;
+const RIPPLE_FFT_PATCH = 6;
+/** Fetch is only a SHAPE control here: 150 m puts the JONSWAP peak at ~30 cm
+* (2 km put it at 2 m — the pool wore broad soft bulges, not ripple). */
+const RIPPLE_FETCH = 150;
+/** Ripple slope the layer is normalized to, per unit of `detailStrength`. */
+const RIPPLE_SLOPE_PER_DETAIL = .8;
+/** The bed depth grid (`bed`): samples per side over the terrain's footprint,
+* the depth assumed beyond it, and how many spray sprites the band gets. */
+const BED_GRID = 256;
+const BED_DEEP = 12;
+const SPRAY_COUNT = 120;
+const SPRAY_SEED = 9001;
 /**
 * Idle frames before a surface hands its render targets back — ~2 seconds at
 * 60 fps, and longer at a capped 30. Long enough that turning to look at a lake
@@ -4007,6 +5121,7 @@ var Water3D = class Water3D extends Node3D {
 		reflectionInterval: { default: 1e3 },
 		mirror: { default: false },
 		mirrorInterval: { default: 33 },
+		ssr: { default: true },
 		swellSteepness: { default: .35 },
 		foam: { default: true },
 		reflectivity: {
@@ -4039,6 +5154,18 @@ var Water3D = class Water3D extends Node3D {
 		swellDirectionDeg: { default: 0 },
 		swellWavelength: { default: 30 },
 		whitecaps: { default: 0 },
+		bed: {
+			default: "",
+			nodePath: true
+		},
+		wind: {
+			default: 0,
+			range: { min: 0 }
+		},
+		choppiness: {
+			default: .85,
+			range: { min: 0 }
+		},
 		preset: {
 			default: "custom",
 			options: WATER_PRESET_NAMES
@@ -4080,6 +5207,16 @@ var Water3D = class Water3D extends Node3D {
 	*/
 	mirror = false;
 	/**
+	* Screen-space reflections (fancy only, default on): the scene ABOVE the
+	* waterline is rendered once at half resolution and every water pixel
+	* marches its reflected ray through that image — so a rock, a pier, a
+	* wader or a boat is mirrored on the water WITHOUT the planar `mirror`
+	* pass. What the screen cannot see (behind the camera, off its edges)
+	* falls back to the sky cube, which is why a mirror-calm lake still wants
+	* `mirror: true`; with `mirror` on this is skipped as redundant.
+	*/
+	ssr = true;
+	/**
 	* Milliseconds between planar-mirror re-renders. A reflection seen through a
 	* rippling surface does not need 60 Hz — 33 ms halves the pass's cost and
 	* nobody can tell. 0 re-renders every frame.
@@ -4144,6 +5281,30 @@ var Water3D = class Water3D extends Node3D {
 	/** Primary swell wavelength in meters (the two crossing trains derive). */
 	swellWavelength = 30;
 	/**
+	* The bottom under this water: a node path to a Terrain3D (fancy only). With
+	* it the swell KNOWS the beach — waves slow and rise as the bottom comes up
+	* (Green's law), their crests peak, and at 0.78× the depth they BREAK into
+	* foam, with spray sprites bursting where the foam fronts pass. Sampled
+	* once into a 256² depth grid over the terrain's footprint; beyond it the
+	* water is assumed deep. Pair with `swell` (the waves that shoal) and
+	* `shoreWaves` (the foam fronts the spray rides).
+	*/
+	bed = "";
+	/**
+	* Wind speed in m/s — THE realistic-sea dial (fancy only; 0 = off). Above 0
+	* the surface stops being a noise field and becomes a JONSWAP spectrum:
+	* thousands of waves at every wavelength and heading, each moving at the
+	* speed deep water gives it, inverse-FFT'd on the GPU every frame into a
+	* tiling patch with real crest shapes, choppy horizontal drag and whitecaps
+	* born where the surface folds. The wind blows toward `swellDirectionDeg`.
+	* 4 = a light breeze (ripples, 20 cm), 7 = a fresh breeze (1 m waves),
+	* 12 = rough. The CPU twin (buoyancy, waders) sums the same spectrum.
+	*/
+	wind = 0;
+	/** Horizontal drag of the FFT sea toward its crests, 0..~1.5 — narrow
+	* crests, broad troughs; past ~1.2 the surface folds and foams everywhere. */
+	choppiness = .85;
+	/**
 	* GERSTNER pinch on the swell: 0 keeps the legacy height-only trains, 1 is
 	* maximum trochoid (crests narrow to a peak, troughs go broad). It also
 	* decides where whitecaps break — the surface's Jacobian collapses on a
@@ -4218,6 +5379,8 @@ var Water3D = class Water3D extends Node3D {
 		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.wind >= 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' wind must be >= 0 m/s, got ${w.wind}.`, { prop: "wind" });
+		if (!(w.choppiness >= 0)) throw new IncantoError("BAD_FORMAT", `Water3D '${node.name}' choppiness must be >= 0, got ${w.choppiness}.`, { prop: "choppiness" });
 		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" });
@@ -4270,6 +5433,26 @@ var Water3D = class Water3D extends Node3D {
 	/** Per-frame scene pre-pass: depth (absorption/foam) + color grab (refraction). */
 	scenePassTarget = null;
 	mirrorTarget = null;
+	/** Half-res render of the scene ABOVE the waterline — what SSR reflects. */
+	aboveTarget = null;
+	ssrViewProj = new Matrix4();
+	/** The FFT sea (wind > 0): the GPU passes, and the CPU spectrum they share. */
+	seaFft = null;
+	seaFftUnsupported = false;
+	spectrum = null;
+	spectrumKey = "";
+	uploadedSpectrumKey = "";
+	rippleFft = null;
+	rippleSpectrum = null;
+	rippleKey = "";
+	uploadedRippleKey = "";
+	/** The bed depth grid (see `bed`), its footprint, and the spray that rides it. */
+	bedTexture = null;
+	bedRect = null;
+	bedKey = "";
+	spray = null;
+	/** Vertex spacing of the fancy grid — the mip the vertex shader reads at. */
+	fancySegments = FANCY_SEGMENTS_MIN;
 	mirrorCamera = new PerspectiveCamera();
 	mirrorMatrix = new Matrix4();
 	lastMirrorAt = 0;
@@ -4324,6 +5507,40 @@ var Water3D = class Water3D extends Node3D {
 		if (u.uCameraSubmerged) u.uCameraSubmerged.value = 0;
 		this.idleFrames = 0;
 		const now = Date.now();
+		const spectrum = this.seaSpectrum();
+		if (spectrum && !this.seaFftUnsupported) {
+			if (!this.seaFft) if (!seaFftSupported(ctx.gl)) this.seaFftUnsupported = true;
+			else this.seaFft = new SeaFft(SEA_FFT_SIZE, SEA_FFT_PATCH);
+			if (this.seaFft) {
+				if (this.uploadedSpectrumKey !== this.spectrumKey) {
+					this.seaFft.setSpectrum(spectrum);
+					this.uploadedSpectrumKey = this.spectrumKey;
+				}
+				this.seaFft.update(ctx.gl, this.time);
+				if (u.uFftDisp) u.uFftDisp.value = this.seaFft.displacement;
+				if (u.uFftNormal) u.uFftNormal.value = this.seaFft.normal;
+				if (u.uFftOn) u.uFftOn.value = 1;
+			}
+		} else if (u.uFftOn) u.uFftOn.value = 0;
+		if (!this.seaFftUnsupported) {
+			if (!this.rippleFft) if (!seaFftSupported(ctx.gl)) this.seaFftUnsupported = true;
+			else this.rippleFft = new SeaFft(RIPPLE_FFT_SIZE, RIPPLE_FFT_PATCH);
+			if (this.rippleFft) {
+				const rs = this.rippleSpectrumFor();
+				if (this.uploadedRippleKey !== this.rippleKey) {
+					this.rippleFft.setSpectrum(rs);
+					this.uploadedRippleKey = this.rippleKey;
+				}
+				this.rippleFft.update(ctx.gl, this.time);
+				if (u.uRippleNormal) u.uRippleNormal.value = this.rippleFft.normal;
+				if (u.uRippleOn) u.uRippleOn.value = 1;
+				if (u.uRippleGain) {
+					const target = this.rp("detailStrength") * RIPPLE_SLOPE_PER_DETAIL;
+					u.uRippleGain.value = rs.rmsSlope > 0 ? target / rs.rmsSlope : 0;
+				}
+			}
+		}
+		if (this.seaFftUnsupported && u.uRippleOn) u.uRippleOn.value = 0;
 		if (this.reflection) {
 			if (!this.cubeTarget) this.cubeTarget = new WebGLCubeRenderTarget(REFLECTION_RESOLUTION, {
 				generateMipmaps: true,
@@ -4460,6 +5677,44 @@ var Water3D = class Water3D extends Node3D {
 		ctx.scene.overrideMaterial = prevOverride;
 		ctx.scene.background = prevBackground;
 		this.renderCutoutMasks(ctx);
+		if (this.ssr && !this.effectiveMirror() && (this.caps ? this.caps.waterMirror : true)) {
+			if (this.aboveTarget && (this.aboveTarget.width !== passW || this.aboveTarget.height !== passH)) {
+				this.aboveTarget.depthTexture?.dispose();
+				this.aboveTarget.dispose();
+				this.aboveTarget = null;
+			}
+			if (!this.aboveTarget) {
+				const depthTexture = new DepthTexture(passW, passH);
+				depthTexture.type = FloatType;
+				this.aboveTarget = new WebGLRenderTarget(passW, passH, {
+					depthTexture,
+					depthBuffer: true,
+					stencilBuffer: false,
+					type: HalfFloatType,
+					generateMipmaps: true,
+					minFilter: LinearMipmapLinearFilter
+				});
+			}
+			ctx.gl.clippingPlanes = depthOnlyClipPlanes;
+			ctx.gl.setRenderTarget(this.aboveTarget);
+			ctx.gl.autoClear = true;
+			ctx.gl.clear(true, true, false);
+			hideForWaterPass(ctx.scene, this._passHidden);
+			ctx.gl.render(ctx.scene, ctx.camera);
+			restoreForWaterPass(this._passHidden);
+			this.ssrViewProj.multiplyMatrices(ctx.camera.projectionMatrix, ctx.camera.matrixWorldInverse);
+			if (u.uUseSsr) u.uUseSsr.value = 1;
+			if (u.uAboveColor) u.uAboveColor.value = this.aboveTarget.texture;
+			if (u.uAboveDepth) u.uAboveDepth.value = this.aboveTarget.depthTexture;
+			(u.uSsrViewProj?.value)?.copy(this.ssrViewProj);
+		} else {
+			if (u.uUseSsr) u.uUseSsr.value = 0;
+			if (this.aboveTarget) {
+				this.aboveTarget.depthTexture?.dispose();
+				this.aboveTarget.dispose();
+				this.aboveTarget = null;
+			}
+		}
 		ctx.gl.setRenderTarget(prevTarget);
 		ctx.gl.autoClear = prevAutoClear;
 		ctx.gl.clippingPlanes = prevClippingPlanes;
@@ -4521,6 +5776,23 @@ var Water3D = class Water3D extends Node3D {
 		this.scenePassTarget?.depthTexture?.dispose();
 		this.scenePassTarget?.dispose();
 		this.scenePassTarget = null;
+		this.seaFft?.dispose();
+		this.seaFft = null;
+		this.uploadedSpectrumKey = "";
+		this.aboveTarget?.depthTexture?.dispose();
+		this.aboveTarget?.dispose();
+		this.aboveTarget = null;
+		this.rippleFft?.dispose();
+		this.rippleFft = null;
+		this.uploadedRippleKey = "";
+		this.bedTexture?.dispose();
+		this.bedTexture = null;
+		this.bedKey = "";
+		if (this.spray) {
+			this._builtObject3D?.remove(this.spray.mesh);
+			this.spray.dispose();
+			this.spray = null;
+		}
 	}
 	/**
 	* Frames in a row that took no pass at all (submerged, or off camera).
@@ -4614,7 +5886,9 @@ var Water3D = class Water3D extends Node3D {
 			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));
+			const segments = Math.min(Math.max(Math.round(Math.max(w, d) * FANCY_SEGMENTS_PER_M), FANCY_SEGMENTS_MIN), FANCY_SEGMENTS_MAX);
+			this.fancySegments = segments;
+			mesh.geometry = buildWaterGeometry(w, d, segments);
 			mesh.material = this.buildFancyMaterial();
 		}
 	}
@@ -4686,7 +5960,24 @@ var Water3D = class Water3D extends Node3D {
 				uShoreWaves: { value: this.rp("shoreWaves") },
 				uReflectivityMax: { value: .6 },
 				uCameraSubmerged: { value: 0 },
-				uEdgeFadeOn: { value: 1 }
+				uEdgeFadeOn: { value: 1 },
+				uUseSsr: { value: 0 },
+				uAboveColor: { value: null },
+				uAboveDepth: { value: null },
+				uSsrViewProj: { value: new Matrix4() },
+				uBedOn: { value: 0 },
+				uBedDepth: { value: null },
+				uBedRect: { value: new Vector4(0, 0, 1, 1) },
+				uBedDeep: { value: BED_DEEP },
+				uRippleOn: { value: 0 },
+				uRippleNormal: { value: null },
+				uRipplePatch: { value: RIPPLE_FFT_PATCH },
+				uRippleGain: { value: 0 },
+				uFftOn: { value: 0 },
+				uFftDisp: { value: null },
+				uFftNormal: { value: null },
+				uFftPatch: { value: SEA_FFT_PATCH },
+				uFftLod: { value: 0 }
 			},
 			transparent: true,
 			depthTest: true,
@@ -4817,7 +6108,14 @@ var Water3D = class Water3D extends Node3D {
 		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;
+		const spectrum = this.seaSpectrum();
+		if (u.uWaveEnvelope) u.uWaveEnvelope.value = (spectrum ? spectrum.significantHeight * .5 : this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT * 1.5) + this.rp("swell") * 1.03;
+		if (u.uFftOn) u.uFftOn.value = spectrum ? 1 : 0;
+		if (u.uFftLod) {
+			const spacing = Math.max(w, d) / Math.max(this.fancySegments, 1);
+			const texel = SEA_FFT_PATCH / SEA_FFT_SIZE;
+			u.uFftLod.value = Math.max(0, Math.min(7, Math.log2(spacing / texel)));
+		}
 		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;
@@ -4830,6 +6128,67 @@ var Water3D = class Water3D extends Node3D {
 			else ripples[i].set(0, 0, 0, 0);
 			if (foam) foam[i] = r ? r.foam ?? 0 : 0;
 		}
+		this.syncBed(mesh, u, center.y);
+	}
+	/**
+	* The bed depth grid and the spray that rides it. Built once per `bed`
+	* (terrain heights are static); torn down when the path is cleared.
+	*/
+	syncBed(mesh, u, waterY) {
+		const path = this.bed;
+		const terrain = path ? this.getNodeOrNull(path) : null;
+		const usable = terrain && typeof terrain.heightAt === "function" && Array.isArray(terrain.size);
+		const key = usable ? `${path}|${waterY.toFixed(3)}|${this.rp("shoreWaves")}` : "";
+		if (key !== this.bedKey) {
+			this.bedKey = key;
+			this.bedTexture?.dispose();
+			this.bedTexture = null;
+			this.bedRect = null;
+			if (this.spray) {
+				mesh.remove(this.spray.mesh);
+				this.spray.dispose();
+				this.spray = null;
+			}
+			if (usable && terrain) {
+				const t = terrain;
+				const centre = worldTranslationOf(t);
+				const w = t.size[0] ?? 1;
+				const d = t.size[1] ?? 1;
+				const rect = {
+					minX: centre.x - w / 2,
+					minZ: centre.z - d / 2,
+					width: w,
+					depth: d
+				};
+				const grid = bedDepthGrid((x, z) => t.heightAt(x, z), waterY, rect, BED_GRID);
+				const half = new Uint16Array(BED_GRID * BED_GRID * 4);
+				for (let i = 0; i < grid.length; i++) {
+					half[i * 4] = DataUtils.toHalfFloat(grid[i]);
+					half[i * 4 + 3] = DataUtils.toHalfFloat(1);
+				}
+				const tex = new DataTexture(half, BED_GRID, BED_GRID, RGBAFormat, HalfFloatType);
+				tex.minFilter = LinearFilter;
+				tex.magFilter = LinearFilter;
+				tex.needsUpdate = true;
+				this.bedTexture = tex;
+				this.bedRect = rect;
+				if (this.rp("shoreWaves") > 0) {
+					const points = sprayPoints(grid, BED_GRID, rect, SPRAY_COUNT, SPRAY_SEED, .3, .9);
+					if (points.length > 0) {
+						this.spray = createSprayMesh(points);
+						mesh.add(this.spray.mesh);
+					}
+				}
+			}
+		}
+		if (u.uBedOn) u.uBedOn.value = this.bedTexture ? 1 : 0;
+		if (u.uBedDepth) u.uBedDepth.value = this.bedTexture;
+		if (this.bedRect) (u.uBedRect?.value)?.set(this.bedRect.minX, this.bedRect.minZ, 1 / this.bedRect.width, 1 / this.bedRect.depth);
+		if (this.spray) {
+			this.spray.uniforms.uTime.value = this.time;
+			this.spray.uniforms.uWaterY.value = waterY;
+			this.spray.uniforms.uStrength.value = Math.min(this.rp("shoreWaves"), 1);
+		}
 	}
 	/**
 	* @internal Environment-sky sun hand-off (see {@link SunConsumer3D}): the
@@ -5019,8 +6378,56 @@ var Water3D = class Water3D extends Node3D {
 	}
 	/** 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. */
+	/**
+	* The sea's spectrum, or null when there is no wind (or the tier collapsed
+	* the surface to the simple shader, whose CPU waves are its own). Built on
+	* the CPU once per (wind, heading, choppiness) and shared by the GPU upload
+	* and the headless twin — one sea, two evaluators.
+	*/
+	seaSpectrum() {
+		const wind = this.rp("wind");
+		if (!(wind > 0) || this.effectiveQuality() !== "fancy" || this.seaFftUnsupported) return null;
+		const key = `${wind}|${this.swellDirectionDeg}|${this.rp("choppiness")}`;
+		if (key !== this.spectrumKey || !this.spectrum) {
+			this.spectrum = buildSeaSpectrum({
+				size: SEA_FFT_SIZE,
+				patch: SEA_FFT_PATCH,
+				wind,
+				windDirectionDeg: this.swellDirectionDeg,
+				seed: SEA_FFT_SEED,
+				choppiness: this.rp("choppiness")
+			});
+			this.spectrumKey = key;
+		}
+		return this.spectrum;
+	}
+	/**
+	* The ripple layer's spectrum: the sea's own wind when it blows, else the
+	* breeze that puts wind ripple on a pool — its ENERGY is irrelevant (the
+	* layer is normalized to `detailStrength` by rms slope), only its shape.
+	*/
+	rippleSpectrumFor() {
+		const wind = Math.min(Math.max(this.rp("wind"), 2.5), 9);
+		const key = `${wind}|${this.swellDirectionDeg}`;
+		if (key !== this.rippleKey || !this.rippleSpectrum) {
+			this.rippleSpectrum = buildSeaSpectrum({
+				size: RIPPLE_FFT_SIZE,
+				patch: RIPPLE_FFT_PATCH,
+				wind,
+				windDirectionDeg: this.swellDirectionDeg,
+				seed: 1338,
+				choppiness: .4,
+				fetch: RIPPLE_FETCH,
+				modes: 0
+			});
+			this.rippleKey = key;
+		}
+		return this.rippleSpectrum;
+	}
 	waveOffsetAt(x, z, center) {
 		if (this.effectiveQuality() === "simple") return simpleWaveHeight(x - center.x, z - center.z, this.time, this.rp("waveHeight"));
+		const spectrum = this.seaSpectrum();
+		if (spectrum) return seaElevation(spectrum, x, z, this.time);
 		return waveElevation(x, z, this.time, {
 			amplitude: this.rp("waveHeight") * AMPLITUDE_PER_WAVE_HEIGHT,
 			frequency: FANCY_WAVE.frequency,
@@ -11424,4 +12831,4 @@ function registerGameplayBehaviors(opts) {
 	for (const [name, ctor] of Object.entries(GAMEPLAY_BEHAVIORS)) registerBehavior(name, ctor, { replace });
 }
 //#endregion
-export { Water3D as $, Lifetime as A, FollowCamera as B, Pickup as C, Oscillate as D, PathFollow as E, Interactable as F, phaseOf as G, FloatAway as H, GroupCamera as I, Collector as J, DamageOnContact as K, GameFlow as L, Cooldown as M, hitStop as N, MoveTo as O, screenFlash as P, tolerateUnknownAction as Q, goToScene as R, PrefabShelf as S, Patrol as T, FaceTarget as U, effectRng as V, DayNight as W, ChaseCamera as X, Checkpoint as Y, Chase as Z, Node2D as _, Wander as a, PhysicsBody3D as at, SavePoint as b, ballisticPath as c, Node3D as ct, Sight as d, WATER_MAX_RIPPLES as dt, WATER_CUTOUT_MAX as et, Area2D as f, colliderFootDrop as ft, StaticBody2D as g, RigidBody2D as h, findHealth as ht, WaveSpawner as i, CharacterBody3D as it, CameraShake as j, Mount as k, maxRangeAim as l, validateCollider3D as lt, PhysicsBody2D as m, Health as mt, registerGameplayBehaviors as n, rejectScale as nt, Turret as o, RigidBody3D as ot, CharacterBody2D as p, Blast as pt, Currency as q, ZombieAI as r, Area3D as rt, ballisticAim as s, StaticBody3D as st, GAMEPLAY_BEHAVIORS as t, WaterCutout3D as tt, Spawner as u, createCausticsQuad as ut, validateCollider2D as v, Phases as w, Projectile as x, ScoreKeeper as y, restartScene as z };
+export { Water3D as $, Lifetime as A, FollowCamera as B, Pickup as C, Oscillate as D, PathFollow as E, Interactable as F, phaseOf as G, FloatAway as H, GroupCamera as I, Collector as J, DamageOnContact as K, GameFlow as L, Cooldown as M, hitStop as N, MoveTo as O, screenFlash as P, tolerateUnknownAction as Q, goToScene as R, PrefabShelf as S, Patrol as T, FaceTarget as U, effectRng as V, DayNight as W, ChaseCamera as X, Checkpoint as Y, Chase as Z, Node2D as _, Health as _t, Wander as a, PhysicsBody3D as at, SavePoint as b, ballisticPath as c, Node3D as ct, Sight as d, WATER_MAX_RIPPLES as dt, WATER_CUTOUT_MAX as et, Area2D as f, colliderFootDrop as ft, StaticBody2D as g, Blast as gt, RigidBody2D as h, buildSeaSpectrum as ht, WaveSpawner as i, CharacterBody3D as it, CameraShake as j, Mount as k, maxRangeAim as l, validateCollider3D as lt, PhysicsBody2D as m, seaFftSupported as mt, registerGameplayBehaviors as n, rejectScale as nt, Turret as o, RigidBody3D as ot, CharacterBody2D as p, SeaFft as pt, Currency as q, ZombieAI as r, Area3D as rt, ballisticAim as s, StaticBody3D as st, GAMEPLAY_BEHAVIORS as t, WaterCutout3D as tt, Spawner as u, createCausticsQuad as ut, validateCollider2D as v, findHealth as vt, Phases as w, Projectile as x, ScoreKeeper as y, restartScene as z };