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

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

@@ -0,0 +1,57 @@
+import { PerspectiveCamera } from 'three';
+import type { MutableRefObject, RefObject } from 'react';
+import type { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
+interface UseCameraSmoothingOptions {
+    /**
+     * Single critically-damped time-constant (s) for the rendered camera's chase spring, used in both
+     * active manipulation and post-release coast. Keep it single: a dual drag/rest T jumps the chase
+     * velocity calibration at release and reads as smoothing stopping abruptly at the end of a motion.
+     * The post-release glide already comes from OrbitControls' momentum decay
+     * ({@link UseCameraSmoothingOptions.dampingFactor}).
+     */
+    smoothTime: number;
+    /**
+     * User-configured OrbitControls damping factor, interpreted at a 60 fps reference. Each frame this
+     * hook recomputes the equivalent factor for the actual `dt` and writes it to `controls.dampingFactor`,
+     * keeping the per-second decay rate constant across variable framerates (three-stdlib applies its
+     * decay per-frame with no dt term, so without this the coast length floats with fps).
+     */
+    dampingFactor: number;
+    /** Programmatic-animation guard. While `true`, real ← proxy each frame (no smoothing). */
+    animating: MutableRefObject<boolean>;
+    /** Optional floor clamp applied to the rendered camera after smoothing, to mask catch-up clipping. */
+    floorY: number;
+}
+/**
+ * Spring the rendered camera (`real`) toward the user-intent camera (`proxy`)
+ * each frame. The proxy is what OrbitControls and every sibling camera hook
+ * write to; the real camera is what R3F renders and what picking uses. By
+ * decoupling them we can apply **frame-rate-independent, critically-damped**
+ * smoothing on top of OrbitControls without touching its private inertia
+ * state (closure-private in three-stdlib).
+ *
+ * Position uses a true Padé spring (overshoot-free); FOV uses the same
+ * scalar spring so dolly-on-rotate settles smoothly. **Orientation is
+ * derived, not smoothed**: each frame the rendered camera does
+ * `lookAt(controls.target)` from its current (lagged) position. Smoothing
+ * position and quaternion as two independent quantities lets the
+ * orientation drift off the focus point during the coast (the two springs
+ * use different math even at the same `T`), so the camera briefly looks
+ * "past" the target. Deriving the look direction from the live focus
+ * point keeps the rendered camera always pointed exactly where
+ * OrbitControls says it should be, just from a lagged location — which
+ * is the classic cinematic dolly behavior. `up`, `near`, `far`, `aspect`
+ * are hard-mirrored — they're projection state, not pose.
+ *
+ * Runs at {@link FRAME_ORDER.CAMERA_SMOOTHING} so it deterministically lands
+ * AFTER drei's OrbitControls update and AFTER all default-priority sibling hooks.
+ *
+ * Registers a `snap()` function in the handle registry (`registerCameraSnap`) so the
+ * capture engine can hard-cut real←proxy after a snapshot restore without
+ * a visible bounce. `animating === true` triggers the same snap path each
+ * frame so programmatic animations (focus, reset, viewMode transitions)
+ * run at their own easing without a smoothing layer on top.
+ */
+export declare function useCameraSmoothing(real: PerspectiveCamera, proxy: PerspectiveCamera, controlsRef: RefObject<OrbitControlsImpl | null>, opts: UseCameraSmoothingOptions): void;
+export {};
+//# sourceMappingURL=useCameraSmoothing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCameraSmoothing.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useCameraSmoothing.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAW,MAAM,OAAO,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAMvE,UAAU,yBAAyB;IACjC;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB,0FAA0F;IAC1F,SAAS,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACrC,sGAAsG;IACtG,MAAM,EAAE,MAAM,CAAC;CAChB;AAKD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,iBAAiB,EACvB,KAAK,EAAE,iBAAiB,EACxB,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAChD,IAAI,EAAE,yBAAyB,QAoHhC"}

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

@@ -0,0 +1,5 @@
+export declare function useMaterialFade(): {
+    setMaterialOpacity: (opacity: number) => void;
+    restoreMaterials: () => void;
+};
+//# sourceMappingURL=useMaterialFade.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMaterialFade.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useMaterialFade.ts"],"names":[],"mappings":"AAUA,wBAAgB,eAAe;kCAKjB,MAAM;;EAoCnB"}

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

@@ -0,0 +1,19 @@
+import type { MutableRefObject, RefObject } from 'react';
+import { PerspectiveCamera } from 'three';
+import type { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
+import type { RTVScene2D } from '../../types/scene2d';
+import type { CameraFrameContext } from '../../utils/cameraFraming';
+import type { CameraPoseBook } from './cameraPoseBook';
+import type { AnimateFn } from './useCameraAnimation';
+interface UseViewModeTransitionOptions {
+    restoreMaterials: () => void;
+    poseBook: CameraPoseBook;
+    hasFramed3D: MutableRefObject<boolean>;
+    scene2d: RTVScene2D | null;
+    frameCtx: CameraFrameContext;
+    /** Programmatic-animation guard; used to clear `viewModeTransitioning` once the fly settles. */
+    animating: MutableRefObject<boolean>;
+}
+export declare function useViewModeTransition(camera: PerspectiveCamera, controlsRef: RefObject<OrbitControlsImpl | null>, animate: AnimateFn, viewMode: '3d' | '2d', opts: UseViewModeTransitionOptions): '2d' | '3d';
+export {};
+//# sourceMappingURL=useViewModeTransition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useViewModeTransition.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useViewModeTransition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEzD,OAAO,EAAE,iBAAiB,EAAW,MAAM,OAAO,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEvE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAOtD,UAAU,4BAA4B;IACpC,gBAAgB,EAAE,MAAM,IAAI,CAAC;IAC7B,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACvC,OAAO,EAAE,UAAU,GAAG,IAAI,CAAC;IAC3B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,gGAAgG;IAChG,SAAS,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;CACtC;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAChD,OAAO,EAAE,SAAS,EAClB,QAAQ,EAAE,IAAI,GAAG,IAAI,EACrB,IAAI,EAAE,4BAA4B,GACjC,IAAI,GAAG,IAAI,CA+Hb"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/DimensionLine2D.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+export interface DimensionLine2DProps {
+    /** Start point in world meters [x, z] */
+    start: [number, number];
+    /** End point in world meters [x, z] */
+    end: [number, number];
+    /** Perpendicular offset from the geometry edge (meters) */
+    offset: number;
+    /** Unit vector for offset direction [x, z] */
+    offsetDirection: [number, number];
+    /** Measurement value in cm */
+    valueCm: number;
+    color?: string;
+    fontSize?: number;
+    /** Y height in world space (default: 0.01) */
+    y?: number;
+    /** Text rendered before the formatted value (e.g. "4x", "Paket ca. ") */
+    prefix?: string;
+    /** Text rendered after the formatted value */
+    postfix?: string;
+    /** Stroke style of the measurement run (ticks/arrows stay solid). Default: solid. */
+    lineStyle?: 'solid' | 'dashed' | 'dotted';
+    /** Label anchor along the run (0–1, default 0.5). Inside dimensions use off-center anchors
+     *  so lines crossing mid-element don't stack their labels. */
+    labelT?: number;
+}
+export declare function DimensionLine2D({ start, end, offset, offsetDirection, valueCm, color, fontSize, y, prefix, postfix, lineStyle, labelT, }: DimensionLine2DProps): React.JSX.Element | null;
+//# sourceMappingURL=DimensionLine2D.d.ts.map

package/build/types/real-time-viewer-next/src/core/dimension-lines/DimensionLine2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DimensionLine2D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/DimensionLine2D.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkC,MAAM,OAAO,CAAC;AAgCvD,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,uCAAuC;IACvC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtB,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,8BAA8B;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qFAAqF;IACrF,SAAS,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC1C;kEAC8D;IAC9D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,GAAG,EACH,MAAM,EACN,eAAe,EACf,OAAO,EAEP,KAAK,EAIL,QAAc,EACd,CAAQ,EACR,MAAM,EACN,OAAO,EACP,SAAS,EACT,MAAY,GACb,EAAE,oBAAoB,4BA4ItB"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/DimensionLines2D.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare function DimensionLines2D(): React.JSX.Element;
+//# sourceMappingURL=DimensionLines2D.d.ts.map

package/build/types/real-time-viewer-next/src/core/dimension-lines/DimensionLines2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DimensionLines2D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/DimensionLines2D.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAKvC,wBAAgB,gBAAgB,sBA6B/B"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/DimensionLines3D.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare function DimensionLines3D(): React.JSX.Element;
+//# sourceMappingURL=DimensionLines3D.d.ts.map

package/build/types/real-time-viewer-next/src/core/dimension-lines/DimensionLines3D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DimensionLines3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/DimensionLines3D.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqD,MAAM,OAAO,CAAC;AA8E1E,wBAAgB,gBAAgB,sBAoJ/B"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/dimensionGeometry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Geometry for the dimension-line renderers: the label metrics both the 2D and 3D labels are
+ * placed by, plus the run direction and the end-cap / label-gap points a 3D run is drawn from.
+ */
+/** Point or direction in world meters. */
+export type Vec3 = [number, number, number];
+/** Read-only surface of a three `Box3`, so the pure line builders can take measured bounds. */
+export interface Bounds3 {
+    min: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    max: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+/** Half the width of `label` when rendered at `fontSize`, in the label's own world units. */
+export declare function labelHalfWidth(label: string, fontSize: number): number;
+/** Unit direction and length of a run; null when the run is degenerate. */
+export declare function runDirection(start: Vec3, end: Vec3): {
+    u: Vec3;
+    len: number;
+} | null;
+export declare function midpoint(start: Vec3, end: Vec3): Vec3;
+/** Cap direction when a line does not ask for one: vertical runs cap along X, others along Y. */
+export declare function defaultCapPerp(u: Vec3): Vec3;
+/** The two ends of the perpendicular end cap (the `|` in |-----|) centered on `point`. */
+export declare function capEnds(point: Vec3, perp: Vec3, half: number): [Vec3, Vec3];
+/** Inner endpoints of a run interrupted by a centered label, leaving `half` clear each way. */
+export declare function labelGapEnds(mid: Vec3, u: Vec3, half: number): [Vec3, Vec3];
+//# sourceMappingURL=dimensionGeometry.d.ts.map

package/build/types/real-time-viewer-next/src/core/dimension-lines/dimensionGeometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensionGeometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/dimensionGeometry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,0CAA0C;AAC1C,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAE5C,+FAA+F;AAC/F,MAAM,WAAW,OAAO;IACtB,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,GAAG,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC1C;AAKD,6FAA6F;AAC7F,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,2EAA2E;AAC3E,wBAAgB,YAAY,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG;IAAE,CAAC,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAOpF;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,GAAG,IAAI,CAErD;AAED,iGAAiG;AACjG,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,CAE5C;AAED,0FAA0F;AAC1F,wBAAgB,OAAO,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAK3E;AAED,+FAA+F;AAC/F,wBAAgB,YAAY,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAK3E"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/dimensionLineBuilders.test.d.ts

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

package/build/types/real-time-viewer-next/src/core/dimension-lines/dimensionLineBuilders.test.d.ts.map

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

package/build/types/real-time-viewer-next/src/core/dimension-lines/dimensionLineBuilders2D.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Pure builders for the 2D (plan-view) dimension lines. `buildDimensionLines2D` measures the
+ * scene2d elements once and then runs the levels in draw order:
+ *   1a per-element (element-local / OBB)   1c automatic gaps   1b per-element (grid-aligned / AABB)
+ *   2  per docking group                   3  total planning bbox
+ * Nothing here touches three.js or the store — the component only renders the descriptors.
+ */
+import type { RTVElement2D, RTVScene2D } from '../../types/scene2d';
+import type { DimensionLineMode } from '../../store';
+import type { ElementBounds } from './utils';
+export interface DimLine2DDesc {
+    start: [number, number];
+    end: [number, number];
+    offset: number;
+    offsetDirection: [number, number];
+    valueCm: number;
+    color?: string;
+    prefix?: string;
+    postfix?: string;
+    lineStyle?: 'solid' | 'dashed' | 'dotted';
+    /** Label anchor along the run (0–1). Absent = centered. */
+    labelT?: number;
+}
+/** The measured plan every level builds from. */
+export interface Plan2D {
+    elements: RTVElement2D[];
+    dockingGroups?: number[][];
+    /** Element bounds, index-aligned with {@link Plan2D.elements}. */
+    bounds: ElementBounds[];
+    boundsById: Map<number, ElementBounds>;
+    /** Outer edges of the plan in meters (union of the element bounds). */
+    minX: number;
+    maxX: number;
+    minZ: number;
+    maxZ: number;
+    totalWidthCm: number;
+    totalDepthCm: number;
+}
+/** Lines of a level plus the element values they display (the total level suppresses repeats). */
+interface LevelLines {
+    lines: DimLine2DDesc[];
+    shownWidths: number[];
+    shownDepths: number[];
+}
+/**
+ * Measure the plan. The total extents are the union of the element bounds, i.e. the same source
+ * the docking-group unions use. (The bridge's `boundingBox` ignores element rotation; any mismatch
+ * would render a group line AND a total line for the same physical extent.)
+ */
+export declare function measurePlan2D(scene2d: RTVScene2D): Plan2D | null;
+/**
+ * Level 1a: per-element, element-local (OBB-aligned) lines. `dimensionConfig` (catalog-driven)
+ * controls visibility, colors, prefix/postfix, edge offsets and inside placement per element.
+ */
+export declare function buildElementLines(plan: Plan2D): LevelLines;
+/**
+ * Level 1c: automatic gap dimensions. Two axis-aligned elements that share the same extent on one
+ * axis and do not overlap on the other get a line between their facing edges (e.g. parallel
+ * Laufschienen). Identical gaps (same facing interval) are MERGED into one line, drawn outside the
+ * plan at row 1 — right edge for vertical gaps, bottom edge for horizontal ones. Elements opt out
+ * via `gapDimensions: false`.
+ */
+export declare function buildAutoGapLines(plan: Plan2D): DimLine2DDesc[];
+/**
+ * Level 1b: per-element grid-aligned (AABB) lines. Only when mode includes grid AND the element is
+ * rotated (non-axis-aligned), or when mode is grid-only (always show). Same bottom/right placement
+ * as the element-local lines (Level 1a).
+ */
+export declare function buildGridLines(plan: Plan2D, mode: DimensionLineMode): LevelLines;
+/** Level 2: one line pair per docking group, top/left of the plan. */
+export declare function buildGroupLines(plan: Plan2D, mode: DimensionLineMode): DimLine2DDesc[];
+/**
+ * Level 3: total planning bbox. Skips an axis only when a per-element line already DISPLAYS the
+ * same value — a full-extent element with hidden lines must not suppress the total, and a
+ * fully-docked scene (group == total, group line skipped in Level 2) must still show its overall
+ * planning dimensions exactly once.
+ */
+export declare function buildTotalLines(plan: Plan2D, mode: DimensionLineMode, shownWidths: number[], shownDepths: number[]): DimLine2DDesc[];
+/** All 2D dimension lines for a scene, in draw order. */
+export declare function buildDimensionLines2D(scene2d: RTVScene2D, mode: DimensionLineMode): DimLine2DDesc[];
+export {};
+//# sourceMappingURL=dimensionLineBuilders2D.d.ts.map

package/build/types/real-time-viewer-next/src/core/dimension-lines/dimensionLineBuilders2D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensionLineBuilders2D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/dimensionLineBuilders2D.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAa7C,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC;IAC1C,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,iDAAiD;AACjD,MAAM,WAAW,MAAM;IACrB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAC3B,kEAAkE;IAClE,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACvC,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,kGAAkG;AAClG,UAAU,UAAU;IAClB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAeD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,GAAG,IAAI,CAsChE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,CA0F1D;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,EAAE,CAuE/D;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,UAAU,CAqChF;AAED,sEAAsE;AACtE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,aAAa,EAAE,CAoEtF;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,GAAG,aAAa,EAAE,CAmCpI;AAED,yDAAyD;AACzD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,iBAAiB,GAAG,aAAa,EAAE,CA2BnG"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/dimensionLineBuilders3D.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Pure builders for the 3D dimension lines: they turn measured bounds (plus scene2d element data
+ * and the camera-facing side signs) into line + label descriptors. No three.js and no scene access
+ * — the component measures the scene and feeds the results in.
+ */
+import type { RTVElement2D, RTVScene2D } from '../../types/scene2d';
+import type { AllGrids } from '../../types/accessoryGrids';
+import type { Bounds3, Vec3 } from './dimensionGeometry';
+export interface DimLine3DDesc {
+    start: Vec3;
+    end: Vec3;
+    labelPos: Vec3;
+    valueCm: number;
+    kind?: 'size' | 'gap';
+    /** Unit direction of the perpendicular end caps. Defaults by orientation when unset. */
+    capPerp?: Vec3;
+}
+/**
+ * Which side each size line sits on, so it faces the camera instead of hiding behind the article.
+ * `sW` = +1 puts the depth line (and height corner) on the +width edge, -1 on the -width edge.
+ * `sD` = +1 puts the width line (and height corner) on the +depth edge, -1 on the -depth edge.
+ * For a rotated element +width/+depth are its own axes; for a docked AABB group they are world X/Z.
+ */
+export interface SideSigns {
+    sW: 1 | -1;
+    sD: 1 | -1;
+}
+/** One dimensioned block: a docking group, or a single detached element. */
+export interface ArticleGroup {
+    /** Stable key over the member ids — also the key of the measured bounds and side signs. */
+    key: string;
+    elementIds: number[];
+    /** The lone element of a detached group; absent for docked groups (they dimension as an AABB). */
+    element?: RTVElement2D;
+}
+/**
+ * Build OBB-aligned dimension lines from scene2d element data.
+ * Width & depth lines follow the element's rotation; height uses the 3D Y range.
+ */
+export declare function buildOBBLines(elem2d: RTVElement2D, bounds: Bounds3, sides: SideSigns): DimLine3DDesc[];
+/** Axis-aligned lines for a docked group (or a scene2d-less fallback), sides picked by camera. */
+export declare function buildAABBLines(bounds: Bounds3, sides: SideSigns): DimLine3DDesc[];
+/** Stable key for a group of element ids (order-independent). */
+export declare function groupKey(ids: number[]): string;
+/**
+ * The blocks the black size lines are anchored to: each docking group collapses to one block,
+ * every detached article is its own. Accessories are folded into their article's bounds by the
+ * caller's selection scope, never dimensioned on their own.
+ */
+export declare function planArticleGroups(scene2d: RTVScene2D | null): ArticleGroup[];
+/** Size lines (W/D/H) for every group that could be measured, keyed by {@link ArticleGroup.key}. */
+export declare function buildArticleLines(groups: ArticleGroup[], boundsByGroup: Map<string, Bounds3>, sidesByGroup: Map<string, SideSigns>): DimLine3DDesc[];
+/** Whether the selected accessory occupies the BOTTOM-most cell of its grid — cell 0 for
+ *  bottom-up grids (`deltaGrid.y > 0`), cell count-1 for top-down. */
+export declare function isAtGridBottomCell(selectedKey: string, grids: AllGrids[] | null): boolean;
+/**
+ * Vertical clearance gaps for the SELECTED ACCESSORY: the distance to the nearest sibling
+ * (a board/drawer on the same grid) directly above and below it. When there is no sibling in
+ * a direction the line runs to the top / bottom of the containing grid (`container`) instead.
+ * Computed purely from the 3D bounds (scene2d has no vertical Y origin). Gaps below MIN_GAP_CM
+ * are dropped. `candidates` are the grid siblings' bounds, so the gap only relates to the
+ * selection. `hideBottomGap` drops the downward line (a bottom-cell accessory's gap is carcass,
+ * not clearance).
+ */
+export declare function buildGapLines(selBox: Bounds3, candidates: Iterable<Bounds3>, container: {
+    minY: number;
+    maxY: number;
+}, hideBottomGap: boolean): DimLine3DDesc[];
+/**
+ * Pick, per docking group, which sides the size lines face so they sit toward the camera.
+ * A detached (single) element projects the camera onto its own width/depth axes; a docked group
+ * compares the camera to the group centre on world X/Z (its lines are axis-aligned). Cheap and
+ * scene-independent — derived from scene2d + camera only — so it can run every frame.
+ */
+export declare function computeGroupSides(scene2d: RTVScene2D | null, camX: number, camZ: number): Map<string, SideSigns>;
+//# sourceMappingURL=dimensionLineBuilders3D.d.ts.map

package/build/types/real-time-viewer-next/src/core/dimension-lines/dimensionLineBuilders3D.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensionLineBuilders3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/dimensionLineBuilders3D.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACpE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAI3D,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AASzD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,IAAI,CAAC;IACZ,GAAG,EAAE,IAAI,CAAC;IACV,QAAQ,EAAE,IAAI,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACtB,wFAAwF;IACxF,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED;;;;;GAKG;AACH,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IACX,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;CACZ;AAID,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IAC3B,2FAA2F;IAC3F,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,kGAAkG;IAClG,OAAO,CAAC,EAAE,YAAY,CAAC;CACxB;AAgGD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,aAAa,EAAE,CAgBtG;AAED,kGAAkG;AAClG,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,GAAG,aAAa,EAAE,CAuBjF;AAED,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,CAE9C;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,GAAG,YAAY,EAAE,CAQ5E;AAED,oGAAoG;AACpG,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EAAE,EACtB,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,GACnC,aAAa,EAAE,CASjB;AASD;sEACsE;AACtE,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,GAAG,OAAO,CAMzF;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,OAAO,EACf,UAAU,EAAE,QAAQ,CAAC,OAAO,CAAC,EAC7B,SAAS,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,EACzC,aAAa,EAAE,OAAO,GACrB,aAAa,EAAE,CA8CjB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAsChH"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/dimensionLines.config.d.ts

@@ -0,0 +1,25 @@
+import { type ConfigInput, type ConfigResolved } from '../../config/descriptor';
+/**
+ * Dimension-line label settings — the single source for their types, defaults, round-trip and
+ * analyzer inputs (see `config/descriptor.ts`).
+ *
+ * These three live at the TOP level of `EnvironmentConfig` (they predate the per-subsystem
+ * grouping), so this group's `fields` are spread into the environment descriptor rather than
+ * nested under a key. The group itself exists so the analyzer can derive its leva inputs from it.
+ */
+export declare const DIMENSION_LINES_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    /** Unit for dimension line labels. */
+    dimensionLineUnit: import("../../config/descriptor").EnumField<"in" | "cm" | "m" | "mm">;
+    /** Hide the unit suffix in dimension labels ("4300" instead of "4300 mm"). */
+    dimensionLineHideUnit: import("../../config/descriptor").BooleanField;
+    /**
+     * Default color for 2D dimension lines and their labels; per-element `dimensionConfig.color`
+     * overrides win. `#3a4250` is ~3.5:1 against #fff (WCAG-AA-large) while staying softer than the
+     * SVG planes' ink.
+     */
+    dimensionLineColor: import("../../config/descriptor").ColorField;
+}>;
+export type DimensionLinesConfig = ConfigInput<typeof DIMENSION_LINES_CONFIG>;
+export type ResolvedDimensionLinesConfig = ConfigResolved<typeof DIMENSION_LINES_CONFIG>;
+export type DimensionLineUnit = ResolvedDimensionLinesConfig['dimensionLineUnit'];
+//# sourceMappingURL=dimensionLines.config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dimensionLines.config.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/dimensionLines.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEvF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;IACjC,sCAAsC;;IAWtC,8EAA8E;;IAE9E;;;;OAIG;;EAEH,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC9E,MAAM,MAAM,4BAA4B,GAAG,cAAc,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACzF,MAAM,MAAM,iBAAiB,GAAG,4BAA4B,CAAC,mBAAmB,CAAC,CAAC"}

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

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

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

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

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

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare function DimensionLines(): React.JSX.Element;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/index.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAiB,MAAM,OAAO,CAAC;AAQtC,wBAAgB,cAAc,sBAgB7B"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/useDimensionFade.d.ts

@@ -0,0 +1,12 @@
+import type { RefObject } from 'react';
+import type { Group } from 'three';
+/**
+ * Fade a dimension-line group in/out by ramping every descendant material's opacity each frame.
+ * When fully faded out the group is parked `visible=false` so it stops rendering.
+ *
+ * Returns whether the group's content should be mounted: true while visible and for the whole
+ * fade-out, false once it has settled fully hidden — so hidden dimension lines stop measuring
+ * bounds and stop scaling labels per frame.
+ */
+export declare function useDimensionFade(groupRef: RefObject<Group | null>, visible: boolean): boolean;
+//# sourceMappingURL=useDimensionFade.d.ts.map

package/build/types/real-time-viewer-next/src/core/dimension-lines/useDimensionFade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDimensionFade.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/useDimensionFade.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,KAAK,EAAY,MAAM,OAAO,CAAC;AAiB7C;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAsC7F"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/useLabelScale.d.ts

@@ -0,0 +1,11 @@
+import type { RefObject } from 'react';
+import type { Group } from 'three';
+/**
+ * Screen-clamped label sizing: scales `ref` every frame so its content (authored at
+ * `worldFontSize` meters) keeps a readable on-screen size regardless of scene extent —
+ * a 0.1 m label on a 12 m pool is unreadable at fit zoom without this. Scale never drops
+ * below 1, so the close-up look is unchanged. Scaling is centered on the group's origin,
+ * so anchor the label content at the group origin.
+ */
+export declare function useLabelScale(ref: RefObject<Group | null>, worldFontSize: number): void;
+//# sourceMappingURL=useLabelScale.d.ts.map

package/build/types/real-time-viewer-next/src/core/dimension-lines/useLabelScale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLabelScale.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/useLabelScale.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAGvC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC;AAUnC;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,aAAa,EAAE,MAAM,QAwBhF"}

package/build/types/real-time-viewer-next/src/core/dimension-lines/utils.d.ts

@@ -0,0 +1,26 @@
+import type { RefObject } from 'react';
+import type { Group } from 'three';
+import type { DimensionLineUnit } from '../../types/environment';
+import type { RTVElement2D } from '../../types/scene2d';
+export declare function disableRaycastAndShadows(groupRef: RefObject<Group | null>): void;
+export declare function formatValue(valueCm: number, unit: DimensionLineUnit, decimals?: number, hideUnit?: boolean): string;
+export interface ElementBounds {
+    elementId: number;
+    minX: number;
+    maxX: number;
+    minZ: number;
+    maxZ: number;
+    widthCm: number;
+    depthCm: number;
+    aabbWidthCm: number;
+    aabbDepthCm: number;
+    /** World-space corners: [c0, c1, c2, c3]
+     *  c0 = (-hw, -hd)  bottom-left
+     *  c1 = (+hw, -hd)  bottom-right  (width edge)
+     *  c2 = (+hw, +hd)  top-right
+     *  c3 = (-hw, +hd)  top-left      (depth edge) */
+    corners: [number, number][];
+    isAxisAligned: boolean;
+}
+export declare function computeElementBounds(el: RTVElement2D): ElementBounds;
+//# sourceMappingURL=utils.d.ts.map

package/build/types/real-time-viewer-next/src/core/dimension-lines/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../../../src/core/dimension-lines/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,KAAK,EAAY,MAAM,OAAO,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAOxD,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,QAiBzE;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,QAAQ,SAAI,EAAE,QAAQ,UAAQ,GAAG,MAAM,CAgB5G;AAOD,MAAM,WAAW,aAAa;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB;;;;sDAIkD;IAClD,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAC5B,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,YAAY,GAAG,aAAa,CAuDpE"}

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

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { ResolvedEnvironmentConfig } from '../../types/environment';
+interface EnvironmentDomeProps {
+    dome: ResolvedEnvironmentConfig['dome'];
+    is2D: boolean;
+}
+/**
+ * Picks the IBL source for `dome.hdr` — drei preset, computed room, the visible
+ * skydome image or a custom HDRI URL — and renders the flat background colour
+ * when no environment background is shown.
+ */
+export declare function EnvironmentDome({ dome, is2D }: EnvironmentDomeProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=EnvironmentDome.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentDome.d.ts","sourceRoot":"","sources":["../../../../../../src/core/environment/EnvironmentDome.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAGzE,UAAU,oBAAoB;IAC5B,IAAI,EAAE,yBAAyB,CAAC,MAAM,CAAC,CAAC;IACxC,IAAI,EAAE,OAAO,CAAC;CACf;AAwCD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,oBAAoB,qBA+EnE"}

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

@@ -0,0 +1,14 @@
+import React from 'react';
+/** Scene-load id registered with the core store while the environment GLB loads. */
+export declare const ENVIRONMENT_SCENE_LOAD_ID = "environment-scene";
+/**
+ * Renders the standalone GLB environment scene. Only mounts when
+ * `env.scene.sceneUrl` is set — the analyzer Leva panel writes into that field
+ * via `patchActiveProfile`, and host bundles can pre-seed it.
+ *
+ * `<R3FAssetBoundary>` keeps a load failure (stale `blob:` URL, 404, network,
+ * malformed GLB) from bubbling up to `RTVErrorBoundary` and taking the whole 3D
+ * view down. Picking a different URL resets the boundary for a fresh attempt.
+ */
+export declare function EnvironmentSceneLoader(): React.JSX.Element | null;
+//# sourceMappingURL=EnvironmentSceneLoader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentSceneLoader.d.ts","sourceRoot":"","sources":["../../../../../../src/core/environment/EnvironmentSceneLoader.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA+C,MAAM,OAAO,CAAC;AAcpE,oFAAoF;AACpF,eAAO,MAAM,yBAAyB,sBAAsB,CAAC;AAoL7D;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,6BAwCrC"}

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

@@ -0,0 +1,33 @@
+import React from 'react';
+/** How one IBL source is applied to the two drei channels. */
+interface EnvironmentChannels {
+    background: boolean;
+    backgroundBlurriness: number;
+    intensity: number;
+    rotation: [number, number, number];
+}
+interface PresetEnvironmentProps extends EnvironmentChannels {
+    preset: string;
+}
+export declare function PresetEnvironment({ preset, ...channels }: PresetEnvironmentProps): React.JSX.Element;
+export declare function ComputedRoomEnvironment(channels: EnvironmentChannels): React.JSX.Element;
+interface CustomEnvironmentProps extends EnvironmentChannels {
+    url: string;
+    tileX: number;
+    tileY: number;
+    offsetX: number;
+    offsetY: number;
+    highlightBoost: number;
+}
+/**
+ * Loads a single equirectangular HDRI, applying optional `tile`/`offset` to the
+ * equirect via a pre-PMREM render pass so that the lighting and the
+ * (drei-rendered) background reflect the same UV transform.
+ *
+ * `url` arrives already resolved: `mergeProfile` collapses any per-device
+ * `TieredAsset` to the active performance tier upstream, so a resolution swap
+ * reaches this component as a plain new URL.
+ */
+export declare function CustomEnvironment({ url, tileX, tileY, offsetX, offsetY, highlightBoost, ...channels }: CustomEnvironmentProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=EnvironmentSources.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentSources.d.ts","sourceRoot":"","sources":["../../../../../../src/core/environment/EnvironmentSources.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6B,MAAM,OAAO,CAAC;AAOlD,8DAA8D;AAC9D,UAAU,mBAAmB;IAC3B,UAAU,EAAE,OAAO,CAAC;IACpB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAkBD,UAAU,sBAAuB,SAAQ,mBAAmB;IAC1D,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,iBAAiB,CAAC,EAAE,MAAM,EAAE,GAAG,QAAQ,EAAE,EAAE,sBAAsB,qBAEhF;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,mBAAmB,qBAsBpE;AAED,UAAU,sBAAuB,SAAQ,mBAAmB;IAC1D,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,GAAG,QAAQ,EAAE,EAAE,sBAAsB,4BAM7H"}

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

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare function EnvironmentSunLensflare(): React.JSX.Element | null;
+//# sourceMappingURL=EnvironmentSunLensflare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EnvironmentSunLensflare.d.ts","sourceRoot":"","sources":["../../../../../../src/core/environment/EnvironmentSunLensflare.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,wBAAgB,uBAAuB,6BAoBtC"}

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

@@ -0,0 +1,28 @@
+import React from 'react';
+import type { ResolvedEnvironmentConfig } from '../../types/environment';
+interface LightingRigProps {
+    lighting: ResolvedEnvironmentConfig['lighting'];
+    is2D: boolean;
+}
+/**
+ * Non-shadow fill lights (key / fill / rim / back) plus ambient/hemisphere.
+ *
+ * The sun directional light is intentionally NOT rendered here — it lives in
+ * `core/shadows/SunShadow` so all sun-related shadow camera fitting and
+ * `autoUpdate` gating live in one place.
+ *
+ * Key/Fill/Rim/Back default to `SpotLight`s: a world-space position, cone angle
+ * and target make them genuinely draggable studio lights whose cone keeps
+ * illumination focused on the product. Each light can instead opt into a
+ * `DirectionalLight` via `type: 'directional'` — parallel rays from `position`
+ * toward the scene center that light the whole scene evenly with no ground
+ * pool (matching the old Babylon viewer's 4-directional rig). The choice is
+ * per-light so a preset can mix both.
+ *
+ * The key light can also opt into shadow casting via `shadows.lights.key`;
+ * fill/rim/back never cast. Shadow casting is forced off in 2D mode and gated
+ * on the master `shadows.enabled` flag.
+ */
+export declare function LightingRig({ lighting, is2D }: LightingRigProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=LightingRig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LightingRig.d.ts","sourceRoot":"","sources":["../../../../../../src/core/environment/LightingRig.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA4B,MAAM,OAAO,CAAC;AAEjD,OAAO,KAAK,EAAE,yBAAyB,EAAe,MAAM,yBAAyB,CAAC;AAQtF,UAAU,gBAAgB;IACxB,QAAQ,EAAE,yBAAyB,CAAC,UAAU,CAAC,CAAC;IAChD,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,gBAAgB,qBAwC/D"}