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

package/build/types/real-time-viewer-next/src/utils/footprintTrace.d.ts

@@ -0,0 +1,55 @@
+import { type FootprintPoint } from './polygon2d';
+export interface TraceFootprintOptions {
+    /** Raster cell size (m) — the fidelity floor of the trace. Default 0.005. */
+    cellSize?: number;
+    /** Douglas–Peucker tolerance (m) for the traced contour. Default = cellSize. */
+    simplifyTolerance?: number;
+    /**
+     * Gap (m) the morphological closing bridges — seams between separately
+     * modelled rim parts must not split the contour. Kept as a DISTANCE rather
+     * than a cell count so raising the resolution doesn't weaken the sealing.
+     * Default 0.02.
+     */
+    closeGap?: number;
+    /**
+     * Offset (m) applied to the silhouette before its contour is traced —
+     * negative shrinks it, positive grows it. Default 0.
+     *
+     * Done on the RASTER (see {@link offsetMask}) rather than on the finished
+     * polygon: a per-vertex miter offset cuts the corner wherever two edges meet
+     * at a sharp angle and crosses itself across any concavity narrower than the
+     * offset, both of which leave the contour cutting into the shape.
+     */
+    offset?: number;
+    /**
+     * Mutable out-parameter the trace fills with what it actually did. Reading it
+     * is the only way to tell a clean single-contour trace from one where the
+     * offset split the mask and a whole component (a step, a spa end) was
+     * dropped, since both return a perfectly valid-looking polygon.
+     */
+    diagnostics?: TraceDiagnostics;
+}
+/** What a trace did internally — see {@link TraceFootprintOptions.diagnostics}. */
+export interface TraceDiagnostics {
+    /** Mask cells set after closing and offsetting. */
+    filledCells: number;
+    /** Cells added by solidifying the silhouette — large for a ring-shaped projection (a basin rim). */
+    enclosedFilled: number;
+    /** Closed contours marching squares found. More than one means the shape is in pieces. */
+    loops: number;
+    /** Area of the contour kept, as a share of ALL contours' area. Below 1 means components were dropped. */
+    chosenAreaShare: number;
+    /** Contour points before Douglas-Peucker, and after. */
+    pointsBeforeSimplify: number;
+    pointsAfterSimplify: number;
+}
+/**
+ * Trace the outer silhouette of a triangle soup already projected onto the
+ * plane: `triangleXZ` holds 6 numbers per triangle (x0 z0 x1 z1 x2 z2). The
+ * triangles are rasterized into a binary mask (cell centers + vertices + edge
+ * samples, then a 3×3 closing to seal sliver gaps), the mask is contoured with
+ * marching squares, and the largest closed loop is simplified. Returns [] when
+ * nothing usable comes out (fewer than 3 triangles, degenerate extent).
+ */
+export declare function traceFootprintFromTriangles(triangleXZ: ArrayLike<number>, options?: TraceFootprintOptions): FootprintPoint[];
+//# sourceMappingURL=footprintTrace.d.ts.map

package/build/types/real-time-viewer-next/src/utils/footprintTrace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"footprintTrace.d.ts","sourceRoot":"","sources":["../../../../../src/utils/footprintTrace.ts"],"names":[],"mappings":"AAMA,OAAO,EAA4C,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAc5F,MAAM,WAAW,qBAAqB;IACpC,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;;;OAQG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;CAChC;AAED,mFAAmF;AACnF,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,WAAW,EAAE,MAAM,CAAC;IACpB,oGAAoG;IACpG,cAAc,EAAE,MAAM,CAAC;IACvB,0FAA0F;IAC1F,KAAK,EAAE,MAAM,CAAC;IACd,yGAAyG;IACzG,eAAe,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,OAAO,GAAE,qBAA0B,GAAG,cAAc,EAAE,CAkJhI"}

package/build/types/real-time-viewer-next/src/utils/footprintTrace.test.d.ts

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

package/build/types/real-time-viewer-next/src/utils/footprintTrace.test.d.ts.map

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

package/build/types/real-time-viewer-next/src/utils/geoViewAngle.d.ts

@@ -0,0 +1,17 @@
+import { Vector3 } from 'three';
+import type { Object3D } from 'three';
+import type { ViewAngle } from '../types/camera';
+interface GeoFrameResult {
+    center: Vector3;
+    radius: number;
+    angle: ViewAngle;
+    padding: number;
+}
+/**
+ * Frame a geo using a geometry-derived viewing angle. Uses the true bbox
+ * center and computes the framing radius from the bbox's vertical and
+ * horizontal extent so tall/thin geos are never clipped.
+ */
+export declare function frameGeoObject(obj: Object3D, baseAngle: ViewAngle, padding: number, aspect?: number): GeoFrameResult | null;
+export {};
+//# sourceMappingURL=geoViewAngle.d.ts.map

package/build/types/real-time-viewer-next/src/utils/geoViewAngle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geoViewAngle.d.ts","sourceRoot":"","sources":["../../../../../src/utils/geoViewAngle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAA8B,MAAM,OAAO,CAAC;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAwB,MAAM,OAAO,CAAC;AAC5D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAuJjD,UAAU,cAAc;IACtB,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAgB3H"}

package/build/types/real-time-viewer-next/src/utils/gltfLoader.d.ts

@@ -0,0 +1,34 @@
+import { DRACOLoader } from 'three/examples/jsm/loaders/DRACOLoader.js';
+import { type GLTF } from 'three/examples/jsm/loaders/GLTFLoader.js';
+/**
+ * Returns a singleton DRACOLoader configured with the Google CDN decoder path.
+ *
+ * `preload()` starts the decoder (wasm wrapper + wasm) download right here instead of leaving it
+ * to the first `decodeDracoFile` call — which only happens once a GLB has finished downloading and
+ * parsing, putting a cold CDN round trip in series behind every asset. Kicking it at construction
+ * puts that fetch in parallel with the GLB download it is going to decode.
+ */
+export declare function getSharedDracoLoader(): DRACOLoader;
+/**
+ * Starts the Draco decoder download without needing a GLB URL yet, so it can overlap whatever else
+ * the boot is doing. Idempotent — it just builds the shared loader, which preloads.
+ */
+export declare function preloadDracoDecoder(): void;
+/**
+ * The article-geo GLB cache: one download + Draco decode per URL, shared by
+ * BOTH consumers of a geo asset — the boot preload pass (`preloadGeoAssets`)
+ * and the render path (`GeoLoader` suspends on the same promise). Callers must
+ * treat the loaded scene graph as immutable and shared: clone before
+ * mutating/reparenting, never dispose its geometries/materials.
+ *
+ * A rejected load is evicted so a later attempt retries; in-flight and
+ * resolved entries are kept for the lifetime of the page.
+ */
+export declare function loadGLTFCached(url: string): Promise<GLTF>;
+/**
+ * The cache entry for `url` if there is one (in-flight included), otherwise `undefined`. For
+ * warm-up passes that may only act on geos someone else already loaded and must never start a
+ * download themselves — see `warmStandardMaterials`.
+ */
+export declare function peekGLTFCached(url: string): Promise<GLTF> | undefined;
+//# sourceMappingURL=gltfLoader.d.ts.map

package/build/types/real-time-viewer-next/src/utils/gltfLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltfLoader.d.ts","sourceRoot":"","sources":["../../../../../src/utils/gltfLoader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAC;AACxE,OAAO,EAAc,KAAK,IAAI,EAAE,MAAM,0CAA0C,CAAC;AASjF;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,IAAI,WAAW,CAQlD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C;AAMD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAezD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAErE"}

package/build/types/real-time-viewer-next/src/utils/gridGeometryApi.d.ts

@@ -0,0 +1,17 @@
+import type { AllGrids, FreePlacesOnGrids, PlannedPlacesOnGrids } from '../types/accessoryGrids';
+export interface GridGeometryRequest {
+    constructorServiceUrl: string;
+    jwt?: string;
+    catalogCodex: string;
+    iln: string;
+    planned: PlannedPlacesOnGrids[];
+    freePlaces: FreePlacesOnGrids[];
+}
+/**
+ * Fetch the server-computed grid + accessory geometry for one catalog, session-cached and
+ * in-flight-deduped. Resolves to `null` when there is nothing to apply — a duplicate request is
+ * already running, or the fetch failed (logged, never thrown: missing geometry only means the
+ * accessory boxes don't render).
+ */
+export declare function fetchGridGeometry(request: GridGeometryRequest): Promise<AllGrids[] | null>;
+//# sourceMappingURL=gridGeometryApi.d.ts.map

package/build/types/real-time-viewer-next/src/utils/gridGeometryApi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gridGeometryApi.d.ts","sourceRoot":"","sources":["../../../../../src/utils/gridGeometryApi.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AAYjG,MAAM,WAAW,mBAAmB;IAClC,qBAAqB,EAAE,MAAM,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,oBAAoB,EAAE,CAAC;IAChC,UAAU,EAAE,iBAAiB,EAAE,CAAC;CACjC;AAqBD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,CA8ChG"}

package/build/types/real-time-viewer-next/src/utils/localUVSampler.d.ts

@@ -0,0 +1,89 @@
+/** Floats per triangle in the soup: (x, z, u, v) per vertex. */
+export declare const UV_TRIANGLE_STRIDE = 12;
+/** One affine UV mapping over XZ: `u = ux·x + uz·z + u0`, likewise for v. */
+export interface AffineUV {
+    ux: number;
+    uz: number;
+    u0: number;
+    vx: number;
+    vz: number;
+    v0: number;
+    /**
+     * RMS error of the fit expressed along the surface (m) — how far the mapped
+     * pattern lands from where the source triangles actually put it. Near zero
+     * means the source really is one plane at one density and the mapping can be
+     * used wholesale; anything else means it is not, and only the local sampler
+     * can continue it faithfully.
+     */
+    residualMetres: number;
+}
+/**
+ * Least-squares fit of ONE affine mapping over every vertex in the soup.
+ *
+ * Where it fits (a planar unwrap at uniform density), it beats
+ * {@link sampleNearestTriangleUV} on generated geometry: the local sampler
+ * decides per vertex, so two ends of a generated triangle can land on different
+ * source triangles and the interpolation between them blends two mappings —
+ * a visible shear, worst on long thin triangles like those a curved outline
+ * produces. One mapping for every vertex cannot shear. Check
+ * {@link AffineUV.residualMetres} before trusting it.
+ */
+export declare function fitAffineUV(triangles: Float32Array, triangleCount: number): AffineUV | null;
+/**
+ * Uniform XZ grid over a triangle soup, so a nearest-triangle query touches a
+ * handful of cells instead of every triangle. Build it once per surface with
+ * {@link buildTriangleGridIndex} and pass it to {@link sampleNearestTriangleUV},
+ * which then returns exactly what the linear scan returns — same triangle, same
+ * tie-break, same UV.
+ */
+export interface TriangleGridIndex {
+    /** The soup this index describes; a different count means it is stale and is ignored. */
+    triangleCount: number;
+    minX: number;
+    minZ: number;
+    cellSize: number;
+    cols: number;
+    rows: number;
+    /** CSR offsets: cell `c` holds `cellItems[cellStart[c] … cellStart[c + 1])`. */
+    cellStart: Int32Array;
+    /** Triangle indices per cell, ascending. */
+    cellItems: Int32Array;
+    /**
+     * Triangles no cell can stand in for — scanned on every query. Three kinds:
+     * non-finite XZ; zero area, whose inside test reports distance 0 for ANY point
+     * and so cannot be pruned by position at all; and triangles spanning more
+     * cells than it is worth registering them in.
+     */
+    extras: Int32Array;
+}
+/**
+ * Uniform grid over the soup's XZ bounds, each triangle registered in every cell
+ * its bounding box overlaps. Build it once per surface — it depends on the soup
+ * alone — and reuse it for every query against that soup.
+ *
+ * Cell size is the larger of the mean triangle extent and the size that puts
+ * about one triangle in a cell: smaller than the triangles themselves only
+ * multiplies registrations without narrowing a query, larger leaves too many
+ * triangles per cell to skip.
+ *
+ * Returns null when an index would not pay for itself or could not be trusted —
+ * too few triangles, a soup that is one point, or too much of it non-finite. The
+ * caller then scans linearly, which is what the index reproduces anyway.
+ */
+export declare function buildTriangleGridIndex(triangles: ArrayLike<number>, triangleCount: number): TriangleGridIndex | null;
+/**
+ * UV at (x, z) taken from the triangle nearest to it, evaluated through that
+ * triangle's own affine mapping. Points outside the triangle EXTRAPOLATE it,
+ * which is the point: the sampled position generally lies in the hole beside
+ * the surface, and extrapolating its neighbour's plank mapping continues the
+ * pattern across the seam.
+ *
+ * `triangles` holds {@link UV_TRIANGLE_STRIDE} floats per triangle:
+ * `x0, z0, u0, v0, x1, z1, u1, v1, x2, z2, u2, v2`. Returns null for an empty
+ * soup or when every triangle is degenerate in XZ.
+ *
+ * Pass the soup's {@link TriangleGridIndex} to skip the linear scan over every
+ * triangle; the result is identical either way.
+ */
+export declare function sampleNearestTriangleUV(triangles: ArrayLike<number>, triangleCount: number, x: number, z: number, index?: TriangleGridIndex | null): [u: number, v: number] | null;
+//# sourceMappingURL=localUVSampler.d.ts.map

package/build/types/real-time-viewer-next/src/utils/localUVSampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localUVSampler.d.ts","sourceRoot":"","sources":["../../../../../src/utils/localUVSampler.ts"],"names":[],"mappings":"AAeA,gEAAgE;AAChE,eAAO,MAAM,kBAAkB,KAAK,CAAC;AAIrC,6EAA6E;AAC7E,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX;;;;;;OAMG;IACH,cAAc,EAAE,MAAM,CAAC;CACxB;AAcD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,CA2D3F;AAmED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,yFAAyF;IACzF,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,gFAAgF;IAChF,SAAS,EAAE,UAAU,CAAC;IACtB,4CAA4C;IAC5C,SAAS,EAAE,UAAU,CAAC;IACtB;;;;;OAKG;IACH,MAAM,EAAE,UAAU,CAAC;CACpB;AAkBD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,aAAa,EAAE,MAAM,GAAG,iBAAiB,GAAG,IAAI,CA2GpH;AA2ED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,SAAS,EAAE,SAAS,CAAC,MAAM,CAAC,EAC5B,aAAa,EAAE,MAAM,EACrB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,KAAK,CAAC,EAAE,iBAAiB,GAAG,IAAI,GAC/B,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,CAAC,GAAG,IAAI,CAwB/B"}

package/build/types/real-time-viewer-next/src/utils/localUVSampler.test.d.ts

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

package/build/types/real-time-viewer-next/src/utils/localUVSampler.test.d.ts.map

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

package/build/types/real-time-viewer-next/src/utils/overlayGeometry.d.ts

@@ -0,0 +1,28 @@
+import { Box3, Object3D, Vector3 } from 'three';
+import type { OverlayAnchor } from '../types/environment';
+/**
+ * Tight local-space AABB built from child geometry bounds.
+ * Transforms each geometry's bbox directly into the element's local
+ * frame — no intermediate world-space AABB that would inflate when
+ * the element is rotated.
+ */
+export declare function getLocalBoundingBox(object: Object3D): Box3;
+/**
+ * Returns a point on the top face of the local-space AABB at the given corner.
+ * "top/bottom" maps to the Z axis (top = min.z = back in world, top in plan view).
+ * "left/right" maps to the X axis.
+ * Y is always bbox.max.y + offset (floating above the element).
+ *
+ * `inset` pulls the point in from the edges toward the element centre (world units, clamped to the
+ * half-extent so it never crosses centre). Used to keep the trash icon off the shared edge where a
+ * docked neighbour's posNr badge sits at the same corner.
+ */
+export declare function getCornerLocal(bbox: Box3, anchor: OverlayAnchor, inset?: number): Vector3;
+export type SideCenter = 'left' | 'right' | 'top';
+/**
+ * Anchor point on one face of the local-space AABB, for 3D chrome that hangs off an element's
+ * side. `left`/`right` return the X face centre at mid height; `top` returns the TOP face centre
+ * (`max.y`), not a plan-view side. Falls back to `(0, 0.05, 0)` for an empty box.
+ */
+export declare function getSideCenterLocal(bbox: Box3, side: SideCenter): Vector3;
+//# sourceMappingURL=overlayGeometry.d.ts.map

package/build/types/real-time-viewer-next/src/utils/overlayGeometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlayGeometry.d.ts","sourceRoot":"","sources":["../../../../../src/utils/overlayGeometry.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,IAAI,EAAW,QAAQ,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAgB1D;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI,CA8B1D;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,aAAa,EAAE,KAAK,SAAI,GAAG,OAAO,CAOpF;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,OAAO,GAAG,KAAK,CAAC;AAElD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAQxE"}

package/build/types/real-time-viewer-next/src/utils/overlayGeometry.test.d.ts

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

package/build/types/real-time-viewer-next/src/utils/overlayGeometry.test.d.ts.map

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

package/build/types/real-time-viewer-next/src/utils/planarTransform.d.ts

@@ -0,0 +1,20 @@
+/** A point in the ground plane, as `[x, z]`. */
+export type PointXZ = [number, number];
+/** Rotates `(x, z)` about the origin by `angle` radians. */
+export declare function rotateXZ(x: number, z: number, angle: number): PointXZ;
+/**
+ * Lands a rotated offset on an origin: `origin + rotateXZ(dx, dz, angle)`.
+ *
+ * Adds inside the same expression rather than rotating and adding in two steps.
+ * Callers that measure a span between results (bounding boxes, dimension values)
+ * are sensitive to the rounding of that intermediate, so the two forms are not
+ * interchangeable — use {@link rotateXZ} where the rotated offset is wanted on
+ * its own.
+ */
+export declare function translateRotatedXZ(originX: number, originZ: number, dx: number, dz: number, angle: number): PointXZ;
+/**
+ * Orbits `(x, z)` about `(pivotX, pivotZ)` by `angle` radians —
+ * `pivot + rotateXZ(point − pivot)`.
+ */
+export declare function rotateXZAroundPivot(x: number, z: number, pivotX: number, pivotZ: number, angle: number): PointXZ;
+//# sourceMappingURL=planarTransform.d.ts.map

package/build/types/real-time-viewer-next/src/utils/planarTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planarTransform.d.ts","sourceRoot":"","sources":["../../../../../src/utils/planarTransform.ts"],"names":[],"mappings":"AAiBA,gDAAgD;AAChD,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEvC,4DAA4D;AAC5D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAIrE;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAInH;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEhH"}

package/build/types/real-time-viewer-next/src/utils/planarTransform.test.d.ts

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

package/build/types/real-time-viewer-next/src/utils/planarTransform.test.d.ts.map

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

package/build/types/real-time-viewer-next/src/utils/polygon2d.d.ts

@@ -0,0 +1,25 @@
+/** 2D point; axis meaning depends on context (path space: x/y, floor space: x/z). */
+export type FootprintPoint = [number, number];
+/** Shoelace signed area — positive for counter-clockwise winding (y-up convention). */
+export declare function polygonSignedArea(points: readonly FootprintPoint[]): number;
+/** Douglas–Peucker for a closed polygon: split at the point farthest from the start, simplify both halves. */
+export declare function simplifyClosedPolygon(points: readonly FootprintPoint[], tolerance: number): FootprintPoint[];
+/** True when no two non-adjacent edges of the closed polygon cross. O(n²) — fine for outline-sized input. */
+export declare function isSimplePolygon(points: readonly FootprintPoint[]): boolean;
+/** Convex hull (Andrew's monotone chain), counter-clockwise. */
+export declare function convexHull(points: readonly FootprintPoint[]): FootprintPoint[];
+/**
+ * Guarantee a polygon a triangulator can use. A self-intersecting outline is
+ * NOT rejected by earcut — it silently produces garbage (a stray wedge across
+ * the shape), so anything feeding generated geometry has to be checked first.
+ *
+ * The repair is the convex hull: a pool/article silhouette is convex or nearly
+ * so, which makes the hull a close and always-simple stand-in — visibly a
+ * little too generous rather than visibly broken. Returns null when even that
+ * degenerates.
+ */
+export declare function ensureSimplePolygon(points: readonly FootprintPoint[]): {
+    points: FootprintPoint[];
+    repaired: boolean;
+} | null;
+//# sourceMappingURL=polygon2d.d.ts.map

package/build/types/real-time-viewer-next/src/utils/polygon2d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon2d.d.ts","sourceRoot":"","sources":["../../../../../src/utils/polygon2d.ts"],"names":[],"mappings":"AAIA,qFAAqF;AACrF,MAAM,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAI9C,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAQ3E;AA6BD,8GAA8G;AAC9G,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,cAAc,EAAE,CAgB5G;AAeD,6GAA6G;AAC7G,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG,OAAO,CAe1E;AAED,gEAAgE;AAChE,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG,cAAc,EAAE,CAe9E;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,GAAG;IAAE,MAAM,EAAE,cAAc,EAAE,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAa7H"}

package/build/types/real-time-viewer-next/src/utils/preloadEnvironment.d.ts

@@ -0,0 +1,15 @@
+import type { ResolvedEnvironmentConfig } from '../types/environment';
+/**
+ * Starts the two heavy environment downloads — the equirect behind the skydome / IBL and the
+ * environment GLB — as soon as the environment is known, instead of when the components that
+ * consume them mount.
+ *
+ * Those components live inside the R3F `<Canvas>`, so without this their fetches queue behind
+ * WebGL context creation. The equirect lands in the very cache the consumers read
+ * (`utils/equirectCache`), so nothing is fetched twice.
+ *
+ * Fire-and-forget by design: it starts requests and never blocks or reports. The consumer that
+ * actually needs an asset surfaces the failure.
+ */
+export declare function preloadEnvironmentAssets(env: ResolvedEnvironmentConfig): void;
+//# sourceMappingURL=preloadEnvironment.d.ts.map

package/build/types/real-time-viewer-next/src/utils/preloadEnvironment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preloadEnvironment.d.ts","sourceRoot":"","sources":["../../../../../src/utils/preloadEnvironment.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAkCtE;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,yBAAyB,GAAG,IAAI,CAgB7E"}

package/build/types/real-time-viewer-next/src/utils/profiles.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Profile merge / diff / path-manipulation helpers.
+ *
+ * The performance-profile feature stores one config per tier:
+ *
+ *   - `high`   full {@link EnvironmentConfig} baseline (always present).
+ *   - others?  sparse {@link RecursivePartial} override on top of `high`.
+ *
+ * Each lower tier is computed independently from `high` (the lower tiers do
+ * NOT chain through medium). This keeps "diff vs high" unambiguous and easy
+ * to display in the analyzer's diff panel.
+ *
+ * Config leaves may hold {@link TieredAsset} objects; {@link mergeProfile}
+ * flattens those to the active tier so downstream consumers receive plain `T`.
+ */
+import { type EnvironmentConfig, type OverrideProfileTier, type PerformanceProfiles, type PerformanceProfileTier, type RecursivePartial, type TieredAsset } from '../types/environment';
+/**
+ * Collapse a {@link TieredAsset} to its value at the active tier. Fallback
+ * chain when a tier bucket is missing (or explicitly `undefined`):
+ *
+ *   - `low` / `mobileLow`     → `low` → `medium` → `high`
+ *   - `medium` / `mobileHigh` → `medium` → `high` → `low`
+ *   - `high`                  → `high` → `medium` → `low`
+ *
+ * Plain scalar / array / non-tiered values pass through unchanged.
+ */
+export declare function resolveTieredAsset<T>(value: TieredAsset<T>, tier: PerformanceProfileTier): T;
+/** Step one rung within `tier`'s ladder; `null` at the ends or for unknown tiers. */
+export declare function stepTier(tier: PerformanceProfileTier, direction: 'up' | 'down'): PerformanceProfileTier | null;
+/**
+ * Compute the effective {@link EnvironmentConfig} for the active performance
+ * tier:
+ *
+ *   1. Deep-clone {@link PerformanceProfiles.high} (always-present baseline).
+ *   2. For any other tier, deep-merge that tier's override partial on top.
+ *   3. Walk {@link TIERED_ASSET_PATHS} and flatten any per-tier asset object
+ *      to its plain value for the active tier.
+ *
+ * The returned config is safe to pass straight into `resolveEnvironment` —
+ * no tier-aware values remain.
+ */
+export declare function mergeProfile(profiles: PerformanceProfiles, tier: PerformanceProfileTier): EnvironmentConfig;
+/**
+ * Remove the leaf at a dotted `path` inside `obj`. After removal, walks back
+ * up and prunes any parent object that's now empty — keeping the override
+ * partials minimal (so `diffProfileFromHigh` never reports phantom paths).
+ *
+ * Returns `true` if a defined value was actually removed. A key explicitly
+ * holding `undefined` is pruned but not reported — `mergeProfile` skips
+ * undefined leaves, so such a key never acted as an override.
+ */
+export declare function clearProfileValueByPath(obj: Record<string, unknown>, path: string): boolean;
+/**
+ * Read the leaf value at a dotted `path` inside `obj`. Returns `undefined`
+ * if any segment is missing or hits a non-object scalar before the leaf.
+ */
+export declare function getValueByPath(obj: Record<string, unknown>, path: string): unknown;
+/** Single override entry surfaced by {@link diffProfileFromHigh}. */
+export interface ProfileOverrideEntry {
+    /** Dotted path inside `EnvironmentConfig`. */
+    path: string;
+    /** Value stored in the override partial. */
+    overrideValue: unknown;
+    /** Corresponding value in the `high` config (may be `undefined`). */
+    highValue: unknown;
+}
+/**
+ * Walk every leaf in `override` and report it as a path-keyed override
+ * against `high`. Used by the analyzer's diff panel to list "where does
+ * this tier differ from high?" and offer per-path reset buttons.
+ *
+ * Arrays are treated as leaves (we don't diff inside arrays — the override
+ * either replaces the whole array or doesn't touch it). Leaves explicitly
+ * set to `undefined` are skipped — `mergeProfile` ignores them, so they
+ * never act as overrides.
+ */
+export declare function diffProfileFromHigh(high: EnvironmentConfig, override: RecursivePartial<EnvironmentConfig> | undefined): ProfileOverrideEntry[];
+/** Per-path entry returned by {@link propagateHighEditAndCollectClearedOverrides}. */
+export interface ClearedOverride {
+    tier: OverrideProfileTier;
+    path: string;
+}
+/**
+ * After a patch lands on the `high` profile, walk every leaf in that patch
+ * and remove the same path from the lower-tier override profiles.
+ *
+ * Rationale: A lower-tier override is a delta from `high`. If `high` itself
+ * changes at path P, the lower-tier value at P may no longer carry the
+ * meaning the user originally intended ("this is the perf-reduced variant
+ * of the old high value"). The least-surprise default is to drop the
+ * stale delta and let the lower tier inherit the new high value. The
+ * analyzer surfaces the list of cleared paths via a toast so the change is
+ * never silent.
+ *
+ * A leaf only counts as changed when `priorHigh[path]` differs from the
+ * (already-merged) `profiles.high[path]` — a patch that merely re-states the
+ * current high value must not drop lower-tier deltas. `profiles.high` must
+ * already be the *new* (post-merge) baseline by the time this is called.
+ *
+ * Mutates the lower-tier overrides in place (removing keys and collapsing
+ * empty parents); an override left empty is dropped from the bundle
+ * entirely so exported JSON never carries phantom `{}` tiers. Returns the
+ * list of cleared paths for the toast.
+ */
+export declare function propagateHighEditAndCollectClearedOverrides(profiles: PerformanceProfiles, highPatch: RecursivePartial<EnvironmentConfig>, priorHigh: EnvironmentConfig): ClearedOverride[];
+/**
+ * Default profile bundle used when the host doesn't pass `profiles` via
+ * {@link RTVConfig}. Hosts that want a different baseline (e.g. a planner
+ * with shadows-off-by-default on `high`) supply their own bundle; the
+ * analyzer can then export it back out as JSON.
+ */
+export declare const DEFAULT_PROFILES: PerformanceProfiles;
+//# sourceMappingURL=profiles.d.ts.map

package/build/types/real-time-viewer-next/src/utils/profiles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiles.d.ts","sourceRoot":"","sources":["../../../../../src/utils/profiles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,WAAW,EACjB,MAAM,sBAAsB,CAAC;AAwC9B;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,sBAAsB,GAAG,CAAC,CAS5F;AAgBD,qFAAqF;AACrF,wBAAgB,QAAQ,CAAC,IAAI,EAAE,sBAAsB,EAAE,SAAS,EAAE,IAAI,GAAG,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAO9G;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,mBAAmB,EAAE,IAAI,EAAE,sBAAsB,GAAG,iBAAiB,CAa3G;AAgBD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAyB3F;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAQlF;AAoBD,qEAAqE;AACrE,MAAM,WAAW,oBAAoB;IACnC,8CAA8C;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,aAAa,EAAE,OAAO,CAAC;IACvB,qEAAqE;IACrE,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,GAAG,SAAS,GAAG,oBAAoB,EAAE,CAmB9I;AAoBD,sFAAsF;AACtF,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,mBAAmB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,2CAA2C,CACzD,QAAQ,EAAE,mBAAmB,EAC7B,SAAS,EAAE,gBAAgB,CAAC,iBAAiB,CAAC,EAC9C,SAAS,EAAE,iBAAiB,GAC3B,eAAe,EAAE,CAuBnB;AAmHD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,EAAE,mBAM9B,CAAC"}

package/build/types/real-time-viewer-next/src/utils/profiles.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Unit tests for the performance-profile merge stack in `./profiles`:
+ * `mergeProfile`, `resolveTieredAsset`, `diffProfileFromHigh`,
+ * `getValueByPath`, `clearProfileValueByPath`,
+ * `propagateHighEditAndCollectClearedOverrides` and `stepTier`.
+ *
+ * These helpers are pure and store-independent, so no module mocking is
+ * needed — `./profiles` imports only types plus one const from
+ * `../types/environment`, which itself has no runtime imports (unlike
+ * `resolveEnvironment`, whose test has to mock `@crystaldesign/diva-core`).
+ *
+ * A few tests below pin CURRENT behaviour that is deliberate but easy to
+ * misread; each is marked `CURRENT BEHAVIOUR` with the reason it is
+ * asserted as-is.
+ */
+import '../testUtils/structuredClonePolyfill';
+//# sourceMappingURL=profiles.test.d.ts.map

package/build/types/real-time-viewer-next/src/utils/profiles.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profiles.test.d.ts","sourceRoot":"","sources":["../../../../../src/utils/profiles.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,sCAAsC,CAAC"}

package/build/types/real-time-viewer-next/src/utils/rasterMask.d.ts

@@ -0,0 +1,31 @@
+import type { FootprintPoint } from './polygon2d';
+/**
+ * Morphological closing (dilate then erode) with a square kernel of the given
+ * radius — bridges seams between separately modelled parts without moving the
+ * silhouette.
+ *
+ * Each of the four passes is a SLIDING-WINDOW box count: the window is updated
+ * by one entering and one leaving row/column instead of being re-summed, so
+ * the cost is O(cells) independent of radius and every access is sequential.
+ * The naive per-cell kernel form (especially its column-strided half) costs an
+ * order of magnitude more at a fine raster.
+ */
+export declare function closeMask(mask: Uint8Array, nx: number, nz: number, radius: number): void;
+/**
+ * Turn the mask into the SOLID region its outer contour encloses: flood the
+ * background inward from the (always empty) border and set everything the
+ * flood could not reach. Returns how many cells were added.
+ */
+export declare function fillEnclosed(mask: Uint8Array, nx: number, nz: number): number;
+/**
+ * Single morphological pass — dilate (grow) or erode (shrink) by a square
+ * kernel of the given radius. The raster form of a polygon offset: the same
+ * operation applied uniformly to every boundary cell, so it can neither miter
+ * a corner off nor cross itself across a concavity. The kernel is a square, so
+ * the offset is Chebyshev — exact on axis-aligned edges, up to √2 larger on
+ * 45° ones.
+ */
+export declare function offsetMask(mask: Uint8Array, nx: number, nz: number, radius: number, dilate: boolean): void;
+/** Contour a binary node grid (values at cell centers) into closed loops of edge-midpoint coordinates. */
+export declare function marchingSquaresLoops(mask: Uint8Array, nx: number, nz: number, originX: number, originZ: number, cell: number): FootprintPoint[][];
+//# sourceMappingURL=rasterMask.d.ts.map

package/build/types/real-time-viewer-next/src/utils/rasterMask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterMask.d.ts","sourceRoot":"","sources":["../../../../../src/utils/rasterMask.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAOxF;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAiC7E;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAI1G;AAiFD,0GAA0G;AAC1G,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,EAAE,EAAE,CAoDjJ"}

package/build/types/real-time-viewer-next/src/utils/rasterMask.test.d.ts

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

package/build/types/real-time-viewer-next/src/utils/rasterMask.test.d.ts.map

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

package/build/types/real-time-viewer-next/src/utils/resolveEnvironment.d.ts

@@ -0,0 +1,16 @@
+import type { EnvironmentConfig, ResolvedEnvironmentConfig } from '../types/environment';
+import { DEFAULT_ENVIRONMENT } from '../config/environment.config';
+export { DEFAULT_ENVIRONMENT };
+/** Ensure `lighting.sun.direction` matches `azimuth`/`elevation` (canonical for RTV). */
+export declare function syncLightingSunDirectionWithAngles(env: ResolvedEnvironmentConfig): void;
+/**
+ * Fill an authored {@link EnvironmentConfig} to the shape every renderer consumes: defaults for
+ * everything unset, numbers clamped to their field's range, switchable blocks collapsed to
+ * `false | full`.
+ *
+ * Per-field work belongs in the subsystem descriptors (`ENVIRONMENT_CONFIG`); the only steps left
+ * here are the ones that read ACROSS fields — deriving the sun's angles from a legacy `direction`,
+ * and re-deriving `direction` from the angles afterwards.
+ */
+export declare function resolveEnvironment(config?: EnvironmentConfig): ResolvedEnvironmentConfig;
+//# sourceMappingURL=resolveEnvironment.d.ts.map

package/build/types/real-time-viewer-next/src/utils/resolveEnvironment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveEnvironment.d.ts","sourceRoot":"","sources":["../../../../../src/utils/resolveEnvironment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,sBAAsB,CAAC;AAEzF,OAAO,EAAsB,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAIvF,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAE/B,yFAAyF;AACzF,wBAAgB,kCAAkC,CAAC,GAAG,EAAE,yBAAyB,GAAG,IAAI,CAIvF;AAeD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,yBAAyB,CAKxF"}

package/build/types/real-time-viewer-next/src/utils/resolveGridCells.d.ts

@@ -0,0 +1,35 @@
+import type { AllGrids, AccessoryGridGeo, FreePlacesOnGrids, ResolvedGridCell } from '../types/accessoryGrids';
+/**
+ * Resolve the free cells belonging to a single element (matched by scene node name).
+ * `elementNodeName` is the Three.js group name (e.g. "Element#SET1E12"); `free.elementId`
+ * is the shelf key (e.g. "E12"). Matched by suffix.
+ */
+export declare function resolveFreeCellsForElement(freePlaces: FreePlacesOnGrids[] | null, allGrids: AllGrids[] | null, elementNodeName: string): ResolvedGridCell[];
+/**
+ * Pick the default cell for an `autoPlaceDrag` auto-placement. Fills TOP-DOWN: the first item lands
+ * near the top of the first element/grid that has room (a top clearance of `gapFraction` of the
+ * grid's cells), and each subsequent placement sits `gapFraction` of the cells BELOW the previous
+ * one — so items stack downward with even spacing. Because each placement consumes its footprint
+ * and `freePlacesOnGrids` refreshes, repeated arms walk down the grid and jump to the next
+ * element/grid once full. Falls back to gap-less, then to the topmost free cell.
+ *
+ * Assumes higher `cellIdx` = higher position (standard for vertical shelf grids, `deltaGrid.y > 0`).
+ */
+export declare function pickDefaultPlacementCell(cells: ResolvedGridCell[], allGrids: AllGrids[] | null): ResolvedGridCell | null;
+/**
+ * The accessory-geometry part of a cell's bbox-CENTER offset (metres), rotated by the grid and
+ * sign-calibrated — i.e. `resolveCell`'s offset with the cell step (`cellIdx·deltaGrid`) and grid
+ * origin removed. Depends only on the accessory's own geometry (geoPosition, bbox, rulePosition).
+ *
+ * Reused by the variant mesh swap to re-centre a differently-sized variant on its anchor:
+ *   recenter = geoLocalOffset(draggedGeo, rotationY) − geoLocalOffset(variantGeo, rotationY)
+ * which yields the exact, calibration-consistent shift (no hand-rolled bbox/2 or guessed sign).
+ */
+export declare function geoLocalOffset(geo: AccessoryGridGeo, rotationY: number): [number, number, number];
+/**
+ * ONLY the ±bbox/2 part of {@link geoLocalOffset} (anchor→bbox-center), WITHOUT the accessory's
+ * in-cell placement (`geoPosition`/`rulePosition`) — the placement is variant-specific and is what
+ * distinguishes left/right family pairs sharing one cell, so preview math must not cancel it.
+ */
+export declare function geoBBoxCenterOffset(geo: AccessoryGridGeo, rotationY: number): [number, number, number];
+//# sourceMappingURL=resolveGridCells.d.ts.map