@crystaldesign/real-time-viewer-next 26.11.0-beta.18

package/build/types/real-time-viewer-next/src/core/water/CausticsTexture.d.ts

@@ -0,0 +1,48 @@
+import { Texture, Vector3, WebGLRenderer } from 'three';
+export interface CausticsTextureOptions {
+    /** Output texture resolution (square). Demo uses 1024. */
+    size?: number;
+    /**
+     * Plane subdivision count along the LONGER pool axis. Demo uses 200 on a
+     * unit-square pool; we keep ~200 segments/2m and let the shorter axis
+     * scale down proportionally with a floor of 32 so degenerate aspect
+     * ratios don't produce a 1-segment strip.
+     */
+    detail?: number;
+    /**
+     * Pool half-extents in WORLD METERS (halfX, depth, halfZ). The caustic
+     * plane is built as `2*halfX × 2*halfZ` so `position.xy` in the shader is
+     * the world XZ of a water-surface point and the heightfield sampling
+     * formula stays consistent with everything else.
+     */
+    poolHalf?: Vector3;
+}
+export declare class CausticsTexture {
+    readonly size: number;
+    readonly poolHalf: Vector3;
+    private rt;
+    private scene;
+    private camera;
+    private quad;
+    private material;
+    constructor(opts?: CausticsTextureOptions);
+    /** Output texture handle. Bind this where the demo bound `causticTex`. */
+    get texture(): Texture;
+    /**
+     * Render the caustics for the current heightfield + light. Should
+     * be called once per frame, after `Heightfield.updateNormals()` so the
+     * normals sampled here are in sync with the displaced surface.
+     *
+     * Inputs are read from the uniform setters below — pass updates BEFORE
+     * calling render().
+     */
+    render(renderer: WebGLRenderer): void;
+    setHeightfield(tex: Texture | null): void;
+    setLight(x: number, y: number, z: number): void;
+    /** MOD #4 — caustic intensity multiplier (replaces demo's `info.ba *= 0.5`). */
+    setIntensity(intensity: number): void;
+    /** MOD #7 — bind (or clear) the receiving-geometry height map. */
+    setHeightMap(tex: Texture | null): void;
+    dispose(): void;
+}
+//# sourceMappingURL=CausticsTexture.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/CausticsTexture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CausticsTexture.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/CausticsTexture.ts"],"names":[],"mappings":"AAkBA,OAAO,EAOL,OAAO,EAEP,OAAO,EACP,aAAa,EAEd,MAAM,OAAO,CAAC;AAIf,MAAM,WAAW,sBAAsB;IACrC,0DAA0D;IAC1D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,qBAAa,eAAe;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,QAAQ,CAAiB;gBAErB,IAAI,GAAE,sBAA2B;IA0D7C,0EAA0E;IAC1E,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;IAOrC,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAIlC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM;IAIxC,gFAAgF;IAChF,YAAY,CAAC,SAAS,EAAE,MAAM;IAI9B,kEAAkE;IAClE,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,IAAI;IAKhC,OAAO;CAKR"}

package/build/types/real-time-viewer-next/src/core/water/Heightfield.d.ts

@@ -0,0 +1,88 @@
+import { Vector2, WebGLRenderer } from 'three';
+export interface HeightfieldOptions {
+    /**
+     * Heightfield X-axis resolution (texels). When omitted, falls back to 256.
+     * The wave kernel propagates 1 texel per simulation step, so the X-axis
+     * wave speed in world meters is `(2·poolHalf.x / sizeX) m/step`. Sizing
+     * `sizeX / sizeY` proportional to `poolHalf.x / poolHalf.y` gives
+     * isotropic wave propagation in world space.
+     */
+    sizeX?: number;
+    /** Heightfield Y-axis (= world Z) resolution. Defaults to `sizeX`. */
+    sizeY?: number;
+    /**
+     * Pool half-extents in WORLD METERS, used by the drop kernel to measure
+     * horizontal distances in real meters (so a drop stays circular in world
+     * space on rectangular pools).
+     * Defaults to (1, 1) which reproduces the demo's unit-cube behaviour.
+     */
+    poolHalf?: Vector2;
+}
+/**
+ * GPU heightfield with a ping-pong pair of float render targets. Constructed
+ * without a renderer; the per-frame calls take one.
+ *
+ * Rectangular pools need no kernel change: all three shaders sample through
+ * the `coord` varying (UV ∈ [0,1]²) and `delta` (per-axis texel size), both of
+ * which work unchanged on non-square textures. The only physically-relevant
+ * difference is the drop falloff math — see MOD #A1 in this file.
+ */
+export declare class Heightfield {
+    readonly sizeX: number;
+    readonly sizeY: number;
+    readonly delta: Vector2;
+    readonly poolHalf: Vector2;
+    private rtA;
+    private rtB;
+    private scene;
+    private camera;
+    private quad;
+    private dropMat;
+    private updateMat;
+    private normalMat;
+    private clearedOnce;
+    constructor(opts?: HeightfieldOptions);
+    /**
+     * Read-only handle of the front-buffer (the one that holds the latest simulation
+     * state). Sample this texture from the surface and caustics shaders.
+     */
+    get currentTexture(): import("three").Texture;
+    /**
+     * Clear both ping-pong RTs to (0,0,0,0) on the first frame so neither buffer
+     * starts with garbage. Stability bug guard: skipping this gives the kernel
+     * uninitialized data and the wave amplitude blows up.
+     */
+    private ensureCleared;
+    /**
+     * One ping-pong step: draw the quad into the back buffer, then swap.
+     *
+     * Deliberately not a `withRenderTarget` pass — it touches no clear/tone-mapping
+     * state and unbinds to the default framebuffer rather than restoring whatever
+     * was bound. Callers run it from the water frame stage, where nothing is bound.
+     */
+    private renderPass;
+    /**
+     * Add a drop. Center is in pool-normalized [-1, 1] coordinates so the same
+     * call site works across pool sizes. `radius` is in WORLD METERS — see the
+     * MOD #A1 comment above DROP_FRAGMENT — so a 0.2 m drop has the same
+     * physical size on a 4×4 pool and a 2×10 pool. Strength is unitless
+     * (height delta applied at the drop centre).
+     */
+    addDrop(renderer: WebGLRenderer, center: Vector2, radius?: number, strength?: number): void;
+    /** Advance the wave simulation one substep. */
+    step(renderer: WebGLRenderer): void;
+    /**
+     * Per-substep damping coefficient applied to the velocity channel after
+     * each `step()`. With more substeps per second (e.g. when the host
+     * component auto-scales substep count for higher-resolution
+     * heightfields) this value must be closer to 1.0 to keep amplitude
+     * decay constant in real time. The host component computes this as
+     *   `damping = (perSecondDamping) ^ (1 / substepsPerSecond)`
+     * and pushes it every frame.
+     */
+    setDamping(value: number): void;
+    /** Recompute surface normals into channels (b, a). */
+    updateNormals(renderer: WebGLRenderer): void;
+    dispose(): void;
+}
+//# sourceMappingURL=Heightfield.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/Heightfield.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Heightfield.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/Heightfield.ts"],"names":[],"mappings":"AAoBA,OAAO,EAUL,OAAO,EACP,aAAa,EAEd,MAAM,OAAO,CAAC;AAqHf,MAAM,WAAW,kBAAkB;IACjC;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,qBAAa,WAAW;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B,OAAO,CAAC,GAAG,CAAoB;IAC/B,OAAO,CAAC,GAAG,CAAoB;IAC/B,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,IAAI,CAAO;IAEnB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,SAAS,CAAiB;IAClC,OAAO,CAAC,SAAS,CAAiB;IAElC,OAAO,CAAC,WAAW,CAAS;gBAEhB,IAAI,GAAE,kBAAuB;IA2EzC;;;OAGG;IACH,IAAI,cAAc,4BAEjB;IAED;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAYrB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAQlB;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,EAAE,aAAa,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,SAAM,EAAE,QAAQ,SAAO;IAS/E,+CAA+C;IAC/C,IAAI,CAAC,QAAQ,EAAE,aAAa;IAM5B;;;;;;;;OAQG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM;IAIxB,sDAAsD;IACtD,aAAa,CAAC,QAAQ,EAAE,aAAa;IAMrC,OAAO;CAQR"}

package/build/types/real-time-viewer-next/src/core/water/PoolHeightMap.d.ts

@@ -0,0 +1,36 @@
+import { Scene, Texture, Vector3, WebGLRenderer } from 'three';
+import type { Object3D } from 'three';
+export declare class PoolHeightMap {
+    private rt;
+    private overrideMaterial;
+    private camera;
+    private lastCenter;
+    private lastHalf;
+    private lastGeometryVersion;
+    private age;
+    constructor();
+    /** Output texture handle — stable reference across re-renders. */
+    get texture(): Texture;
+    /**
+     * Fit the top-down camera to the volume. The axis mapping must reproduce
+     * the read formula `uv = local.xz / (2 * poolHalf.xz) + 0.5`: with
+     * `up = (0, 0, -1)` camera-right is world +X, and the swapped
+     * `top`/`bottom` flip NDC y back to world +Z. Depth increases downward,
+     * so the topmost surface wins the depth test.
+     */
+    private updateCamera;
+    /**
+     * Re-render the height map when it is stale, otherwise do nothing.
+     * Call once per frame BEFORE `CausticsTexture.render` so the caustics
+     * pass never samples a blank first-frame target.
+     *
+     * @param volumeCenter World-space water-volume center (surface Y).
+     * @param poolHalf     (halfX, depth, halfZ) in world meters.
+     * @param geometryVersion Article + decor version sum — a change forces a render.
+     * @param excluded     Subtrees hidden for the pass (the water group).
+     * @returns true when a render actually happened.
+     */
+    renderIfNeeded(renderer: WebGLRenderer, scene: Scene, volumeCenter: Vector3, poolHalf: Vector3, geometryVersion: number, excluded: Array<Object3D | null>): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=PoolHeightMap.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/PoolHeightMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PoolHeightMap.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/PoolHeightMap.ts"],"names":[],"mappings":"AAgBA,OAAO,EAQL,KAAK,EAEL,OAAO,EACP,OAAO,EAEP,aAAa,EACd,MAAM,OAAO,CAAC;AACf,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,OAAO,CAAC;AA0DhD,qBAAa,aAAa;IACxB,OAAO,CAAC,EAAE,CAAoB;IAC9B,OAAO,CAAC,gBAAgB,CAAiB;IACzC,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,UAAU,CAA6C;IAC/D,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,mBAAmB,CAAM;IACjC,OAAO,CAAC,GAAG,CAA2B;;IA+BtC,kEAAkE;IAClE,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAepB;;;;;;;;;;OAUG;IACH,cAAc,CACZ,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,OAAO,EACrB,QAAQ,EAAE,OAAO,EACjB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,GAC/B,OAAO;IAqFV,OAAO,IAAI,IAAI;CAIhB"}

package/build/types/real-time-viewer-next/src/core/water/RefractionCapture.d.ts

@@ -0,0 +1,73 @@
+import { Box3, Matrix4, Vector3, Vector4 } from 'three';
+import type { Camera, Mesh, Scene, ShaderMaterial, Texture, WebGLRenderer } from 'three';
+export interface RefractionCaptureFrame {
+    renderer: WebGLRenderer;
+    scene: Scene;
+    camera: Camera;
+    /** Water surface material — receives the capture texture + resolution. */
+    material: ShaderMaterial;
+    /** Excluded from the pass so the water doesn't refract itself. */
+    surfaceMesh: Mesh | null;
+    /** World-space center of the water surface. */
+    volumeCenter: Vector3;
+    /** Pool half-extents in world meters: (halfX, depth, halfZ). */
+    poolHalf: Vector3;
+    /** R3F canvas size in CSS pixels. */
+    cssWidth: number;
+    cssHeight: number;
+    /** Bumped whenever the captured scene content changes. */
+    geometryVersion: number;
+    /** True while transforms mutate per frame without bumping a version. */
+    sceneMutating: boolean;
+}
+/**
+ * Capture-throttle decision. A reallocated target is blank, so it can't wait
+ * out an interval — the surface would sample the cleared texture and flash
+ * the refraction fallback colour.
+ */
+export declare function isCaptureDue(framesSinceCapture: number, dirty: boolean, targetResized: boolean): boolean;
+export declare class RefractionCapture {
+    private readonly capture;
+    /**
+     * Six planes installed on the renderer ONLY during the capture pass, so
+     * EVERY fragment outside the water volume — above water, below the pool
+     * floor, beside the pool — is discarded and the surface shader can detect
+     * the resulting alpha=0 pixels as capture misses.
+     *
+     * Three.js keeps a point P iff `dot(normal, P) + constant >= 0`, so every
+     * plane here points INWARD. Allocated once and mutated per frame;
+     * SceneCapture saves and restores `renderer.clippingPlanes` so they never
+     * leak into the main R3F render.
+     */
+    private readonly clipPlanes;
+    /**
+     * Frames since the last capture, and the state that capture was taken with.
+     * Together they answer "is the texture we already have still a correct
+     * picture of the scene?". Starts due so the first frame captures.
+     */
+    private framesSinceCapture;
+    private readonly capturedViewProj;
+    private readonly capturedBox;
+    private capturedGeometryVersion;
+    get texture(): Texture;
+    /**
+     * Publish the refraction uniforms and re-render the capture if it is stale
+     * and the water is on screen. Call once per frame from the water frame
+     * stage, after the heightfield/caustics passes and before the composite.
+     */
+    update(frame: RefractionCaptureFrame): void;
+    dispose(): void;
+}
+/** Element-wise matrix compare with a tolerance. */
+export declare function matricesApproxEqual(a: Matrix4, b: Matrix4, epsilon: number): boolean;
+/**
+ * Fit `box`'s screen-space extent into `out` (render-target pixels, GL
+ * bottom-left origin), padded by `marginUV` in each axis to cover the camera
+ * motion between two captures.
+ *
+ * Returns false when the box straddles the camera plane — a corner with
+ * w <= 0 projects to garbage, so the caller must fall back to capturing the
+ * full target rather than trusting a bogus rect.
+ */
+export declare function fitScissorToBox(box: Box3, viewProj: Matrix4, width: number, height: number, marginUV: number, out: Vector4): boolean;
+//# sourceMappingURL=RefractionCapture.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/RefractionCapture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefractionCapture.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/RefractionCapture.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,IAAI,EAAW,OAAO,EAAkB,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACjF,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAwEzF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,aAAa,CAAC;IACxB,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,QAAQ,EAAE,cAAc,CAAC;IACzB,kEAAkE;IAClE,WAAW,EAAE,IAAI,GAAG,IAAI,CAAC;IACzB,+CAA+C;IAC/C,YAAY,EAAE,OAAO,CAAC;IACtB,gEAAgE;IAChE,QAAQ,EAAE,OAAO,CAAC;IAClB,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAC;IACxB,wEAAwE;IACxE,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,kBAAkB,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,GAAG,OAAO,CAExG;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAE9C;;;;;;;;;;OAUG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAOzB;IAEF;;;;OAIG;IACH,OAAO,CAAC,kBAAkB,CAA+B;IACzD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAiB;IAClD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,uBAAuB,CAAM;IAErC,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,sBAAsB,GAAG,IAAI;IAiG3C,OAAO,IAAI,IAAI;CAGhB;AAED,oDAAoD;AACpD,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAOpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CA8BpI"}

package/build/types/real-time-viewer-next/src/core/water/RefractionCapture.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RefractionCapture.test.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/RefractionCapture.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RefractionCapture.test.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/RefractionCapture.test.ts"],"names":[],"mappings":""}

package/build/types/real-time-viewer-next/src/core/water/SceneCapture.d.ts

@@ -0,0 +1,66 @@
+import { Box3, RGBAFormat, Scene, Texture, WebGLRenderer } from 'three';
+import type { Camera, Object3D, Plane, Vector4 } from 'three';
+export interface SceneCaptureOptions {
+    /**
+     * Texture format. RGBA on the renderer's default linear working space — the
+     * capture is sampled back into a fragment shader that mixes it with other
+     * linear-space colours.
+     */
+    format?: typeof RGBAFormat;
+}
+export declare class SceneCapture {
+    private rt;
+    /** Drawing-buffer pixel width currently allocated for the RT. */
+    width: number;
+    /** Drawing-buffer pixel height currently allocated for the RT. */
+    height: number;
+    constructor(opts?: SceneCaptureOptions);
+    /**
+     * Output texture handle. Stable reference across frames — the
+     * WebGLRenderTarget keeps the same `.texture` even after we render into
+     * it, so consumers can assign this once and stop worrying about
+     * per-frame refreshes (unlike the heightfield ping-pong).
+     */
+    get texture(): Texture;
+    /**
+     * Resize the render target if `(w, h, pr, scale)` differs from the
+     * currently allocated extent. Pass DRAWING-BUFFER pixels (CSS pixels *
+     * pixelRatio). The host typically gets this from `useThree(s => s.size)`
+     * and `renderer.getPixelRatio()`.
+     *
+     * `resolutionScale` renders the capture BELOW the canvas resolution.
+     * Consumers sample it with a normalized UV, so a smaller target costs
+     * nothing but sharpness — and refraction is a blur, so half-res is
+     * effectively free while cutting fill and bandwidth by 4x.
+     *
+     * Returns true when the target was actually reallocated. Its contents
+     * are gone at that point, so a consumer that skips captures on idle
+     * frames must treat this as "must re-capture now".
+     */
+    resizeIfNeeded(cssWidth: number, cssHeight: number, pixelRatio: number, resolutionScale?: number): boolean;
+    /**
+     * Render `scene` to the offscreen target with `excluded` meshes
+     * temporarily hidden. Renderer state is taken over and put back via
+     * {@link withRenderTarget} so the main R3F render is undisturbed.
+     *
+     * `excluded` is typically `[surfaceMeshRef.current]` so the water
+     * surface excludes itself from the captured scene (otherwise we'd
+     * refract through the water and see... the same water).
+     *
+     * `scissor` (in RENDER-TARGET pixels, GL bottom-left origin) restricts
+     * the pass to the screen region the consumer can actually sample. The
+     * full target is still cleared first, so everything outside the rect
+     * stays at alpha 0 and reads as a miss — exactly like a clipped pixel.
+     *
+     * `cullBox` (world space) hides every Mesh whose world bounds miss the
+     * box for the duration of the pass. The clip planes already discard
+     * out-of-volume FRAGMENTS, but each mesh still costs a draw call and its
+     * full vertex work — for a pool inside a large scene this skips almost
+     * all of it. Caveat: an InstancedMesh is tested by its BASE geometry
+     * bounds, so instanced content meant to appear underwater would be
+     * over-culled (none exists today).
+     */
+    render(renderer: WebGLRenderer, scene: Scene, camera: Camera, excluded: Array<Object3D | null>, clippingPlanes?: Plane[], scissor?: Vector4 | null, cullBox?: Box3 | null): void;
+    dispose(): void;
+}
+//# sourceMappingURL=SceneCapture.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/SceneCapture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneCapture.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/SceneCapture.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,IAAI,EAA8C,UAAU,EAAE,KAAK,EAAE,OAAO,EAAqB,aAAa,EAAE,MAAM,OAAO,CAAC;AACvI,OAAO,KAAK,EAAE,MAAM,EAAQ,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAMpE,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,MAAM,CAAC,EAAE,OAAO,UAAU,CAAC;CAC5B;AAED,qBAAa,YAAY;IACvB,OAAO,CAAC,EAAE,CAAoB;IAC9B,iEAAiE;IACjE,KAAK,SAAK;IACV,kEAAkE;IAClE,MAAM,SAAK;gBAEC,IAAI,GAAE,mBAAwB;IA2B1C;;;;;OAKG;IACH,IAAI,OAAO,IAAI,OAAO,CAErB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,eAAe,SAAI,GAAG,OAAO;IAUrG;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,MAAM,CACJ,QAAQ,EAAE,aAAa,EACvB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAAC,EAChC,cAAc,CAAC,EAAE,KAAK,EAAE,EACxB,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,EACxB,OAAO,CAAC,EAAE,IAAI,GAAG,IAAI,GACpB,IAAI;IAsHP,OAAO,IAAI,IAAI;CAGhB"}

package/build/types/real-time-viewer-next/src/core/water/WaterSurface.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+/**
+ * The scene's water surface: scene basins are plain geometry, so the surface
+ * is placed standalone at `water.volume` (or the article-derived override).
+ * Mounted by `SceneRenderer` on `water.enabled`.
+ */
+export declare function WaterSurface(): React.JSX.Element;
+//# sourceMappingURL=WaterSurface.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/WaterSurface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaterSurface.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/WaterSurface.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAKvC;;;;GAIG;AACH,wBAAgB,YAAY,sBAsC3B"}

package/build/types/real-time-viewer-next/src/core/water/WaterSurfaceLazy.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+/**
+ * Starts the water chunk download. Called from `preloadLazySubsystems` as soon as the resolved
+ * config says water is coming — long before the mount — so the request overlaps the scene's
+ * GLB / HDR downloads and Suspense usually resolves on the first render.
+ */
+export declare function preloadWaterSurface(): void;
+/** `WaterSurface` behind its chunk boundary — same (prop-less) surface as the component itself. */
+export declare function WaterSurfaceLazy(): React.JSX.Element;
+//# sourceMappingURL=WaterSurfaceLazy.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/WaterSurfaceLazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaterSurfaceLazy.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/WaterSurfaceLazy.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAyB,MAAM,OAAO,CAAC;AAsB9C;;;;GAIG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAG1C;AAKD,mGAAmG;AACnG,wBAAgB,gBAAgB,sBAM/B"}

package/build/types/real-time-viewer-next/src/core/water/WaterSurfaceRenderer.d.ts

@@ -0,0 +1,71 @@
+import React from 'react';
+import { type CausticDebugMode } from './waterDebug';
+export interface WaterSurfaceRendererProps {
+    /** World-space center of the WATER SURFACE; the floor sits `volumeSize[1]` below it. */
+    position: [number, number, number];
+    /** AABB extent in world meters: [width, depth, length]. Depth is surface-to-floor. */
+    volumeSize: [number, number, number];
+    /** Sun direction in WORLD space (already normalized). */
+    sunDirection: [number, number, number];
+    /** Pool wall flat color — replaces the demo's `tiles` sampler. */
+    wallColor: string;
+    /** Sky horizon / zenith colors used by the procedural sky stub. */
+    skyHorizonColor: string;
+    skyZenithColor: string;
+    /**
+     * Heightfield resolution along the LONGER pool axis; the shorter axis gets
+     * fewer texels in proportion so wave propagation is isotropic in world space.
+     */
+    heightfieldSize: number;
+    /** Resolution of the caustic render target, per side. */
+    causticTextureSize: number;
+    /**
+     * Wave speed as **substeps at 60 fps** (the historical per-frame meaning, so
+     * existing tunings carry over); the sim converts it to a per-second rate.
+     *
+     * There is NO resolution compensation: world speed is
+     * `substeps × 60 × (2 × poolHalf.x / heightfieldSize)`, so a smaller
+     * heightfield means bigger cells and faster waves.
+     */
+    substeps: number;
+    /** Period (seconds) for ambient auto-drops. 0 disables them. */
+    ambientDropPeriod: number;
+    /** Multiplier on pointer-driven (hover + press) drop strength. */
+    pointerStrength: number;
+    /** Multiplier on the wave-normal contribution driving the caustic pattern. */
+    causticIntensity: number;
+    /** Water clarity / transparency (0–1). */
+    waterClarity: number;
+    /**
+     * True samples a per-frame scene capture for refracted colour (real geo
+     * through the water); false uses the demo's in-shader AABB raytrace and
+     * runs no capture pass at all.
+     */
+    useScreenSpaceRefraction: boolean;
+    /** Colour the surface shader falls back to on a capture miss. Hex string. */
+    refractionFallbackColor: string;
+    /** Grazing-angle reflection ceiling for the Schlick fresnel approximation. */
+    fresnelMax: number;
+    /** Debug visualization mode for the caustic receivers / surface shader. */
+    causticDebugMode: CausticDebugMode;
+}
+/**
+ * Drop the demo's self-contained pool world into the scene at the configured
+ * AABB. EVERY internal coordinate is in WORLD METERS in the pool's local
+ * frame (origin at the water-surface centre, +Y up):
+ *
+ *   xz ∈ [-poolHalf.x, +poolHalf.x] × [-poolHalf.z, +poolHalf.z]   (pool footprint)
+ *   y  ∈ [-poolHalf.y, +2 * poolHalf.y]                            (floor → sky ceiling)
+ *
+ * The parent `<group>` carries ONLY a `position` (no scale) so non-cubic pools
+ * don't introduce anisotropic stretching to the inside-the-pool view (wall
+ * caustics, etc.); the shaders get a `uPoolHalf` uniform so their internal
+ * math (intersectCube, caustic projection, wall detection, rim shadow) runs in
+ * the same world-meter frame.
+ *
+ * The above-water surface is rendered; the pool interior is ray-traced inside
+ * the surface shader. The underwater pass is intentionally skipped (the camera
+ * never goes below the water in the host scene).
+ */
+export declare function WaterSurfaceRenderer({ position, volumeSize, sunDirection, wallColor, skyHorizonColor, skyZenithColor, heightfieldSize, causticTextureSize, substeps, ambientDropPeriod, pointerStrength, causticIntensity, waterClarity, useScreenSpaceRefraction, refractionFallbackColor, fresnelMax, causticDebugMode, }: WaterSurfaceRendererProps): React.JSX.Element;
+//# sourceMappingURL=WaterSurfaceRenderer.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/WaterSurfaceRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WaterSurfaceRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/WaterSurfaceRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAS1D,OAAO,EAA2B,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAI9E,MAAM,WAAW,yBAAyB;IACxC,wFAAwF;IACxF,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,sFAAsF;IACtF,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,yDAAyD;IACzD,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;;;;OAOG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,gEAAgE;IAChE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kEAAkE;IAClE,eAAe,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,gBAAgB,EAAE,MAAM,CAAC;IACzB,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,wBAAwB,EAAE,OAAO,CAAC;IAClC,6EAA6E;IAC7E,uBAAuB,EAAE,MAAM,CAAC;IAChC,8EAA8E;IAC9E,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,gBAAgB,EAAE,gBAAgB,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACR,UAAU,EACV,YAAY,EACZ,SAAS,EACT,eAAe,EACf,cAAc,EACd,eAAe,EACf,kBAAkB,EAClB,QAAQ,EACR,iBAAiB,EACjB,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,wBAAwB,EACxB,uBAAuB,EACvB,UAAU,EACV,gBAAgB,GACjB,EAAE,yBAAyB,qBAwN3B"}

package/build/types/real-time-viewer-next/src/core/water/useCausticReceivers.d.ts

@@ -0,0 +1,11 @@
+import { type Object3D } from 'three';
+/**
+ * Swap every standard-like material under `root` for a caustic-receiver
+ * clone and keep the clones' uniforms current each frame.
+ *
+ * @param root    Subtree to patch. Re-patched whenever the reference changes.
+ * @param enabled When false the subtree keeps its original materials, so a
+ *                scene without water pays nothing.
+ */
+export declare function useCausticReceivers(root: Object3D | null | undefined, enabled: boolean): void;
+//# sourceMappingURL=useCausticReceivers.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/useCausticReceivers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCausticReceivers.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/useCausticReceivers.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAkD,KAAK,QAAQ,EAAE,MAAM,OAAO,CAAC;AAetF;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CA4D7F"}

package/build/types/real-time-viewer-next/src/core/water/useWaterPointer.d.ts

@@ -0,0 +1,13 @@
+import { Vector2 } from 'three';
+import type { ThreeEvent } from '@react-three/fiber';
+export interface WaterPointerHandlers {
+    onPointerMove(event: ThreeEvent<PointerEvent>): void;
+    onPointerDown(event: ThreeEvent<PointerEvent>): void;
+}
+/**
+ * `queueDrop` receives pool-normalized `[-1, +1]` centers. The raycast plane
+ * is rotated -π/2 about X, so its local +Y aligns with world -Z: the v
+ * coordinate is flipped to put the drop under the cursor.
+ */
+export declare function useWaterPointer(queueDrop: (center: Vector2, radius: number, strength: number) => void, pointerStrength: number): WaterPointerHandlers;
+//# sourceMappingURL=useWaterPointer.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/useWaterPointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWaterPointer.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/useWaterPointer.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAiBrD,MAAM,WAAW,oBAAoB;IACnC,aAAa,CAAC,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;IACrD,aAAa,CAAC,KAAK,EAAE,UAAU,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC;CACtD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,IAAI,EACtE,eAAe,EAAE,MAAM,GACtB,oBAAoB,CAoBtB"}

package/build/types/real-time-viewer-next/src/core/water/useWaveSimulation.d.ts

@@ -0,0 +1,44 @@
+import { Vector2, Vector3 } from 'three';
+import type { Texture } from 'three';
+/**
+ * Fractional fixed-step accumulator. `take` turns a frame delta into a whole
+ * number of substeps at the requested per-second rate and carries the
+ * remainder, so the rate is exact on average and wave speed is INDEPENDENT
+ * of rendered fps — a 30 fps frame runs twice the substeps of a 60 fps one.
+ */
+export declare class SubstepAccumulator {
+    private leftover;
+    take(substepsPerSecond: number, delta: number): number;
+    reset(): void;
+}
+export interface WaveSimulationOptions {
+    /** Pool half-extents in world meters: (halfX, depth, halfZ). */
+    poolHalf: Vector3;
+    /** Heightfield texel count along the LONGER pool axis. */
+    heightfieldSize: number;
+    /** Caustic render-target resolution per side. */
+    causticTextureSize: number;
+    /** Substeps per frame at 60 fps, converted here to a per-second rate. */
+    substeps: number;
+    /** Seconds between ambient auto-drops; 0 disables them. */
+    ambientDropPeriod: number;
+}
+export interface WaveSimulation {
+    /** Queue a disturbance, flushed into the heightfield on the next `advance`. */
+    queueDrop(center: Vector2, radius: number, strength: number): void;
+    /**
+     * Run this frame's drops, the fixed-step wave integration and the normal
+     * pass. Returns false while the GPU resources are being (re)built — the
+     * caller must skip the rest of its water frame then.
+     */
+    advance(delta: number): boolean;
+    /** Bind the receiving-geometry height map consumed by the caustic pass. */
+    setHeightMap(texture: Texture | null): void;
+    /** Render the caustic pattern for this frame's waves and light direction. */
+    renderCaustics(light: Vector3, intensity: number): void;
+    /** Heightfield front buffer — a DIFFERENT texture most frames (ping-pong). */
+    readonly heightTexture: Texture | null;
+    readonly causticTexture: Texture | null;
+}
+export declare function useWaveSimulation({ poolHalf, heightfieldSize, causticTextureSize, substeps, ambientDropPeriod, }: WaveSimulationOptions): WaveSimulation;
+//# sourceMappingURL=useWaveSimulation.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/useWaveSimulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWaveSimulation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/useWaveSimulation.ts"],"names":[],"mappings":"AAYA,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AA+BrC;;;;;GAKG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAK;IAErB,IAAI,CAAC,iBAAiB,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM;IAOtD,KAAK,IAAI,IAAI;CAGd;AAED,MAAM,WAAW,qBAAqB;IACpC,gEAAgE;IAChE,QAAQ,EAAE,OAAO,CAAC;IAClB,0DAA0D;IAC1D,eAAe,EAAE,MAAM,CAAC;IACxB,iDAAiD;IACjD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACnE;;;;OAIG;IACH,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,2EAA2E;IAC3E,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,IAAI,CAAC;IAC5C,6EAA6E;IAC7E,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACxD,8EAA8E;IAC9E,QAAQ,CAAC,aAAa,EAAE,OAAO,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,cAAc,EAAE,OAAO,GAAG,IAAI,CAAC;CACzC;AAED,wBAAgB,iBAAiB,CAAC,EAChC,QAAQ,EACR,eAAe,EACf,kBAAkB,EAClB,QAAQ,EACR,iBAAiB,GAClB,EAAE,qBAAqB,GAAG,cAAc,CAgIxC"}

package/build/types/real-time-viewer-next/src/core/water/useWaveSimulation.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useWaveSimulation.test.d.ts.map

package/build/types/real-time-viewer-next/src/core/water/useWaveSimulation.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWaveSimulation.test.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/useWaveSimulation.test.ts"],"names":[],"mappings":""}

package/build/types/real-time-viewer-next/src/core/water/water.config.d.ts

@@ -0,0 +1,90 @@
+import { type ConfigInput, type ConfigResolved } from '../../config/descriptor';
+/**
+ * Water subsystem config — the single source for its types, defaults, clamps, round-trip and
+ * analyzer inputs (see `config/descriptor.ts`).
+ *
+ * The implementation is a verbatim port of evanw/webgl-water: the demo's pool (5-face cube +
+ * surface + caustics) dropped into an AABB at `volume`. All GLSL runs in pool-normalized `[-1, 1]`
+ * space; the volume size/center define the world-meter mapping.
+ */
+export declare const WATER_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    /** Mounts the standalone `<WaterSurface>` over `volume`. */
+    enabled: import("../../config/descriptor").BooleanField;
+    /**
+     * Pool AABB. `center` is the world position of the WATER SURFACE center (the demo's normalized
+     * origin); `size` is `[width, depth, length]` in metres — depth runs from the surface down to
+     * the floor.
+     */
+    volume: import("../../config/descriptor").GroupDescriptor<{
+        center: import("../../config/descriptor").TupleField<[number, number, number]>;
+        size: import("../../config/descriptor").TupleField<[number, number, number]>;
+    }>;
+    /** Pool wall flat color — replaces the demo's tile texture (`uWallColor`). */
+    wallColor: import("../../config/descriptor").ColorField;
+    /** Procedural sky colors sampled by the surface's upward reflection branch. */
+    skyHorizonColor: import("../../config/descriptor").ColorField;
+    skyZenithColor: import("../../config/descriptor").ColorField;
+    /** Seconds between ambient auto-drops on the heightfield; `0` = no ambient drops (pointer still works). */
+    ambientDropPeriod: import("../../config/descriptor").NumberField;
+    /** Multiplier on pointer-driven drops (hover and click); the demo's tuned strengths are baked in. */
+    pointerStrength: import("../../config/descriptor").NumberField;
+    /**
+     * Heightfield simulation texture size per side (`size²` pixels per pass × 3 passes per frame).
+     * Wave speed in world metres per second is resolution-independent; only wave sharpness changes.
+     * Discrete options because every change recreates the render targets.
+     */
+    heightfieldSize: import("../../config/descriptor").NumberField;
+    /**
+     * Caustic texture size per side — the OUTPUT texture holding the broken-sunlight pattern.
+     * Independent of `heightfieldSize`: the source-side plane subdivision stays constant.
+     */
+    causticTextureSize: import("../../config/descriptor").NumberField;
+    /**
+     * Multiplier on the wave-normal contribution driving the caustic pattern (the demo's hard-coded
+     * `info.ba *= 0.5`). Lower mutes residual-ripple noise; `0` turns caustics off.
+     */
+    causticIntensity: import("../../config/descriptor").NumberField;
+    /** Wave-speed multiplier; `2` ≈ 4 s to cross a 4 m pool, `~4` matches the demo's pace. */
+    waveSpeed: import("../../config/descriptor").NumberField;
+    /**
+     * 0 = deep blue-green pool (strong Fresnel, tint, depth darkening); 1 = crystal clear. Also
+     * drives the fresnel floor and the underwater AO divide in `getWallColor`.
+     */
+    waterClarity: import("../../config/descriptor").NumberField;
+    /**
+     * Master switch for the caustic-receiver patch: every scene mesh gets its material cloned and
+     * patched to receive the caustic pattern (geo outside the pool AABB is masked to zero by the
+     * shader). Off restores the original materials — a cheap A/B of the cost.
+     */
+    causticReceivers: import("../../config/descriptor").BooleanField;
+    /**
+     * Caustic-receiver visualization: `overlay` adds strong magenta on top of the PBR result,
+     * `isolate` shows only the caustic pattern, `mask` paints R/G/B diagnostics (inside AABB / below
+     * water / caustic hit); `landing` / `heightmap` paint on the water surface (SSR mode).
+     */
+    causticDebugMode: import("../../config/descriptor").EnumField<"off" | "mask" | "overlay" | "isolate" | "landing" | "heightmap">;
+    /**
+     * Dedicated caustic-light direction (degrees, same convention as `lighting.sun`). `false`
+     * follows `lighting.sun`; override when the scene sun cannot drive usable caustics (grazing
+     * sunset disc) or to steer the underwater rim shadow independently.
+     */
+    causticSun: import("../../config/descriptor").ToggleDescriptor<{
+        azimuth: import("../../config/descriptor").NumberField;
+        elevation: import("../../config/descriptor").NumberField;
+    }>;
+    /**
+     * `false` uses the demo's in-shader AABB raytrace (stable, no black wave crests); `true` samples
+     * a per-frame SceneCapture texture so real pool geo shows through.
+     */
+    useScreenSpaceRefraction: import("../../config/descriptor").BooleanField;
+    /**
+     * Fill color where the SSR sample lands on a clipped/empty capture pixel — without it those
+     * fragments render pure black (`0 * waterColor`).
+     */
+    refractionFallbackColor: import("../../config/descriptor").ColorField;
+    /** Grazing-angle ceiling of the Schlick fresnel curve; `1` is physical, lower softens crest highlights. */
+    fresnelMax: import("../../config/descriptor").NumberField;
+}>;
+export type WaterConfig = ConfigInput<typeof WATER_CONFIG>;
+export type ResolvedWaterConfig = ConfigResolved<typeof WATER_CONFIG>;
+//# sourceMappingURL=water.config.d.ts.map