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

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

@@ -0,0 +1,38 @@
+/**
+ * Opt-in frame-cost logger: one summary line per window, so two runs can be compared directly
+ * (e.g. with and without `?rtv-debug`). Deliberately lives in rtv-next rather than the analyzer —
+ * the interesting comparison is the run where the analyzer is NOT mounted, and r3f-perf's HUD is
+ * analyzer-only (and itself costs GPU work, which is exactly the thing being measured).
+ *
+ * Reported per window:
+ *   - `fps` / `msAvg`     — mean over the window. Averages hide stutter, so they are never the whole
+ *                           story; a scene can average 60fps and still feel bad.
+ *   - `msP95` / `msWorst` — the jank signal. `msP95` is the one to compare between runs: `msWorst`
+ *                           catches a single GC pause or asset decode and is very noisy.
+ *   - `slow`              — frames over 33ms. A rising ratio at unchanged `fps` means the frame cost
+ *                           became bimodal (periodic expensive work), which reads as stutter.
+ *   - `callsAvg`/`callsMax`— draw calls per frame, mean and peak over the window (`trisMax` is the
+ *                           peak triangle count). `callsMax` far above `callsAvg` means a few frames
+ *                           do much more work than the rest — the signature of periodic work, which
+ *                           is exactly what stutter at a healthy average FPS looks like.
+ *   - `geo`/`tex`/`prog`  — resident GPU resources. Identical counts across two runs prove the same
+ *                           scene is loaded; rising counts across consecutive windows are a leak.
+ *   - `tier` / `dpr`      — resolved profile and pixel ratio, so a run is self-describing (a tier
+ *                           difference alone explains a frame-cost difference).
+ *
+ * KNOWN LIMITATION: `callsAvg`/`callsMax`/`trisMax` read 0 while r3f-perf's `<Perf>` is mounted
+ * (analyzer at debug level 2). It owns the same `info.autoReset = false` counter and clears it on its
+ * own schedule, so there is nothing left to bank here. The timing metrics are unaffected — only the
+ * draw counters are, and they are meaningful in every other configuration.
+ *
+ * Sampling note: the window is closed from an interval timer rather than the frame loop, so the
+ * logging work stays off the render path. The draw counters need `info.autoReset = false` (see the
+ * effect below) — without it they only ever report the composer's final fullscreen pass.
+ *
+ * `fps` counts `useFrame` ticks, which run at the rAF rate. `renderer.maxFps` throttles PRESENTS only
+ * (see `useFrameloopVisibility`), so a capped scene still ticks at display rate — read this as "how
+ * well the loop keeps up", not as the presented frame rate. Comparing two runs of the same profile is
+ * apples to apples; comparing across profiles with different caps is not.
+ */
+export declare function PerfLogController(): null;
+//# sourceMappingURL=PerfLog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PerfLog.d.ts","sourceRoot":"","sources":["../../../../../src/core/PerfLog.tsx"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAyFxC"}

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

@@ -0,0 +1,83 @@
+import React, { type MutableRefObject } from 'react';
+/**
+ * Two-tier "pristine grid" planner backdrop.
+ *
+ * Replaces drei's `<Grid>` for the 2D top-down view because drei's grid
+ * shader uses a screen-space distance approximation that visibly breaks
+ * down at small line widths and certain camera distances — the line
+ * collapses into a series of discrete "dabs" along its run, reading as a
+ * dashed line instead of a continuous stroke.
+ *
+ * The implementation here is a direct port of Ben Golus's *Pristine Grid*
+ * algorithm — the de-facto reference for analytical screen-space grids
+ * (Figma's canvas grid, Blender's overlay grid, modern CAD viewports use
+ * variants of it). Reference: https://bgolus.medium.com/the-best-darn-grid-shader-yet-727f9278b9d8
+ *
+ * The key idea is to **define line width in screen pixels**, not world
+ * units, and use `fwidth()` of the world-space UV to compute the
+ * per-fragment derivative. The shader then:
+ *
+ *   1. Picks an anti-alias half-width equal to the derivative (so AA is
+ *      always exactly one pixel wide, regardless of zoom).
+ *   2. Clamps the requested line width up to that derivative — when the
+ *      camera pulls back so far that a 1.5 px line would be sub-pixel,
+ *      the shader transparently lets the line widen and fades its
+ *      opacity proportionally so total visual weight stays constant.
+ *      This is exactly what stops the dotted/dashed degeneration.
+ *   3. Inverts the math when `lineWidth > 0.5` so dense grids (large
+ *      thickness) don't double-draw at intersections.
+ *
+ * Two cell tiers are composed by running the algorithm twice — once for
+ * the minor 25 cm cells and once for the major 1 m sections — and
+ * blending major over minor. Distance fade from camera matches drei's
+ * `fadeDistance` / `fadeStrength` semantics so the rest of the pipeline
+ * stays predictable.
+ *
+ * The mesh is a giant ground plane (1000 m square) that follows the
+ * camera in X/Z each frame; that's the cheapest way to give an
+ * "infinite" grid without recomputing geometry. The grid pattern is
+ * fully procedural so no texture is uploaded.
+ */
+interface PlannerGridProps {
+    /** Minor grid cell size in metres. */
+    cellSize: number;
+    /** Major grid section size in metres (typically `4 × cellSize`). */
+    sectionSize: number;
+    /** CSS hex string for minor (cell) lines. */
+    cellColor: string;
+    /** CSS hex string for major (section) lines. */
+    sectionColor: string;
+    /** Line width in screen pixels for minor cells. ≥1 recommended. */
+    cellThickness: number;
+    /** Line width in screen pixels for major sections. ≥1 recommended. */
+    sectionThickness: number;
+    /** Distance (m) past which the grid fully fades. */
+    fadeDistance: number;
+    /**
+     * 0–1: how aggressively distance fades the grid.
+     * `0` = no fade, `1` = full fade across `fadeDistance`.
+     */
+    fadeStrength: number;
+    /**
+     * Camera distance (m) at which the minor cell lines start to fade
+     * out, leaving only the major sections visible. The fade band is
+     * 30 % of the threshold, centred on it. Set to a very large value
+     * (e.g. `1e6`) to effectively disable.
+     */
+    cellHideDistance: number;
+    /** Y offset of the grid plane in world units. */
+    y?: number;
+    /** Plane size in metres. Default 1000 (effectively "infinite" at planner zoom). */
+    size?: number;
+    /** When `true` the plane re-centres on the camera each frame, giving an infinite grid. */
+    followCamera?: boolean;
+    /**
+     * Live global fade (0 = hidden, 1 = full), read every frame so the grid can
+     * cross-fade with the 2D↔3D camera transition without re-rendering. Multiplies
+     * the final fragment alpha. Omit for a permanently-opaque grid.
+     */
+    opacityRef?: MutableRefObject<number>;
+}
+export declare function PlannerGrid({ cellSize, sectionSize, cellColor, sectionColor, cellThickness, sectionThickness, fadeDistance, fadeStrength, cellHideDistance, y, size, followCamera, opacityRef, }: PlannerGridProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=PlannerGrid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PlannerGrid.d.ts","sourceRoot":"","sources":["../../../../../src/core/PlannerGrid.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAmB,KAAK,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAItE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,UAAU,gBAAgB;IACxB,sCAAsC;IACtC,QAAQ,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAC;IACtB,sEAAsE;IACtE,gBAAgB,EAAE,MAAM,CAAC;IACzB,oDAAoD;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB,iDAAiD;IACjD,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,mFAAmF;IACnF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,0FAA0F;IAC1F,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;CACvC;AAuID,wBAAgB,WAAW,CAAC,EAC1B,QAAQ,EACR,WAAW,EACX,SAAS,EACT,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,CAAK,EACL,IAAW,EACX,YAAmB,EACnB,UAAU,GACX,EAAE,gBAAgB,qBA6DlB"}

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

@@ -0,0 +1,31 @@
+import React from 'react';
+interface Props {
+    /** Children to render unless an asset load throws. */
+    children: React.ReactNode;
+    /**
+     * Identifier that distinguishes the current asset from previous ones.
+     * Typically the URL itself. When this changes the boundary clears any
+     * recorded error so the new asset can try afresh.
+     */
+    resetKey: string;
+    /** Optional human-readable label included in the log line on failure. */
+    label?: string;
+    /** Optional UI to render on failure. Defaults to `null` (silent skip). */
+    fallback?: React.ReactNode;
+}
+interface State {
+    /** URL/key under which the current error was recorded. */
+    /** Whether an asset load below this boundary threw. */
+    hasError: boolean;
+    /** `resetKey` as of the last render — a change in it is what clears the error. */
+    seenKey: string | null;
+}
+export declare class R3FAssetBoundary extends React.Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(): Partial<State>;
+    static getDerivedStateFromProps(props: Props, state: State): Partial<State> | null;
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    render(): React.ReactNode;
+}
+export {};
+//# sourceMappingURL=R3FAssetBoundary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"R3FAssetBoundary.d.ts","sourceRoot":"","sources":["../../../../../src/core/R3FAssetBoundary.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAsB1B,UAAU,KAAK;IACb,sDAAsD;IACtD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;CAC5B;AAED,UAAU,KAAK;IACb,0DAA0D;IAC1D,uDAAuD;IACvD,QAAQ,EAAE,OAAO,CAAC;IAClB,kFAAkF;IAClF,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,qBAAa,gBAAiB,SAAQ,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC;IACjE,KAAK,EAAE,KAAK,CAAsC;IAElD,MAAM,CAAC,wBAAwB,IAAI,OAAO,CAAC,KAAK,CAAC;IAIjD,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,IAAI;IAUlF,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,SAAS;IAUrD,MAAM;CAMP"}

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

@@ -0,0 +1,16 @@
+import React, { Component, type ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+}
+interface State {
+    hasError: boolean;
+    error: Error | null;
+}
+export declare class RTVErrorBoundary extends Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, info: React.ErrorInfo): void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+}
+export {};
+//# sourceMappingURL=RTVErrorBoundary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"RTVErrorBoundary.d.ts","sourceRoot":"","sources":["../../../../../src/core/RTVErrorBoundary.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAKzD,UAAU,KAAK;IACb,QAAQ,EAAE,SAAS,CAAC;CACrB;AAED,UAAU,KAAK;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED,qBAAa,gBAAiB,SAAQ,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC;IAC3D,KAAK,EAAE,KAAK,CAAoC;IAEhD,MAAM,CAAC,wBAAwB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IAIpD,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,CAAC,SAAS;IASrD,MAAM;CAsBP"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"SceneRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/core/SceneRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA6E,MAAM,OAAO,CAAC;AAsClG,wBAAgB,aAAa,sBA6I5B"}

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { SceneNode, GeoAsset, MatRef } from '../parser/parseRenderScript';
+interface SceneTreeProps {
+    node: SceneNode;
+    geoAssets: GeoAsset[];
+    archiveBaseUrl: string;
+    parentMatRefs?: MatRef[];
+    elementName?: string;
+    parentSetName?: string;
+    insideElement?: boolean;
+    /** Accumulated path of node names for generating unique geo group names. */
+    nodePath?: string;
+}
+export declare function SceneTree({ node, geoAssets, archiveBaseUrl, parentMatRefs, elementName, parentSetName, insideElement, nodePath }: SceneTreeProps): React.JSX.Element;
+export {};
+//# sourceMappingURL=SceneTree.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SceneTree.d.ts","sourceRoot":"","sources":["../../../../../src/core/SceneTree.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAiB,MAAM,OAAO,CAAC;AAGtC,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAyC/E,UAAU,cAAc;IACtB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAgB,SAAS,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,QAAa,EAAE,EAAE,cAAc,qBA+CrJ"}

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

@@ -0,0 +1,62 @@
+import React from 'react';
+import type { ReactNode } from 'react';
+import type { GeoAsset, MatRef, SceneNode } from '../parser/parseRenderScript';
+import type { AccessoryGridGeo, AllGrids } from '../types/accessoryGrids';
+/** Full grid geometry of the accessory whose artNr matches `name`, across all loaded grids. */
+export declare function geoOf(grids: AllGrids[] | null, name: string | undefined): AccessoryGridGeo | undefined;
+interface VariantMeshOverrideProps {
+    /** ArticleCodex of the variant the drag is currently targeting (≠ the dragged accessory's own). */
+    variantCodex: string;
+    /** Variant's real geo (glb) name (e.g. `GEO_TAB_50_VR`) — from the host. Resolved by the caller
+     *  from the live move or a just-committed switch, so it survives the move state being cleared. */
+    geo3DName?: string;
+    /** Variant's model name (accessoire3DName) — used to look up its bbox for the loading proxy. */
+    modelName?: string;
+    /** Dragged accessory's model name — to look up its bbox for re-centering (variants are corner-anchored). */
+    draggedModelName?: string;
+    /** The dragged accessory's scene node — source of its REAL loaded glb URL + local mesh placement. */
+    node: SceneNode;
+    geoAssets: GeoAsset[];
+    archiveBaseUrl: string;
+    matRefs: MatRef[];
+}
+/** Local error boundary so a 404 on the variant glb degrades to the proxy, not the global boundary. */
+export declare class MeshErrorBoundary extends React.Component<{
+    fallback: ReactNode;
+    onError: () => void;
+    children: ReactNode;
+}, {
+    hasError: boolean;
+}> {
+    state: {
+        hasError: boolean;
+    };
+    static getDerivedStateFromError(): {
+        hasError: boolean;
+    };
+    componentDidCatch(): void;
+    render(): React.ReactNode;
+}
+interface BaseMesh {
+    asset: GeoAsset;
+    /** Mesh placement in the element group's local frame (accumulated child-node + geoRef positions). */
+    position: [number, number, number];
+    rotation: [number, number, number];
+}
+/** The dragged accessory's own mesh + its placement (accumulated child-node + geoRef positions) — the
+ *  variant mesh reuses this anchor (the group is already snapped to the target by SceneTree). */
+export declare function findBaseMesh(node: SceneNode, geoAssets: GeoAsset[], accPos?: [number, number, number]): BaseMesh | undefined;
+/**
+ * While a family accessory is dragged over a cell that expects a DIFFERENT variant (size/position
+ * swap), this shows the targeted variant so the accessory visibly resizes mid-drag. `SceneTree`
+ * hides the accessory's own geometry while this is mounted, and snaps the element group to the
+ * target cell — so this renders at the dragged accessory's own mesh placement (same anchor).
+ *
+ * The variant's REAL glb is loaded on demand: its geo (glb) name comes from the host on the
+ * free-places entry (`geo3DName`, e.g. `GEO_TAB_50_VR`; NOT the codex/model3DName), and the URL
+ * reuses the dragged accessory's own glb path (same catalog/blob, only the filename differs). A
+ * translucent bbox proxy shows while it loads / if `geo3DName` or the base path is unavailable / on 404.
+ */
+export declare function VariantMeshOverride({ variantCodex, geo3DName: geoModel, modelName, draggedModelName, node, geoAssets, archiveBaseUrl, matRefs }: VariantMeshOverrideProps): React.JSX.Element | null;
+export {};
+//# sourceMappingURL=VariantMeshOverride.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"VariantMeshOverride.d.ts","sourceRoot":"","sources":["../../../../../src/core/VariantMeshOverride.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2B,MAAM,OAAO,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAIvC,OAAO,KAAK,EAAE,QAAQ,EAAU,MAAM,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACvF,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAyC1E,+FAA+F;AAC/F,wBAAgB,KAAK,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,gBAAgB,GAAG,SAAS,CAOtG;AAED,UAAU,wBAAwB;IAChC,mGAAmG;IACnG,YAAY,EAAE,MAAM,CAAC;IACrB;sGACkG;IAClG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gGAAgG;IAChG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4GAA4G;IAC5G,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qGAAqG;IACrG,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,uGAAuG;AACvG,qBAAa,iBAAkB,SAAQ,KAAK,CAAC,SAAS,CAAC;IAAE,QAAQ,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,MAAM,IAAI,CAAC;IAAC,QAAQ,EAAE,SAAS,CAAA;CAAE,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;IAC9I,KAAK;;MAAuB;IAC5B,MAAM,CAAC,wBAAwB;;;IAG/B,iBAAiB;IAGjB,MAAM;CAGP;AAED,UAAU,QAAQ;IAChB,KAAK,EAAE,QAAQ,CAAC;IAChB,qGAAqG;IACrG,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC;AAED;iGACiG;AACjG,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,MAAM,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAQ,GAAG,QAAQ,GAAG,SAAS,CAUlI;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,gBAAgB,EAAE,IAAI,EAAE,SAAS,EAAE,cAAc,EAAE,OAAO,EAAE,EAAE,wBAAwB,4BAqCzK"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"CameraController.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/CameraController.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkD,MAAM,OAAO,CAAC;AAgDvE,wBAAgB,gBAAgB,sBA8a/B"}

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

@@ -0,0 +1,69 @@
+import { Vector3, Quaternion, Euler, PerspectiveCamera } from 'three';
+export type EasingFn = 'smoothstep' | 'easeInOut';
+export interface AnimationRequest {
+    endPos: Vector3;
+    endTarget: Vector3;
+    duration: number;
+    easing: EasingFn;
+    fade?: 'in' | 'out';
+    onComplete?: () => void;
+}
+export interface AnimationState {
+    active: boolean;
+    progress: number;
+    startPos: Vector3;
+    endPos: Vector3;
+    startTarget: Vector3;
+    endTarget: Vector3;
+    /** Carried-in per-second velocity of position/target (non-zero only when a fly interrupts another). */
+    startVel: Vector3;
+    startTargetVel: Vector3;
+    startQuat: Quaternion;
+    endQuat: Quaternion;
+    /** When true, orientation interpolates as a roll-free pan+tilt via {@link startEuler}/{@link endEuler} instead of a quaternion slerp. */
+    panTilt: boolean;
+    startEuler: Euler;
+    endEuler: Euler;
+    duration: number;
+    easing: EasingFn;
+    fade?: 'in' | 'out';
+    onComplete?: () => void;
+}
+export declare function createAnimationState(): AnimationState;
+export interface AnimUpHints {
+    /** Override start quaternion: reconstruct from position/target with this up vector instead of using camera.quaternion */
+    startUp?: Vector3;
+    /** Up vector for end quaternion computation (default: 0,1,0) */
+    endUp?: Vector3;
+    /**
+     * Roll-free pan+tilt orientation for a 2D↔3D transition; names which endpoint
+     * is the top-down 2D pole. The 2D side is pinned to the canonical
+     * `yaw=0, pitch=-90°`; only the oblique 3D side is decomposed (avoids
+     * gimbal-lock at the pole). Supersedes `startUp`/`endUp` for orientation.
+     */
+    panTilt?: 'to2D' | 'from2D';
+}
+/** Per-second velocity carried into a fly that interrupts another (keeps momentum across re-targets). */
+export interface AnimInitialVel {
+    pos: Vector3;
+    target: Vector3;
+}
+/**
+ * Start a new animation. Captures current camera state as the start,
+ * computes end quaternion by pointing a temp camera at the target.
+ * `currentTarget` is the current OrbitControls target (where the camera is looking).
+ */
+export declare function startAnimation(anim: AnimationState, camera: PerspectiveCamera, request: AnimationRequest, currentTarget: Vector3, upHints?: AnimUpHints, initialVel?: AnimInitialVel): void;
+export interface AnimFrameResult {
+    done: boolean;
+    /** 0..1 eased progress for opacity fading (only meaningful when anim.fade is set) */
+    fadeOpacity: number;
+    /** The interpolated target position for this frame */
+    target: Vector3;
+}
+/**
+ * Advance animation by `delta` seconds. Returns the interpolated target and
+ * whether the animation completed this frame.
+ */
+export declare function updateAnimation(anim: AnimationState, camera: PerspectiveCamera, delta: number): AnimFrameResult;
+//# sourceMappingURL=cameraAnimationEngine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cameraAnimationEngine.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/cameraAnimationEngine.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,iBAAiB,EAAa,MAAM,OAAO,CAAC;AAUjF,MAAM,MAAM,QAAQ,GAAG,YAAY,GAAG,WAAW,CAAC;AAOlD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;IACjB,IAAI,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,uGAAuG;IACvG,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,SAAS,EAAE,UAAU,CAAC;IACtB,OAAO,EAAE,UAAU,CAAC;IACpB,yIAAyI;IACzI,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,KAAK,CAAC;IAClB,QAAQ,EAAE,KAAK,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,QAAQ,CAAC;IACjB,IAAI,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAQD,wBAAgB,oBAAoB,IAAI,cAAc,CAkBrD;AAED,MAAM,WAAW,WAAW;IAC1B,yHAAyH;IACzH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gEAAgE;IAChE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC7B;AAED,yGAAyG;AACzG,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,OAAO,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;CACjB;AAyBD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,gBAAgB,EACzB,aAAa,EAAE,OAAO,EACtB,OAAO,CAAC,EAAE,WAAW,EACrB,UAAU,CAAC,EAAE,cAAc,GAC1B,IAAI,CA6DN;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,qFAAqF;IACrF,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,iBAAiB,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,CAoC/G"}

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

@@ -0,0 +1,24 @@
+import { Vector3 } from 'three';
+export interface SavedPose {
+    position: Vector3;
+    target: Vector3;
+}
+/**
+ * Single owner of the camera's "remembered" poses (3D overview + last 2D), so what each pose means
+ * and when it's updated lives in one place rather than being threaded through every camera hook.
+ */
+export declare class CameraPoseBook {
+    /**
+     * The 3D overview / "home" pose: where `reset`, `reframe`, `unfocus` and the
+     * return-to-3D transition fly to. Always present (seeded by the initial
+     * auto-frame). Mutated in place via {@link setOverview3D}.
+     */
+    readonly overview3D: SavedPose;
+    /** Last 2D top-down pose, or `null` when invalidated (scene content changed). */
+    private _saved2D;
+    setOverview3D(position: Vector3, target: Vector3): void;
+    get saved2D(): SavedPose | null;
+    setSaved2D(position: Vector3, target: Vector3): void;
+    clearSaved2D(): void;
+}
+//# sourceMappingURL=cameraPoseBook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cameraPoseBook.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/cameraPoseBook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhC,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,qBAAa,cAAc;IACzB;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAsD;IAEpF,iFAAiF;IACjF,OAAO,CAAC,QAAQ,CAA0B;IAE1C,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAKvD,IAAI,OAAO,IAAI,SAAS,GAAG,IAAI,CAE9B;IAED,UAAU,CAAC,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI;IAIpD,YAAY,IAAI,IAAI;CAGrB"}

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

@@ -0,0 +1,25 @@
+/**
+ * Refcounted arbiter for `OrbitControls.enabled`.
+ *
+ * Several independent subsystems suspend the orbit controls — a camera fly, a capture batch, an
+ * element drag/rotate, an accessory press/move. Left to restore `enabled = true` each on its own,
+ * overlapping suspensions stomp each other: whichever finishes LAST wins, so a drag that ends inside
+ * a capture batch re-enables controls the capture still wants off. Every writer takes a lock
+ * instead, and the controls are enabled exactly while no lock is held.
+ */
+/** The only property this module arbitrates — keeps callers free of the OrbitControls type. */
+export interface ControlsHandle {
+    enabled: boolean;
+}
+/**
+ * Registers the live OrbitControls instance so held locks apply to it, and returns the unregister
+ * to call on teardown. Registering re-applies the current lock state, so a remount can never come
+ * back enabled while a lock is still held.
+ */
+export declare function registerControls(instance: ControlsHandle): () => void;
+/**
+ * Suspends the orbit controls until the returned release is called. Releasing twice is a no-op, so
+ * a handler that releases both imperatively (on pointer-up) and in an effect cleanup is safe.
+ */
+export declare function acquireControlsLock(reason: string): () => void;
+//# sourceMappingURL=controlsLock.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"controlsLock.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/controlsLock.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,+FAA+F;AAC/F,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;CAClB;AAWD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,IAAI,CAMrE;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,CAQ9D"}

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

@@ -0,0 +1,38 @@
+import type { CameraSectorLimit } from '../../types/camera';
+/** Default blend band inside each sector edge (radians, ≈ 11.5°). */
+export declare const DEFAULT_SECTOR_FEATHER = 0.2;
+/**
+ * How strongly `sector` applies at `azimuth`: 0 outside the window, 1 in its core, smoothstepped
+ * across the feather band inside each edge. The feather eats into the window (never leaks out), and
+ * is capped at half the span so narrow sectors still reach full strength at their centre.
+ */
+export declare function sectorWeightAt(sector: CameraSectorLimit, azimuth: number): number;
+export interface EffectiveOrbitLimits {
+    minDistance: number;
+    maxDistance: number;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+}
+/**
+ * Where in the orbit the limits are being evaluated — required for `maxHeight` sectors, whose
+ * polar floor depends on the orbit distance and the target's world height. The per-frame
+ * enforcement passes the camera's live distance; the cage passes the radius it is drawing at.
+ */
+export interface SectorEvalContext {
+    /** Camera-to-target distance (meters) the limits apply at. */
+    distance: number;
+    /** World Y of the orbit target. */
+    targetY: number;
+}
+/**
+ * Effective orbit limits at `azimuth`: the base limits tightened by every sector active there.
+ * Sector values are blended toward base by the sector's weight, and only ever restrict — a sector
+ * declaring a bound looser than base is a no-op. Overlapping sectors combine most-restrictive-wins.
+ *
+ * A sector's `maxHeight` needs `ctx` to resolve: the camera sits at `targetY + distance * cos(polar)`,
+ * so the ceiling converts to a polar floor of `acos((maxHeight - targetY) / distance)` — no
+ * restriction while the whole orbit sphere is under the ceiling, tightening toward horizontal as the
+ * distance grows. Without `ctx` the ceiling is ignored.
+ */
+export declare function evaluateCameraLimitsAt(base: EffectiveOrbitLimits, sectors: readonly CameraSectorLimit[], azimuth: number, ctx?: SectorEvalContext): EffectiveOrbitLimits;
+//# sourceMappingURL=sectorLimits.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sectorLimits.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/sectorLimits.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAQ1C;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAcjF;AAED,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,mCAAmC;IACnC,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,SAAS,iBAAiB,EAAE,EACrC,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,iBAAiB,GACtB,oBAAoB,CAwBtB"}

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

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

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

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

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

@@ -0,0 +1,29 @@
+import type { MutableRefObject, RefObject } from 'react';
+import { PerspectiveCamera, Vector3 } from 'three';
+import type { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
+import type { ParsedScene } from '../../parser/parseRenderScript';
+import type { CameraFrameContext } from '../../utils/cameraFraming';
+import type { CameraPoseBook } from './cameraPoseBook';
+interface UseAutoFrameOptions {
+    scene3d: ParsedScene | null;
+    frameCtx: CameraFrameContext;
+    activateAutoRotate: () => void;
+    poseBook: CameraPoseBook;
+    hasFramed3D: MutableRefObject<boolean>;
+    prevCamPos: MutableRefObject<Vector3>;
+    /**
+     * Becomes `true` the first time the user touches the orbit controls
+     * (pointer down on OrbitControls' 'start' event). Until then, the
+     * auto-frame pass stays "live" — re-running whenever framing config
+     * arrives (e.g. from analyzer config restore after a reload, or live
+     * edits to Initial azimuth / elevation / target height / zoom / FOV).
+     *
+     * After the user has interacted, framing-config changes never move
+     * the camera; the explicit "Re-frame world" button is the only way
+     * to snap back.
+     */
+    userInteractedRef: MutableRefObject<boolean>;
+}
+export declare function useAutoFrame(camera: PerspectiveCamera, controlsRef: RefObject<OrbitControlsImpl | null>, opts: UseAutoFrameOptions): void;
+export {};
+//# sourceMappingURL=useAutoFrame.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAutoFrame.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useAutoFrame.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAKvD,UAAU,mBAAmB;IAC3B,OAAO,EAAE,WAAW,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,kBAAkB,EAAE,MAAM,IAAI,CAAC;IAC/B,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACvC,UAAU,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACtC;;;;;;;;;;OAUG;IACH,iBAAiB,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;CAC9C;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,IAAI,EAAE,mBAAmB,QAoDlI"}

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

@@ -0,0 +1,8 @@
+import type { RefObject } from 'react';
+import type { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
+import type { CameraConfig } from '../../types/camera';
+export declare function useAutoRotate(controlsRef: RefObject<OrbitControlsImpl | null>, autoRotateCfg: CameraConfig['autoRotate'], viewMode: '3d' | '2d', animating: RefObject<boolean>): {
+    cancelAutoRotate: () => void;
+    activateAutoRotate: () => void;
+};
+//# sourceMappingURL=useAutoRotate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAutoRotate.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useAutoRotate.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAiBvD,wBAAgB,aAAa,CAC3B,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAChD,aAAa,EAAE,YAAY,CAAC,YAAY,CAAC,EACzC,QAAQ,EAAE,IAAI,GAAG,IAAI,EACrB,SAAS,EAAE,SAAS,CAAC,OAAO,CAAC;;;EA0J9B"}

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

@@ -0,0 +1,13 @@
+import type { RefObject } from 'react';
+import type { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
+import type { CameraFrameContext } from '../../utils/cameraFraming';
+import type { CameraPoseBook } from './cameraPoseBook';
+import type { AnimateFn } from './useCameraAnimation';
+interface UseCameraActionsOptions {
+    viewMode: '3d' | '2d';
+    frameCtx: CameraFrameContext;
+    poseBook: CameraPoseBook;
+}
+export declare function useCameraActions(controlsRef: RefObject<OrbitControlsImpl | null>, animate: AnimateFn, opts: UseCameraActionsOptions): void;
+export {};
+//# sourceMappingURL=useCameraActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCameraActions.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useCameraActions.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAGvE,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;AAUtD,UAAU,uBAAuB;IAC/B,QAAQ,EAAE,IAAI,GAAG,IAAI,CAAC;IACtB,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,uBAAuB,QA4InI"}

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

@@ -0,0 +1,15 @@
+import { PerspectiveCamera, Vector3 } from 'three';
+import type { MutableRefObject, RefObject } from 'react';
+import type { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
+import type { AnimationRequest, AnimUpHints } from './cameraAnimationEngine';
+export type AnimateFn = (request: Omit<AnimationRequest, 'duration' | 'easing'> & Partial<Pick<AnimationRequest, 'duration' | 'easing'>>, upHints?: AnimUpHints) => void;
+/**
+ * `cancelAutoRotateRef` / `onAnimationSettledRef` are refs so the caller can
+ * wire them up after sibling hooks mount, avoiding circular hook dependencies.
+ */
+export declare function useCameraAnimation(camera: PerspectiveCamera, controlsRef: RefObject<OrbitControlsImpl | null>, cancelAutoRotateRef: MutableRefObject<() => void>, onAnimationSettledRef: MutableRefObject<() => void>, setMaterialOpacity: (opacity: number) => void, prevCamPos: MutableRefObject<Vector3>, animating: MutableRefObject<boolean>, 
+/** "Rest" FOV the camera snaps back to at the end of an animation (degrees). */
+baseFov: number): {
+    animate: AnimateFn;
+};
+//# sourceMappingURL=useCameraAnimation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCameraAnimation.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useCameraAnimation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,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;AAKvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAI7E,MAAM,MAAM,SAAS,GAAG,CACtB,OAAO,EAAE,IAAI,CAAC,gBAAgB,EAAE,UAAU,GAAG,QAAQ,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,gBAAgB,EAAE,UAAU,GAAG,QAAQ,CAAC,CAAC,EAC/G,OAAO,CAAC,EAAE,WAAW,KAClB,IAAI,CAAC;AAEV;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,iBAAiB,EACzB,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAChD,mBAAmB,EAAE,gBAAgB,CAAC,MAAM,IAAI,CAAC,EACjD,qBAAqB,EAAE,gBAAgB,CAAC,MAAM,IAAI,CAAC,EACnD,kBAAkB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,EAC7C,UAAU,EAAE,gBAAgB,CAAC,OAAO,CAAC,EACrC,SAAS,EAAE,gBAAgB,CAAC,OAAO,CAAC;AACpC,gFAAgF;AAChF,OAAO,EAAE,MAAM;;EAiHhB"}

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

@@ -0,0 +1,25 @@
+import { PerspectiveCamera, Vector3 } from 'three';
+import type { MutableRefObject, RefObject } from 'react';
+import type { OrbitControls as OrbitControlsImpl } from 'three-stdlib';
+import { type ResolvedCameraLimits } from '../../types/camera';
+interface UseCameraConstraintsOptions {
+    controlsMode: '2d' | '3d';
+    /** Skip dolly, target clamp, floor, geometry collision; keep dynamic near/far only. */
+    developmentMode: boolean;
+    dollyOnRotate: number;
+    /** "Rest" FOV the dolly-on-rotate effect eases back to (degrees). */
+    baseFov: number;
+    /** Merged orbit limits (defaults + host overrides): floor, collision toggle, sector overrides. */
+    limits: ResolvedCameraLimits;
+    sceneBBox: {
+        min: Vector3;
+        max: Vector3;
+    } | null;
+    animating: RefObject<boolean>;
+    prevCamPos: MutableRefObject<Vector3>;
+}
+export declare function useCameraConstraints(camera: PerspectiveCamera, controlsRef: RefObject<OrbitControlsImpl | null>, opts: UseCameraConstraintsOptions): {
+    resetAfterAnimation: () => void;
+};
+export {};
+//# sourceMappingURL=useCameraConstraints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCameraConstraints.d.ts","sourceRoot":"","sources":["../../../../../../src/core/camera/useCameraConstraints.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAmC,MAAM,OAAO,CAAC;AACpF,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,IAAI,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACvE,OAAO,EAA2B,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAmDxF,UAAU,2BAA2B;IACnC,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;IAC1B,uFAAuF;IACvF,eAAe,EAAE,OAAO,CAAC;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,OAAO,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,MAAM,EAAE,oBAAoB,CAAC;IAC7B,SAAS,EAAE;QAAE,GAAG,EAAE,OAAO,CAAC;QAAC,GAAG,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IACjD,SAAS,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;IAC9B,UAAU,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;CACvC;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,iBAAiB,EAAE,WAAW,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,IAAI,EAAE,2BAA2B;;EAySlJ"}