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

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

@@ -0,0 +1,35 @@
+import type { RTVCallbacks } from '../store';
+/**
+ * Module-level registry for imperative handles and host callbacks — the things the viewer holds
+ * exactly one live instance of and only ever reads imperatively.
+ *
+ * Deliberately NOT store state: a function identity is not state, so every (re)registration would
+ * publish a store update no subscriber cares about. Nothing here is read through a selector.
+ */
+/** Structural handle to the pmndrs EffectComposer (avoids a direct `postprocessing` type dependency). */
+export interface CaptureComposer {
+    setSize(width?: number, height?: number): void;
+}
+/**
+ * Register the hard-snap that copies the proxy camera pose onto the rendered camera and zeroes the
+ * spring velocities (owned by `useCameraSmoothing`). Returns the unregister function; it only clears
+ * the registry when `fn` is still the registered handle, so a late unmount can't wipe a newer one.
+ */
+export declare function registerCameraSnap(fn: () => void): () => void;
+/** The live camera snap, or `null` while no camera controller is mounted. */
+export declare function getCameraSnap(): (() => void) | null;
+/**
+ * Register the mounted post-processing composer. The capture engine resizes the canvas via
+ * `gl.setSize` directly (bypassing r3f's size state, which the composer's render targets are keyed
+ * on), so it must call `setSize()` on this handle afterwards — argument-less, that re-sizes all
+ * targets to the current drawing buffer. Without it the composite keeps rendering at the interactive
+ * resolution and the shot output is upscaled. Returns the unregister function (identity-guarded).
+ */
+export declare function registerCaptureComposer(composer: CaptureComposer): () => void;
+/** The mounted composer, or `null` when the scene renders straight to the canvas. */
+export declare function getCaptureComposer(): CaptureComposer | null;
+/** Publish the host's event callbacks. Called on every host render — hence not store state. */
+export declare function setHostCallbacks(callbacks: RTVCallbacks): void;
+/** The host's event callbacks; empty object until the host supplies any. */
+export declare function getHostCallbacks(): RTVCallbacks;
+//# sourceMappingURL=handles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handles.d.ts","sourceRoot":"","sources":["../../../../../src/core/handles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7C;;;;;;GAMG;AAEH,yGAAyG;AACzG,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAChD;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAK7D;AAED,6EAA6E;AAC7E,wBAAgB,aAAa,IAAI,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAEnD;AAID;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI,CAK7E;AAED,qFAAqF;AACrF,wBAAgB,kBAAkB,IAAI,eAAe,GAAG,IAAI,CAE3D;AAID,+FAA+F;AAC/F,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,YAAY,GAAG,IAAI,CAE9D;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,IAAI,YAAY,CAE/C"}

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

@@ -0,0 +1,9 @@
+/**
+ * Palette drag & drop targeting: while an accessory tile is dragged over the canvas, snaps the drop
+ * target to the nearest free cell and commits via `onAccessoryPlace`; a drop before cells are
+ * resolvable is parked and committed once they arrive. Listens window-level — pointer events don't
+ * fire during a native drag, and `dragover`/`drop` go to whatever HTML element is topmost, so a
+ * canvas listener goes deaf under overlays.
+ */
+export declare function AccessoryDropController(): null;
+//# sourceMappingURL=AccessoryDropController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AccessoryDropController.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/AccessoryDropController.tsx"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AACH,wBAAgB,uBAAuB,SA8EtC"}

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

@@ -0,0 +1,15 @@
+/**
+ * `autoPlaceDrag` free-follow targeting. While an accessory is being dragged (the
+ * `useAccessoryMoveDrag` press-drag started it and commits on pointer-up), this drives the move
+ * target from the CURSOR instead of from hovered free-cell boxes: it snaps to whichever valid cell
+ * is nearest to the cursor on screen — across all elements, including over gaps. The `SceneTree`
+ * `useFrame` preview and `commitAccessoryMove` are shared with the `cellBoxes` (box-hover) path;
+ * only the targeting source differs.
+ *
+ * Screen-space nearest (project each cell center, pick min pixel distance) is camera-correct for
+ * any shelf orientation, so no drag-plane orientation is needed. Cell world-centers are cached
+ * once per drag: the candidate cells belong to (stationary) parent elements, not the moving
+ * accessory, so they stay valid for the whole drag.
+ */
+export declare function AccessoryFollowController(): null;
+//# sourceMappingURL=AccessoryFollowController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AccessoryFollowController.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/AccessoryFollowController.tsx"],"names":[],"mappings":"AASA;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,SAwExC"}

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

@@ -0,0 +1,2 @@
+export declare function DragController(): null;
+//# sourceMappingURL=DragController.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DragController.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/DragController.tsx"],"names":[],"mappings":"AAkBA,wBAAgB,cAAc,SAoN7B"}

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

@@ -0,0 +1,16 @@
+import React, { type RefObject } from 'react';
+import { Group } from 'three';
+interface ElementOverlayProps {
+    elementName: string;
+    setId: string;
+    elementId: number;
+    /** Composite key matching `elementsInfo` (`"2"` for mains, `"2.0.6"` for accessories). */
+    elementKey: string;
+    /** Ref to the element root `<group>` — avoids `ref.current === null` on first React render. */
+    elementRootRef: RefObject<Group | null>;
+    onStartDrag: () => void;
+    onStartRotate: () => void;
+}
+export declare function ElementOverlay({ elementName, setId, elementId, elementKey, elementRootRef, onStartDrag, onStartRotate }: ElementOverlayProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=ElementOverlay.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ElementOverlay.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/ElementOverlay.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAA6B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAGzE,OAAO,EAAE,KAAK,EAAW,MAAM,OAAO,CAAC;AA6BvC,UAAU,mBAAmB;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,UAAU,EAAE,MAAM,CAAC;IACnB,+FAA+F;IAC/F,cAAc,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IACxC,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,aAAa,EAAE,MAAM,IAAI,CAAC;CAC3B;AAwED,wBAAgB,cAAc,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,EAAE,EAAE,mBAAmB,qBAyS5I"}

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

@@ -0,0 +1,18 @@
+import React from 'react';
+export declare const MoveSVG: ({ size }: {
+    size: number;
+}) => React.JSX.Element;
+export declare const RotateSVG: ({ size }: {
+    size: number;
+}) => React.JSX.Element;
+export declare const TrashSVG: ({ size }: {
+    size: number;
+}) => React.JSX.Element;
+/**
+ * Chrome-less copy arrow: a solid triangle glyph at 20x40. The base glyph points
+ * left; right/top reuse it rotated 180° / 90°.
+ */
+export declare const CopyArrowSVG: ({ rotateDeg }: {
+    rotateDeg?: number;
+}) => React.JSX.Element;
+//# sourceMappingURL=ElementOverlayIcons.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ElementOverlayIcons.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/ElementOverlayIcons.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAK1B,eAAO,MAAM,OAAO,aAAc;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,sBAkBjD,CAAC;AAEF,eAAO,MAAM,SAAS,aAAc;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,sBAgBnD,CAAC;AAEF,eAAO,MAAM,QAAQ,aAAc;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,sBAiBlD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,kBAAmB;IAAE,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,sBAgBjE,CAAC"}

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

@@ -0,0 +1,10 @@
+import React from 'react';
+/**
+ * Renders the placeable free-cell boxes for one shelf element (mounted inside the element group in
+ * `SceneTree`, so boxes inherit the element's world transform). Clicking an empty box fires
+ * `onAccessoryPlace`; selecting/deleting placed accessories rides the element-selection path.
+ */
+export declare function FreeGridLayer({ elementName }: {
+    elementName: string;
+}): React.JSX.Element | null;
+//# sourceMappingURL=FreeGridLayer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FreeGridLayer.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/FreeGridLayer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkD,MAAM,OAAO,CAAC;AAiBvE;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,WAAW,EAAE,EAAE;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,4BAiJrE"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"InteractionGuides.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/InteractionGuides.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkC,MAAM,OAAO,CAAC;AA6BvD,wBAAgB,iBAAiB,sBAOhC"}

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

@@ -0,0 +1,31 @@
+import { Vector3 } from 'three';
+import type { Camera, Object3D } from 'three';
+import type { AllGrids, FreePlacesOnGrids, ResolvedGridCell } from '../../types/accessoryGrids';
+/** A candidate cell with its world-space centre. */
+export interface WorldCell {
+    cell: ResolvedGridCell;
+    world: Vector3;
+    /** World-space half-diagonal of the cell box. */
+    radius: number;
+}
+/** The nearest {@link WorldCell} to a screen point, with the squared pixel distance that won it. */
+export interface NearestCell {
+    worldCell: WorldCell;
+    distanceSq: number;
+}
+/**
+ * World-space centres of every free cell in the scene, ready for screen-space nearest-cell search.
+ *
+ * Each element node resolves only its own free cells (suffix match inside
+ * `resolveFreeCellsForElement`), so this visits every element node and transforms that node's cells
+ * through its own world matrix. Meant to be called once per drag: the candidate cells belong to the
+ * (stationary) parent elements, not to whatever is being dragged.
+ */
+export declare function collectFreeCellWorldPositions(scene: Object3D, freePlaces: FreePlacesOnGrids[] | null, grids: AllGrids[] | null): WorldCell[];
+/**
+ * Candidate whose projected centre is closest to `clientX`/`clientY` in pixels, or `null` for an
+ * empty list. Screen-space (rather than world-space) distance is camera-correct for any shelf
+ * orientation, so no drag-plane needs to be derived. `rect` is the canvas' `getBoundingClientRect()`.
+ */
+export declare function nearestCellByScreenDistance(list: WorldCell[], clientX: number, clientY: number, rect: DOMRect, camera: Camera): NearestCell | null;
+//# sourceMappingURL=accessoryCellTargeting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accessoryCellTargeting.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/accessoryCellTargeting.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAChC,OAAO,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAC9C,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAMhG,oDAAoD;AACpD,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,oGAAoG;AACpG,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,iBAAiB,EAAE,GAAG,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,GAAG,SAAS,EAAE,CAc5I;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAclJ"}

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

@@ -0,0 +1,65 @@
+import { type ConfigInput, type ConfigResolved } from '../../config/descriptor';
+declare const OVERLAY_ANCHOR_OPTIONS: readonly ["top-left", "top-right", "bottom-left", "bottom-right"];
+declare const OVERLAY_DIRECTION_OPTIONS: readonly ["left", "right", "up", "down"];
+/**
+ * Chrome around a selected element: where the button cluster anchors, which way it grows, and
+ * which buttons it carries. Instantiated twice — once for the 3D overlay, once for 2D.
+ */
+declare function overlayGroup(buttonSize: number, showMove: boolean): import("../../config/descriptor").GroupDescriptor<{
+    primaryAnchor: import("../../config/descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+    primaryDirection: import("../../config/descriptor").EnumField<"left" | "right" | "up" | "down">;
+    trashAnchor: import("../../config/descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+    buttonSize: import("../../config/descriptor").NumberField;
+    showPosNr: import("../../config/descriptor").BooleanField;
+    showMove: import("../../config/descriptor").BooleanField;
+    showRotate: import("../../config/descriptor").BooleanField;
+    showTrash: import("../../config/descriptor").BooleanField;
+}>;
+/**
+ * Selection / manipulation config — the single source for its types, defaults, clamps, round-trip
+ * and analyzer inputs (see `config/descriptor.ts`).
+ */
+export declare const SELECTION_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    /** When false, the hover outline effect never fires (selection outlines are unaffected). */
+    hover: import("../../config/descriptor").BooleanField;
+    showPivotIndicator: import("../../config/descriptor").BooleanField;
+    showArticleName: import("../../config/descriptor").BooleanField;
+    rotationPivot: import("../../config/descriptor").EnumField<"center" | "visual-center">;
+    /** Magnetic snap threshold in degrees — snaps to 45° multiples when within this range (0 = disabled). */
+    snapRotationDeg: import("../../config/descriptor").NumberField;
+    overlay3d: import("../../config/descriptor").GroupDescriptor<{
+        primaryAnchor: import("../../config/descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+        primaryDirection: import("../../config/descriptor").EnumField<"left" | "right" | "up" | "down">;
+        trashAnchor: import("../../config/descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+        buttonSize: import("../../config/descriptor").NumberField;
+        showPosNr: import("../../config/descriptor").BooleanField;
+        showMove: import("../../config/descriptor").BooleanField;
+        showRotate: import("../../config/descriptor").BooleanField;
+        showTrash: import("../../config/descriptor").BooleanField;
+    }>;
+    /**
+     * 2D buttons are larger than 3D because in the planner top-down view the SVG planes already
+     * crowd the canvas — small chrome (22 px) was hard to read and harder to hit. 30 px gives a
+     * 16 px icon (~52% of button) which is roughly the Material/HIG minimum for a touch-friendly
+     * target while staying within reach of mouse precision. The pos-nr badge inherits the same size
+     * so the chrome row reads as one cohesive cluster. `showMove` is off: 2D drags the plane itself.
+     */
+    overlay2d: import("../../config/descriptor").GroupDescriptor<{
+        primaryAnchor: import("../../config/descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+        primaryDirection: import("../../config/descriptor").EnumField<"left" | "right" | "up" | "down">;
+        trashAnchor: import("../../config/descriptor").EnumField<"top-left" | "top-right" | "bottom-left" | "bottom-right">;
+        buttonSize: import("../../config/descriptor").NumberField;
+        showPosNr: import("../../config/descriptor").BooleanField;
+        showMove: import("../../config/descriptor").BooleanField;
+        showRotate: import("../../config/descriptor").BooleanField;
+        showTrash: import("../../config/descriptor").BooleanField;
+    }>;
+}>;
+export type SelectionConfig = ConfigInput<typeof SELECTION_CONFIG>;
+export type ResolvedSelectionConfig = ConfigResolved<typeof SELECTION_CONFIG>;
+/** One selection-overlay button cluster, fully resolved. */
+export type OverlayGroupConfig = ConfigResolved<ReturnType<typeof overlayGroup>>;
+export type OverlayAnchor = (typeof OVERLAY_ANCHOR_OPTIONS)[number];
+export type OverlayDirection = (typeof OVERLAY_DIRECTION_OPTIONS)[number];
+export {};
+//# sourceMappingURL=selection.config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selection.config.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/selection.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEvF,QAAA,MAAM,sBAAsB,mEAAoE,CAAC;AACjG,QAAA,MAAM,yBAAyB,0CAA2C,CAAC;AAE3E;;;GAGG;AACH,iBAAS,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO;;;;;;;;;GAW1D;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B,4FAA4F;;;;;IAQ5F,yGAAyG;;;;;;;;;;;;IAGzG;;;;;;OAMG;;;;;;;;;;;EAEH,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AACnE,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE9E,4DAA4D;AAC5D,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC;AACjF,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAC"}

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

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

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

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

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

@@ -0,0 +1,21 @@
+import type { RefObject } from 'react';
+import type { ThreeEvent } from '@react-three/fiber';
+import { Group } from 'three';
+/**
+ * Drag-to-move for a placed accessory. Press on any *selectable* accessory and drag: once past the
+ * threshold the accessory is selected (if it wasn't) and the move
+ * begins (free-to-move target cells render, OrbitControls suspends), the hovered cell drives the live
+ * preview, and release commits via `commitAccessoryMove`. Returns the `onPointerDown` to attach to the
+ * accessory group. Selectability is gated on the overlay state so accessories outside the shelf-
+ * planner step (state `unselectable`/`active`/absent) are not draggable.
+ */
+export declare function useAccessoryMoveDrag({ elementName, elementKey, setId, isAccessory, elementRootRef, }: {
+    elementName: string;
+    elementKey: string;
+    setId: string;
+    isAccessory: boolean;
+    elementRootRef: RefObject<Group | null>;
+}): {
+    onPointerDownAccessory: (e: ThreeEvent<PointerEvent>) => void;
+};
+//# sourceMappingURL=useAccessoryMoveDrag.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAccessoryMoveDrag.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/useAccessoryMoveDrag.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,KAAK,EAAqB,MAAM,OAAO,CAAC;AAuBjD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,WAAW,EACX,UAAU,EACV,KAAK,EACL,WAAW,EACX,cAAc,GACf,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;CACzC;gCA4DO,UAAU,CAAC,YAAY,CAAC;EAwF/B"}

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

@@ -0,0 +1,35 @@
+import type { ThreeEvent } from '@react-three/fiber';
+interface ElementIdentity {
+    name: string;
+    setId: string;
+    elementId: number;
+    /** Composite key matching `elementsInfo` (`"2"` for mains, `"2.0.6"` for accessories). */
+    elementKey: string;
+    /** When true, hover and click are gated on viewMode === '3d' */
+    gateOn3D?: boolean;
+}
+export declare function useElementInteraction({ name, setId, elementId, elementKey, gateOn3D }: ElementIdentity): {
+    viewMode: "3d" | "2d";
+    isSelected: boolean;
+    isBeingDragged: boolean;
+    isBeingRotated: boolean;
+    dragPosition: [number, number, number] | null;
+    dragRotationY: number;
+    ancestorDragDelta: [number, number, number] | null;
+    groupDragDelta: [number, number, number] | null;
+    ancestorRotation: {
+        angle: number;
+        pivot: [number, number, number];
+    } | null;
+    groupRotation: {
+        angle: number;
+        pivot: [number, number, number];
+    } | null;
+    handleClick: (e: ThreeEvent<MouseEvent>) => void;
+    handlePointerOver: (e: ThreeEvent<PointerEvent>) => void;
+    handlePointerOut: (e: ThreeEvent<PointerEvent>) => void;
+    handleStartDrag: () => void;
+    handleStartRotate: () => void;
+};
+export {};
+//# sourceMappingURL=useElementInteraction.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useElementInteraction.d.ts","sourceRoot":"","sources":["../../../../../../src/core/interaction/useElementInteraction.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAuCrD,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,0FAA0F;IAC1F,UAAU,EAAE,MAAM,CAAC;IACnB,gEAAgE;IAChE,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,qBAAqB,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,QAAgB,EAAE,EAAE,eAAe;;;;;;;;;;;;;;;;;qBA8FzE,UAAU,CAAC,UAAU,CAAC;2BA2ChB,UAAU,CAAC,YAAY,CAAC;0BAwBzB,UAAU,CAAC,YAAY,CAAC;;;EAgClE"}

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

@@ -0,0 +1,16 @@
+import type { ResolvedEnvironmentConfig } from '../types/environment';
+/**
+ * Starts the chunk download for every code-split subsystem the resolved config says will mount.
+ *
+ * Called from `projectResolvedEnvironment` — the single place `resolvedEnvironment` is computed —
+ * rather than from the components, because a chunk requested at mount time is requested at the
+ * worst possible moment: inside the `<Canvas>`, behind WebGL context creation, on the frame the
+ * subsystem is supposed to appear. Requesting it here puts it in flight alongside the scene's GLB
+ * and HDR downloads (see `preloadEnvironmentAssets`), so the capsules' Suspense boundaries
+ * normally resolve on their first render.
+ *
+ * Every `preload*` is idempotent, so re-resolving the environment (tier switch, analyzer patch,
+ * host config push) costs nothing. Scenes that never enable a subsystem never request its chunk.
+ */
+export declare function preloadLazySubsystems(env: ResolvedEnvironmentConfig): void;
+//# sourceMappingURL=lazySubsystems.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lazySubsystems.d.ts","sourceRoot":"","sources":["../../../../../src/core/lazySubsystems.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAKtE;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,yBAAyB,GAAG,IAAI,CAO1E"}

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

@@ -0,0 +1,23 @@
+import React, { type ReactNode } from 'react';
+import type { MeshStandardMaterial } from 'three';
+import type { MatAsset } from '../../parser/parseRenderScript';
+import { type MaterialManagerConfig } from './MaterialManager';
+interface MaterialContextValue {
+    materialMap: Map<string, MeshStandardMaterial>;
+    /** Constructor-service config, so consumers can fetch standard materials by name. */
+    config: MaterialManagerConfig;
+}
+export declare function useMaterials(): MaterialContextValue;
+interface MaterialProviderProps {
+    matAssets: MatAsset[];
+    config: MaterialManagerConfig;
+    children: ReactNode;
+}
+/**
+ * Suspends until every product (matRef) material incl. textures is resolved — the tree below
+ * always mounts with final materials, no post-mount swap. Content-keyed, so re-parses with the
+ * same assets resolve from cache. Must render INSIDE the scene's `<Suspense>` boundary.
+ */
+export declare function MaterialProvider({ matAssets, config, children }: MaterialProviderProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=MaterialContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MaterialContext.d.ts","sourceRoot":"","sources":["../../../../../../src/core/materials/MaterialContext.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAsC,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAClF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,OAAO,CAAC;AAElD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAiB,KAAK,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE9E,UAAU,oBAAoB;IAC5B,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC/C,qFAAqF;IACrF,MAAM,EAAE,qBAAqB,CAAC;CAC/B;AASD,wBAAgB,YAAY,yBAE3B;AAED,UAAU,qBAAqB;IAC7B,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,MAAM,EAAE,qBAAqB,CAAC;IAC9B,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,qBAAqB,qBAOtF"}

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

@@ -0,0 +1,4 @@
+export type { MaterialManagerConfig } from './types';
+export { applyMaterials, enableAnisotropy } from './apply';
+export { collectGltfMaterialNames, disposeTextureCache, getStandardMaterial, loadMaterials, warmStandardMaterials } from './caches';
+//# sourceMappingURL=MaterialManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MaterialManager.d.ts","sourceRoot":"","sources":["../../../../../../src/core/materials/MaterialManager.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC"}

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

@@ -0,0 +1,17 @@
+import type { MeshStandardMaterial, Object3D } from 'three';
+/**
+ * Traverse a loaded Object3D graph (e.g. from GLTFLoader) and enable max
+ * anisotropic filtering on every texture. This prevents blurriness when
+ * surfaces are viewed at grazing angles.
+ */
+export declare function enableAnisotropy(root: Object3D): void;
+/**
+ * Apply materials to a loaded GLB scene based on matRefs.
+ * Each matRef specifies which material (by asset ID) should be applied
+ * to which sub-node (by name, or '' / 'ALL' for all meshes).
+ */
+export declare function applyMaterials(object: Object3D, matRefs: Array<{
+    assetId: string;
+    targetNodeName: string;
+}>, materialMap: Map<string, MeshStandardMaterial>): void;
+//# sourceMappingURL=apply.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../../../../../src/core/materials/apply.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,oBAAoB,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAG5E;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAerD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,QAAQ,EAChB,OAAO,EAAE,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,CAAC,EAC3D,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,QAa/C"}

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

@@ -0,0 +1,44 @@
+import type { MeshStandardMaterial, Object3D } from 'three';
+import type { MatAsset } from '../../parser/parseRenderScript';
+import type { MaterialManagerConfig } from './types';
+/**
+ * Fetch + build the "standard material" for a GLB-embedded material name.
+ * DIVA GLBs ship placeholder materials (flat roughness, no maps); the real look
+ * (chrome, decors, …) lives in the DivaStandardMaterials library and is fetched
+ * by name with `isStdMat=true`. Returns null on 404/error so the caller keeps
+ * the GLB placeholder. The response shape is identical to product materials, so
+ * it flows through the same parse + build pipeline (incl. packed AO + glass).
+ */
+export declare function getStandardMaterial(rawName: string, archiveBaseUrl: string, config: MaterialManagerConfig): Promise<MeshStandardMaterial | null>;
+/**
+ * The GLB-embedded material names in a loaded geo graph — exactly the keys the
+ * DivaStandardMaterials lookup runs on. Shared by `GeoLoader`'s std-material suspend and
+ * {@link warmStandardMaterials} so both resolve the identical name set.
+ */
+export declare function collectGltfMaterialNames(root: Object3D, into?: Set<string>): Set<string>;
+/**
+ * Fire-and-forget warm-up of {@link getStandardMaterial} for every material name in the geo GLBs
+ * that are ALREADY in the geo cache. `peekGLTFCached` means this never starts a download of its own.
+ *
+ * WHY: on the render path a std material is only requested once `GeoLoader` mounts, and that is
+ * behind `MaterialProvider`'s product-material suspend — so the two fetch waves run one after the
+ * other. Worse, React 18 retries a Suspense boundary child by child, so each `GeoLoader` that
+ * introduces a new material name adds another serial fetch + texture round. The inputs (the GLB's
+ * material names) are known the moment `preloadGeoAssets` decoded the GLBs, so kicking the same
+ * cache there lets the whole std wave run concurrently, overlapped with the product-material wave.
+ *
+ * Purely a scheduling change: `stdMaterialCache` is keyed by material name alone, so `GeoLoader`
+ * reads back exactly the promise it would otherwise have created itself — same args, same cache,
+ * same material. Failures are swallowed here; the real suspend surfaces them as it does today.
+ */
+export declare function warmStandardMaterials(geoUrls: Iterable<string>, archiveBaseUrl: string, config: MaterialManagerConfig): void;
+/** Disposes all cached textures/materials and clears the caches. Call on viewer unmount. */
+export declare function disposeTextureCache(): void;
+/**
+ * Fetches all materials from the constructorService and builds a lookup map (mat asset ID →
+ * material). Resolves only when every material INCLUDING its textures is ready — callers can
+ * mount the result directly with no later visual update. Individual failures resolve to
+ * "absent" (the mesh keeps its GLB placeholder), never reject.
+ */
+export declare function loadMaterials(matAssets: MatAsset[], config: MaterialManagerConfig): Promise<Map<string, MeshStandardMaterial>>;
+//# sourceMappingURL=caches.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"caches.d.ts","sourceRoot":"","sources":["../../../../../../src/core/materials/caches.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,oBAAoB,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAElE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAI/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAyCrD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAwChJ;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,GAAE,GAAG,CAAC,MAAM,CAAa,GAAG,GAAG,CAAC,MAAM,CAAC,CAQnG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,qBAAqB,GAAG,IAAI,CA2B5H;AAcD,4FAA4F;AAC5F,wBAAgB,mBAAmB,SASlC;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CA2BpI"}

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

@@ -0,0 +1,37 @@
+import { MeshStandardMaterial } from 'three';
+import type { MatAsset } from '../../parser/parseRenderScript';
+import type { MaterialManagerConfig } from './types';
+export interface FetchedMaterialData {
+    baseTextureUrl?: string;
+    metallicRoughnessTextureUrl?: string;
+    normalTextureUrl?: string;
+    emissiveTextureUrl?: string;
+    aoTextureUrl?: string;
+    alphaTextureUrl?: string;
+    clearcoatTextureUrl?: string;
+    clearcoatNormalTextureUrl?: string;
+    sheenColorTextureUrl?: string;
+    baseColor: [number, number, number];
+    emissiveColor: [number, number, number];
+    emissiveIntensity: number;
+    metallic: number;
+    roughness: number;
+    alpha: number;
+    clearcoat: number;
+    clearcoatRoughness: number;
+    sheen: number;
+    sheenRoughness: number;
+    sheenColor: [number, number, number];
+    transmission: number;
+    ior: number;
+    thickness: number;
+    uScale: number;
+    vScale: number;
+}
+export declare function fetchMaterialDefinition(matAsset: MatAsset, config: MaterialManagerConfig): Promise<FetchedMaterialData | null>;
+export declare function parseBabylonMaterialResponse(data: any): FetchedMaterialData;
+/** Monotonic count of awaited texture slots. See the counter's comment; diagnostics only. */
+export declare function awaitedTextureCount(): number;
+/** Builds the three material; resolves once every referenced texture has loaded or failed. */
+export declare function createThreeMaterial(name: string, data: FetchedMaterialData): Promise<MeshStandardMaterial>;
+//# sourceMappingURL=factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../../../../src/core/materials/factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAsC,MAAM,OAAO,CAAC;AAEjF,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAKrD,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,2BAA2B,CAAC,EAAE,MAAM,CAAC;IACrC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,yBAAyB,CAAC,EAAE,MAAM,CAAC;IACnC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,aAAa,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CA2BpI;AAkBD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,GAAG,GAAG,mBAAmB,CA6D3E;AAYD,6FAA6F;AAC7F,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED,8FAA8F;AAC9F,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAkGhH"}

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

@@ -0,0 +1,13 @@
+import { type ConfigInput, type ConfigResolved } from '../../config/descriptor';
+/**
+ * Material subsystem config — the single source for its types, defaults, clamps, round-trip and
+ * analyzer inputs (see `config/descriptor.ts`). Applied by `MaterialManager` to every std material
+ * it produces.
+ */
+export declare const MATERIALS_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    /** Multiplier on each material's environment-map contribution (drei/three `envMapIntensity`). */
+    envMapIntensity: import("../../config/descriptor").NumberField;
+}>;
+export type MaterialsConfig = ConfigInput<typeof MATERIALS_CONFIG>;
+export type ResolvedMaterialsConfig = ConfigResolved<typeof MATERIALS_CONFIG>;
+//# sourceMappingURL=materials.config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"materials.config.d.ts","sourceRoot":"","sources":["../../../../../../src/core/materials/materials.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,KAAK,WAAW,EAAE,KAAK,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEvF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB;IAC3B,iGAAiG;;EAEjG,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AACnE,MAAM,MAAM,uBAAuB,GAAG,cAAc,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

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

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

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

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

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

@@ -0,0 +1,26 @@
+import { type Texture } from 'three';
+export interface CachedTexture {
+    tex: Texture;
+    /** Resolves when the image has loaded OR failed — never rejects, never hangs. */
+    ready: Promise<void>;
+}
+export declare const MAX_ANISOTROPY = 16;
+/**
+ * Load (and cache) a texture. Callers must await `ready` before handing the owning material
+ * to meshes — three.js binds a not-yet-loaded texture as 1×1 BLACK with the map define active,
+ * zeroing that channel (roughness/metalness/AO → dark flicker) until the image arrives.
+ *
+ * The tiling is part of the cache identity and is applied here. `repeat` lives on the `Texture`,
+ * so two materials that share a URL but tile it differently would otherwise overwrite each other's
+ * tiling on the one shared instance and both render with whichever was applied last. Material
+ * identity already works this way — `productMaterialKey` and `matKey` both include `tileU`/`tileV`.
+ *
+ * @param url the texture URL
+ * @param srgb whether to tag the texture as sRGB (colour maps) rather than linear (data maps)
+ * @param repeatU horizontal tiling factor
+ * @param repeatV vertical tiling factor
+ */
+export declare function loadTexture(url: string, srgb: boolean, repeatU: number, repeatV: number): CachedTexture;
+/** Disposes every cached texture and clears the cache. */
+export declare function disposeTextures(): void;
+//# sourceMappingURL=textureCache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textureCache.d.ts","sourceRoot":"","sources":["../../../../../../src/core/materials/textureCache.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiD,KAAK,OAAO,EAAE,MAAM,OAAO,CAAC;AAOpF,MAAM,WAAW,aAAa;IAC5B,GAAG,EAAE,OAAO,CAAC;IACb,iFAAiF;IACjF,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB;AAID,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CA0BvG;AAED,0DAA0D;AAC1D,wBAAgB,eAAe,IAAI,IAAI,CAGtC"}

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

@@ -0,0 +1,5 @@
+export interface MaterialManagerConfig {
+    constructorServiceUrl: string;
+    jwt?: string;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../src/core/materials/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;CACd"}

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

@@ -0,0 +1,22 @@
+import type { Object3D } from 'three';
+/**
+ * Queue `root` for BVH construction once the browser is idle. Until then its
+ * meshes raycast the default way — `acceleratedRaycast` is only installed
+ * together with the tree, so nothing observes a half-built state.
+ */
+export declare function enableBVHWhenIdle(root: Object3D): void;
+/**
+ * Build every queued tree now. Called by the camera-collision probe before it
+ * collects its targets: a `boundsTree` is what marks decor geometry collidable
+ * (see `utils/collisionTargets.ts`), so the set has to be gathered with the
+ * trees in place, not around them.
+ */
+export declare function flushPendingBVH(): void;
+/**
+ * Tear down BVHs created by {@link enableBVHWhenIdle} and restore the default
+ * raycast. Call on unmount / before swapping the loaded geometry so the tree
+ * (which can be a few MB for dense meshes) isn't retained — and so a root that
+ * never got its turn drops out of the queue instead of resurrecting later.
+ */
+export declare function disposeBVH(root: Object3D): void;
+//# sourceMappingURL=meshBVH.d.ts.map