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

package/build/types/real-time-viewer-next/src/core/shadows/SunShadow.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import type { ResolvedEnvironmentConfig } from '../../types/environment';
+interface SunShadowProps {
+    cfg: ResolvedEnvironmentConfig['shadows'];
+    sun: ResolvedEnvironmentConfig['lighting']['sun'];
+    /** Scene radius from `sceneMetrics.radius`; ortho frustum = radius * fitMultiplier. */
+    sceneRadius: number;
+    /** Scene center from `sceneMetrics.center` so the shadow camera frames the scene. */
+    sceneCenter: [number, number, number];
+    /**
+     * When false, the directional light still renders (preserves existing
+     * lighting behavior) but does not cast shadows. Shadow-related state is
+     * still configured so flipping this to true at runtime works without a
+     * remount.
+     */
+    castShadow: boolean;
+}
+/**
+ * The single shadow path: one directional light driven by `lighting.sun` that
+ * renders one PCFSoft shadow map. Every mesh marked `castShadow=true` casts
+ * into it; every mesh marked `receiveShadow=true` reads from it. No layer
+ * filtering, no extra catcher plane — shadows fall on real scene geometry.
+ *
+ * Per-light gating (`shadow.autoUpdate=false`) means the shadow map only
+ * renders on a `shadowsVersion` bump, not every frame.
+ */
+export declare function SunShadow({ cfg, sun, sceneRadius, sceneCenter, castShadow }: SunShadowProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=SunShadow.d.ts.map

package/build/types/real-time-viewer-next/src/core/shadows/SunShadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SunShadow.d.ts","sourceRoot":"","sources":["../../../../../../src/core/shadows/SunShadow.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqC,MAAM,OAAO,CAAC;AAG1D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAMzE,UAAU,cAAc;IACtB,GAAG,EAAE,yBAAyB,CAAC,SAAS,CAAC,CAAC;IAC1C,GAAG,EAAE,yBAAyB,CAAC,UAAU,CAAC,CAAC,KAAK,CAAC,CAAC;IAClD,uFAAuF;IACvF,WAAW,EAAE,MAAM,CAAC;IACpB,qFAAqF;IACrF,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC;;;;;OAKG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAYD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE,cAAc,qBA2G3F"}

package/build/types/real-time-viewer-next/src/core/shadows/index.d.ts

@@ -0,0 +1,4 @@
+export { SceneShadowSystem } from './SceneShadowSystem';
+export { resolveShadowFlags, type ShadowElementKind, } from './shadowRegistry';
+export { useShadowFlags } from './useShadowFlags';
+//# sourceMappingURL=index.d.ts.map

package/build/types/real-time-viewer-next/src/core/shadows/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/core/shadows/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EACL,kBAAkB,EAClB,KAAK,iBAAiB,GACvB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC"}

package/build/types/real-time-viewer-next/src/core/shadows/shadowMapSize.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Sun shadow texel-density stabilisation. The ortho shadow frustum is fit to the scene
+ * (`size = sceneRadius * fitMultiplier`) and grows as elements are added; with a fixed `mapSize` that
+ * spreads fewer texels per world unit each time, so self/contact shadows wash out and elements read
+ * brighter. Scaling the map size with the frustum keeps density ~constant.
+ *
+ * Pure math, kept out of `SunShadow.tsx` so it is testable without pulling in the store / R3F.
+ */
+/**
+ * Map size that holds texel density constant as the frustum grows:
+ * `density = mapSize / REFERENCE_FRUSTUM_WIDTH`, then the result is `frustumWidth * density` clamped
+ * to `[mapSize, maxMapSize]`. Rounded to an even int (NPOT shadow render targets are fine in WebGL2;
+ * an even size avoids half-texel seams).
+ *
+ * Past a few times the reference width the growth term saturates, so on a large scene it is
+ * `maxMapSize` — not `mapSize` — that sets the allocation. `maxMapSize` is the hard ceiling and wins
+ * over `mapSize` when the two disagree.
+ */
+export declare function densityStableMapSize(mapSize: number, maxMapSize: number, frustumWidth: number): number;
+//# sourceMappingURL=shadowMapSize.d.ts.map

package/build/types/real-time-viewer-next/src/core/shadows/shadowMapSize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowMapSize.d.ts","sourceRoot":"","sources":["../../../../../../src/core/shadows/shadowMapSize.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAKH;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAKtG"}

package/build/types/real-time-viewer-next/src/core/shadows/shadowMapSize.test.d.ts

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

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

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

package/build/types/real-time-viewer-next/src/core/shadows/shadowRegistry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Element kind — drives the cast/receive matrix.
+ *
+ * - `sceneGeo`  — HQRenderScript scene tree GLBs (the user's product).
+ * - `water`     — water plane (`ShaderMaterial`; honors neither cast nor receive).
+ * - `none`      — explicitly opt-out (guides, dimensions, sky, grid, etc.).
+ */
+export type ShadowElementKind = 'sceneGeo' | 'water' | 'none';
+/**
+ * Resolve effective cast/receive booleans from runtime config, gated by
+ * capabilities. Pure helper — no React, no traversal.
+ */
+export declare function resolveShadowFlags(kind: ShadowElementKind, config: {
+    casters: {
+        sceneGeo: boolean;
+    };
+    receivers: {
+        sceneGeo: boolean;
+    };
+}): {
+    castShadow: boolean;
+    receiveShadow: boolean;
+};
+//# sourceMappingURL=shadowRegistry.d.ts.map

package/build/types/real-time-viewer-next/src/core/shadows/shadowRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shadowRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/shadows/shadowRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,OAAO,GAAG,MAAM,CAAC;AAyB9D;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,MAAM,EAAE;IACN,OAAO,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IAC/B,SAAS,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;CAClC,GACA;IAAE,UAAU,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAA;CAAE,CAsBjD"}

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

@@ -0,0 +1,75 @@
+import { type ConfigInput, type ConfigResolved } from '../../config/descriptor';
+/**
+ * Shadow subsystem config — the single source for its types, defaults, clamps, round-trip and
+ * analyzer inputs (see `config/descriptor.ts`).
+ *
+ * A single realtime `DirectionalLight` driven by `lighting.sun` renders one PCFSoft shadow map.
+ * Bake-on-demand: `light.shadow.autoUpdate = false` and the store's `shadowsVersion`
+ * (`markShadowsDirty`) flips `needsUpdate = true`, so the shadow only re-renders when the scene
+ * actually changes — not on camera motion. Cast/receive flags are owned by
+ * `core/shadows/shadowRegistry.ts` keyed by element kind; shadows fall onto whatever scene meshes
+ * have `receiveShadow = true` (no transparent catcher plane is mounted).
+ */
+export declare const SHADOWS_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    enabled: import("../../config/descriptor").BooleanField;
+    /** PCFSoft shadow map resolution (square), at the reference frustum width. */
+    mapSize: import("../../config/descriptor").NumberField;
+    /**
+     * Ceiling on the density-stabilised map size (see `SunShadow.densityStableMapSize`). The
+     * effective map size GROWS with the shadow frustum to hold texel density constant, so on any
+     * scene bigger than the reference frustum it is this value — not `mapSize` — that decides the
+     * allocation. A 4096² PCFSoft map costs ~134 MB of GPU memory; lower it on mobile tiers.
+     */
+    maxMapSize: import("../../config/descriptor").NumberField;
+    /** PCF blur radius (`light.shadow.radius`). */
+    radius: import("../../config/descriptor").NumberField;
+    /** Bias to combat acne. */
+    bias: import("../../config/descriptor").NumberField;
+    /** Normal bias to combat peter-panning. */
+    normalBias: import("../../config/descriptor").NumberField;
+    /** Multiplier on `sceneMetrics.radius` for the ortho shadow camera frustum. */
+    fitMultiplier: import("../../config/descriptor").NumberField;
+    /**
+     * Per-element-kind cast toggles. `true` means meshes of that kind contribute to the shadow map;
+     * `false` means they are silent. Capability-gated by `SHADOW_CAPABILITIES` in
+     * `shadowRegistry.ts` (e.g. water can never cast).
+     */
+    casters: import("../../config/descriptor").GroupDescriptor<{
+        sceneGeo: import("../../config/descriptor").BooleanField;
+    }>;
+    /** Per-element-kind receive toggles. Capability-gated identically. */
+    receivers: import("../../config/descriptor").GroupDescriptor<{
+        sceneGeo: import("../../config/descriptor").BooleanField;
+    }>;
+    /**
+     * Per-light shadow casting toggles. Each enabled light allocates its own shadow map render
+     * target and re-bakes when relevant scene state changes. Sun is the cheapest (single ortho
+     * camera, bake-on-demand); the key spotlight adds another shadow pass on top, so leave it off
+     * unless you actually want multi-source shadowing.
+     *
+     * Master `shadows.enabled` and 2D view mode override these toggles — shadows are forced off when
+     * either is set.
+     */
+    lights: import("../../config/descriptor").GroupDescriptor<{
+        sun: import("../../config/descriptor").BooleanField;
+        key: import("../../config/descriptor").BooleanField;
+    }>;
+    /**
+     * Contact-hardening soft shadows (PCSS). Unlike the uniform `radius` blur, the penumbra widens
+     * with distance from the occluder — sharp where the object meets the floor, blurrier the farther
+     * the shadow is cast. Implemented via drei's `<SoftShadows>`, a global shadow-sampling shader
+     * patch (affects every shadow; forces a one-time recompile when toggled).
+     */
+    soft: import("../../config/descriptor").GroupDescriptor<{
+        enabled: import("../../config/descriptor").BooleanField;
+        /** Light "size" — larger = softer and faster penumbra growth with distance. */
+        size: import("../../config/descriptor").NumberField;
+        /** Depth that stays sharp. `0` = crisp right at the contact point. */
+        focus: import("../../config/descriptor").NumberField;
+        /** Blocker-search/PCF sample count. Higher = smoother but heavier. */
+        samples: import("../../config/descriptor").NumberField;
+    }>;
+}>;
+export type ShadowsConfig = ConfigInput<typeof SHADOWS_CONFIG>;
+export type ResolvedShadowsConfig = ConfigResolved<typeof SHADOWS_CONFIG>;
+//# sourceMappingURL=shadows.config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shadows.config.d.ts","sourceRoot":"","sources":["../../../../../../src/core/shadows/shadows.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEvF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc;;IAKzB,8EAA8E;;IAK9E;;;;;OAKG;;IAEH,+CAA+C;;IAQ/C,2BAA2B;;IAQ3B,2CAA2C;;IAQ3C,+EAA+E;;IAQ/E;;;;OAIG;;;;IAIH,sEAAsE;;;;IAItE;;;;;;;;OAQG;;;;;IAKH;;;;;OAKG;;;QAMD,+EAA+E;;QAQ/E,sEAAsE;;QAQtE,sEAAsE;;;EASxE,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC;AAC/D,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC,OAAO,cAAc,CAAC,CAAC"}

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

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

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

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

package/build/types/real-time-viewer-next/src/core/shadows/useShadowDirty.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Store facts that invalidate the shadow map → `markShadowsDirty`.
+ *
+ * This is the producer side of the single shadow-dirty channel
+ * (`shadowsVersion`); the casting lights consume it and re-bake once per bump.
+ * Light-local inputs (frustum fit, map size, aim) are marked by the light
+ * components themselves where they apply them.
+ *
+ * Camera motion is intentionally NOT a trigger — that's the perf win of the
+ * bake-on-demand approach: the user can orbit freely with zero cost beyond
+ * the normal forward render.
+ */
+export declare function useShadowDirty(): void;
+//# sourceMappingURL=useShadowDirty.d.ts.map

package/build/types/real-time-viewer-next/src/core/shadows/useShadowDirty.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useShadowDirty.d.ts","sourceRoot":"","sources":["../../../../../../src/core/shadows/useShadowDirty.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAyCrC"}

package/build/types/real-time-viewer-next/src/core/shadows/useShadowFlags.d.ts

@@ -0,0 +1,28 @@
+import type { Object3D } from 'three';
+import { type ShadowElementKind } from './shadowRegistry';
+type Object3DRef = {
+    readonly current: Object3D | null;
+};
+type ShadowFlagsTarget = Object3D | Object3DRef | null | undefined;
+/**
+ * Reactively keep `castShadow` / `receiveShadow` flags on a mesh subtree
+ * in sync with the live `shadows.casters` / `shadows.receivers` config.
+ *
+ * Walks the subtree once on mount and again whenever the relevant config
+ * slice changes. Capability-gated: a kind that physically can't cast or
+ * receive (e.g. water cast) will not flip flags on
+ * regardless of the config value.
+ *
+ * Accepts either a stable `Object3D` (e.g. a `useMemo`'d cloned scene) or
+ * a ref-shaped object (`useRef<Object3D>`). When given a ref, the hook
+ * reads `ref.current` lazily inside its effect — that means r3f-attached
+ * meshes work correctly even though `ref.current` is null at render time.
+ *
+ * The hook does NOT itself mark the sun shadow dirty — that's owned by
+ * `useShadowDirty`, which subscribes to the same config slice. Both react
+ * independently to the same change, which keeps the bake correctly aligned
+ * with the new flags on the very next render.
+ */
+export declare function useShadowFlags(target: ShadowFlagsTarget, kind: ShadowElementKind): void;
+export {};
+//# sourceMappingURL=useShadowFlags.d.ts.map

package/build/types/real-time-viewer-next/src/core/shadows/useShadowFlags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useShadowFlags.d.ts","sourceRoot":"","sources":["../../../../../../src/core/shadows/useShadowFlags.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAkB,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtD,OAAO,EAAsB,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAE9E,KAAK,WAAW,GAAG;IAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI,CAAA;CAAE,CAAC;AACzD,KAAK,iBAAiB,GAAG,QAAQ,GAAG,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;AAUnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,iBAAiB,EAAE,IAAI,EAAE,iBAAiB,GAAG,IAAI,CA0CvF"}

package/build/types/real-time-viewer-next/src/core/shadows/useShadowRebake.d.ts

@@ -0,0 +1,14 @@
+import { type RefObject } from 'react';
+import type { DirectionalLight, SpotLight } from 'three';
+/**
+ * Consumer side of the shadow-dirty channel: re-bake `light`'s shadow map once
+ * per `shadowsVersion` bump. Three renders the map on the next frame and clears
+ * the flags again.
+ *
+ * Both flags are needed: drei's `<BakeShadows>` (from `adaptive.bakeShadows`)
+ * sets `gl.shadowMap.autoUpdate = false`, and three skips the whole shadow pass
+ * while the GLOBAL `needsUpdate` is false — before it ever checks the per-light
+ * flag. `invalidate()` makes the bake happen under a `demand` frameloop too.
+ */
+export declare function useShadowRebake(lightRef: RefObject<DirectionalLight | SpotLight | null>, enabled?: boolean): void;
+//# sourceMappingURL=useShadowRebake.d.ts.map

package/build/types/real-time-viewer-next/src/core/shadows/useShadowRebake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useShadowRebake.d.ts","sourceRoot":"","sources":["../../../../../../src/core/shadows/useShadowRebake.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAElD,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGzD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,SAAS,CAAC,gBAAgB,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,OAAO,UAAO,GAAG,IAAI,CAW9G"}

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

@@ -0,0 +1,37 @@
+/**
+ * Single source of truth for the R3F render loop, handling both tab/window
+ * visibility (pause when invisible) and the profile's `maxFps` cap.
+ *
+ * Visibility toggles `frameloop` between the env-resolved value and `'never'`
+ * on tab hide / window blur.
+ *
+ * The FPS cap is gated at the renderer level, not via `frameloop` — we wrap
+ * `gl.render` and throttle only the final present:
+ *
+ *   - Off-screen renders (`gl.getRenderTarget() !== null`: water FFT,
+ *     reflection/refraction captures, composer intermediate passes)
+ *     always pass through, so GPU sims don't freeze at the cap rate.
+ *   - Default-framebuffer renders (`=== null`) are the actual screen present
+ *     and are the only ones gated by `now - lastPresentedAt >= intervalMs`.
+ *
+ * `useFrame` keeps running at full display rate so `delta` stays small and
+ * sims integrate correctly; only screen presents are clamped. (R3F v10's
+ * native `useFrame(cb, { fps })` would replace this once we upgrade.)
+ *
+ * Must run INSIDE `<Canvas>` — `<Canvas frameloop>` is constructor-only;
+ * `state.setFrameloop()` is the only runtime path. Active captures keep
+ * rendering so in-flight screenshots finish even if the user looks away.
+ *
+ * Visibility detection: `visibilitychange` for tab show/hide, `window.blur`/
+ * `focus` for window focus (unreliable on macOS Cmd+Tab), plus a 1 Hz
+ * `document.hasFocus()` poll as a backup. `window.blur` doesn't fire when a
+ * child element (Leva panel) takes focus, so UI interaction won't pause the
+ * canvas.
+ */
+export declare function useFrameloopVisibility(): void;
+/**
+ * Thin component wrapper that calls {@link useFrameloopVisibility}.
+ * Mount it as a child of `<Canvas>`.
+ */
+export declare function FrameloopVisibilityController(): null;
+//# sourceMappingURL=useFrameloopVisibility.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useFrameloopVisibility.d.ts","sourceRoot":"","sources":["../../../../../src/core/useFrameloopVisibility.tsx"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,sBAAsB,SAiKrC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,SAG5C"}

package/build/types/real-time-viewer-next/src/core/view2d/DockingPoints2D.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import type { RTVElement2D } from '../../types/scene2d';
+interface DockingPoints2DProps {
+    element: RTVElement2D;
+}
+/**
+ * Accessory docking-point buttons for the 2D viewer. Renders one button per `element.dockingButtons`
+ * (AVO/AVU/AVC/…), anchored at the docking point's local position inside the element's rotated group,
+ * so it tracks the element's rotation for free. A free point attaches an accessory (click →
+ * `onDockingPointInteraction` selects the DP and filters the palette); an occupied point removes the
+ * attached accessory.
+ *
+ * Shown only in 2D planner mode.
+ */
+export declare function DockingPoints2D({ element }: DockingPoints2DProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=DockingPoints2D.d.ts.map

package/build/types/real-time-viewer-next/src/core/view2d/DockingPoints2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DockingPoints2D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/view2d/DockingPoints2D.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,OAAO,CAAC;AAI1B,OAAO,KAAK,EAAc,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGpE,UAAU,oBAAoB;IAC5B,OAAO,EAAE,YAAY,CAAC;CACvB;AAKD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,EAAE,OAAO,EAAE,EAAE,oBAAoB,4BAiDhE"}

package/build/types/real-time-viewer-next/src/core/view2d/Element2DPlane.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { RTVElement2D } from '../../types/scene2d';
+interface Element2DPlaneProps {
+    element: RTVElement2D;
+    /** Dense rank among ALL rendered planes, ordered by (zLayer, elementId) (0 = bottom). See {@link STACK_Y_STEP}. */
+    stackRank?: number;
+}
+/**
+ * One planner element in the 2D view: the element's SVG rasterised to a `CanvasTexture` on a plane,
+ * placed in the element's rotated frame and lifted by `stackRank` so overlapping
+ * elements stay depth-sorted. Carries the 2D interaction surface — click to select, drag to move
+ * (including docked-group follow and the live auto-dock snap preview) — plus the selection badge,
+ * catalog side annotations and the accessory docking-point buttons. Falls back to a labelled
+ * placeholder texture when the element has no SVG or the SVG fails to load.
+ */
+export declare function Element2DPlane({ element, stackRank }: Element2DPlaneProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=Element2DPlane.d.ts.map

package/build/types/real-time-viewer-next/src/core/view2d/Element2DPlane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Element2DPlane.d.ts","sourceRoot":"","sources":["../../../../../../src/core/view2d/Element2DPlane.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4D,MAAM,OAAO,CAAC;AAIjF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAUxD,UAAU,mBAAmB;IAC3B,OAAO,EAAE,YAAY,CAAC;IACtB,mHAAmH;IACnH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA6HD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,EAAE,OAAO,EAAE,SAAa,EAAE,EAAE,mBAAmB,4BAqM7E"}

package/build/types/real-time-viewer-next/src/core/view2d/ElementAnnotation2D.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { ElementAnnotation } from '../../types/scene2d';
+interface ElementAnnotation2DProps {
+    annotation: ElementAnnotation;
+    /** Element footprint in meters (local frame: width along x, depth along z). */
+    widthM: number;
+    depthM: number;
+}
+/**
+ * Free text along one side of a 2D element (e.g. "Frontwand: hochklappbar 18,5 cm").
+ * Rendered inside the element's rotated group at the plane centre, so it tracks position
+ * and rotation. Local sides: left = -x, right = +x, top = -z (screen-up in 2D), bottom = +z.
+ */
+export declare function ElementAnnotation2D({ annotation, widthM, depthM }: ElementAnnotation2DProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=ElementAnnotation2D.d.ts.map

package/build/types/real-time-viewer-next/src/core/view2d/ElementAnnotation2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElementAnnotation2D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/view2d/ElementAnnotation2D.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkC,MAAM,OAAO,CAAC;AAOvD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAqB7D,UAAU,wBAAwB;IAChC,UAAU,EAAE,iBAAiB,CAAC;IAC9B,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,wBAAwB,qBA4D3F"}

package/build/types/real-time-viewer-next/src/core/view2d/Scene2DOverlay.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+/**
+ * The 2D plan overlay: one {@link Element2DPlane} per scene2d element, mounted only while the store
+ * is in 2D mode. Elements with unresolved geometry are dropped (see `isRenderable2DElement`) and the
+ * skipped count is logged once, so a broken article degrades to "not shown" instead of a NaN plane.
+ * Planes are ranked by (zLayer, elementId) so `Element2DPlane` can lift each onto its own slot, which
+ * keeps blending and pointer picking resolving top-first and avoids z-fighting.
+ */
+export declare function Scene2DOverlay(): React.JSX.Element | null;
+//# sourceMappingURL=Scene2DOverlay.d.ts.map

package/build/types/real-time-viewer-next/src/core/view2d/Scene2DOverlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Scene2DOverlay.d.ts","sourceRoot":"","sources":["../../../../../../src/core/view2d/Scene2DOverlay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6B,MAAM,OAAO,CAAC;AAQlD;;;;;;GAMG;AACH,wBAAgB,cAAc,6BAmC7B"}

package/build/types/real-time-viewer-next/src/core/viewMode/ViewModeRuntimeContext.d.ts

@@ -0,0 +1,20 @@
+import React from 'react';
+import type { ViewModeRuntime } from './types';
+/**
+ * Provider that subscribes to the slim subset of store state used by the
+ * runtime selector and produces a single `ViewModeRuntime` snapshot per
+ * change. Mounted near the top of `SceneRenderer` so every R3F descendant
+ * can read flags via `useViewModeRuntime()` without each component
+ * subscribing to 5+ raw store fields.
+ */
+export declare function ViewModeRuntimeProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+/**
+ * Read the current `ViewModeRuntime`. Throws in development when used
+ * outside the provider so missing wiring is caught immediately. Consumers
+ * should NEVER branch on `viewMode === '2d'` directly — use the runtime
+ * flags so the policy stays centralised.
+ */
+export declare function useViewModeRuntime(): ViewModeRuntime;
+//# sourceMappingURL=ViewModeRuntimeContext.d.ts.map

package/build/types/real-time-viewer-next/src/core/viewMode/ViewModeRuntimeContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ViewModeRuntimeContext.d.ts","sourceRoot":"","sources":["../../../../../../src/core/viewMode/ViewModeRuntimeContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6C,MAAM,OAAO,CAAC;AAGlE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI/C;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,qBAwBlF;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAMpD"}

package/build/types/real-time-viewer-next/src/core/viewMode/index.d.ts

@@ -0,0 +1,4 @@
+export type { ViewMode, ViewModeCapabilities, ViewModeRuntime, ViewModeRuntimeStateInput } from './types';
+export { selectViewModeRuntime } from './selectViewModeRuntime';
+export { ViewModeRuntimeProvider, useViewModeRuntime } from './ViewModeRuntimeContext';
+//# sourceMappingURL=index.d.ts.map

package/build/types/real-time-viewer-next/src/core/viewMode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/core/viewMode/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,QAAQ,EAAE,oBAAoB,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAC1G,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC"}

package/build/types/real-time-viewer-next/src/core/viewMode/selectViewModeRuntime.d.ts

@@ -0,0 +1,9 @@
+import type { ViewModeCapabilities, ViewModeRuntime, ViewModeRuntimeStateInput } from './types';
+/**
+ * Pure builder for {@link ViewModeRuntime}: no React, no side effects — safe to
+ * call in selectors and tests. `mount*` is capability-driven lifetime,
+ * `show3DDecoration` / `disableHeavyEffects` are mode-driven per-frame
+ * visibility. See `docs/VIEW_MODES_2D_3D.md` § ViewModeRuntime for the policy.
+ */
+export declare function selectViewModeRuntime(state: ViewModeRuntimeStateInput, capabilities: ViewModeCapabilities): ViewModeRuntime;
+//# sourceMappingURL=selectViewModeRuntime.d.ts.map

package/build/types/real-time-viewer-next/src/core/viewMode/selectViewModeRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectViewModeRuntime.d.ts","sourceRoot":"","sources":["../../../../../../src/core/viewMode/selectViewModeRuntime.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,eAAe,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAC;AAqBhG;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,yBAAyB,EAAE,YAAY,EAAE,oBAAoB,GAAG,eAAe,CA+B3H"}

package/build/types/real-time-viewer-next/src/core/viewMode/selectViewModeRuntime.test.d.ts

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

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

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

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

@@ -0,0 +1,67 @@
+/**
+ * ViewModeRuntime — single derived snapshot that answers "what is allowed
+ * in this mode?" Components read flags from this snapshot instead of
+ * branching on raw `viewMode === '2d'` / `is2D` / `controlsMode === '2d'`.
+ *
+ * Policy (lifetime vs visibility, and where a new flag belongs):
+ * `packages/real-time-viewer-next/docs/VIEW_MODES_2D_3D.md` § ViewModeRuntime.
+ * `selectViewModeRuntime.ts` is the pure builder.
+ */
+import type { Limits2DConfig } from '../../types/camera';
+import type { OverlayGroupConfig } from '../../types/environment';
+export type ViewMode = '2d' | '3d';
+/**
+ * Host + RTV-level static inputs. Set once at mount via `RTVConfig.capabilities`
+ * (defaults to `{ supports3d: true }` so existing COBI hosts keep working).
+ * Treated as immutable for the lifetime of the canvas — flipping mid-session
+ * does not retro-actively code-split the 3D capsule.
+ */
+export interface ViewModeCapabilities {
+    /**
+     * When false, the host never assembles HQS and the 3D capsule
+     * (`Scene3DContent`) is never imported. The 2D-only entry path skips
+     * water, sky, scene floor, shadows, full PP, and `useViewModeTransition`.
+     */
+    supports3d: boolean;
+}
+/** Pure derived runtime snapshot. Built by `selectViewModeRuntime(state, capabilities)`. */
+export interface ViewModeRuntime {
+    mode: ViewMode;
+    /** Per-frame visibility hinge for every 3D-decoration surface: `true` in 3D, `false` in 2D. */
+    show3DDecoration: boolean;
+    /** SceneTree / GLB load path is mounted (`supports3d && sceneIsProvided`). */
+    mountScene3D: boolean;
+    /** Scene2DOverlay / Element2DPlane is visible this frame. */
+    showScene2DOverlay: boolean;
+    /** Composer is mounted. Driven by `env.postProcessing.enabled`. */
+    mountPostProcessing: boolean;
+    /** Skip SSAO / Bloom / DoF / ToneMapping / colour grading this frame (`true` in 2D). */
+    disableHeavyEffects: boolean;
+    /** EnvironmentDome HDRI background + SkydomeBackground. */
+    mountSky: boolean;
+    /** Sun lensflare overlay. */
+    mountSunLensflare: boolean;
+    /** Water surfaces, caustics receivers, water reflection RT. */
+    mountWater: boolean;
+    /** Planner FloorGrid wrapper. Always true — the component picks 2D grid vs 3D drei.Grid. */
+    mountFloorGrid: boolean;
+    /** drei AdaptiveDpr / AdaptiveEvents / BakeShadows + PerformanceMonitor. */
+    mountAdaptivePerf: boolean;
+    camera: {
+        /** Resolved 2D limits when `mode === '2d'`, else null. */
+        limits2d: Required<Limits2DConfig> | null;
+        /** OrbitControls.enableRotate. */
+        enableRotate: boolean;
+    };
+    /** Selection overlay group config (`overlay2d` in 2D, `overlay3d` in 3D). */
+    selectionOverlay: OverlayGroupConfig;
+}
+/** Minimal subset of the RTV store that `selectViewModeRuntime` reads. */
+export interface ViewModeRuntimeStateInput {
+    viewMode: ViewMode;
+    scene: unknown | null;
+    scene2d: unknown | null;
+    resolvedEnvironment: import('../../types/environment').ResolvedEnvironmentConfig;
+    cameraConfig: import('../../types/camera').CameraConfig;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/core/viewMode/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,CAAC;AAEnC;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,4FAA4F;AAC5F,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,QAAQ,CAAC;IAEf,+FAA+F;IAC/F,gBAAgB,EAAE,OAAO,CAAC;IAG1B,8EAA8E;IAC9E,YAAY,EAAE,OAAO,CAAC;IACtB,6DAA6D;IAC7D,kBAAkB,EAAE,OAAO,CAAC;IAE5B,mEAAmE;IACnE,mBAAmB,EAAE,OAAO,CAAC;IAC7B,wFAAwF;IACxF,mBAAmB,EAAE,OAAO,CAAC;IAG7B,2DAA2D;IAC3D,QAAQ,EAAE,OAAO,CAAC;IAClB,6BAA6B;IAC7B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,+DAA+D;IAC/D,UAAU,EAAE,OAAO,CAAC;IACpB,4FAA4F;IAC5F,cAAc,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,iBAAiB,EAAE,OAAO,CAAC;IAE3B,MAAM,EAAE;QACN,0DAA0D;QAC1D,QAAQ,EAAE,QAAQ,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;QAC1C,kCAAkC;QAClC,YAAY,EAAE,OAAO,CAAC;KACvB,CAAC;IAEF,6EAA6E;IAC7E,gBAAgB,EAAE,kBAAkB,CAAC;CACtC;AAED,0EAA0E;AAC1E,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IACxB,mBAAmB,EAAE,OAAO,yBAAyB,EAAE,yBAAyB,CAAC;IACjF,YAAY,EAAE,OAAO,oBAAoB,EAAE,YAAY,CAAC;CACzD"}

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

@@ -0,0 +1,49 @@
+import { MeshStandardMaterial } from 'three';
+import type { WaterUniforms } from './waterUniforms';
+/**
+ * Brand applied to materials produced by `patchMaterialAsCausticReceiver`.
+ * `refreshCausticReceiverUniforms` uses it as a duck-type check to avoid
+ * accidentally writing into a vanilla material's uniforms map (which
+ * wouldn't have the receiver uniform slots and would throw).
+ */
+declare const CAUSTIC_RECEIVER_FLAG = "__rtvCausticReceiverPatched";
+/**
+ * Subset of a Three.js material we touch. Keeps the helper compatible
+ * with MeshStandardMaterial AND MeshPhysicalMaterial (which extends it)
+ * without pulling either of them in as a constructor.
+ */
+type ReceiverCapableMaterial = MeshStandardMaterial & {
+    [CAUSTIC_RECEIVER_FLAG]?: true;
+};
+/**
+ * Suspend / resume the caustic term on ALL receiver materials for the draws
+ * that follow. Used by the water surface around its SSR SceneCapture pass:
+ * the captured texture must NOT contain the animated caustics (the surface
+ * shader composites the live pattern instead), both to avoid double-applying
+ * them and to keep a still scene's captures identical so the capture
+ * throttle can skip re-renders.
+ */
+export declare function setCausticReceiversSuspended(suspended: boolean): void;
+/**
+ * Clone `source` and patch its fragment shader to add the water surface's
+ * caustic light. Returns the patched clone — caller is responsible for
+ * assigning it to a mesh and disposing it when done.
+ *
+ * Seed uniforms are READ from the supplied snapshot at patch time and then
+ * never re-touched by this function. To keep them current across frames
+ * the caller must call `refreshCausticReceiverUniforms` per frame.
+ */
+export declare function patchMaterialAsCausticReceiver(source: MeshStandardMaterial, uniforms: WaterUniforms): ReceiverCapableMaterial;
+/**
+ * Per-frame refresh: copy current values from the singleton into the
+ * patched material's uniform slots. Cheap — pure ref reads + a handful
+ * of `.copy()` calls. Bail early if the material wasn't produced by
+ * `patchMaterialAsCausticReceiver`.
+ */
+export declare function refreshCausticReceiverUniforms(material: MeshStandardMaterial, uniforms: WaterUniforms): void;
+/** Get (or create) the shared receiver clone for `source`; pairs with `releaseCausticReceiver`. */
+export declare function acquireCausticReceiver(source: MeshStandardMaterial, uniforms: WaterUniforms): MeshStandardMaterial;
+/** Drop one reference to `source`'s receiver clone; disposes it when the last holder releases. */
+export declare function releaseCausticReceiver(source: MeshStandardMaterial): void;
+export {};
+//# sourceMappingURL=CausticReceiver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"CausticReceiver.d.ts","sourceRoot":"","sources":["../../../../../../src/core/water/CausticReceiver.ts"],"names":[],"mappings":"AA4BA,OAAO,EAAE,oBAAoB,EAAoB,MAAM,OAAO,CAAC;AAE/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD;;;;;GAKG;AACH,QAAA,MAAM,qBAAqB,gCAAgC,CAAC;AAE5D;;;;GAIG;AACH,KAAK,uBAAuB,GAAG,oBAAoB,GAAG;IACpD,CAAC,qBAAqB,CAAC,CAAC,EAAE,IAAI,CAAC;CAChC,CAAC;AAUF;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI,CAErE;AAsKD;;;;;;;;GAQG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,oBAAoB,EAAE,QAAQ,EAAE,aAAa,GAAG,uBAAuB,CAoE7H;AAED;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,QAAQ,EAAE,oBAAoB,EAAE,QAAQ,EAAE,aAAa,GAAG,IAAI,CAwC5G;AAwBD,mGAAmG;AACnG,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,oBAAoB,EAAE,QAAQ,EAAE,aAAa,GAAG,oBAAoB,CAQlH;AAED,kGAAkG;AAClG,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,oBAAoB,GAAG,IAAI,CAQzE"}