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

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

@@ -0,0 +1,440 @@
+import { type ConfigInput, type ConfigResolved } from '../../config/descriptor';
+declare const ANCHOR_MODE_OPTIONS: readonly ["min", "center", "max"];
+/**
+ * Axis-aligned XZ hole rectangle in the LOCAL space of the matched deck mesh (not world space —
+ * independent of the scene transform).
+ */
+declare const DECK_CUTOUT_HOLE_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    centerX: import("../../config/descriptor").NumberField;
+    centerZ: import("../../config/descriptor").NumberField;
+    halfExtentX: import("../../config/descriptor").NumberField;
+    halfExtentZ: import("../../config/descriptor").NumberField;
+}>;
+/**
+ * One article-family rule for the scene cutout. `match` is a comma-separated substring OR-list
+ * against the articleCodex; `''`/`'*'` matches everything (also while no codex is known). A
+ * matching rule with `footprintFromGeometry` is what shapes the cutout: the collar is generated
+ * between the authored hole edge and the article's traced outline. With no matching rule there is
+ * no outline and therefore NO COLLAR, which leaves the authored hole open.
+ */
+declare const DECK_CUTOUT_ARTICLE_RULE_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    /** Codex matcher — see {@link DECK_CUTOUT_CONFIG}'s `articleRules`. */
+    match: import("../../config/descriptor").ValueField<string>;
+    /**
+     * Derive the outline from the article's own meshes: everything within `footprintSliceDepth`
+     * below the deck top is projected onto the floor plane and its silhouette traced. Without it the
+     * rule shapes nothing and the article simply sits in the authored rectangular hole.
+     */
+    footprintFromGeometry: import("../../config/descriptor").BooleanField;
+    /**
+     * How far (m) below the deck top the geometry projection reaches — captures the rim, ignores the
+     * sunk basin body.
+     */
+    footprintSliceDepth: import("../../config/descriptor").NumberField;
+}>;
+/**
+ * Textures + world-planar tiling for a collar that carries its own material. All maps are
+ * optional; a missing one just isn't applied. Lengths in m.
+ */
+declare const DECK_CUTOUT_COLLAR_MATERIAL_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    /** Base colour map. '' (the default) = continue the deck's material instead. */
+    mapUrl: import("../../config/descriptor").ValueField<string>;
+    normalMapUrl: import("../../config/descriptor").ValueField<string>;
+    roughnessMapUrl: import("../../config/descriptor").ValueField<string>;
+    /** Metres per texture tile — the real-world size the image covers. */
+    textureScale: import("../../config/descriptor").NumberField;
+    /** Rotation (deg) of the tiling within the deck plane, to line boards up with the deck's. */
+    rotationDeg: import("../../config/descriptor").NumberField;
+    /** Tiling phase (m), to line a board EDGE up rather than only its direction. */
+    offsetX: import("../../config/descriptor").NumberField;
+    offsetZ: import("../../config/descriptor").NumberField;
+}>;
+/**
+ * Generated collar ring between the authored rectangular hole edge and a footprint outline
+ * (a coping surround, in pool terms). All lengths in m.
+ */
+declare const DECK_CUTOUT_COLLAR_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    /**
+     * How far (m) the collar top sits below the deck surface. Only needs to be enough to stop
+     * z-fighting in the band where the collar tucks under the deck (see `overlap`) — it is NOT meant
+     * to be visible, so keep it sub-millimetre unless a deliberately sunken surround is wanted.
+     */
+    recess: import("../../config/descriptor").NumberField;
+    /**
+     * Depth (m) of the skirt extruded downward from the collar top, which stops you seeing under the
+     * deck at the collar's inner edge. `0` (the default) matches the DECK SLAB's own thickness, so
+     * the collar reads as one more of the deck's boards instead of a deep kerb; set a value only for
+     * a deliberately deeper edge.
+     */
+    skirtDepth: import("../../config/descriptor").NumberField;
+    /** How far the collar reaches outward past the authored hole edge, tucked under the deck. */
+    overlap: import("../../config/descriptor").NumberField;
+    /** Collar material color. Used as the flat fallback and as the tint over `material.mapUrl`. */
+    color: import("../../config/descriptor").ColorField;
+    /** Collar material roughness. */
+    roughness: import("../../config/descriptor").NumberField;
+    /**
+     * Give the collar its OWN material instead of continuing the deck's, so the surround can be a
+     * different material than the deck it sits in — another wood, stone, tile. Set `mapUrl` to take
+     * this path; leave it empty and the collar clones the matched deck's material and continues its
+     * mapping.
+     *
+     * Its UVs are then world-planar (`textureScale` metres per tile, rotated by `rotationDeg`), so
+     * the tiling is DECLARED here rather than inherited from whatever unwrap the deck happens to
+     * have — which is also what makes the material swappable without re-deriving anything.
+     */
+    material: import("../../config/descriptor").GroupDescriptor<{
+        /** Base colour map. '' (the default) = continue the deck's material instead. */
+        mapUrl: import("../../config/descriptor").ValueField<string>;
+        normalMapUrl: import("../../config/descriptor").ValueField<string>;
+        roughnessMapUrl: import("../../config/descriptor").ValueField<string>;
+        /** Metres per texture tile — the real-world size the image covers. */
+        textureScale: import("../../config/descriptor").NumberField;
+        /** Rotation (deg) of the tiling within the deck plane, to line boards up with the deck's. */
+        rotationDeg: import("../../config/descriptor").NumberField;
+        /** Tiling phase (m), to line a board EDGE up rather than only its direction. */
+        offsetX: import("../../config/descriptor").NumberField;
+        offsetZ: import("../../config/descriptor").NumberField;
+    }>;
+}>;
+/**
+ * Fits a resizable article into a rectangular hole authored in a flat slab mesh of the loaded
+ * scene GLB (e.g. a pool cutout in a wooden deck). The slab itself is never modified: the article
+ * is moved into the authored hole and `DeckCutoutCollar` generates a ring wearing the deck's own
+ * material that fills everything between the hole edge and the article's traced outline, so the
+ * visible cutout follows the article's shape.
+ */
+declare const DECK_CUTOUT_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    enabled: import("../../config/descriptor").BooleanField;
+    /**
+     * Comma-separated substrings OR-matched against scene-GLB node names (e.g.
+     * `'FLOOR_Wood_2,FLOOR_Wood_3'`) — the deck meshes the collar continues (material, UV mapping,
+     * top height, slab thickness) and whose shared local space all rects below are expressed in.
+     * Empty = no match.
+     */
+    nodeMatch: import("../../config/descriptor").ValueField<string>;
+    /**
+     * The hole rect as authored in the mesh, measured once per asset. Has to be at least the largest
+     * article's footprint: the collar can only fill space that the hole actually leaves.
+     *
+     * Deliberately NOT exposed as analyzer sliders: it's per-asset calibration from the preset, and
+     * a value that doesn't match the mesh puts the collar somewhere the deck has no opening.
+     */
+    authoredHole: import("../../config/descriptor").GroupDescriptor<{
+        centerX: import("../../config/descriptor").NumberField;
+        centerZ: import("../../config/descriptor").NumberField;
+        halfExtentX: import("../../config/descriptor").NumberField;
+        halfExtentZ: import("../../config/descriptor").NumberField;
+    }>;
+    /**
+     * Measure the live article: union bbox of the planner elements in the scene, expressed in the
+     * deck's local space, plus `margin` (m) of deck clearance per side around the outline (negative
+     * laps the deck over the article's rim).
+     */
+    articleSync: import("../../config/descriptor").GroupDescriptor<{
+        enabled: import("../../config/descriptor").BooleanField;
+        margin: import("../../config/descriptor").NumberField;
+    }>;
+    /**
+     * Reposition the planner elements so their union bbox sits inside the authored hole (HQS
+     * `PosPivot === 'CENTER'` grows articles from their center, so the resting spot is re-derived
+     * per size). `offsetX`/`offsetZ` (deck-local meters) fine-tune where the article rests within
+     * the hole. Requires `articleSync`.
+     */
+    elementAnchor: import("../../config/descriptor").GroupDescriptor<{
+        enabled: import("../../config/descriptor").BooleanField;
+        offsetX: import("../../config/descriptor").NumberField;
+        offsetZ: import("../../config/descriptor").NumberField;
+        /**
+         * Lift the article so its TOP meets the deck surface instead of its bottom resting on the
+         * ground. Off by default: it is only right for a catalog whose articles are sunk into the
+         * scene floor (pools), where the rim has to meet the deck whatever the basin's depth is.
+         */
+        alignTopToDeck: import("../../config/descriptor").BooleanField;
+        /**
+         * Nudges the result vertically — the article's measured top is its bbox, which sits a little
+         * above the visible rim on most models.
+         */
+        offsetY: import("../../config/descriptor").NumberField;
+        /**
+         * Choose WHICH part of the article the offset positions: `'center'` centres it, `'min'`/`'max'`
+         * pin that edge to the corresponding edge of the region. Pinning matters when the article
+         * resizes: a centred article grows in both directions, so the edge that mates with a fixed
+         * scene feature (a villa wall the deck runs up to) drifts. `offsetX` / `offsetZ` then read as
+         * an inset from the pinned edge.
+         */
+        anchorX: import("../../config/descriptor").EnumField<"center" | "min" | "max">;
+        anchorZ: import("../../config/descriptor").EnumField<"center" | "min" | "max">;
+    }>;
+    /**
+     * Derive `water.volume` XZ from the anchored article rect: `inset` (m) shrinks it per
+     * side (pool rim width), `offsetX`/`offsetZ` (floor-local meters) shift it for asymmetric basins
+     * (e.g. stair modules). The volume's Y center/size stay as configured. Requires `articleSync`.
+     */
+    waterSync: import("../../config/descriptor").GroupDescriptor<{
+        enabled: import("../../config/descriptor").BooleanField;
+        inset: import("../../config/descriptor").NumberField;
+        offsetX: import("../../config/descriptor").NumberField;
+        offsetZ: import("../../config/descriptor").NumberField;
+    }>;
+    /**
+     * Per-article-family cutout rules, matched against the measured article's codex — first match
+     * wins (append a `match: '*'` entry as fallback). A rule selects which families get a
+     * geometry-traced outline and how deep the slice reaches; the margin stays scene-global in
+     * `articleSync`, which is required.
+     */
+    articleRules: import("../../config/descriptor").ArrayDescriptor<import("../../config/descriptor").GroupDescriptor<{
+        /** Codex matcher — see {@link DECK_CUTOUT_CONFIG}'s `articleRules`. */
+        match: import("../../config/descriptor").ValueField<string>;
+        /**
+         * Derive the outline from the article's own meshes: everything within `footprintSliceDepth`
+         * below the deck top is projected onto the floor plane and its silhouette traced. Without it the
+         * rule shapes nothing and the article simply sits in the authored rectangular hole.
+         */
+        footprintFromGeometry: import("../../config/descriptor").BooleanField;
+        /**
+         * How far (m) below the deck top the geometry projection reaches — captures the rim, ignores the
+         * sunk basin body.
+         */
+        footprintSliceDepth: import("../../config/descriptor").NumberField;
+    }>>;
+    /**
+     * Look of the generated collar ring that bridges a footprint rule's shaped outline to the
+     * authored hole edge.
+     */
+    collar: import("../../config/descriptor").GroupDescriptor<{
+        /**
+         * How far (m) the collar top sits below the deck surface. Only needs to be enough to stop
+         * z-fighting in the band where the collar tucks under the deck (see `overlap`) — it is NOT meant
+         * to be visible, so keep it sub-millimetre unless a deliberately sunken surround is wanted.
+         */
+        recess: import("../../config/descriptor").NumberField;
+        /**
+         * Depth (m) of the skirt extruded downward from the collar top, which stops you seeing under the
+         * deck at the collar's inner edge. `0` (the default) matches the DECK SLAB's own thickness, so
+         * the collar reads as one more of the deck's boards instead of a deep kerb; set a value only for
+         * a deliberately deeper edge.
+         */
+        skirtDepth: import("../../config/descriptor").NumberField;
+        /** How far the collar reaches outward past the authored hole edge, tucked under the deck. */
+        overlap: import("../../config/descriptor").NumberField;
+        /** Collar material color. Used as the flat fallback and as the tint over `material.mapUrl`. */
+        color: import("../../config/descriptor").ColorField;
+        /** Collar material roughness. */
+        roughness: import("../../config/descriptor").NumberField;
+        /**
+         * Give the collar its OWN material instead of continuing the deck's, so the surround can be a
+         * different material than the deck it sits in — another wood, stone, tile. Set `mapUrl` to take
+         * this path; leave it empty and the collar clones the matched deck's material and continues its
+         * mapping.
+         *
+         * Its UVs are then world-planar (`textureScale` metres per tile, rotated by `rotationDeg`), so
+         * the tiling is DECLARED here rather than inherited from whatever unwrap the deck happens to
+         * have — which is also what makes the material swappable without re-deriving anything.
+         */
+        material: import("../../config/descriptor").GroupDescriptor<{
+            /** Base colour map. '' (the default) = continue the deck's material instead. */
+            mapUrl: import("../../config/descriptor").ValueField<string>;
+            normalMapUrl: import("../../config/descriptor").ValueField<string>;
+            roughnessMapUrl: import("../../config/descriptor").ValueField<string>;
+            /** Metres per texture tile — the real-world size the image covers. */
+            textureScale: import("../../config/descriptor").NumberField;
+            /** Rotation (deg) of the tiling within the deck plane, to line boards up with the deck's. */
+            rotationDeg: import("../../config/descriptor").NumberField;
+            /** Tiling phase (m), to line a board EDGE up rather than only its direction. */
+            offsetX: import("../../config/descriptor").NumberField;
+            offsetZ: import("../../config/descriptor").NumberField;
+        }>;
+    }>;
+}>;
+/**
+ * Environment scene config — the single source for its types, defaults, clamps, round-trip and
+ * analyzer inputs (see `config/descriptor.ts`).
+ *
+ * Carries the URL of the standalone environment GLB (deck / backdrop) plus its transform and
+ * cutout rules. Presets ship it in production (e.g. villa-cliff); the analyzer edits it live.
+ * It lives in env so it round-trips through the bundle without a separate persistence channel.
+ */
+export declare const SCENE_CONFIG: import("../../config/descriptor").GroupDescriptor<{
+    /**
+     * `string` for an HTTP-served URL (works across reloads); `'blob:…'` for a locally-uploaded file
+     * (the blob handle dies on reload — the underlying file is cached separately in IndexedDB by the
+     * upload pipeline and `useConfigPersistence.restoreCachedFiles` rehydrates the blob URL there);
+     * `null` for "no scene loaded".
+     */
+    sceneUrl: import("../../config/descriptor").ValueField<string | null>;
+    sceneTransform: import("../../config/descriptor").GroupDescriptor<{
+        /** World-space offset (m). Split into per-axis analyzer sliders. */
+        position: import("../../config/descriptor").TupleField<[number, number, number]>;
+        /** Euler angles in RADIANS (Three.js default XYZ order); the analyzer edits them in degrees. */
+        rotation: import("../../config/descriptor").TupleField<[number, number, number]>;
+        scale: import("../../config/descriptor").NumberField;
+    }>;
+    /**
+     * Additional GLBs loaded alongside `sceneUrl` under the SAME scene transform — e.g. cutout-bearing
+     * floor parts exported in-place from the same authoring scene, while the static remainder (with
+     * its baked AO) stays in the main GLB. Node-name matching (`deckCutout.nodeMatch`) applies to
+     * these too.
+     */
+    sceneParts: import("../../config/descriptor").ArrayDescriptor<import("../../config/descriptor").ValueField<string>>;
+    deckCutout: import("../../config/descriptor").GroupDescriptor<{
+        enabled: import("../../config/descriptor").BooleanField;
+        /**
+         * Comma-separated substrings OR-matched against scene-GLB node names (e.g.
+         * `'FLOOR_Wood_2,FLOOR_Wood_3'`) — the deck meshes the collar continues (material, UV mapping,
+         * top height, slab thickness) and whose shared local space all rects below are expressed in.
+         * Empty = no match.
+         */
+        nodeMatch: import("../../config/descriptor").ValueField<string>;
+        /**
+         * The hole rect as authored in the mesh, measured once per asset. Has to be at least the largest
+         * article's footprint: the collar can only fill space that the hole actually leaves.
+         *
+         * Deliberately NOT exposed as analyzer sliders: it's per-asset calibration from the preset, and
+         * a value that doesn't match the mesh puts the collar somewhere the deck has no opening.
+         */
+        authoredHole: import("../../config/descriptor").GroupDescriptor<{
+            centerX: import("../../config/descriptor").NumberField;
+            centerZ: import("../../config/descriptor").NumberField;
+            halfExtentX: import("../../config/descriptor").NumberField;
+            halfExtentZ: import("../../config/descriptor").NumberField;
+        }>;
+        /**
+         * Measure the live article: union bbox of the planner elements in the scene, expressed in the
+         * deck's local space, plus `margin` (m) of deck clearance per side around the outline (negative
+         * laps the deck over the article's rim).
+         */
+        articleSync: import("../../config/descriptor").GroupDescriptor<{
+            enabled: import("../../config/descriptor").BooleanField;
+            margin: import("../../config/descriptor").NumberField;
+        }>;
+        /**
+         * Reposition the planner elements so their union bbox sits inside the authored hole (HQS
+         * `PosPivot === 'CENTER'` grows articles from their center, so the resting spot is re-derived
+         * per size). `offsetX`/`offsetZ` (deck-local meters) fine-tune where the article rests within
+         * the hole. Requires `articleSync`.
+         */
+        elementAnchor: import("../../config/descriptor").GroupDescriptor<{
+            enabled: import("../../config/descriptor").BooleanField;
+            offsetX: import("../../config/descriptor").NumberField;
+            offsetZ: import("../../config/descriptor").NumberField;
+            /**
+             * Lift the article so its TOP meets the deck surface instead of its bottom resting on the
+             * ground. Off by default: it is only right for a catalog whose articles are sunk into the
+             * scene floor (pools), where the rim has to meet the deck whatever the basin's depth is.
+             */
+            alignTopToDeck: import("../../config/descriptor").BooleanField;
+            /**
+             * Nudges the result vertically — the article's measured top is its bbox, which sits a little
+             * above the visible rim on most models.
+             */
+            offsetY: import("../../config/descriptor").NumberField;
+            /**
+             * Choose WHICH part of the article the offset positions: `'center'` centres it, `'min'`/`'max'`
+             * pin that edge to the corresponding edge of the region. Pinning matters when the article
+             * resizes: a centred article grows in both directions, so the edge that mates with a fixed
+             * scene feature (a villa wall the deck runs up to) drifts. `offsetX` / `offsetZ` then read as
+             * an inset from the pinned edge.
+             */
+            anchorX: import("../../config/descriptor").EnumField<"center" | "min" | "max">;
+            anchorZ: import("../../config/descriptor").EnumField<"center" | "min" | "max">;
+        }>;
+        /**
+         * Derive `water.volume` XZ from the anchored article rect: `inset` (m) shrinks it per
+         * side (pool rim width), `offsetX`/`offsetZ` (floor-local meters) shift it for asymmetric basins
+         * (e.g. stair modules). The volume's Y center/size stay as configured. Requires `articleSync`.
+         */
+        waterSync: import("../../config/descriptor").GroupDescriptor<{
+            enabled: import("../../config/descriptor").BooleanField;
+            inset: import("../../config/descriptor").NumberField;
+            offsetX: import("../../config/descriptor").NumberField;
+            offsetZ: import("../../config/descriptor").NumberField;
+        }>;
+        /**
+         * Per-article-family cutout rules, matched against the measured article's codex — first match
+         * wins (append a `match: '*'` entry as fallback). A rule selects which families get a
+         * geometry-traced outline and how deep the slice reaches; the margin stays scene-global in
+         * `articleSync`, which is required.
+         */
+        articleRules: import("../../config/descriptor").ArrayDescriptor<import("../../config/descriptor").GroupDescriptor<{
+            /** Codex matcher — see {@link DECK_CUTOUT_CONFIG}'s `articleRules`. */
+            match: import("../../config/descriptor").ValueField<string>;
+            /**
+             * Derive the outline from the article's own meshes: everything within `footprintSliceDepth`
+             * below the deck top is projected onto the floor plane and its silhouette traced. Without it the
+             * rule shapes nothing and the article simply sits in the authored rectangular hole.
+             */
+            footprintFromGeometry: import("../../config/descriptor").BooleanField;
+            /**
+             * How far (m) below the deck top the geometry projection reaches — captures the rim, ignores the
+             * sunk basin body.
+             */
+            footprintSliceDepth: import("../../config/descriptor").NumberField;
+        }>>;
+        /**
+         * Look of the generated collar ring that bridges a footprint rule's shaped outline to the
+         * authored hole edge.
+         */
+        collar: import("../../config/descriptor").GroupDescriptor<{
+            /**
+             * How far (m) the collar top sits below the deck surface. Only needs to be enough to stop
+             * z-fighting in the band where the collar tucks under the deck (see `overlap`) — it is NOT meant
+             * to be visible, so keep it sub-millimetre unless a deliberately sunken surround is wanted.
+             */
+            recess: import("../../config/descriptor").NumberField;
+            /**
+             * Depth (m) of the skirt extruded downward from the collar top, which stops you seeing under the
+             * deck at the collar's inner edge. `0` (the default) matches the DECK SLAB's own thickness, so
+             * the collar reads as one more of the deck's boards instead of a deep kerb; set a value only for
+             * a deliberately deeper edge.
+             */
+            skirtDepth: import("../../config/descriptor").NumberField;
+            /** How far the collar reaches outward past the authored hole edge, tucked under the deck. */
+            overlap: import("../../config/descriptor").NumberField;
+            /** Collar material color. Used as the flat fallback and as the tint over `material.mapUrl`. */
+            color: import("../../config/descriptor").ColorField;
+            /** Collar material roughness. */
+            roughness: import("../../config/descriptor").NumberField;
+            /**
+             * Give the collar its OWN material instead of continuing the deck's, so the surround can be a
+             * different material than the deck it sits in — another wood, stone, tile. Set `mapUrl` to take
+             * this path; leave it empty and the collar clones the matched deck's material and continues its
+             * mapping.
+             *
+             * Its UVs are then world-planar (`textureScale` metres per tile, rotated by `rotationDeg`), so
+             * the tiling is DECLARED here rather than inherited from whatever unwrap the deck happens to
+             * have — which is also what makes the material swappable without re-deriving anything.
+             */
+            material: import("../../config/descriptor").GroupDescriptor<{
+                /** Base colour map. '' (the default) = continue the deck's material instead. */
+                mapUrl: import("../../config/descriptor").ValueField<string>;
+                normalMapUrl: import("../../config/descriptor").ValueField<string>;
+                roughnessMapUrl: import("../../config/descriptor").ValueField<string>;
+                /** Metres per texture tile — the real-world size the image covers. */
+                textureScale: import("../../config/descriptor").NumberField;
+                /** Rotation (deg) of the tiling within the deck plane, to line boards up with the deck's. */
+                rotationDeg: import("../../config/descriptor").NumberField;
+                /** Tiling phase (m), to line a board EDGE up rather than only its direction. */
+                offsetX: import("../../config/descriptor").NumberField;
+                offsetZ: import("../../config/descriptor").NumberField;
+            }>;
+        }>;
+    }>;
+}>;
+export type SceneConfig = ConfigInput<typeof SCENE_CONFIG>;
+export type ResolvedSceneConfig = ConfigResolved<typeof SCENE_CONFIG>;
+/** @see DECK_CUTOUT_CONFIG */
+export type DeckCutoutConfig = ConfigInput<typeof DECK_CUTOUT_CONFIG>;
+export type ResolvedDeckCutoutConfig = ConfigResolved<typeof DECK_CUTOUT_CONFIG>;
+export type DeckCutoutHoleConfig = ConfigInput<typeof DECK_CUTOUT_HOLE_CONFIG>;
+export type ResolvedDeckCutoutHole = ConfigResolved<typeof DECK_CUTOUT_HOLE_CONFIG>;
+export type DeckCutoutArticleRuleConfig = ConfigInput<typeof DECK_CUTOUT_ARTICLE_RULE_CONFIG>;
+export type ResolvedDeckCutoutArticleRule = ConfigResolved<typeof DECK_CUTOUT_ARTICLE_RULE_CONFIG>;
+export type DeckCutoutCollarConfig = ConfigInput<typeof DECK_CUTOUT_COLLAR_CONFIG>;
+export type ResolvedDeckCutoutCollar = ConfigResolved<typeof DECK_CUTOUT_COLLAR_CONFIG>;
+export type DeckCutoutCollarMaterialConfig = ConfigInput<typeof DECK_CUTOUT_COLLAR_MATERIAL_CONFIG>;
+export type ResolvedDeckCutoutCollarMaterial = ConfigResolved<typeof DECK_CUTOUT_COLLAR_MATERIAL_CONFIG>;
+/** Which part of an article an axis positions: an edge, or its middle. */
+export type DeckCutoutAnchorMode = (typeof ANCHOR_MODE_OPTIONS)[number];
+export {};
+//# sourceMappingURL=scene.config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scene.config.d.ts","sourceRoot":"","sources":["../../../../../../src/core/environment/scene.config.ts"],"names":[],"mappings":"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"}

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

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

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

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

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

@@ -0,0 +1,19 @@
+import type { Texture } from 'three';
+export interface UseEnvironmentMapOptions {
+    url: string;
+    tileX: number;
+    tileY: number;
+    offsetX: number;
+    offsetY: number;
+    highlightBoost: number;
+}
+/**
+ * Loads one equirectangular HDRI and prefilters it into an IBL env map: load →
+ * tile/offset+boost bake → PMREM. Returns `null` until the map is ready.
+ *
+ * Holds the `environment-hdr` scene-load gate for the whole chain, and owns the
+ * GPU resources: the PMREM generator, the intermediate textures and — once
+ * superseded or unmounted — the env map itself.
+ */
+export declare function useEnvironmentMap({ url, tileX, tileY, offsetX, offsetY, highlightBoost }: UseEnvironmentMapOptions): Texture | null;
+//# sourceMappingURL=useEnvironmentMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useEnvironmentMap.d.ts","sourceRoot":"","sources":["../../../../../../src/core/environment/useEnvironmentMap.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,OAAO,EAAiB,MAAM,OAAO,CAAC;AAyIpD,MAAM,WAAW,wBAAwB;IACvC,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;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,EAAE,wBAAwB,GAAG,OAAO,GAAG,IAAI,CAmGnI"}

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

@@ -0,0 +1,28 @@
+import { type RefObject } from 'react';
+import type { DirectionalLight, SpotLight } from 'three';
+import type { ResolvedEnvironmentConfig } from '../../types/environment';
+/**
+ * Ref to whichever light variant a studio slot rendered — spot or directional.
+ * Both expose the `target` / `shadow` surface these hooks touch.
+ */
+type StudioLightRef = RefObject<DirectionalLight | SpotLight | null>;
+/**
+ * Park a light's `target` at `aimAt` (typically the scene center) so the light
+ * always points at the product.
+ *
+ * Three.js requires `light.target.updateMatrixWorld()` after moving the target,
+ * otherwise the light stays aimed at wherever the matrix was last computed.
+ */
+export declare function useAimedTarget(lightRef: StudioLightRef, aimAt: [number, number, number]): void;
+/**
+ * Push the master shadow scalars onto this light's own `light.shadow`. Mirrors
+ * the same fields SunShadow tracks, so changing mapSize / radius / bias /
+ * normalBias affects every shadow-casting light identically.
+ *
+ * The shadow runs in bake-on-demand mode (`autoUpdate = false`) on the shared
+ * `shadowsVersion` channel, and is marked dirty here where the scalars are
+ * applied. No-op while the light does not cast or no master config resolved.
+ */
+export declare function useMirroredShadowConfig(lightRef: StudioLightRef, castShadow?: boolean, shadowCfg?: ResolvedEnvironmentConfig['shadows']): void;
+export {};
+//# sourceMappingURL=useStudioLightEffects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useStudioLightEffects.d.ts","sourceRoot":"","sources":["../../../../../../src/core/environment/useStudioLightEffects.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAClD,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAGzE;;;GAGG;AACH,KAAK,cAAc,GAAG,SAAS,CAAC,gBAAgB,GAAG,SAAS,GAAG,IAAI,CAAC,CAAC;AAErE;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAO9F;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,cAAc,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,yBAAyB,CAAC,SAAS,CAAC,GAAG,IAAI,CAqB9I"}

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

@@ -0,0 +1,91 @@
+/**
+ * Single source of truth for `useFrame` execution order in this package.
+ *
+ * R3F runs every `useFrame` subscriber in ascending priority and then — unless
+ * some subscriber has taken over rendering — renders the scene itself. Ties are
+ * broken by subscription order, which is React mount order (children before
+ * parents, hooks in call order): an implicit, refactor-fragile contract. Every
+ * ordering-sensitive call site in the package therefore names a stage from this
+ * table instead of writing a literal.
+ *
+ * Taking over the render: R3F disables its automatic render as soon as ANY
+ * subscriber has a priority > 0 (`internal.priority` in the fiber store). The
+ * camera spring at {@link FRAME_ORDER.CAMERA_SMOOTHING} is always mounted, so
+ * this package is permanently in manual-render mode and something MUST present
+ * at {@link FRAME_ORDER.SCREEN_PRESENT} or the canvas freezes.
+ *
+ * The three sub-zero camera stages sit between two fixed points we do not own:
+ * drei's `OrbitControls` hard-codes its `controls.update()` at
+ * {@link FRAME_ORDER.CONTROLS_UPDATE}, and drei's `<Html>` overlays project at
+ * the default 0. That is why {@link FRAME_ORDER.CAMERA_ANIMATION} and
+ * {@link FRAME_ORDER.CAMERA_PRE_HTML_SNAP} are fractional — the only room to
+ * order them explicitly is inside that window.
+ */
+export declare const FRAME_ORDER: {
+    /**
+     * Frame-rate-independent OrbitControls damping (`useCameraSmoothing`).
+     * Must land before {@link FRAME_ORDER.CONTROLS_UPDATE} so the dt-corrected
+     * `dampingFactor` is in place for this frame's `(1 - dampingFactor)` decay.
+     */
+    readonly CONTROLS_DAMPING_SYNC: -2;
+    /**
+     * drei `OrbitControls.update()` — writes the **proxy** camera (user-intent
+     * pose). Owned by `@react-three/drei` and not settable from here; listed so
+     * the stages around it are readable. Pinned at -1 in drei's source.
+     */
+    readonly CONTROLS_UPDATE: -1;
+    /**
+     * Programmatic camera fly (`useCameraAnimation`) advances the proxy.
+     * After OrbitControls (which is disabled mid-fly, so running behind it is
+     * free) and before the pre-`<Html>` snap that mirrors the pose it produced.
+     */
+    readonly CAMERA_ANIMATION: -0.9;
+    /**
+     * Pre-`<Html>` snap (`useCameraSmoothing`): mirrors real ← proxy during a
+     * programmatic animation. Must sit after {@link FRAME_ORDER.CAMERA_ANIMATION}
+     * (it reads the pose that stage just wrote) and before drei's `<Html>`
+     * overlays project through the real camera at the default 0 — otherwise the
+     * DOM overlays lag a frame and swim during a focus fly.
+     */
+    readonly CAMERA_PRE_HTML_SNAP: -0.8;
+    /**
+     * Everything with no explicit priority: drei `<Html>`, the sibling camera
+     * hooks that write the proxy (auto-frame, auto-rotate, constraints, view-mode
+     * transition), dimension-line fades, overlays, the analyzer probes. Not passed
+     * anywhere — R3F's own default. Listed so the window it occupies is visible.
+     */
+    readonly DEFAULT: 0;
+    /**
+     * Camera chase spring (`useCameraSmoothing`) — springs the **real** (rendered)
+     * camera toward the proxy. Must land after OrbitControls and after every
+     * default-priority sibling hook that writes the proxy, so it springs toward
+     * this frame's final user-intent pose.
+     */
+    readonly CAMERA_SMOOTHING: 1;
+    /**
+     * Water: heightfield sim, screen-space-refraction scene capture,
+     * caustics bake, uniform publish. Must run AFTER
+     * {@link FRAME_ORDER.CAMERA_SMOOTHING} so the capture and the `eye` uniform
+     * read the same settled pose the surface is later composited from — at the
+     * default 0 the capture ran before the spring advanced the rendered camera
+     * while the composite ran after it, so the underwater view lagged the camera
+     * by a frame of motion (worst at low fps / high DPR).
+     */
+    readonly WATER_CAPTURE: 2;
+    /**
+     * The screen present. Exactly one of two mutually exclusive call sites
+     * occupies this stage (`SceneEnvironment` picks between them):
+     * the pmndrs `EffectComposer` composite, or the plain `gl.render` fallback
+     * for the no-post-processing path. Same ordinal on purpose — the frame order
+     * is identical either way. After {@link FRAME_ORDER.WATER_CAPTURE} so the
+     * composite draws the water surface against a same-pose refraction texture.
+     */
+    readonly SCREEN_PRESENT: 3;
+    /**
+     * Screenshot readback (`useCaptureEngine`) — reads the canvas via
+     * `toDataURL`, so it must run after {@link FRAME_ORDER.SCREEN_PRESENT} has
+     * drawn this frame into the default framebuffer.
+     */
+    readonly SCREENSHOT_READBACK: 4;
+};
+//# sourceMappingURL=frameOrder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frameOrder.d.ts","sourceRoot":"","sources":["../../../../../src/core/frameOrder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,WAAW;IACtB;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;OAIG;;IAGH;;;;;;OAMG;;IAGH;;;;;OAKG;;IAGH;;;;;OAKG;;IAGH;;;;;;;;OAQG;;IAGH;;;;;;;OAOG;;IAGH;;;;OAIG;;CAEK,CAAC"}