three-low-poly 0.9.24 → 0.9.26

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { BoxGeometry } from 'three';
 import { BufferGeometry } from 'three';
-import { Camera } from 'three';
 import { Color } from 'three';
 import { ColorRepresentation } from 'three';
 import { DataTexture } from 'three';
@@ -16,13 +15,17 @@ import { MeshPhongMaterial } from 'three';
 import { MeshPhysicalMaterial } from 'three';
 import { MeshStandardMaterial } from 'three';
 import { Object3D } from 'three';
+import { OrbitControls } from 'three/addons/controls/OrbitControls.js';
 import { ParametricGeometry } from 'three-stdlib';
 import { PerspectiveCamera } from 'three';
+import { Plane } from 'three';
 import { PlaneGeometry } from 'three';
 import { PointLight } from 'three';
 import { Points } from 'three';
+import { Quaternion } from 'three';
 import { ShaderMaterial } from 'three';
 import { Shape } from 'three';
+import { ShapeGeometry } from 'three';
 import { SphereGeometry } from 'three';
 import * as THREE from 'three';
 import { Uniform } from 'three';
@@ -166,6 +169,124 @@ export declare function alignToRow<T extends Object3D>(objects: T[], direction?:
  */
 export declare function appendSphericalCurve(sphereRadiusX: number, sphereRadiusY: number, sphereStartY: number, holeTopRadius?: number, holeBottomRadius?: number, segments?: number): Vector2[];
 
+export declare function applySnapshot(camera: PerspectiveCamera, controls: OrbitControls | undefined, snapshot: CameraSnapshot): void;
+
+declare interface ArchedDiamondLatticePartOptions {
+    width: number;
+    rectHeight: number;
+    archHeight?: number;
+    centerY?: number;
+    grid: DiamondLatticeGrid;
+    leadThickness: number;
+    leadDepth: number;
+    /**
+     * Shrink the opening the cames are clipped to (positioning stays on the full
+     * grid). Set to the frame thickness so came ends tuck under the frame ring
+     * instead of poking past the outer silhouette. Defaults to `0`.
+     */
+    clipInset?: number;
+}
+
+/**
+ * Arched diamond lattice window — diagonal lead cames analytically clipped to a
+ * Tudor head opening, with an extruded frame ring. The lattice is real trimmed
+ * geometry (no stencil mask), so it casts a correct arch-shaped shadow and any
+ * collider derived from the mesh matches what's drawn.
+ *
+ * Local frame: centered on the opening, XY plane facing +Z. Lead is centered on
+ * `z = 0`; optional glass sits in the same plane (both faces).
+ */
+export declare class ArchedDiamondLatticeWindow extends Group {
+    readonly lattice: Mesh<ArchedDiamondLatticeWindowGeometry, MeshStandardMaterial>;
+    readonly frame: Mesh;
+    readonly glass?: Mesh<ShapeGeometry, MeshPhysicalMaterial>;
+    readonly cellsX: number;
+    readonly cellsY: number;
+    readonly fittedGrid: DiamondLatticeGrid;
+    readonly opening: ArchedOpeningMetrics;
+    constructor({ leadColor, glass, glassColor, glassEmissive, glassEmissiveIntensity, width, rectHeight, archHeight, centerY, leadThickness, leadDepth, ...geometryOptions }?: ArchedDiamondLatticeWindowOptions);
+}
+
+/**
+ * Diamond cames analytically clipped to the arched (rect-plus-Tudor-head)
+ * opening — real trimmed geometry, no stencil, so it shadows and raycasts
+ * correctly. Frame is a separate extruded ring on {@link ArchedDiamondLatticeWindow}.
+ */
+export declare class ArchedDiamondLatticeWindowGeometry extends BufferGeometry {
+    readonly cellsX: number;
+    readonly cellsY: number;
+    readonly fittedGrid: DiamondLatticeGrid;
+    readonly opening: ArchedOpeningMetrics;
+    constructor({ width, rectHeight, archHeight, leadThickness, leadDepth, cellsX, cellsY, centerY, }?: ArchedDiamondLatticeWindowGeometryOptions);
+}
+
+declare interface ArchedDiamondLatticeWindowGeometryOptions {
+    /** Opening width (world units). */
+    width?: number;
+    /** Height of the straight-sided lower section. */
+    rectHeight?: number;
+    /** Arch rise from the spring line to the apex. Defaults to `width / 2`. */
+    archHeight?: number;
+    /** Lead came thickness (cross-section). Defaults to `0.055`. */
+    leadThickness?: number;
+    /** Lead depth (Z extent). Defaults to `0.11`. */
+    leadDepth?: number;
+    /** Quarrels spanning east–west across the bounding opening. Defaults to `10`. */
+    cellsX?: number;
+    /** Quarrels spanning north–south across the bounding opening. Defaults to `12`. */
+    cellsY?: number;
+    /** Vertical center of the full opening. Defaults to `0`. */
+    centerY?: number;
+}
+
+declare interface ArchedDiamondLatticeWindowOptions extends ArchedDiamondLatticeWindowGeometryOptions {
+    /** Lead + outer frame tint. Defaults to `#0c0f14`. */
+    leadColor?: ColorRepresentation;
+    /** Optional glass pane centered in the lead depth (`z = 0`), visible from both sides. */
+    glass?: boolean;
+    glassColor?: ColorRepresentation;
+    glassEmissive?: ColorRepresentation;
+    glassEmissiveIntensity?: number;
+}
+
+/** Rectangular lower section plus circular arch head. */
+export declare interface ArchedOpeningBounds {
+    width: number;
+    /** Height of the straight-sided lower section. */
+    rectHeight: number;
+    /** Arch rise from the spring line to the apex. Defaults to `width / 2` (semicircle). */
+    archHeight?: number;
+    /** Vertical center of the full opening. Defaults to `0`. */
+    centerY?: number;
+}
+
+export declare interface ArchedOpeningMetrics {
+    hw: number;
+    ymin: number;
+    ymax: number;
+    rectTopY: number;
+    /** Circle center Y — lies on or below the spring line. */
+    archCy: number;
+    /** Circular arc radius derived from `width` and `archHeight`. */
+    archRadius: number;
+    archHeight: number;
+    totalHeight: number;
+    centerY: number;
+}
+
+/**
+ * Circular arc through `(-width/2, springY)` and `(width/2, springY)` with rise
+ * `archHeight`. Frame, glass, and lattice clip all use this same arc.
+ */
+export declare function archedOpeningMetrics({ width, rectHeight, archHeight, centerY, }: ArchedOpeningBounds): ArchedOpeningMetrics;
+
+declare interface ArchedOutlineTarget {
+    moveTo(x: number, y: number): unknown;
+    lineTo(x: number, y: number): unknown;
+    absarc(x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise: boolean): unknown;
+    closePath(): unknown;
+}
+
 /**
  * Atmospheric scattering shader.
  *
@@ -392,10 +513,6 @@ export declare const Axis: {
     XYZ: Vector3;
 };
 
-export declare class BifurcatedStaircaseGeometry extends BufferGeometry {
-    constructor(stepWidth?: number, stepHeight?: number, stepDepth?: number, numStepsCentral?: number, numStepsBranch?: number, branchAngle?: number);
-}
-
 declare interface BloomTransitionOptions extends SceneTransitionFXOptions {
     maxBloom?: number;
 }
@@ -441,57 +558,93 @@ export declare class BoneGeometry extends BufferGeometry {
 }
 
 /**
- * Book prefab
+ * Book prefab — cover shell and page block with separate material groups.
  *
- * Material indices:
- * 0. cover
- * 1. page
+ * Local frame: spine at X=0, fore-edge at +X, sits on the Y=0 plane.
  */
 export declare class Book extends Mesh<BookGeometry, MeshStandardMaterial[]> {
-    constructor({ width, height, depth, coverThickness, pageIndent, coverColor, pageColor, }?: {
-        width?: number | undefined;
-        height?: number | undefined;
-        depth?: number | undefined;
-        coverThickness?: number | undefined;
-        pageIndent?: number | undefined;
-        coverColor?: number | undefined;
-        pageColor?: number | undefined;
-    });
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly coverThickness: number;
+    readonly pageIndent: number;
+    constructor({ coverColor, pageColor, ...geometryOptions }?: BookOptions);
 }
 
 /**
- * Book
+ * Closed book — cover shell (group 0) and page block (group 1).
  *
- * Group indices:
- * 0. cover
- * 1. page
+ * Local frame: spine at X=0, fore-edge at +X, sits on the Y=0 plane.
  */
 export declare class BookGeometry extends BufferGeometry {
-    constructor(width?: number, height?: number, depth?: number, coverThickness?: number, pageIndent?: number);
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly coverThickness: number;
+    readonly pageIndent: number;
+    constructor({ width, height, depth, coverThickness, pageIndent, }?: BookGeometryOptions);
+}
+
+export declare interface BookGeometryOptions {
+    /** Cover width (spine to fore-edge). Defaults to `1`. */
+    width?: number;
+    /** Cover height. Defaults to `1.5`. */
+    height?: number;
+    /** Spine depth (cover to cover). Defaults to `0.5`. */
+    depth?: number;
+    /** Cover board thickness. Defaults to `0.05`. */
+    coverThickness?: number;
+    /** Inset of the page block from the cover edges. Defaults to `0.05`. */
+    pageIndent?: number;
+}
+
+export declare interface BookOptions extends BookGeometryOptions {
+    /** Cover tint. Defaults to `#8b0000`. */
+    coverColor?: ColorRepresentation;
+    /** Page block tint. Defaults to `#ffffff`. */
+    pageColor?: ColorRepresentation;
 }
 
+/**
+ * Bookshelf prefab — framed shelving unit.
+ */
 export declare class Bookshelf extends Mesh<BookshelfGeometry, MeshStandardMaterial> {
-    constructor({ width, //
-        height, depth, shelves, frameThickness, open, }?: {
-        width?: number | undefined;
-        height?: number | undefined;
-        depth?: number | undefined;
-        shelves?: number | undefined;
-        frameThickness?: number | undefined;
-        open?: boolean | undefined;
-    });
+    readonly width: number;
+    readonly height: number;
+    constructor({ color, ...geometryOptions }?: BookshelfOptions);
 }
 
+/**
+ * Bookshelf frame with optional back panel and evenly spaced shelves.
+ *
+ * Local frame: sits on the Y=0 plane, centered on X/Z.
+ */
 export declare class BookshelfGeometry extends BufferGeometry {
-    constructor({ width, //
-        height, depth, shelves, frameThickness, open, }?: {
-        width?: number | undefined;
-        height?: number | undefined;
-        depth?: number | undefined;
-        shelves?: number | undefined;
-        frameThickness?: number | undefined;
-        open?: boolean | undefined;
-    });
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    readonly shelves: number;
+    constructor({ width, height, depth, shelves, frameThickness, open, }?: BookshelfGeometryOptions);
+}
+
+export declare interface BookshelfGeometryOptions {
+    /** Overall width. Defaults to `5`. */
+    width?: number;
+    /** Overall height. Defaults to `8`. */
+    height?: number;
+    /** Shelf depth. Defaults to `1`. */
+    depth?: number;
+    /** Number of interior shelves. Defaults to `4`. */
+    shelves?: number;
+    /** Frame board thickness. Defaults to `0.1`. */
+    frameThickness?: number;
+    /** Omit the back panel when `true`. Defaults to `false`. */
+    open?: boolean;
+}
+
+export declare interface BookshelfOptions extends BookshelfGeometryOptions {
+    /** Frame tint. Defaults to `#8b4513`. */
+    color?: ColorRepresentation;
 }
 
 export declare enum BoxSide {
@@ -504,50 +657,72 @@ export declare enum BoxSide {
 }
 
 /**
- * Single brick geometry for low-poly aesthetic.
- * Default dimensions approximate standard brick proportions (in feet scale).
+ * Diagonal cames only, each segment analytically clipped to the rect-plus-arch
+ * opening — no outer frame, no stencil. Bar ends land as real vertices on the
+ * arc, so the merged geometry casts a correct shadow and matches any collider.
  */
-export declare class BrickGeometry extends BufferGeometry {
-    constructor({ width, height, depth, }?: {
-        width?: number | undefined;
-        height?: number | undefined;
-        depth?: number | undefined;
-    });
-}
+export declare function buildArchedDiamondLatticeCameParts({ width, rectHeight, archHeight, centerY, grid, leadThickness: barT, leadDepth: barD, clipInset, }: ArchedDiamondLatticePartOptions): BoxGeometry[];
 
-export declare interface BrickWallOptions {
-    wallWidth?: number;
-    wallHeight?: number;
-    brickWidth?: number;
-    brickHeight?: number;
-    brickDepth?: number;
-    mortarGap?: number;
-    offsetPattern?: boolean;
-    brickColors?: number[];
-    colorVariation?: boolean;
-    positionVariation?: number;
-    rotationVariation?: number;
-    material?: Material;
-}
+/** Extruded frame ring following the arched opening perimeter. */
+export declare function buildArchedDiamondLatticeFrameGeometry(metrics: ArchedOpeningMetrics, barThickness: number, barDepth: number): ExtrudeGeometry;
+
+/** Outer frame (rect sides + circular arch head) and clipped diagonal cames. */
+export declare function buildArchedDiamondLatticeParts(options: ArchedDiamondLatticePartOptions): BoxGeometry[];
+
+/** Diagonal cames only — no outer frame (for stencil-masked openings). */
+export declare function buildDiamondLatticeCameParts(options: DiamondLatticePartOptions): BoxGeometry[];
+
+/**
+ * Build merged box geometries for the outer frame and diagonal lead cames.
+ * Diagonal bars are trimmed to the rectangular opening (segment clip, not stencil).
+ */
+export declare function buildDiamondLatticeParts({ width, height, centerY, grid, leadThickness: barT, leadDepth: barD, }: DiamondLatticePartOptions): BoxGeometry[];
+
+/**
+ * Build merged box geometries for the outer frame and interior mullions.
+ * Orthogonal grid — no clipping required; counts guarantee full panes.
+ */
+export declare function buildGregorianLatticeParts({ width, height, centerY, cellsX, cellsY, mullionThickness: barT, mullionDepth: barD, }: GregorianLatticePartOptions): BoxGeometry[];
+
+/** Outer frame bars — shared topology across lattice window openings. */
+export declare function buildRingLatticeFrameParts({ width, height, centerY, frameThickness: barT, frameDepth: barD, }: RingLatticeFramePartOptions): BoxGeometry[];
 
 export declare class BunsenBurner extends Group {
     constructor();
 }
 
-export declare class Burst extends Mesh {
-    constructor({ sides, innerRadius, outerRadius, depth }?: {
-        sides?: number | undefined;
-        innerRadius?: number | undefined;
-        outerRadius?: number | undefined;
-        depth?: number | undefined;
-    });
+/**
+ * Burst shape prefab.
+ */
+export declare class Burst extends Mesh<BurstGeometry, MeshStandardMaterial> {
+    constructor({ color, emissive, emissiveIntensity, ...geometryOptions }?: BurstOptions);
 }
 
 /**
- * Extrude geometry of Burst Shape.
+ * Extruded burst / starburst prism.
  */
 export declare class BurstGeometry extends ExtrudeGeometry {
-    constructor(sides?: number, innerRadius?: number, outerRadius?: number, depth?: number);
+    constructor({ sides, innerRadius, outerRadius, depth, }?: BurstGeometryOptions);
+}
+
+export declare interface BurstGeometryOptions {
+    /** Number of burst rays. Defaults to `5`. */
+    sides?: number;
+    /** Inner vertex radius. Defaults to `0.5`. */
+    innerRadius?: number;
+    /** Outer vertex radius. Defaults to `1`. */
+    outerRadius?: number;
+    /** Extrusion depth. Defaults to `0.25`. */
+    depth?: number;
+}
+
+export declare interface BurstOptions extends BurstGeometryOptions {
+    /** Surface tint. Defaults to `#ffff00`. */
+    color?: ColorRepresentation;
+    /** Emissive tint. Defaults to `#ffd700`. */
+    emissive?: ColorRepresentation;
+    /** Emissive strength. Defaults to `0.25`. */
+    emissiveIntensity?: number;
 }
 
 export declare class BurstShape extends Shape {
@@ -606,74 +781,84 @@ export declare function calculateXFromSlopeIntercept(x1: number, y1: number, x2:
  */
 export declare function calculateYFromSlopeIntercept(x1: number, y1: number, x2: number, y2: number, x: number): number;
 
-/**
- * Dolly backward
- *
- * Example:
- * ```
- * cameraDollyAnimation(camera, 5, 3000, () => {
- *   console.log("Dolly animation complete");
- * });
- * ```
- */
-export declare function cameraDollyAnimation(camera: Camera, distance: number, duration: number, onComplete?: () => void): void;
+export declare interface CameraClip {
+    readonly label: string;
+    readonly duration: number;
+    start(runtime: ClipRuntime): void;
+    update(runtime: ClipRuntime, dt: number): ClipPhase;
+    /** Called when playback is cancelled mid-clip. */
+    cancel?(runtime: ClipRuntime): void;
+}
 
-/**
- * The camera flies through a sequence of points, ideal for showcasing specific elements in the scene.
- *
- * Example:
- * ```
- * cameraFlythroughAnimation(
- *   camera,
- *   [
- *     new THREE.Vector3(0, 5, 5),
- *     new THREE.Vector3(0, 5, -25.5),
- *     new THREE.Vector3(-20.5, 5, 0),
- *   ],
- *   6000,
- *   () => {
- *     console.log("Flythrough animation complete");
- *   }
- * );
- * ```
- */
-export declare function cameraFlythroughAnimation(camera: Camera, waypoints: Vector3[], duration: number, onComplete?: () => void): void;
+declare interface CameraClipTiming {
+    /** Duration in seconds. */
+    duration: number;
+    /** Progress easing for normalized time `t` in [0, 1]. Defaults to smoothstep. */
+    ease?: EasingFunction;
+}
 
 /**
- * Orbit around a target
+ * Single director for camera showcase clips — Unity demo-scene style playback.
  *
- * Example:
- * ```
- * cameraOrbitAnimation(camera, new THREE.Vector3(0, 0, 0), 10, 5000, () => {
- *   console.log("Orbit animation complete");
- * });
- * ```
- */
-export declare function cameraOrbitAnimation(camera: Camera, target: Vector3, radius: number, duration: number, onComplete?: () => void): void;
-
-/**
- * The camera swings back and forth like a pendulum.
+ * One active clip at a time, driven by {@link update} with elapsed seconds (`dt`),
+ * not nested `requestAnimationFrame` loops. Disables OrbitControls while playing;
+ * re-enables and syncs `controls.target` to the clip focus on complete.
  *
- * Example:
- * ```
- * cameraPendulumAnimation(camera, new THREE.Vector3(0, 5, 5), 0.5, 9000, 3, () => {
- *   console.log("Pendulum animation complete");
- * });
- * ```
- */
-export declare function cameraPendulumAnimation(camera: Camera, center: Vector3, radius: number, duration: number, oscillations: number, onComplete?: () => void): void;
-
-/**
- * The camera spirals upward, perfect for revealing a large scene or structure.
+ * @example
+ * ```ts
+ * const playback = new CameraPlayback(camera, controls);
+ * playback.setRest(); // snapshot current pose as Reset target
  *
- * Example:
- * ```
- * cameraSpiralAscensionAnimation(camera, new THREE.Vector3(0, 0, 0), 10, 300, 7, 12000, () => {
- *   console.log("Spiral ascension animation complete");
+ * onFrame((dt) => {
+ *   playback.update(dt);
+ *   controls.update();
+ *   renderer.render(scene, camera);
  * });
+ *
+ * playback.play(createOrbitClip({ target, radius: 10, duration: 8 }));
  * ```
  */
-export declare function cameraSpiralAscensionAnimation(camera: Camera, center: Vector3, radius: number, height: number, revolutions: number, duration: number, onComplete?: () => void): void;
+export declare class CameraPlayback {
+    private readonly camera;
+    private readonly controls?;
+    private active;
+    private elapsed;
+    private readonly focus;
+    private rest;
+    constructor(camera: PerspectiveCamera, controls?: OrbitControls | undefined);
+    /** Whether a clip is actively playing. */
+    get isPlaying(): boolean;
+    /** Snapshot the current camera + controls pose as the Reset/rest pose. */
+    setRest(): void;
+    /** Replace the rest pose without stopping playback. */
+    setRestSnapshot(snapshot: CameraSnapshot): void;
+    /**
+     * Begin a clip. Cancels any active clip first.
+     * OrbitControls are disabled until the clip completes or {@link stop} is called.
+     */
+    play(clip: CameraClip): void;
+    /** Cancel the active clip and restore the rest pose. */
+    stop(): void;
+    /** Alias for {@link stop} — return to the rest pose. */
+    reset(): void;
+    /**
+     * Advance the active clip. Call from the scene `onFrame` callback each frame.
+     * @param dt Elapsed seconds since last frame.
+     */
+    update(dt: number): void;
+    /** Release references; call from example dispose. */
+    dispose(): void;
+    private cancelActive;
+    private runtime;
+}
+
+/** Rest pose captured when playback is constructed or reset. */
+export declare interface CameraSnapshot {
+    position: Vector3;
+    quaternion: Quaternion;
+    fov: number;
+    target: Vector3;
+}
 
 /**
  * CameraTransition provides smooth animated transitions between perspective and orthographic cameras.
@@ -757,62 +942,52 @@ export declare interface CameraTransitionOptions {
 }
 
 /**
- * Add a slight random wobble for intensity or realism (e.g., during an explosion).
- *
- * Example:
- * ```
- * cameraWobbleAnimation(camera, 0.5, 1000, () => {
- *   console.log("Wobble animation complete");
- * });
- * ```
- */
-export declare function cameraWobbleAnimation(camera: Camera, intensity: number, duration: number, onComplete?: () => void): void;
-
-/**
- * The camera smoothly zooms in toward a target, focusing attention on a specific point,
- * and resets to its original FOV after completion.
- *
- * Example:
- * ```
- * cameraZoomInAnimation(camera, new THREE.Vector3(0, 0, 0), 120, 75, 2000, () => {
- *   console.log("Zoom in animation complete");
- * });
- * ```
- */
-export declare function cameraZoomInAnimation(camera: PerspectiveCamera, target: Vector3, startFov: number, endFov: number, duration: number, onComplete?: () => void): void;
-
-/**
- * Material indices
- * 0: Stick
- * 1: Flame
+ * Candle prefab — wax stick and emissive flame (separate material groups).
  */
 export declare class Candle extends Mesh<CandleGeometry, MeshStandardMaterial[]> {
-    constructor({ radiusTop, //
-        radiusBottom, height, flameHeight, flameRadius, segments, }?: {
-        radiusTop?: number | undefined;
-        radiusBottom?: number | undefined;
-        height?: number | undefined;
-        flameHeight?: number | undefined;
-        flameRadius?: number | undefined;
-        segments?: number | undefined;
-    });
+    readonly height: number;
+    constructor({ stickColor, flameColor, flameEmissive, flameEmissiveIntensity, ...geometryOptions }?: CandleOptions);
 }
 
 /**
- * Group indices
- * 0: Stick
- * 1: Flame
+ * Candle stick and flame — group 0 stick, group 1 flame.
+ *
+ * Local frame: base at Y=0.
  */
 export declare class CandleGeometry extends BufferGeometry {
-    constructor({ radiusTop, //
-        radiusBottom, height, flameHeight, flameRadius, segments, }?: {
-        radiusTop?: number | undefined;
-        radiusBottom?: number | undefined;
-        height?: number | undefined;
-        flameHeight?: number | undefined;
-        flameRadius?: number | undefined;
-        segments?: number | undefined;
-    });
+    readonly radiusTop: number;
+    readonly radiusBottom: number;
+    readonly height: number;
+    readonly flameHeight: number;
+    readonly flameRadius: number;
+    readonly segments: number;
+    constructor({ radiusTop, radiusBottom, height, flameHeight, flameRadius, segments, }?: CandleGeometryOptions);
+}
+
+export declare interface CandleGeometryOptions {
+    /** Stick top radius. Defaults to `0.2`. */
+    radiusTop?: number;
+    /** Stick bottom radius. Defaults to `0.2`. */
+    radiusBottom?: number;
+    /** Stick height. Defaults to `1`. */
+    height?: number;
+    /** Flame tip height. Defaults to `0.25`. */
+    flameHeight?: number;
+    /** Flame base radius. Defaults to `0.05`. */
+    flameRadius?: number;
+    /** Circumference segments. Defaults to `16`. */
+    segments?: number;
+}
+
+export declare interface CandleOptions extends CandleGeometryOptions {
+    /** Wax stick tint. Defaults to `#ffffff`. */
+    stickColor?: ColorRepresentation;
+    /** Flame surface tint. Defaults to `#ffd700`. */
+    flameColor?: ColorRepresentation;
+    /** Flame emissive tint. Defaults to `#ffa500`. */
+    flameEmissive?: ColorRepresentation;
+    /** Flame emissive strength. Defaults to `0.35`. */
+    flameEmissiveIntensity?: number;
 }
 
 /**
@@ -821,6 +996,8 @@ export declare class CandleGeometry extends BufferGeometry {
  */
 export declare const capHeightFromRadius: (radius: number, thetaLength: number) => number;
 
+export declare function captureSnapshot(camera: PerspectiveCamera, controls?: OrbitControls): CameraSnapshot;
+
 /**
  * Calculate the width of a spherical cap.
  *   w = 2 * R * sin(thetaLength)
@@ -887,6 +1064,29 @@ export declare function centerObjectGeometry<T extends Object3D>(object: T, targ
  */
 export declare const checkerboardTexture: (size: number) => DataTexture;
 
+export declare type ClipPhase = "running" | "complete";
+
+/** Per-frame mutable state shared with the active clip. */
+export declare interface ClipRuntime {
+    camera: PerspectiveCamera;
+    controls: OrbitControls | null;
+    /** Seconds elapsed in the active clip. */
+    elapsed: number;
+    /** Clip duration in seconds. */
+    duration: number;
+    /** Look-at point the clip is focused on — synced to OrbitControls on complete. */
+    focus: Vector3;
+}
+
+/** Clip a segment to an axis-aligned rectangle; returns endpoints inside the opening. */
+export declare function clipSegmentToAabb(x1: number, y1: number, x2: number, y2: number, minX: number, minY: number, maxX: number, maxY: number): [number, number, number, number] | null;
+
+/**
+ * Clip a segment to a rect-plus-semicircle opening (analytic, same family as
+ * {@link clipSegmentToAabb}).
+ */
+export declare function clipSegmentToArchedOpening(x1: number, y1: number, x2: number, y2: number, bounds: ArchedOpeningBounds): [number, number, number, number] | null;
+
 export declare const ColorPalette: {
     CADMIUM_RED: number;
     CARDINAL_RED: number;
@@ -959,22 +1159,6 @@ export declare const ColorPalette: {
     TITANIUM_WHITE: number;
 };
 
-/**
- * Creates an instanced mesh brick wall with running bond pattern.
- *
- * @example
- * ```ts
- * const wall = createBrickWall({
- *   wallWidth: 10,
- *   wallHeight: 8,
- *   brickColors: [0x8b4513, 0xa0522d, 0x6b3410],
- *   colorVariation: true
- * });
- * scene.add(wall);
- * ```
- */
-export declare function createBrickWall({ wallWidth, wallHeight, brickWidth, brickHeight, brickDepth, mortarGap, offsetPattern, brickColors, colorVariation, positionVariation, rotationVariation, material, }?: BrickWallOptions): InstancedMesh;
-
 /**
  * Function to create cubic Bezier curve points
  *
@@ -1010,6 +1194,9 @@ export declare const createCubicCurvePoints: (start: Vector2, control1: Vector2,
  */
 export declare const createDampedCurvePoints: (start: Vector2, end: Vector2, damping: number, segments?: number) => Vector2[];
 
+/** Dolly in or out along the current view direction. */
+export declare function createDollyClip(options: DollyClipOptions): CameraClip;
+
 /**
  * Function to create exponential curve points
  *
@@ -1028,6 +1215,9 @@ export declare const createDampedCurvePoints: (start: Vector2, end: Vector2, dam
  */
 export declare const createExponentialCurvePoints: (start: Vector2, end: Vector2, base: number, factor: number, segments?: number) => Vector2[];
 
+/** Waypoint tour through a sequence of positions. */
+export declare function createFlythroughClip(options: FlythroughClipOptions): CameraClip;
+
 /**
  * Hexagonal tile pattern factory with density control.
  *
@@ -1084,6 +1274,15 @@ export declare function createHexagonalTilesByRadius(options: HexagonalTileRadiu
  */
 export declare const createLogarithmicCurvePoints: (start: Vector2, end: Vector2, base: number, factor: number, segments?: number) => Vector2[];
 
+/**
+ * Four clipping planes for a rectangular opening (shadow + mesh clip).
+ * Fragments are discarded when `dot(normal, position) > constant`.
+ */
+export declare function createOpeningClippingPlanes(width: number, height: number, centerY?: number): Plane[];
+
+/** Circle the scene — showcase reel orbit. */
+export declare function createOrbitClip(options: OrbitClipOptions): CameraClip;
+
 /**
  * Function to create parabolic curve points
  *
@@ -1103,6 +1302,12 @@ export declare const createLogarithmicCurvePoints: (start: Vector2, end: Vector2
  */
 export declare const createParabolicCurvePoints: (start: Vector2, end: Vector2, a: number, b: number, c: number, segments?: number) => Vector2[];
 
+/**
+ * Atmospheric focus drift — slow Ken Burns sway while locked on a subject.
+ * Not a full orbit; subtle back-and-forth for mood and screen capture.
+ */
+export declare function createPendulumClip(options: PendulumClipOptions): CameraClip;
+
 /**
  * Generates vertices for two triangles based upon a quad.
  *
@@ -1173,6 +1378,17 @@ p2: [number, number, number], p3: [number, number, number], p4: [number, number,
  */
 export declare const createQuadraticCurvePoints: (start: Vector2, control: Vector2, end: Vector2, segments?: number) => Vector2[];
 
+/**
+ * Create a random source.
+ *
+ * - **No seed** — wraps `Math.random()`. Unique every runtime; default for examples.
+ * - **With seed** — {@link mulberry32} stream. Same seed ⇒ same sequence.
+ */
+export declare function createRandom(seed?: number): RandomSource;
+
+/** Hollow square profile extruded for one lattice ring (local XY, facing +Z). */
+export declare function createRingLatticeGeometry(outer: number, wall: number, depth: number): ExtrudeGeometry;
+
 /**
  * Function to create sigmoid curve points
  *
@@ -1189,6 +1405,23 @@ export declare const createQuadraticCurvePoints: (start: Vector2, control: Vecto
  */
 export declare const createSigmoidCurvePoints: (start: Vector2, end: Vector2, a: number, segments?: number) => Vector2[];
 
+/**
+ * Scene-transition spiral — orbit upward while looking down at the scene.
+ * Camera rises and optionally widens its orbit; `lookAt` stays on the ground
+ * target so the view pitches into a bird's-eye survey (not a horizontal orbit).
+ */
+export declare function createSpiralClip(options: SpiralClipOptions): CameraClip;
+
+/**
+ * Impact wobble — short head-shake / recovery shake (gameplay feedback).
+ * Decaying sinusoidal offset, not random noise. For showcase orbit rigs use
+ * {@link createPendulumClip} instead.
+ */
+export declare function createWobbleClip(options: WobbleClipOptions): CameraClip;
+
+/** Focus punch — smooth FOV narrow toward a target. Restores FOV on cancel; keeps end FOV on complete. */
+export declare function createZoomClip(options: ZoomClipOptions): CameraClip;
+
 export declare const crossfadeShader: {
     uniforms: {
         tDiffuseA: {
@@ -1205,20 +1438,43 @@ export declare const crossfadeShader: {
     fragmentShader: string;
 };
 
+/**
+ * Cross headstone prefab.
+ */
 export declare class CrossHeadstone extends Mesh<CrossHeadstoneGeometry, MeshStandardMaterial> {
-    constructor({ width, height, depth, }?: CrossHeadstoneOptions);
+    readonly width: number;
+    readonly height: number;
+    constructor({ color, roughness, ...geometryOptions }?: CrossHeadstoneOptions);
 }
 
+/**
+ * Cross headstone — vertical shaft and horizontal arm.
+ *
+ * Local frame: base on Y=0, centered on X/Z.
+ */
 export declare class CrossHeadstoneGeometry extends BufferGeometry {
-    constructor(width?: number, height?: number, depth?: number);
+    readonly width: number;
+    readonly height: number;
+    readonly depth: number;
+    constructor({ width, height, depth }?: CrossHeadstoneGeometryOptions);
 }
 
-declare interface CrossHeadstoneOptions {
+export declare interface CrossHeadstoneGeometryOptions {
+    /** Overall cross width (arm span). Defaults to `0.4`. */
     width?: number;
+    /** Total height. Defaults to `1.2`. */
     height?: number;
+    /** Slab depth. Defaults to `0.2`. */
     depth?: number;
 }
 
+export declare interface CrossHeadstoneOptions extends CrossHeadstoneGeometryOptions {
+    /** Stone tint. Defaults to `#777777`. */
+    color?: ColorRepresentation;
+    /** Surface roughness. Defaults to `0.8`. */
+    roughness?: number;
+}
+
 /**
  * Cubic UV Mapping
  * Applies a texture by projecting UVs along each face of a cube.
@@ -1297,6 +1553,22 @@ export declare interface DaySkyUniforms {
     bottomColor: Uniform<Color>;
 }
 
+/**
+ * Derive an independent sub-stream seed from a master seed and domain salt.
+ *
+ * XOR the salt before mixing so each subsystem gets its own mulberry32 stream
+ * without sequential `seed + 1` collision risk. Use stable hex constants per
+ * domain (`0x101` books, `0x202` fog, `0x303` windows, …).
+ *
+ * @example
+ * ```ts
+ * const master = 1337;
+ * const bookRng = createRandom(deriveSubSeed(master, 0x101));
+ * const fogRng = createRandom(deriveSubSeed(master, 0x202));
+ * ```
+ */
+export declare function deriveSubSeed(masterSeed: number, salt: number): number;
+
 /**
  * Material indices:
  * 0. Desk surface
@@ -1315,41 +1587,114 @@ export declare class DeskGeometry extends BufferGeometry {
     constructor();
 }
 
+/** Derive uniform cell size from center-to-corner periods. Legacy — prefer grid counts. */
+export declare function diamondLatticeCellFromCount(width: number, height: number, cellsAcross: number): number;
+
+/**
+ * Perpendicular distance from the window center to a corner along the diamond
+ * grid axis (45° families share this spacing when square).
+ */
+export declare function diamondLatticeCornerSpan(width: number, height: number): number;
+
+/**
+ * Axis-aligned diamond lattice
+ */
+export declare interface DiamondLatticeGrid {
+    /** Horizontal half-diagonal of each quarrel (east–west point spacing). */
+    a: number;
+    /** Vertical half-diagonal of each quarrel (north–south point spacing). */
+    b: number;
+    /**
+     * Came angle from +X; the two families run at `+angle` and `−angle`.
+     * Equals 45° only when `a === b`.
+     */
+    angle: number;
+    /** Shared perpendicular spacing for both came families. */
+    spacing: number;
+}
+
 /**
- * A diorama with a floor and walls.
+ * Build an axis-aligned diamond grid from cell counts.
  *
- * Material indices:
- * 0: Interior walls
- * 1: Floor
- * 2: Exterior walls
+ * `cellsX` quarrels span the width (east–west); `cellsY` span the height.
+ * Equal counts on a square opening yield square diamonds; `5×10` elongates them
+ * vertically while keeping north/south tips on the same vertical axis.
+ */
+export declare function diamondLatticeGridFromCells(width: number, height: number, cellsX: number, cellsY: number): DiamondLatticeGrid;
+
+declare interface DiamondLatticePartOptions {
+    width: number;
+    height: number;
+    /** Center Y of the opening in local space. Defaults to `0`. */
+    centerY?: number;
+    grid: DiamondLatticeGrid;
+    leadThickness: number;
+    leadDepth: number;
+}
+
+/** Spring-to-apex Y shift that snaps the lattice phase to the rect/arch junction. */
+export declare function diamondLatticeSpringPhaseShift(ymin: number, rectTopY: number, grid: DiamondLatticeGrid): number;
+
+/**
+ * Diamond lattice window — diagonal lead cames with axis-aligned quarrels (`<>`).
+ *
+ * Local frame: centered on the opening, XY plane facing +Z. Lead is centered on
+ * `z = 0`; optional glass sits in the same plane (both faces). Pair with
+ * a scene-owned backing plane behind the wall.
  */
-export declare class Diorama extends Mesh<DioramaGeometry, MeshStandardMaterial[]> {
-    constructor({ width, height, depth, wallThickness, interiorColor, floorColor, exteriorColor, }?: {
-        width?: number | undefined;
-        height?: number | undefined;
-        depth?: number | undefined;
-        wallThickness?: number | undefined;
-        interiorColor?: number | undefined;
-        floorColor?: number | undefined;
-        exteriorColor?: number | undefined;
-    });
+export declare class DiamondLatticeWindow extends Group {
+    readonly lattice: Mesh<DiamondLatticeWindowGeometry, MeshStandardMaterial>;
+    readonly glass?: Mesh<PlaneGeometry, MeshPhysicalMaterial>;
+    readonly cellsX: number;
+    readonly cellsY: number;
+    readonly fittedGrid: DiamondLatticeGrid;
+    constructor({ leadColor, glass, glassColor, glassEmissive, glassEmissiveIntensity, centerY, leadDepth, ...geometryOptions }?: DiamondLatticeWindowOptions);
 }
 
 /**
- * Geometry for a diorama with a floor and walls.
+ * Diamond lattice window — outer frame plus diagonal cames.
+ * Quarrel tips align to the vertical and horizontal axes (`<>`).
+ * Built in the XY plane facing +Z.
  *
- * Group indices:
- * 0: Interior walls
- * 1: Floor
- * 2: Exterior walls
+ * Glass is a separate pane on {@link DiamondLatticeWindow} — this geometry is
+ * lead and frame only (casts shadow; glass typically does not).
  */
-export declare class DioramaGeometry extends BufferGeometry {
-    constructor({ width, height, depth, wallThickness }?: {
-        width?: number | undefined;
-        height?: number | undefined;
-        depth?: number | undefined;
-        wallThickness?: number | undefined;
-    });
+export declare class DiamondLatticeWindowGeometry extends BufferGeometry {
+    readonly cellsX: number;
+    readonly cellsY: number;
+    readonly fittedGrid: DiamondLatticeGrid;
+    constructor({ width, height, leadThickness, leadDepth, cellsX, cellsY, centerY, }?: DiamondLatticeWindowGeometryOptions);
+}
+
+declare interface DiamondLatticeWindowGeometryOptions {
+    /** Opening width (world units). */
+    width?: number;
+    /** Opening height (world units). */
+    height?: number;
+    /** Lead came thickness (cross-section). Defaults to `0.055`. */
+    leadThickness?: number;
+    /** Lead depth (Z extent). Defaults to `0.11`. */
+    leadDepth?: number;
+    /** Quarrels spanning east–west across the opening. Defaults to `10`. */
+    cellsX?: number;
+    /** Quarrels spanning north–south across the opening. Defaults to `10`. */
+    cellsY?: number;
+    /** Vertical center of the opening in local geometry space. Defaults to `0`. */
+    centerY?: number;
+}
+
+declare interface DiamondLatticeWindowOptions extends DiamondLatticeWindowGeometryOptions {
+    /** Lead + outer frame tint. Defaults to `#0c0f14`. */
+    leadColor?: ColorRepresentation;
+    /**
+     * Optional glass pane centered in the lead depth (`z = 0`), visible from both sides.
+     * Mad-science uses an emissive sky mesh in the scene instead.
+     */
+    glass?: boolean;
+    glassColor?: ColorRepresentation;
+    /** Glass emissive for moonlit / storm backlight. Defaults to off. */
+    glassEmissive?: ColorRepresentation;
+    glassEmissiveIntensity?: number;
 }
 
 /**
@@ -1432,6 +1777,12 @@ export declare const Direction: {
  */
 export declare const displacementBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number, direction?: Vector3, falloffFn?: (distance: number, radius: number) => number) => void;
 
+export declare interface DollyClipOptions extends CameraClipTiming {
+    /** Distance along view axis — positive pulls back, negative pushes in. */
+    distance: number;
+    ease?: EasingFunction;
+}
+
 /**
  * Easing functions for interpolating values over time.
  *
@@ -1637,26 +1988,42 @@ export declare interface EmissivePulseEffectOptions {
 
 export declare type EmissivePulseMaterial = MeshStandardMaterial | MeshPhysicalMaterial | MeshLambertMaterial | MeshPhongMaterial;
 
+/**
+ * Erlenmeyer flask prefab — translucent glass vessel.
+ */
 export declare class ErlenmeyerFlask extends Mesh<ErlenmeyerFlaskGeometry, MeshPhysicalMaterial> {
-    constructor({ flaskRadius, //
-        neckRadius, height, neckHeight, radialSegments, }?: {
-        flaskRadius?: number | undefined;
-        neckRadius?: number | undefined;
-        height?: number | undefined;
-        neckHeight?: number | undefined;
-        radialSegments?: number | undefined;
-    });
+    constructor({ color, opacity, ...geometryOptions }?: ErlenmeyerFlaskOptions);
 }
 
+/**
+ * Erlenmeyer flask profile — conical body with straight neck and lip.
+ *
+ * Local frame: base at Y=0.
+ */
 export declare class ErlenmeyerFlaskGeometry extends BufferGeometry {
-    constructor({ flaskRadius, //
-        neckRadius, height, neckHeight, radialSegments, }?: {
-        flaskRadius?: number | undefined;
-        neckRadius?: number | undefined;
-        height?: number | undefined;
-        neckHeight?: number | undefined;
-        radialSegments?: number | undefined;
-    });
+    readonly flaskRadius: number;
+    readonly height: number;
+    constructor({ flaskRadius, neckRadius, height, neckHeight, radialSegments, }?: ErlenmeyerFlaskGeometryOptions);
+}
+
+export declare interface ErlenmeyerFlaskGeometryOptions {
+    /** Flask body radius. Defaults to `1`. */
+    flaskRadius?: number;
+    /** Neck radius. Defaults to `0.3`. */
+    neckRadius?: number;
+    /** Body height before the neck. Defaults to `2.5`. */
+    height?: number;
+    /** Neck height. Defaults to `1`. */
+    neckHeight?: number;
+    /** Lathe segments. Defaults to `16`. */
+    radialSegments?: number;
+}
+
+export declare interface ErlenmeyerFlaskOptions extends ErlenmeyerFlaskGeometryOptions {
+    /** Glass tint. Defaults to `#88ccff`. */
+    color?: ColorRepresentation;
+    /** Glass opacity. Defaults to `0.4`. */
+    opacity?: number;
 }
 
 export declare const fadeShader: {
@@ -1732,13 +2099,23 @@ export declare function findClosestColorChannelWise(inputColor: number, dataset:
  */
 export declare function findClosestPoint(point: Vector3, mesh: Mesh): Vector3;
 
+/**
+ * Snap cell size so diagonal cames align symmetrically at all four frame edges.
+ * Legacy single-spacing helper — prefer {@link diamondLatticeGridFromCells}.
+ */
+export declare function fitDiamondLatticeCell(width: number, height: number, preferredCell: number): number;
+
+/**
+ * Emissive flame prefab — parametric teardrop volume for candles and lanterns.
+ *
+ * Local frame: base at Y=0, tip at Y=`height`.
+ */
 export declare class Flame extends Mesh<FlameGeometry, MeshStandardMaterial> {
-    constructor({ height, radius, segmentsU, segmentsV }?: {
-        height?: number | undefined;
-        radius?: number | undefined;
-        segmentsU?: number | undefined;
-        segmentsV?: number | undefined;
-    });
+    readonly height: number;
+    readonly radius: number;
+    readonly segmentsU: number;
+    readonly segmentsV: number;
+    constructor({ color, emissive, emissiveIntensity, ...geometryOptions }?: FlameOptions);
 }
 
 /**
@@ -1788,13 +2165,37 @@ export declare interface FlameFlickerEffectOptions {
     haloOpacity?: number;
 }
 
+/**
+ * Teardrop flame volume — parametric surface tapering to a point at the top.
+ *
+ * Local frame: base at Y=0, tip at Y=`height`.
+ */
 export declare class FlameGeometry extends ParametricGeometry {
-    constructor({ height, radius, segmentsU, segmentsV }?: {
-        height?: number | undefined;
-        radius?: number | undefined;
-        segmentsU?: number | undefined;
-        segmentsV?: number | undefined;
-    });
+    readonly height: number;
+    readonly radius: number;
+    readonly segmentsU: number;
+    readonly segmentsV: number;
+    constructor({ height, radius, segmentsU, segmentsV, }?: FlameGeometryOptions);
+}
+
+export declare interface FlameGeometryOptions {
+    /** Flame tip height. Defaults to `0.25`. */
+    height?: number;
+    /** Base radius at the widest point. Defaults to `0.05`. */
+    radius?: number;
+    /** Parametric segments around the circumference. Defaults to `16`. */
+    segmentsU?: number;
+    /** Parametric segments along the height. Defaults to `16`. */
+    segmentsV?: number;
+}
+
+export declare interface FlameOptions extends FlameGeometryOptions {
+    /** Surface tint. Defaults to `#ffd700`. */
+    color?: ColorRepresentation;
+    /** Emissive tint. Defaults to `#ffa500`. */
+    emissive?: ColorRepresentation;
+    /** Emissive strength. Defaults to `0.35`. */
+    emissiveIntensity?: number;
 }
 
 /**
@@ -1810,26 +2211,49 @@ export declare class FlorenceFlaskGeometry extends BufferGeometry {
     constructor();
 }
 
-export declare class Gear extends Mesh {
-    constructor({ sides, innerRadius, outerRadius, holeSides, holeRadius, depth }?: {
-        sides?: number | undefined;
-        innerRadius?: number | undefined;
-        outerRadius?: number | undefined;
-        holeSides?: number | undefined;
-        holeRadius?: number | undefined;
-        depth?: number | undefined;
-    });
+export declare interface FlythroughClipOptions extends CameraClipTiming {
+    waypoints: Vector3[];
+    /** Optional look-at points per waypoint; defaults to next waypoint. */
+    lookAt?: Vector3[];
+    ease?: EasingFunction;
 }
 
 /**
- * Extrude geometry of Gear Shape.
+ * Gear shape prefab.
  */
-export declare class GearGeometry extends ExtrudeGeometry {
-    constructor(sides?: number, innerRadius?: number, outerRadius?: number, holeSides?: number, holeRadius?: number, depth?: number);
+export declare class Gear extends Mesh<GearGeometry, MeshStandardMaterial> {
+    constructor({ color, ...geometryOptions }?: GearOptions);
 }
 
-export declare class GearShape extends Shape {
-    constructor(sides?: number, innerRadius?: number, outerRadius?: number, holeSides?: number, holeRadius?: number);
+/**
+ * Extruded gear profile with center hole.
+ */
+export declare class GearGeometry extends ExtrudeGeometry {
+    constructor({ sides, innerRadius, outerRadius, holeSides, holeRadius, depth, }?: GearGeometryOptions);
+}
+
+export declare interface GearGeometryOptions {
+    /** Number of gear teeth. Defaults to `5`. */
+    sides?: number;
+    /** Inner tooth valley radius. Defaults to `0.5`. */
+    innerRadius?: number;
+    /** Outer tooth tip radius. Defaults to `1`. */
+    outerRadius?: number;
+    /** Center hole sides. Defaults to `5`. */
+    holeSides?: number;
+    /** Center hole radius. Defaults to `0.25`. */
+    holeRadius?: number;
+    /** Extrusion depth. Defaults to `0.25`. */
+    depth?: number;
+}
+
+export declare interface GearOptions extends GearGeometryOptions {
+    /** Metal tint. Defaults to `#aaaaaa`. */
+    color?: ColorRepresentation;
+}
+
+export declare class GearShape extends Shape {
+    constructor(sides?: number, innerRadius?: number, outerRadius?: number, holeSides?: number, holeRadius?: number);
 }
 
 /**
@@ -1876,6 +2300,86 @@ export declare interface GlowHaloOptions {
     opacity?: number;
 }
 
+/** Pane dimensions derived from opening size and cell counts. */
+export declare interface GregorianLatticeGrid {
+    /** Width of each rectangular pane. */
+    paneWidth: number;
+    /** Height of each rectangular pane. */
+    paneHeight: number;
+}
+
+/**
+ * Derive pane size from cell counts.
+ *
+ * `cellsX` panes span the opening width; `cellsY` span the height. Mullions
+ * divide the opening evenly so every segment is a full rectangle.
+ */
+export declare function gregorianLatticeGridFromCells(width: number, height: number, cellsX: number, cellsY: number): GregorianLatticeGrid;
+
+declare interface GregorianLatticePartOptions {
+    width: number;
+    height: number;
+    /** Center Y of the opening in local space. Defaults to `0`. */
+    centerY?: number;
+    cellsX: number;
+    cellsY: number;
+    mullionThickness: number;
+    mullionDepth: number;
+}
+
+/**
+ * Gregorian lattice window — rectangular pane grid with orthogonal mullions.
+ *
+ * Local frame: centered on the opening, XY plane facing +Z. Mullions and
+ * optional glass share `z = 0`.
+ */
+export declare class GregorianLatticeWindow extends Group {
+    readonly mullions: Mesh<GregorianLatticeWindowGeometry, MeshStandardMaterial>;
+    readonly glass?: Mesh<PlaneGeometry, MeshPhysicalMaterial>;
+    readonly cellsX: number;
+    readonly cellsY: number;
+    readonly fittedGrid: GregorianLatticeGrid;
+    constructor({ mullionColor, glass, glassColor, glassEmissive, glassEmissiveIntensity, ...geometryOptions }?: GregorianLatticeWindowOptions);
+}
+
+/**
+ * Gregorian lattice window — outer frame plus orthogonal mullions in a rectangular grid.
+ * Built in the XY plane facing +Z.
+ */
+export declare class GregorianLatticeWindowGeometry extends BufferGeometry {
+    readonly cellsX: number;
+    readonly cellsY: number;
+    readonly fittedGrid: GregorianLatticeGrid;
+    constructor({ width, height, mullionThickness, mullionDepth, cellsX, cellsY, centerY, }?: GregorianLatticeWindowGeometryOptions);
+}
+
+declare interface GregorianLatticeWindowGeometryOptions {
+    /** Opening width (world units). */
+    width?: number;
+    /** Opening height (world units). */
+    height?: number;
+    /** Mullion thickness (cross-section). Defaults to `0.055`. */
+    mullionThickness?: number;
+    /** Mullion depth (Z extent). Defaults to `0.11`. */
+    mullionDepth?: number;
+    /** Rectangular panes across the opening width. Defaults to `4`. */
+    cellsX?: number;
+    /** Rectangular panes up the opening height. Defaults to `6`. */
+    cellsY?: number;
+    /** Vertical center of the opening in local geometry space. Defaults to `0`. */
+    centerY?: number;
+}
+
+declare interface GregorianLatticeWindowOptions extends GregorianLatticeWindowGeometryOptions {
+    /** Frame + mullion tint. Defaults to `#5c4033` (wood). */
+    mullionColor?: ColorRepresentation;
+    /** Optional glass pane coplanar with the mullions (same Z center). */
+    glass?: boolean;
+    glassColor?: ColorRepresentation;
+    glassEmissive?: ColorRepresentation;
+    glassEmissiveIntensity?: number;
+}
+
 /**
  * Creeping ground mist — soft horizontal cards drifting above the floor.
  * Interior patches wrap toroidally within `area`; optional perimeter patches
@@ -1906,7 +2410,7 @@ export declare interface GroundFogEffectOptions {
      * horizons opposite the camera. Defaults to `0` (interior only).
      */
     perimeterCount?: number;
-    /** Half-extent of the inner bounded plot (fence, wall, diorama edge, etc.). Defaults to `12`. */
+    /** Half-extent of the inner bounded plot (fence, wall, scene edge, etc.). Defaults to `12`. */
     plotHalf?: number;
     /** Terrain half-extent; perimeter cards spill outward toward this edge. Defaults to `16`. */
     terrainHalf?: number;
@@ -1927,32 +2431,135 @@ export declare interface GroundFogEffectOptions {
     heightAt?: (x: number, z: number) => number;
 }
 
-export declare class Heart extends Mesh {
-    constructor({ size, width, height, tipDepth, depth }?: {
-        size?: number | undefined;
-        width?: number | undefined;
-        height?: number | undefined;
-        tipDepth?: number | undefined;
-        depth?: number | undefined;
-    });
+/**
+ * Hanging wrought-iron lantern — open cage struts around a solid emissive
+ * inner octahedron (glass-pane lamp). Mount, cage, and lamp use separate
+ * material groups. Pair {@link GlowHalo} and {@link FlameFlickerEffect} at
+ * `cageCenterY` for bloom and flicker.
+ *
+ * Local frame: origin at the chain top (hang point).
+ */
+export declare class HangingLantern extends Mesh<HangingLanternGeometry, MeshStandardMaterial[]> {
+    readonly drop: number;
+    readonly cageCenterY: number;
+    constructor({ color, mountColor, cageColor, lampColor, lampEmissiveIntensity, lampOpacity, inner, ...geometryOptions }?: HangingLanternOptions);
+}
+
+/**
+ * Wrought-iron hanging lantern frame — chain, cap, and open octahedron cage
+ * built from edge struts.
+ *
+ * Material groups: `0` mount (chain + cap), `1` cage struts, `2` inner lamp
+ * (solid octahedron).
+ *
+ * Local frame: origin at the chain top (hang point). The cage top vertex
+ * attaches at the cap center, optionally lowered by `cageGap`.
+ */
+export declare class HangingLanternGeometry extends BufferGeometry {
+    readonly drop: number;
+    readonly chainWidth: number;
+    readonly capWidth: number;
+    readonly capHeight: number;
+    readonly capDepth: number;
+    readonly capOffset: number;
+    readonly cageRadius: number;
+    readonly cageStretch: number;
+    readonly cageGap: number;
+    readonly cageBarWidth: number;
+    readonly innerScale: number;
+    readonly inner: boolean;
+    /** Y of the cage center in local space (negative, below the hang point). */
+    readonly cageCenterY: number;
+    constructor({ drop, chainWidth, capWidth, capHeight, capDepth, capOffset, cageRadius, cageStretch, cageGap, cageBarWidth, innerScale, inner, }?: HangingLanternGeometryOptions);
+}
+
+export declare interface HangingLanternGeometryOptions {
+    /** Chain length from the hang point. Defaults to `3`. */
+    drop?: number;
+    /** Chain link cross-section. Defaults to `0.05`. */
+    chainWidth?: number;
+    /** Cap width (X). Defaults to `0.18`. */
+    capWidth?: number;
+    /** Cap height (Y). Defaults to `0.16`. */
+    capHeight?: number;
+    /** Cap depth (Z). Defaults to `0.18`. */
+    capDepth?: number;
+    /** Cap center offset below the chain bottom. Defaults to `0.02`. */
+    capOffset?: number;
+    /** Cage vertex radius before stretch. Defaults to `0.42`. */
+    cageRadius?: number;
+    /** Vertical stretch on the cage. Defaults to `1.4`. */
+    cageStretch?: number;
+    /** Extra downward offset below the cap-center cage attach. Defaults to `0`. */
+    cageGap?: number;
+    /** Cage strut thickness. Defaults to `0.03`. */
+    cageBarWidth?: number;
+    /** Inner lamp scale relative to the cage (inset to sit inside struts). Defaults to `0.96`. */
+    innerScale?: number;
+    /** Include the solid inner octahedron lamp volume. Defaults to `true`. */
+    inner?: boolean;
+}
+
+export declare interface HangingLanternOptions extends HangingLanternGeometryOptions {
+    /** Wrought-iron tint for mount and cage. Defaults to `#171a1f`. */
+    color?: ColorRepresentation;
+    /** Mount iron tint (chain + cap). Defaults to `color`. */
+    mountColor?: ColorRepresentation;
+    /** Cage strut tint. Defaults to `color`. */
+    cageColor?: ColorRepresentation;
+    /** Inner lamp tint (emissive octahedron). Defaults to `#ffb45a`. */
+    lampColor?: ColorRepresentation;
+    /** Inner lamp emissive strength. Defaults to `1.4`. */
+    lampEmissiveIntensity?: number;
+    /** Inner lamp opacity for a glass-pane read. Defaults to `0.88`. */
+    lampOpacity?: number;
 }
 
 /**
- * Extrude geometry of Heart Shape.
+ * Heart shape prefab.
+ */
+export declare class Heart extends Mesh<HeartGeometry, MeshStandardMaterial> {
+    constructor({ color, emissive, emissiveIntensity, ...geometryOptions }?: HeartOptions);
+}
+
+/**
+ * Extruded heart prism.
  */
 export declare class HeartGeometry extends ExtrudeGeometry {
-    constructor(size?: number, width?: number, height?: number, tipDepth?: number, depth?: number);
+    constructor({ size, width, height, tipDepth, depth, }?: HeartGeometryOptions);
+}
+
+export declare interface HeartGeometryOptions {
+    /** Overall scale factor. Defaults to `1`. */
+    size?: number;
+    /** Heart width. Defaults to `2.1`. */
+    width?: number;
+    /** Heart height. Defaults to `1.4`. */
+    height?: number;
+    /** Tip depth. Defaults to `1.6`. */
+    tipDepth?: number;
+    /** Extrusion depth. Defaults to `0.25`. */
+    depth?: number;
+}
+
+export declare interface HeartOptions extends HeartGeometryOptions {
+    /** Surface tint. Defaults to `#c62828`. */
+    color?: ColorRepresentation;
+    /** Emissive tint. Defaults to `#c61416`. */
+    emissive?: ColorRepresentation;
+    /** Emissive strength. Defaults to `0.25`. */
+    emissiveIntensity?: number;
 }
 
 export declare class HeartShape extends Shape {
     constructor(size?: number, width?: number, height?: number, tipDepth?: number);
 }
 
-export declare class Hexagon extends Mesh {
-    constructor({ radius, depth }?: {
-        radius?: number | undefined;
-        depth?: number | undefined;
-    });
+/**
+ * Hexagon tile prefab.
+ */
+export declare class Hexagon extends Mesh<HexagonGeometry, MeshStandardMaterial> {
+    constructor({ color, emissive, emissiveIntensity, ...geometryOptions }?: HexagonOptions);
 }
 
 export declare interface HexagonalTileCountOptions {
@@ -1974,10 +2581,28 @@ export declare interface HexagonalTileRadiusOptions {
 }
 
 /**
- * Extrude geometry of Hexagon Shape.
+ * Extruded regular hexagon prism.
  */
 export declare class HexagonGeometry extends ExtrudeGeometry {
-    constructor(radius?: number, depth?: number);
+    readonly radius: number;
+    readonly depth: number;
+    constructor({ radius, depth }?: HexagonGeometryOptions);
+}
+
+export declare interface HexagonGeometryOptions {
+    /** Hex circumradius. Defaults to `1`. */
+    radius?: number;
+    /** Extrusion depth. Defaults to `0.01`. */
+    depth?: number;
+}
+
+export declare interface HexagonOptions extends HexagonGeometryOptions {
+    /** Surface tint. Defaults to `#ffffff`. */
+    color?: ColorRepresentation;
+    /** Emissive tint. Defaults to `#ffffff`. */
+    emissive?: ColorRepresentation;
+    /** Emissive strength. Defaults to `0.1`. */
+    emissiveIntensity?: number;
 }
 
 export declare class HexagonShape extends Shape {
@@ -1992,28 +2617,42 @@ export declare function hexToHsl(hex: number): [number, number, number];
  */
 export declare function hexToRgb(hex: number): [number, number, number];
 
+/**
+ * Hill prefab — hemispherical terrain mound.
+ */
 export declare class Hill extends Mesh<HillGeometry, MeshStandardMaterial> {
-    constructor({ radius, //
-        height, widthSegments, heightSegments, phiStart, phiLength, }?: {
-        radius?: number | undefined;
-        height?: number | undefined;
-        widthSegments?: number | undefined;
-        heightSegments?: number | undefined;
-        phiStart?: number | undefined;
-        phiLength?: number | undefined;
-    });
+    readonly radius: number;
+    readonly height: number;
+    constructor({ color, ...geometryOptions }?: HillOptions);
 }
 
+/**
+ * Hemispherical hill — a sphere cap scaled on Y, base on the Y=0 plane.
+ */
 export declare class HillGeometry extends BufferGeometry {
-    constructor({ radius, //
-        height, widthSegments, heightSegments, phiStart, phiLength, }?: {
-        radius?: number | undefined;
-        height?: number | undefined;
-        widthSegments?: number | undefined;
-        heightSegments?: number | undefined;
-        phiStart?: number | undefined;
-        phiLength?: number | undefined;
-    });
+    readonly radius: number;
+    readonly height: number;
+    constructor({ radius, height, widthSegments, heightSegments, phiStart, phiLength, }?: HillGeometryOptions);
+}
+
+export declare interface HillGeometryOptions {
+    /** Base sphere radius before vertical squash. Defaults to `3`. */
+    radius?: number;
+    /** Peak height. Defaults to `0.6`. */
+    height?: number;
+    /** Horizontal segments. Defaults to `64`. */
+    widthSegments?: number;
+    /** Vertical segments. Defaults to `16`. */
+    heightSegments?: number;
+    /** Azimuth start angle (radians). Defaults to `0`. */
+    phiStart?: number;
+    /** Azimuth sweep (radians). Defaults to `2π`. */
+    phiLength?: number;
+}
+
+export declare interface HillOptions extends HillGeometryOptions {
+    /** Surface tint. Defaults to `#00ff00`. */
+    color?: ColorRepresentation;
 }
 
 /**
@@ -2030,6 +2669,9 @@ export declare function hslToHex(h: number, s: number, l: number): [number, numb
 
 export declare function hslToRgb(h: number, s: number, l: number): [number, number, number];
 
+/** Inset opening for frame ring inner edge (uniform `inset` wall thickness). */
+export declare function insetArchedOpeningMetrics(outer: ArchedOpeningMetrics, inset: number): ArchedOpeningMetrics;
+
 /**
  * Generates an array of interpolated 2D points using an easing function.
  * @param curveFunction - The easing function to apply to the normalized value.
@@ -2062,8 +2704,110 @@ export declare class JarGeometry extends BufferGeometry {
     constructor();
 }
 
-export declare class Lantern extends Group {
-    constructor(height?: number, baseWidth?: number);
+/**
+ * Tabletop lantern — frame around an emissive glass body. Geometry only; add
+ * {@link GlowHalo} and {@link FlameFlickerEffect} at `lampCenterY` in the
+ * scene.
+ *
+ * Local frame: sits on the Y=0 plane.
+ */
+export declare class Lantern extends Mesh<LanternGeometry, MeshStandardMaterial[]> {
+    readonly lampCenterY: number;
+    constructor({ color, lampColor, lampEmissiveIntensity, lampOpacity, inner, ...geometryOptions }?: LanternOptions);
+}
+
+/**
+ * Tabletop lantern — wood/metal base, roof, and handle framing an emissive
+ * glass body.
+ *
+ * Material groups: `0` frame (base + roof + handle), `1` glass body.
+ *
+ * Local frame: sits on the Y=0 plane; lamp center at `lampCenterY`.
+ */
+export declare class LanternGeometry extends BufferGeometry {
+    readonly baseWidth: number;
+    readonly bodyHeight: number;
+    readonly baseHeight: number;
+    readonly innerScale: number;
+    readonly inner: boolean;
+    readonly lampCenterY: number;
+    constructor({ baseWidth, bodyHeight, baseHeight, roofHeight, roofRadius, glassRadiusScale, innerScale, handleRadius, handleTubeRadius, handleLift, segments, inner, }?: LanternGeometryOptions);
+}
+
+export declare interface LanternGeometryOptions {
+    /** Base / foot radius. Defaults to `0.5`. */
+    baseWidth?: number;
+    /** Glass body height. Defaults to `1.3`. */
+    bodyHeight?: number;
+    /** Base height. Defaults to `0.2`. */
+    baseHeight?: number;
+    /** Roof cone height. Defaults to `0.5`. */
+    roofHeight?: number;
+    /** Roof cone radius. Defaults to `baseWidth * 1.1`. */
+    roofRadius?: number;
+    /** Glass radius relative to `baseWidth`. Defaults to `0.9`. */
+    glassRadiusScale?: number;
+    /** Glass height inset relative to `bodyHeight`. Defaults to `0.96`. */
+    innerScale?: number;
+    /** Carry-handle major radius. Defaults to `baseWidth * 0.8`. */
+    handleRadius?: number;
+    /** Carry-handle tube radius. Defaults to `0.05`. */
+    handleTubeRadius?: number;
+    /** Gap above the roof to the handle center. Defaults to `0.35`. */
+    handleLift?: number;
+    /** Radial segments on round parts. Defaults to `8`. */
+    segments?: number;
+    /** Include the emissive glass body. Defaults to `true`. */
+    inner?: boolean;
+}
+
+export declare interface LanternOptions extends LanternGeometryOptions {
+    /** Frame tint (base, roof, handle). Defaults to `#8b4513`. */
+    color?: ColorRepresentation;
+    /** Glass lamp tint. Defaults to `#ffd700`. */
+    lampColor?: ColorRepresentation;
+    /** Glass emissive strength. Defaults to `1.2`. */
+    lampEmissiveIntensity?: number;
+    /** Glass opacity. Defaults to `0.75`. */
+    lampOpacity?: number;
+}
+
+/**
+ * Folded autumn leaf prefab — {@link LeafGeometry} with flat-shaded double-sided
+ * material matching the graveyard blowing-leaves look.
+ *
+ * Local frame: tip at +Y, base at −Y, fold rises along +Z.
+ */
+export declare class Leaf extends Mesh<LeafGeometry, MeshStandardMaterial> {
+    readonly size: number;
+    readonly lift: number;
+    constructor({ color, ...geometryOptions }?: LeafOptions);
+}
+
+/**
+ * Low-poly folded leaf — a pointed ellipse with a gently raised midrib so it
+ * catches rim light instead of reading as a flat sliver. Spine vertices sit
+ * slightly above the mirrored rim outline, giving a soft V cross-section under
+ * flat shading.
+ *
+ * Local frame: tip at +Y, base at −Y, fold rises along +Z.
+ */
+export declare class LeafGeometry extends BufferGeometry {
+    readonly size: number;
+    readonly lift: number;
+    constructor({ size, lift }?: LeafGeometryOptions);
+}
+
+export declare interface LeafGeometryOptions {
+    /** Overall leaf scale. Defaults to `0.13`. */
+    size?: number;
+    /** Midrib rise above the rim as a fraction of size. Defaults to `0.22`. */
+    lift?: number;
+}
+
+export declare interface LeafOptions extends LeafGeometryOptions {
+    /** Leaf tint. Defaults to `#a8702c`. */
+    color?: ColorRepresentation;
 }
 
 export declare class LeverPanel extends Group {
@@ -2142,7 +2886,7 @@ export declare const LineEquations: {
  * @param {number} [max=1] - Maximum value of the range.
  * @returns {number} A random number between `min` and `max`, skewed towards `max`.
  */
-export declare function logarithmicRandomMax(exponent?: number, min?: number, max?: number): number;
+export declare function logarithmicRandomMax(exponent?: number, min?: number, max?: number, source?: RandomSource): number;
 
 /**
  * Generates a random number skewed towards the minimum value.
@@ -2154,10 +2898,56 @@ export declare function logarithmicRandomMax(exponent?: number, min?: number, ma
  * @param {number} [max=1] - Maximum value of the range.
  * @returns {number} A random number between `min` and `max`, skewed towards `min`.
  */
-export declare function logarithmicRandomMin(exponent?: number, min?: number, max?: number): number;
+export declare function logarithmicRandomMin(exponent?: number, min?: number, max?: number, source?: RandomSource): number;
 
+/**
+ * L-shaped staircase prefab — two flights with a square width × width landing.
+ */
+export declare class LShapedStaircase extends Mesh<LShapedStaircaseGeometry, MeshStandardMaterial> {
+    readonly width: number;
+    readonly riserHeight: number;
+    readonly treadDepth: number;
+    readonly stepsPerFlight: number;
+    readonly landingSize: number;
+    readonly flightRun: number;
+    readonly totalHeight: number;
+    constructor({ color, ...geometryOptions }?: LShapedStaircaseOptions);
+}
+
+/**
+ * L-shaped staircase with a square landing (width × width) at the 90° turn.
+ *
+ * Local frame:
+ * - First flight climbs +Z, centered on X = 0.
+ * - Landing is a width² platform starting at the last tread (no cantilever over
+ *   the lower flight) and extending forward at the turn.
+ * - Second flight climbs −X from the left edge of the landing.
+ */
 export declare class LShapedStaircaseGeometry extends BufferGeometry {
-    constructor(stepWidth?: number, stepHeight?: number, stepDepth?: number, numStepsPerFlight?: number, landingDepth?: number);
+    readonly width: number;
+    readonly riserHeight: number;
+    readonly treadDepth: number;
+    readonly stepsPerFlight: number;
+    readonly landingSize: number;
+    readonly flightRun: number;
+    readonly totalHeight: number;
+    constructor({ width, riserHeight, treadDepth, stepsPerFlight, }?: LShapedStaircaseGeometryOptions);
+}
+
+export declare interface LShapedStaircaseGeometryOptions {
+    /** Stair width (tread left–right extent). Defaults to `2`. */
+    width?: number;
+    /** Vertical rise per step (riser). Defaults to `0.3`. */
+    riserHeight?: number;
+    /** Horizontal run per step (tread depth). Defaults to `0.5`. */
+    treadDepth?: number;
+    /** Steps in each flight (before and after the landing). Defaults to `5`. */
+    stepsPerFlight?: number;
+}
+
+export declare interface LShapedStaircaseOptions extends LShapedStaircaseGeometryOptions {
+    /** Tread and riser tint. Defaults to `#8b4513`. */
+    color?: ColorRepresentation;
 }
 
 /**
@@ -2188,24 +2978,6 @@ export declare class Microscope extends Group {
     constructor();
 }
 
-export declare class Moon extends Mesh<SphereGeometry, ShaderMaterial> {
-    constructor();
-}
-
-/**
- * Moon shader
- * Simple moon effect with noise
- */
-export declare const moonShader: {
-    uniforms: {
-        time: {
-            value: number;
-        };
-    };
-    vertexShader: string;
-    fragmentShader: string;
-};
-
 export declare class MortarAndPestle extends Group {
     constructor();
 }
@@ -2215,81 +2987,92 @@ export declare class MortarGeometry extends BufferGeometry {
 }
 
 /**
- * Material indices:
- * 0. Rocks
- * 1. Moss
+ * Mossy rock prefab — grey stone with a translucent green moss shell.
+ *
+ * Material groups: `0` rock, `1` moss.
  */
-export declare class MossyRocks extends Mesh<MossyRocksGeometry, MeshStandardMaterial[]> {
-    constructor();
+export declare class MossyRock extends Mesh<MossyRockGeometry, MeshStandardMaterial[]> {
+    constructor({ rockColor, mossColor, mossOpacity, ...geometryOptions }?: MossyRockOptions);
 }
 
 /**
- * Group indices:
- * 0. Rocks
- * 1. Moss
+ * Mossy rock — dodecahedron body with a smaller, flatter moss shell (group 1).
+ *
+ * Material groups: `0` rock, `1` moss.
+ *
+ * Local frame: centered on the rock body.
  */
-export declare class MossyRocksGeometry extends BufferGeometry {
-    constructor();
+export declare class MossyRockGeometry extends BufferGeometry {
+    readonly radius: number;
+    readonly detail: number;
+    constructor({ radius, detail, mossScaleXZ, mossScaleY, mossOffsetY, }?: MossyRockGeometryOptions);
+}
+
+export declare interface MossyRockGeometryOptions {
+    /** Rock dodecahedron radius. Defaults to `1`. */
+    radius?: number;
+    /** Dodecahedron detail level. Defaults to `0`. */
+    detail?: number;
+    /** Moss horizontal scale relative to the rock. Defaults to `0.9`. */
+    mossScaleXZ?: number;
+    /** Moss vertical scale relative to the rock. Defaults to `0.5`. */
+    mossScaleY?: number;
+    /** Moss center offset above the rock origin. Defaults to `0.3`. */
+    mossOffsetY?: number;
+}
+
+export declare interface MossyRockOptions extends MossyRockGeometryOptions {
+    /** Rock tint. Defaults to `#808080`. */
+    rockColor?: ColorRepresentation;
+    /** Moss tint. Defaults to `#4b8b3b`. */
+    mossColor?: ColorRepresentation;
+    /** Moss opacity. Defaults to `0.8`. */
+    mossOpacity?: number;
 }
 
 /**
- * Mound-like mesh with a flat top.
- *
- * To create a radius based on a desired width:
- * ```
- * const mound = new Mound({
- *   radius: radiusFromCapWidth(5, Math.PI / 10),
- * }
- * ```
- *
- * To create a radius based on a desired height:
- * ```
- * const mound = new Mound({
- *  radius: radiusFromCapHeight(5, Math.PI / 10),
- * }
- * ```
+ * Mound prefab — flat-topped terrain cap.
  */
 export declare class Mound extends Mesh<MoundGeometry, MeshStandardMaterial> {
-    constructor({ radius, //
-        widthSegments, heightSegments, phiStart, phiLength, thetaLength, }?: {
-        radius?: number | undefined;
-        widthSegments?: number | undefined;
-        heightSegments?: number | undefined;
-        phiStart?: number | undefined;
-        phiLength?: number | undefined;
-        thetaLength?: number | undefined;
-    });
+    readonly radius: number;
+    constructor({ color, radius, ...geometryOptions }?: MoundOptions);
 }
 
 /**
- * Mound-like geometry with a flat top.
- *
- * To create a radius based on a desired width:
- * ```
- * const moundGeometry = new MoundGeometry({
- *   radius: radiusFromCapWidth(5, Math.PI / 10),
- * }
- * ```
- *
- * To create a radius based on a desired height:
- * ```
- * const moundGeometry = new MoundGeometry({
- *  radius: radiusFromCapHeight(5, Math.PI / 10),
- * }
- * ```
+ * Mound-like geometry with a flat top — sphere cap, base on Y=0.
  */
 export declare class MoundGeometry extends BufferGeometry {
-    constructor({ radius, //
-        widthSegments, heightSegments, phiStart, phiLength, thetaLength, }?: {
-        radius?: number | undefined;
-        widthSegments?: number | undefined;
-        heightSegments?: number | undefined;
-        phiStart?: number | undefined;
-        phiLength?: number | undefined;
-        thetaLength?: number | undefined;
-    });
+    readonly radius: number;
+    readonly thetaLength: number;
+    constructor({ radius, widthSegments, heightSegments, phiStart, phiLength, thetaLength, }?: MoundGeometryOptions);
+}
+
+export declare interface MoundGeometryOptions {
+    /** Sphere radius. Defaults to a cap width of `5` at `thetaLength`. */
+    radius?: number;
+    /** Horizontal segments. Defaults to `64`. */
+    widthSegments?: number;
+    /** Vertical segments. Defaults to `32`. */
+    heightSegments?: number;
+    /** Azimuth start angle (radians). Defaults to `0`. */
+    phiStart?: number;
+    /** Azimuth sweep (radians). Defaults to `2π`. */
+    phiLength?: number;
+    /** Polar sweep from the north pole (radians). Defaults to `π/10`. */
+    thetaLength?: number;
+}
+
+export declare interface MoundOptions extends MoundGeometryOptions {
+    /** Surface tint. Defaults to `#00ff00`. */
+    color?: ColorRepresentation;
 }
 
+/**
+ * Fast seeded PRNG — portfolio Gotham/Water parity.
+ * Returns a closure yielding floats in [0, 1).
+ */
+export declare function mulberry32(seed: number): RandomStream;
+
 export declare class NightSkybox extends Mesh {
     geometry: SphereGeometry;
     material: ShaderMaterial & {
@@ -2376,17 +3159,47 @@ export declare function normalizeUV(uv: [number, number], minU: number, maxU: nu
  */
 export declare function normalizeUVBatch(uvs: [number, number][], minBounds: [number, number], maxBounds: [number, number]): [number, number][];
 
+/**
+ * Obelisk headstone prefab.
+ */
 export declare class ObeliskHeadstone extends Mesh<ObeliskHeadstoneGeometry, MeshStandardMaterial> {
-    constructor({ totalHeight, baseWidth }?: ObeliskHeadstoneOptions);
+    readonly totalHeight: number;
+    constructor({ color, roughness, ...geometryOptions }?: ObeliskHeadstoneOptions);
 }
 
+/**
+ * Tiered obelisk headstone with pyramid cap.
+ *
+ * Local frame: base on Y=0, centered on X/Z.
+ */
 export declare class ObeliskHeadstoneGeometry extends BufferGeometry {
-    constructor(totalHeight?: number, baseWidth?: number);
+    readonly totalHeight: number;
+    readonly baseWidth: number;
+    constructor({ totalHeight, baseWidth }?: ObeliskHeadstoneGeometryOptions);
 }
 
-declare interface ObeliskHeadstoneOptions {
-    baseWidth?: number;
+export declare interface ObeliskHeadstoneGeometryOptions {
+    /** Total monument height. Defaults to `1.75`. */
     totalHeight?: number;
+    /** Base platform width. Defaults to `0.75`. */
+    baseWidth?: number;
+}
+
+export declare interface ObeliskHeadstoneOptions extends ObeliskHeadstoneGeometryOptions {
+    /** Stone tint. Defaults to `#777777`. */
+    color?: ColorRepresentation;
+    /** Surface roughness. Defaults to `0.8`. */
+    roughness?: number;
+}
+
+export declare interface OrbitClipOptions extends CameraClipTiming {
+    target: Vector3;
+    /** Horizontal distance from target. Defaults to current camera distance. */
+    radius?: number;
+    /** Elevation above target Y in radians. Defaults to current camera elevation. */
+    elevation?: number;
+    /** Revolutions over the clip. Defaults to `1`. */
+    revolutions?: number;
 }
 
 /**
@@ -2456,6 +3269,17 @@ export declare const ParametricCurveUtils: {
  */
 export declare function parseHexCode(hex: string): [number, number, number];
 
+export declare interface PendulumClipOptions extends CameraClipTiming {
+    target: Vector3;
+    /** Distance from target. Defaults to current camera distance. */
+    distance?: number;
+    /** Peak azimuth swing in radians — keep small for Ken Burns mood (e.g. `0.12`). */
+    azimuthAmplitude?: number;
+    /** Slow back-and-forth cycles over the clip. Defaults to `2`. */
+    oscillations?: number;
+    ease?: EasingFunction;
+}
+
 /**
  * Soft, slow-drifting petals (or leaves) falling through a bounded volume —
  * cherry-blossom float rather than stiff tumble. Each instance drifts downward
@@ -2710,18 +3534,126 @@ export declare interface RainEffectOptions {
     intensity?: number;
 }
 
+/**
+ * Grouped exports — same function API, namespace import like {@link Easing}.
+ *
+ * @example
+ * ```ts
+ * import { Random } from "three-low-poly";
+ * const rng = Random.create(deriveSubSeed(1337, 0x101));
+ * ```
+ */
+export declare const Random: {
+    readonly create: typeof createRandom;
+    readonly mulberry32: typeof mulberry32;
+    readonly splitmix32: typeof splitmix32;
+    readonly deriveSubSeed: typeof deriveSubSeed;
+    readonly range: typeof randomRange;
+    readonly pick: typeof randomPick;
+};
+
 /**
  * Generates a random number between `min` and `max`.
  */
-export declare function randomFloat(min?: number, max?: number): number;
+export declare function randomFloat(min?: number, max?: number, source?: RandomSource): number;
 
 /**
  * Generates a random integer between `min` and `max`.
  */
-export declare function randomInteger(min?: number, max?: number): number;
+export declare function randomInteger(min?: number, max?: number, source?: RandomSource): number;
+
+/** Pick from a non-empty array using any stream — website `pick()` parity. */
+export declare function randomPick<T>(stream: RandomStream, arr: readonly T[]): T;
+
+/** Float in [min, max) from any stream — website `range()` parity. */
+export declare function randomRange(stream: RandomStream, min: number, max: number): number;
+
+/**
+ * Random source — a stream plus distribution helpers.
+ * Returned by {@link createRandom}; also accepted by {@link RandomNumberUtils}.
+ */
+export declare interface RandomSource {
+    /** `true` when backed by {@link mulberry32}; `false` when using `Math.random()`. */
+    readonly seeded: boolean;
+    /** Next float in [0, 1). */
+    next(): number;
+    /** Float in [min, max). */
+    float(min?: number, max?: number): number;
+    /** Integer in [min, max] (inclusive). */
+    int(min?: number, max?: number): number;
+    /** Uniform element from a non-empty array. */
+    pick<T>(arr: readonly T[]): T;
+    /** `true` with given probability (default 0.5). */
+    boolean(probability?: number): boolean;
+    /**
+     * Skew toward `max`. Lower `exponent` = stronger bias.
+     * Mirrors {@link logarithmicRandomMax}.
+     */
+    skewMax(exponent?: number, min?: number, max?: number): number;
+    /**
+     * Skew toward `min`. Lower `exponent` = stronger bias.
+     * Mirrors {@link logarithmicRandomMin}.
+     */
+    skewMin(exponent?: number, min?: number, max?: number): number;
+}
+
+/**
+ * Randomness for procedural generation — unseeded by default, reproducible on demand.
+ *
+ * ---
+ *
+ * ### Layer 1 — stream primitive (portfolio parity)
+ *
+ * - {@link mulberry32} — fast seeded PRNG; returns a `() => number` closure yielding
+ *   floats in `[0, 1)`. Same algorithm as Gotham/Water on the portfolio site.
+ *
+ * ### Seed mixing
+ *
+ * - {@link splitmix32} — mixer only, **not** a stream. Maps one 32-bit value to another.
+ * - {@link deriveSubSeed} — `splitmix32(masterSeed ^ salt)`. Fan one user-facing master
+ *   seed into independent sub-streams per subsystem. Use stable hex salts per domain
+ *   (`0x101` books, `0x202` fog, `0x303` windows, …) instead of `seed + n` offsets.
+ *
+ * ### Layer 2 — library ergonomics
+ *
+ * - {@link createRandom} — **no seed** → wraps `Math.random()`, unique every runtime
+ *   (showcase default). **With seed** → {@link mulberry32} stream, same seed ⇒ same sequence.
+ * - Returns a {@link RandomSource}: `next`, `float`, `int`, `pick`, `boolean`, `skewMax`, `skewMin`.
+ * - {@link Random} namespace — grouped exports, same API as standalone functions (like {@link Easing}).
+ *
+ * ### Layer 3 — {@link RandomNumberUtils}
+ *
+ * Existing helpers (`randomFloat`, `logarithmicRandomMax`, …) accept an optional
+ * {@link RandomSource} as their last argument. Omit it for unseeded default behavior.
+ *
+ * ---
+ *
+ * @example Unique runtime (default)
+ * ```ts
+ * const rng = createRandom();
+ * rng.float(0, 10); // different every page load
+ * ```
+ *
+ * @example Reproducible layout with sub-seeds
+ * ```ts
+ * const master = 1337;
+ * const books = createRandom(deriveSubSeed(master, 0x101));
+ * const fog = createRandom(deriveSubSeed(master, 0x202));
+ * ```
+ *
+ * @example Namespace import
+ * ```ts
+ * const rng = Random.create(deriveSubSeed(1337, 0x101));
+ * ```
+ */
+/** Callable stream returning floats in [0, 1). */
+export declare type RandomStream = () => number;
 
 export declare function randomTransformVertices<T extends BufferGeometry>(geometry: T, axis?: Vector3, minScale?: number, maxScale?: number): T;
 
+/** Resolve uniform ring spacing — `cell` wins over the `cellsX` density hint. */
+export declare function resolveRingLatticeCell(width: number, _height: number, cell?: number, cellsX?: number): number;
+
 export declare function rgbToHex(r: number, g: number, b: number): number;
 
 /**
@@ -2736,20 +3668,133 @@ export declare function rgbToHex(r: number, g: number, b: number): number;
  */
 export declare function rgbToHsl(r: number, g: number, b: number): [number, number, number];
 
+/** Ring-spacing factor — overlap tightens as this approaches 1. */
+export declare const RING_LATTICE_SPACING_FACTOR = 0.96;
+
+declare interface RingLatticeFramePartOptions {
+    width: number;
+    height: number;
+    centerY?: number;
+    frameThickness: number;
+    frameDepth: number;
+}
+
+export declare interface RingLatticeGrid {
+    /** Requested ring-center spacing before the overlap factor. */
+    cell: number;
+    /** Effective center spacing (`cell × 0.96`). */
+    latticeCell: number;
+    /** Outer half-extent of each square ring profile. */
+    ringOuter: number;
+    /** Ring instance count. */
+    count: number;
+}
+
+declare interface RingLatticeSpotOptions {
+    width: number;
+    height: number;
+    centerY?: number;
+    cell: number;
+}
+
+/** Ring-center positions overscanning the opening (stencil trims the excess). */
+export declare function ringLatticeSpots({ width, height, centerY, cell, }: RingLatticeSpotOptions): {
+    spots: [number, number][];
+    grid: RingLatticeGrid;
+};
+
+/**
+ * Ring lattice window — overlapping square rings on a uniform grid (diaper /
+ * trellis fretwork), stencil-clipped to a rectangular opening.
+ */
+export declare class RingLatticeWindow extends Group {
+    readonly lattice: InstancedMesh;
+    readonly frame: Mesh;
+    readonly glass?: Mesh<PlaneGeometry, MeshPhysicalMaterial>;
+    readonly cell: number;
+    readonly fittedGrid: RingLatticeGrid;
+    private readonly clipPlanesLocal;
+    private readonly clipPlanesWorld;
+    constructor({ width, height, cell: cellOption, cellsX, centerY, ringThickness, ringDepth, frameThickness, frameDepth, latticeColor, glass, glassColor, glassEmissive, glassEmissiveIntensity, }?: RingLatticeWindowOptions);
+}
+
+declare interface RingLatticeWindowOptions {
+    /** Opening width (world units). */
+    width?: number;
+    /** Opening height (world units). */
+    height?: number;
+    /** Uniform ring-center spacing. Overrides `cellsX` when set. Defaults to `0.55`. */
+    cell?: number;
+    /** Density hint — `cell = width / cellsX` when `cell` is omitted. */
+    cellsX?: number;
+    /** Wall thickness of each square ring profile. Defaults to `0.05`. */
+    ringThickness?: number;
+    /** Extrusion depth of each ring. Defaults to `0.06`. */
+    ringDepth?: number;
+    /** Outer frame bar thickness. Defaults to `0.055`. */
+    frameThickness?: number;
+    /** Outer frame depth (Z). Defaults to `0.11`. */
+    frameDepth?: number;
+    /** Vertical center of the opening in local space. Defaults to `0`. */
+    centerY?: number;
+    /** Lattice + frame tint. Defaults to `#0c0f14`. */
+    latticeColor?: ColorRepresentation;
+    /** Optional glass pane recessed slightly on −Z. */
+    glass?: boolean;
+    glassColor?: ColorRepresentation;
+    glassEmissive?: ColorRepresentation;
+    glassEmissiveIntensity?: number;
+}
+
+/**
+ * Single rock prefab — noisy sphere mesh.
+ */
 export declare class Rock extends Mesh<RockGeometry, MeshStandardMaterial> {
-    constructor(radius?: number, widthSegments?: number, heightSegments?: number);
+    constructor({ color, ...geometryOptions }?: RockOptions);
 }
 
+/**
+ * Low-poly rock — sphere with randomized vertex offsets, then centered.
+ */
 export declare class RockGeometry extends BufferGeometry {
-    constructor(radius?: number, widthSegments?: number, heightSegments?: number);
+    readonly radius: number;
+    readonly widthSegments: number;
+    readonly heightSegments: number;
+    constructor({ radius, widthSegments, heightSegments, }?: RockGeometryOptions);
 }
 
-export declare class Rocks extends Mesh<RocksGeometry, MeshStandardMaterial> {
-    constructor();
+export declare interface RockGeometryOptions {
+    /** Base sphere radius before vertex noise. Defaults to `1`. */
+    radius?: number;
+    /** Horizontal segments. Defaults to `4`. */
+    widthSegments?: number;
+    /** Vertical segments. Defaults to `4`. */
+    heightSegments?: number;
 }
 
-export declare class RocksGeometry extends BufferGeometry {
-    constructor();
+export declare interface RockOptions extends RockGeometryOptions {
+    /** Stone tint. Defaults to `#808080`. */
+    color?: ColorRepresentation;
+}
+
+export declare interface RockScatterBounds {
+    /** Scatter extent along X (centered on origin). Defaults to `4`. */
+    width?: number;
+    /** Scatter extent along Z (centered on origin). Defaults to `4`. */
+    depth?: number;
+    /** Max random Y offset above the ground plane. Defaults to `0`. */
+    heightJitter?: number;
+}
+
+export declare interface RockScatterPlacementOptions extends RockScatterBounds {
+    /** Number of instances. Defaults to `5`. */
+    count?: number;
+    /** Min per-axis instance scale. Defaults to `0.8`. */
+    scaleMin?: number;
+    /** Max per-axis instance scale. Defaults to `1.2`. */
+    scaleMax?: number;
+    /** Optional seed for reproducible scatter. Omit for unique runtime. */
+    seed?: number;
 }
 
 export declare class RoundedHeadstone extends Mesh<RoundedHeadstoneGeometry, MeshStandardMaterial> {
@@ -2763,25 +3808,27 @@ export declare class RoundedHeadstoneGeometry extends BufferGeometry {
 /**
  * Creates a row of books with a given count.
  */
-export declare function rowOfBooksByCount<T extends Material>({ coverMaterial, pagesMaterial, count, scaleXMin, scaleXMax, scaleYMin, scaleYMax, scaleZMin, scaleZMax, }: RowOfBooksOptions<T>): InstancedMesh;
+export declare function rowOfBooksByCount<T extends Material>({ coverMaterial, pagesMaterial, count, scaleXMin, scaleXMax, scaleYMin, scaleYMax, scaleZMin, scaleZMax, seed, }: RowOfBooksOptions<T>): InstancedMesh;
 
 /**
  * Creates a row of books with a total length.
  */
-export declare function rowOfBooksByLength<T extends Material>({ coverMaterial, pagesMaterial, length, scaleXMin, scaleXMax, scaleYMin, scaleYMax, scaleZMin, scaleZMax, }: RowOfBooksOptions<T>): InstancedMesh;
+export declare function rowOfBooksByLength<T extends Material>({ coverMaterial, pagesMaterial, length, scaleXMin, scaleXMax, scaleYMin, scaleYMax, scaleZMin, scaleZMax, seed, }: RowOfBooksOptions<T>): InstancedMesh;
 
 /**
  * Creates a row of books from the scales array of Vector3.
  */
-export declare function rowOfBooksByScales<T extends Material>({ coverMaterial, pagesMaterial, scales, }: RowOfBooksByScalesOptions<T>): InstancedMesh;
+export declare function rowOfBooksByScales<T extends Material>({ coverMaterial, pagesMaterial, scales, source, }: RowOfBooksByScalesOptions<T>): InstancedMesh;
 
 declare interface RowOfBooksByScalesOptions<T extends Material = Material> {
     coverMaterial: T;
     pagesMaterial: T;
     scales: Vector3[];
+    /** Shared stream for shelf jitter — must be the same source that built `scales`. */
+    source: RandomSource;
 }
 
-declare interface RowOfBooksOptions<T extends Material = Material> {
+export declare interface RowOfBooksOptions<T extends Material = Material> {
     coverMaterial: T;
     pagesMaterial: T;
     count?: number;
@@ -2792,6 +3839,53 @@ declare interface RowOfBooksOptions<T extends Material = Material> {
     scaleYMax?: number;
     scaleZMin?: number;
     scaleZMax?: number;
+    /** Optional seed for reproducible layout. Omit for unique runtime. */
+    seed?: number;
+}
+
+/**
+ * Scatter instanced mossy rocks inside a horizontal bounds region.
+ *
+ * Uses two material groups (rock + moss) on a shared {@link InstancedMesh}.
+ */
+export declare function scatterMossyRocks({ count, width, depth, heightJitter, scaleMin, scaleMax, seed, radius, detail, mossScaleXZ, mossScaleY, mossOffsetY, rockMaterial, mossMaterial, rockColor, mossColor, mossOpacity, }?: ScatterMossyRocksOptions): InstancedMesh;
+
+export declare interface ScatterMossyRocksOptions extends RockScatterPlacementOptions {
+    /** Dodecahedron radius for each instance geometry. Defaults to `1`. */
+    radius?: number;
+    detail?: number;
+    mossScaleXZ?: number;
+    mossScaleY?: number;
+    mossOffsetY?: number;
+    rockMaterial?: Material;
+    mossMaterial?: Material;
+    /** Rock tint when `rockMaterial` is omitted. Defaults to `#808080`. */
+    rockColor?: ColorRepresentation;
+    /** Moss tint when `mossMaterial` is omitted. Defaults to `#4b8b3b`. */
+    mossColor?: ColorRepresentation;
+    /** Moss opacity when `mossMaterial` is omitted. Defaults to `0.8`. */
+    mossOpacity?: number;
+}
+
+/**
+ * Scatter instanced rocks inside a horizontal bounds region.
+ *
+ * @example
+ * ```ts
+ * const rocks = scatterRocks({ count: 12, width: 8, depth: 8, seed: 1337 });
+ * scene.add(rocks);
+ * ```
+ */
+export declare function scatterRocks({ count, width, depth, heightJitter, scaleMin, scaleMax, seed, radius, widthSegments, heightSegments, material, color, }?: ScatterRocksOptions): InstancedMesh;
+
+export declare interface ScatterRocksOptions extends RockScatterPlacementOptions {
+    /** Base sphere radius for each instance geometry. Defaults to `1`. */
+    radius?: number;
+    widthSegments?: number;
+    heightSegments?: number;
+    material?: Material;
+    /** Stone tint when `material` is omitted. Defaults to `#808080`. */
+    color?: ColorRepresentation;
 }
 
 /**
@@ -3108,14 +4202,89 @@ export declare function sphericalUVMapping(vertices: [number, number, number][])
  */
 export declare const spikeBrush: <T extends BufferGeometry>(geometry: T, position: Vector3, radius: number, strength: number, inward?: boolean, falloffFn?: (distance: number, radius: number) => number) => void;
 
+export declare interface SpiralClipOptions extends CameraClipTiming {
+    /** Ground point to look down at (typically scene center, `y = 0`). */
+    target: Vector3;
+    /** Orbit radius at the start of the clip. */
+    radius: number;
+    /** Optional wider radius at the end — pulls back as you rise. Defaults to `radius`. */
+    endRadius?: number;
+    /** Total vertical rise over the clip. */
+    height: number;
+    revolutions: number;
+    ease?: EasingFunction;
+}
+
+/**
+ * Turret-style spiral staircase prefab — wraps {@link SpiralStaircaseGeometry}.
+ */
+export declare class SpiralStaircase extends Mesh<SpiralStaircaseGeometry, MeshStandardMaterial> {
+    readonly innerRadius: number;
+    readonly width: number;
+    readonly outerRadius: number;
+    readonly treadDepth: number;
+    readonly riserHeight: number;
+    readonly stepCount: number;
+    readonly stepAngle: number;
+    readonly totalHeight: number;
+    readonly totalTurn: number;
+    constructor({ color, ...geometryOptions }?: SpiralStaircaseOptions);
+}
+
+/**
+ * Turret-style spiral staircase — trapezoidal treads between an inner newel radius
+ * and an outer wall radius, ascending counter-clockwise when viewed from above.
+ *
+ * Each step is a four-sided tread (no pinched center point). Step angle is
+ * derived from tread depth at the mid-radius so treads meet without overlapping.
+ */
 export declare class SpiralStaircaseGeometry extends BufferGeometry {
-    constructor(stepWidth?: number, stepDepth?: number, stepHeight?: number, numSteps?: number, radius?: number, angleIncrement?: number);
+    readonly innerRadius: number;
+    readonly width: number;
+    readonly outerRadius: number;
+    readonly treadDepth: number;
+    readonly riserHeight: number;
+    readonly stepCount: number;
+    readonly startAngle: number;
+    readonly stepAngle: number;
+    readonly totalHeight: number;
+    readonly totalTurn: number;
+    constructor({ innerRadius, width, treadDepth, riserHeight, stepCount, startAngle, stepAngle: stepAngleOption, }?: SpiralStaircaseGeometryOptions);
+}
+
+export declare interface SpiralStaircaseGeometryOptions {
+    /** Newel / center-hole radius (inner edge of every tread). Defaults to `0.45`. */
+    innerRadius?: number;
+    /** Radial tread width (outer − inner radius). Defaults to `1.95`. */
+    width?: number;
+    /** Arc run per step at the walking line (mid-radius). Defaults to `0.45`. */
+    treadDepth?: number;
+    /** Vertical rise per step (riser). Defaults to `0.2`. */
+    riserHeight?: number;
+    /** Number of steps. Defaults to `20`. */
+    stepCount?: number;
+    /** Spiral start angle in radians (+X = 0, CCW). Defaults to `0`. */
+    startAngle?: number;
+    /** Override step angle (radians). When omitted, derived from `treadDepth`. */
+    stepAngle?: number;
+}
+
+export declare interface SpiralStaircaseOptions extends SpiralStaircaseGeometryOptions {
+    /** Tread and riser tint. Defaults to `#8b4513`. */
+    color?: ColorRepresentation;
 }
 
 export declare class SpiralTube extends Group {
     constructor();
 }
 
+/**
+ * Seed mixer — maps one 32-bit value to another well-distributed value.
+ * Use with {@link deriveSubSeed}, not as a drop-in stream replacement for
+ * {@link mulberry32}.
+ */
+export declare function splitmix32(seed: number): number;
+
 export declare class SquareHeadstone extends Mesh<SquareHeadstoneGeometry, MeshStandardMaterial> {
     constructor(width?: number, height?: number, depth?: number);
 }
@@ -3124,39 +4293,140 @@ export declare class SquareHeadstoneGeometry extends BufferGeometry {
     constructor(width?: number, height?: number, depth?: number);
 }
 
+/**
+ * Stack of books on the floor — each book lays flat on its cover; count sets stack height.
+ * Each layer is laid flat (+90° X), then given a small in-plane spin (world Y)
+ * around the book's geometric center — not the spine corner.
+ *
+ * Local frame: bottom of the stack at Y=0, centered on X/Z.
+ *
+ * @example
+ * ```ts
+ * const stack = stackOfBooks({
+ *   coverMaterial,
+ *   pagesMaterial,
+ *   count: 8,
+ *   yawMax: 0.6,
+ *   seed: 1337,
+ * });
+ * scene.add(stack);
+ * ```
+ */
+export declare function stackOfBooks<T extends Material>({ coverMaterial, pagesMaterial, count, scaleXMin, scaleXMax, scaleYMin, scaleYMax, scaleZMin, scaleZMax, yawMax, offsetMax, seed, }: StackOfBooksOptions<T>): InstancedMesh;
+
+export declare interface StackOfBooksOptions<T extends Material = Material> {
+    coverMaterial: T;
+    pagesMaterial: T;
+    /** Number of books in the stack. Defaults to `6`. */
+    count?: number;
+    scaleXMin?: number;
+    scaleXMax?: number;
+    scaleYMin?: number;
+    scaleYMax?: number;
+    scaleZMin?: number;
+    scaleZMax?: number;
+    /**
+     * Max in-plane spin (world Y, radians) once the book is laid flat — a lazy
+     * turn on the floor, not a tilt. Defaults to `0.55` (~31°).
+     */
+    yawMax?: number;
+    /** Max horizontal drift per layer on X/Z. Defaults to `0.06`. */
+    offsetMax?: number;
+    /** Optional seed for reproducible layout. Omit for unique runtime. */
+    seed?: number;
+}
+
+/**
+ * Straight run staircase prefab — {@link StaircaseGeometry} with a wood-tone
+ * default material.
+ *
+ * Local frame: centered on width, rises along +Y, runs along +Z.
+ */
+export declare class Staircase extends Mesh<StaircaseGeometry, MeshStandardMaterial> {
+    readonly width: number;
+    readonly riserHeight: number;
+    readonly treadDepth: number;
+    readonly stepCount: number;
+    readonly totalHeight: number;
+    readonly totalDepth: number;
+    constructor({ color, ...geometryOptions }?: StaircaseOptions);
+}
+
+/**
+ * Straight run staircase — open risers and treads (no side stringers yet).
+ *
+ * Local frame: centered on width, rises along +Y, runs along +Z. Each step
+ * emits a front riser (+Z) and a top tread (+Y). UVs are normalized per face
+ * (0–1) so materials can tile per step.
+ */
 export declare class StaircaseGeometry extends BufferGeometry {
-    constructor(width?: number, stepHeight?: number, stepDepth?: number, numSteps?: number);
+    readonly width: number;
+    readonly riserHeight: number;
+    readonly treadDepth: number;
+    readonly stepCount: number;
+    readonly totalHeight: number;
+    readonly totalDepth: number;
+    constructor({ width, riserHeight, treadDepth, stepCount, }?: StaircaseGeometryOptions);
 }
 
+export declare interface StaircaseGeometryOptions {
+    /** Stair width (tread left–right extent). Defaults to `2`. */
+    width?: number;
+    /** Vertical rise per step (riser). Defaults to `0.3`. */
+    riserHeight?: number;
+    /** Horizontal run per step (tread depth). Defaults to `0.5`. */
+    treadDepth?: number;
+    /** Number of steps. Defaults to `10`. */
+    stepCount?: number;
+}
+
+export declare interface StaircaseOptions extends StaircaseGeometryOptions {
+    /** Tread and riser tint. Defaults to `#8b4513`. */
+    color?: ColorRepresentation;
+}
+
+/**
+ * Laboratory stand prefab — ring and legs.
+ */
 export declare class Stand extends Mesh<StandGeometry, MeshStandardMaterial> {
-    constructor({ radius, //
-        height, count, thickness, radialSegments, }?: {
-        radius?: number | undefined;
-        height?: number | undefined;
-        count?: number | undefined;
-        thickness?: number | undefined;
-        radialSegments?: number | undefined;
-    });
+    constructor({ color, ...geometryOptions }?: StandOptions);
 }
 
+/**
+ * Tripod-style stand — torus ring with radial legs.
+ *
+ * Local frame: legs on Y=0.
+ */
 export declare class StandGeometry extends BufferGeometry {
-    constructor({ radius, //
-        height, count, thickness, radialSegments, }?: {
-        radius?: number | undefined;
-        height?: number | undefined;
-        count?: number | undefined;
-        thickness?: number | undefined;
-        radialSegments?: number | undefined;
-    });
+    readonly radius: number;
+    readonly height: number;
+    readonly count: number;
+    constructor({ radius, height, count, thickness, radialSegments, }?: StandGeometryOptions);
 }
 
-export declare class Star extends Mesh {
-    constructor({ points, innerRadius, outerRadius, depth }?: {
-        points?: number | undefined;
-        innerRadius?: number | undefined;
-        outerRadius?: number | undefined;
-        depth?: number | undefined;
-    });
+export declare interface StandGeometryOptions {
+    /** Ring radius. Defaults to `0.3`. */
+    radius?: number;
+    /** Leg height. Defaults to `0.4`. */
+    height?: number;
+    /** Number of legs. Defaults to `3`. */
+    count?: number;
+    /** Ring tube thickness. Defaults to `0.03`. */
+    thickness?: number;
+    /** Circumference segments. Defaults to `16`. */
+    radialSegments?: number;
+}
+
+export declare interface StandOptions extends StandGeometryOptions {
+    /** Metal tint. Defaults to `#888888`. */
+    color?: ColorRepresentation;
+}
+
+/**
+ * Star shape prefab.
+ */
+export declare class Star extends Mesh<StarGeometry, MeshStandardMaterial> {
+    constructor({ color, emissive, emissiveIntensity, ...geometryOptions }?: StarOptions);
 }
 
 export declare interface StarBurstShapeOptions {
@@ -3275,29 +4545,62 @@ export declare interface StarFieldEffectOptions {
 }
 
 /**
- * Extrude geometry of Star Shape.
+ * Extruded star prism.
  */
 export declare class StarGeometry extends ExtrudeGeometry {
-    constructor(points?: number, innerRadius?: number, outerRadius?: number, depth?: number);
+    constructor({ points, innerRadius, outerRadius, depth, }?: StarGeometryOptions);
+}
+
+export declare interface StarGeometryOptions {
+    /** Number of star points. Defaults to `5`. */
+    points?: number;
+    /** Inner vertex radius. Defaults to `0.5`. */
+    innerRadius?: number;
+    /** Outer vertex radius. Defaults to `1`. */
+    outerRadius?: number;
+    /** Extrusion depth. Defaults to `0.25`. */
+    depth?: number;
+}
+
+export declare interface StarOptions extends StarGeometryOptions {
+    /** Surface tint. Defaults to `#ffff00`. */
+    color?: ColorRepresentation;
+    /** Emissive tint. Defaults to `#ffd700`. */
+    emissive?: ColorRepresentation;
+    /** Emissive strength. Defaults to `0.25`. */
+    emissiveIntensity?: number;
 }
 
 export declare class StarShape extends Shape {
     constructor(points?: number, innerRadius?: number, outerRadius?: number);
 }
 
+/**
+ * Stone fence post prefab.
+ */
 export declare class StoneFencePost extends Mesh<StoneFencePostGeometry, MeshStandardMaterial> {
-    constructor({ height }?: {
-        height?: number | undefined;
-    });
+    readonly height: number;
+    constructor({ color, ...geometryOptions }?: StoneFencePostOptions);
 }
 
 /**
- * Fence Column Geometry, a stone slab fence column shape
+ * Stone fence post — wide base, column, and cap.
+ *
+ * Local frame: base on Y=0.
  */
 export declare class StoneFencePostGeometry extends BufferGeometry {
-    constructor({ height }?: {
-        height?: number | undefined;
-    });
+    readonly height: number;
+    constructor({ height }?: StoneFencePostGeometryOptions);
+}
+
+export declare interface StoneFencePostGeometryOptions {
+    /** Main column height (excluding base and cap). Defaults to `2.25`. */
+    height?: number;
+}
+
+export declare interface StoneFencePostOptions extends StoneFencePostGeometryOptions {
+    /** Stone tint. Defaults to `#8b7d7b`. */
+    color?: ColorRepresentation;
 }
 
 /**
@@ -3327,14 +4630,15 @@ export declare class TestTubeGeometry extends BufferGeometry {
 }
 
 /**
- * Wooden rack with instanced test tubes and emissive liquid fills.
+ * Wooden rack with test tubes and emissive liquid fills.
  *
  * Glass shells use `DoubleSide` and `depthWrite: false`; liquid draws first
  * (`renderOrder` 1), glass second (`renderOrder` 2) so fills stay visible at
  * most camera angles.
  */
 export declare class TestTubeRack extends Group {
-    constructor(count?: number, colors?: ColorRepresentation[]);
+    readonly count: number;
+    constructor({ count, colors, }?: TestTubeRackOptions);
 }
 
 export declare interface TestTubeRackOptions {
@@ -3359,60 +4663,60 @@ export declare interface TestTubeRackOptions {
  */
 export declare const thetaLengthForRadius: (sphereRadius: number, holeRadius: number) => number;
 
+/** Trace the shared rect-plus-arch outline (glass, stencil mask, frame outer edge). */
+export declare function traceArchedOpeningOutline(target: ArchedOutlineTarget, metrics: ArchedOpeningMetrics, { hole }?: {
+    hole?: boolean;
+}): void;
+
 /**
- * Material indices:
- * 0. Trunk
- * 1. leafSize
- *
- * Example usage:
- * ```
- * const tree = new Tree({
- *   trunkRadiusTop: 0.25,
- *   trunkRadiusBottom: 0.4,
- *   trunkHeight: 2.5,
- *   trunkSegments: 14,
- *   trunkColor: 0x8b4513,
- *   leafSize: 0.8,
- *   leafCount: 6,
- *   leafDetail: 0,
- *   leafSpreadRadius: 1.5,
- *   leafColor: 0x228b22,
- * });
- * ```
+ * Low-poly tree prefab — trunk and leaf clusters with separate material groups.
  */
 export declare class Tree extends Mesh<TreeGeometry, MeshStandardMaterial[]> {
-    constructor({ trunkRadiusTop, trunkRadiusBottom, trunkHeight, trunkSegments, trunkColor, leafSize, leafCount, leafDetail, leafSpreadRadius, leafColor, }?: {
-        trunkRadiusTop?: number | undefined;
-        trunkRadiusBottom?: number | undefined;
-        trunkHeight?: number | undefined;
-        trunkSegments?: number | undefined;
-        trunkColor?: number | undefined;
-        leafSize?: number | undefined;
-        leafCount?: number | undefined;
-        leafDetail?: number | undefined;
-        leafSpreadRadius?: number | undefined;
-        leafColor?: number | undefined;
-    });
+    readonly trunkHeight: number;
+    constructor({ trunkColor, leafColor, ...geometryOptions }?: TreeOptions);
 }
 
 /**
- * Tree geometry, consisting of a trunk and leaves.
+ * Low-poly tree — trunk (group 0) and leaf clusters (group 1).
  *
- * Group order:
- * - Trunk Material
- * - Leaf Material
+ * Local frame: trunk base at Y=0. Leaf positions use `Math.random()` each build.
  */
 export declare class TreeGeometry extends BufferGeometry {
-    constructor({ trunkRadiusTop, trunkRadiusBottom, trunkHeight, trunkSegments, leafSize, leafCount, leafDetail, leafSpreadRadius, }?: {
-        trunkRadiusTop?: number | undefined;
-        trunkRadiusBottom?: number | undefined;
-        trunkHeight?: number | undefined;
-        trunkSegments?: number | undefined;
-        leafSize?: number | undefined;
-        leafCount?: number | undefined;
-        leafDetail?: number | undefined;
-        leafSpreadRadius?: number | undefined;
-    });
+    readonly trunkRadiusTop: number;
+    readonly trunkRadiusBottom: number;
+    readonly trunkHeight: number;
+    readonly trunkSegments: number;
+    readonly leafSize: number;
+    readonly leafCount: number;
+    readonly leafDetail: number;
+    readonly leafSpreadRadius: number;
+    constructor({ trunkRadiusTop, trunkRadiusBottom, trunkHeight, trunkSegments, leafSize, leafCount, leafDetail, leafSpreadRadius, }?: TreeGeometryOptions);
+}
+
+export declare interface TreeGeometryOptions {
+    /** Trunk top radius. Defaults to `0.25`. */
+    trunkRadiusTop?: number;
+    /** Trunk bottom radius. Defaults to `0.4`. */
+    trunkRadiusBottom?: number;
+    /** Trunk height. Defaults to `2.5`. */
+    trunkHeight?: number;
+    /** Trunk circumference segments. Defaults to `14`. */
+    trunkSegments?: number;
+    /** Leaf dodecahedron radius. Defaults to `0.8`. */
+    leafSize?: number;
+    /** Number of leaf clusters. Defaults to `6`. */
+    leafCount?: number;
+    /** Leaf dodecahedron detail level. Defaults to `0`. */
+    leafDetail?: number;
+    /** Horizontal spread of leaf placement. Defaults to `1.5`. */
+    leafSpreadRadius?: number;
+}
+
+export declare interface TreeOptions extends TreeGeometryOptions {
+    /** Trunk tint. Defaults to `#8b4513`. */
+    trunkColor?: ColorRepresentation;
+    /** Leaf tint. Defaults to `#228b22`. */
+    leafColor?: ColorRepresentation;
 }
 
 /**
@@ -3434,18 +4738,141 @@ export declare function updateNoiseDisplacementTime<T extends Material>(material
  */
 export declare function updateWaterDisplacementTime<T extends Material>(material: T, deltaTime: number): void;
 
+/**
+ * Wall-mounted oil-lamp sconce — iron mount and cap/bowl frame around an
+ * emissive glass chimney. Pair {@link GlowHalo} and {@link FlameFlickerEffect}
+ * at `(lightCenterX, lightCenterY, lightCenterZ)` for bloom and flicker.
+ *
+ * Local frame: faces +X from a −X wall.
+ */
+export declare class WallSconce extends Mesh<WallSconceGeometry, MeshStandardMaterial[]> {
+    readonly lightCenterX: number;
+    readonly lightCenterY: number;
+    readonly lightCenterZ: number;
+    constructor({ color, mountColor, frameColor, lampColor, lampEmissiveIntensity, lampOpacity, inner, ...geometryOptions }?: WallSconceOptions);
+}
+
+/**
+ * Wall-mounted oil-lamp sconce — iron mount, cap, and bowl framing an emissive
+ * glass chimney.
+ *
+ * Material groups: `0` mount (plate + bracket), `1` iron frame (cap + bowl),
+ * `2` glass chimney.
+ *
+ * Local frame: faces +X from a −X wall; lamp center at
+ * `(bodyOffsetX, chimneyCenterY, 0)`.
+ */
+export declare class WallSconceGeometry extends BufferGeometry {
+    readonly bodyOffsetX: number;
+    readonly chimneyCenterY: number;
+    readonly innerScale: number;
+    readonly inner: boolean;
+    readonly lightCenterX: number;
+    readonly lightCenterY: number;
+    readonly lightCenterZ: number;
+    constructor({ plateThickness, plateHeight, plateDepth, plateOffsetX, bracketLength, bracketHeight, bracketDepth, bracketOffsetX, bracketOffsetY, bodyOffsetX, chimneyHeight, chimneyTopRadius, chimneyBottomRadius, chimneyCenterY, capRadius, capHeight, capCenterY, bowlTopRadius, bowlBottomRadius, bowlHeight, bowlCenterY, radialSegments, innerScale, inner, }?: WallSconceGeometryOptions);
+}
+
+export declare interface WallSconceGeometryOptions {
+    /** Wall-plate thickness (X). Defaults to `0.05`. */
+    plateThickness?: number;
+    /** Wall-plate height (Y). Defaults to `0.22`. */
+    plateHeight?: number;
+    /** Wall-plate depth (Z). Defaults to `0.28`. */
+    plateDepth?: number;
+    /** Wall-plate center X (negative = into the wall). Defaults to `-0.055`. */
+    plateOffsetX?: number;
+    /** Bracket length into the room (X). Defaults to `0.1`. */
+    bracketLength?: number;
+    /** Bracket height (Y). Defaults to `0.05`. */
+    bracketHeight?: number;
+    /** Bracket depth (Z). Defaults to `0.07`. */
+    bracketDepth?: number;
+    /** Bracket center X. Defaults to `-0.005`. */
+    bracketOffsetX?: number;
+    /** Bracket center Y. Defaults to `0.1`. */
+    bracketOffsetY?: number;
+    /** Chimney / lamp body center X. Defaults to `0.06`. */
+    bodyOffsetX?: number;
+    /** Chimney height. Defaults to `0.3`. */
+    chimneyHeight?: number;
+    /** Chimney top radius. Defaults to `0.1`. */
+    chimneyTopRadius?: number;
+    /** Chimney bottom radius. Defaults to `0.105`. */
+    chimneyBottomRadius?: number;
+    /** Chimney center Y. Defaults to `-0.05`. */
+    chimneyCenterY?: number;
+    /** Cap radius. Defaults to `0.115`. */
+    capRadius?: number;
+    /** Cap height. Defaults to `0.05`. */
+    capHeight?: number;
+    /** Cap center Y. Defaults to `0.12`. */
+    capCenterY?: number;
+    /** Bowl top radius. Defaults to `0.09`. */
+    bowlTopRadius?: number;
+    /** Bowl bottom radius. Defaults to `0.11`. */
+    bowlBottomRadius?: number;
+    /** Bowl height. Defaults to `0.05`. */
+    bowlHeight?: number;
+    /** Bowl center Y. Defaults to `-0.22`. */
+    bowlCenterY?: number;
+    /** Radial segments on cylinders. Defaults to `8`. */
+    radialSegments?: number;
+    /** Glass chimney scale relative to the frame opening. Defaults to `0.96`. */
+    innerScale?: number;
+    /** Include the emissive glass chimney. Defaults to `true`. */
+    inner?: boolean;
+}
+
+export declare interface WallSconceOptions extends WallSconceGeometryOptions {
+    /** Wrought-iron tint for mount and frame. Defaults to `#1c1e24`. */
+    color?: ColorRepresentation;
+    /** Mount iron tint (plate + bracket). Defaults to `color`. */
+    mountColor?: ColorRepresentation;
+    /** Frame iron tint (cap + bowl). Defaults to `color`. */
+    frameColor?: ColorRepresentation;
+    /** Glass chimney tint. Defaults to `#e8a058`. */
+    lampColor?: ColorRepresentation;
+    /** Glass emissive strength. Defaults to `1.4`. */
+    lampEmissiveIntensity?: number;
+    /** Glass opacity. Defaults to `0.88`. */
+    lampOpacity?: number;
+}
+
+/**
+ * Wine bottle prefab — translucent green glass.
+ */
 export declare class WineBottle extends Mesh<WineBottleGeometry, MeshPhysicalMaterial> {
-    constructor();
+    constructor({ color, ...geometryOptions }?: WineBottleOptions);
 }
 
+/**
+ * Wine bottle — cylindrical body, shoulder taper, and neck.
+ *
+ * Local frame: base at Y=0.
+ */
 export declare class WineBottleGeometry extends BufferGeometry {
-    constructor({ radius, neckRadius, height, neckHeight, segments }?: {
-        radius?: number | undefined;
-        neckRadius?: number | undefined;
-        height?: number | undefined;
-        neckHeight?: number | undefined;
-        segments?: number | undefined;
-    });
+    readonly radius: number;
+    readonly height: number;
+    constructor({ radius, neckRadius, height, neckHeight, segments, }?: WineBottleGeometryOptions);
+}
+
+export declare interface WineBottleGeometryOptions {
+    /** Body radius. Defaults to `0.5`. */
+    radius?: number;
+    /** Neck radius. Defaults to `0.2`. */
+    neckRadius?: number;
+    /** Total height including neck. Defaults to `3`. */
+    height?: number;
+    /** Neck height. Defaults to `1`. */
+    neckHeight?: number;
+    /** Circumference segments. Defaults to `16`. */
+    segments?: number;
+}
+
+export declare interface WineBottleOptions extends WineBottleGeometryOptions {
+    /** Glass tint. Defaults to `#556b2f`. */
+    color?: ColorRepresentation;
 }
 
 /**
@@ -3530,65 +4957,104 @@ export declare interface WispEffectOptions {
     lightPulseSpeed?: number;
 }
 
+export declare interface WobbleClipOptions extends CameraClipTiming {
+    /** Peak positional shake in world units. */
+    intensity: number;
+    ease?: EasingFunction;
+}
+
+/**
+ * Wrought-iron fence post prefab.
+ */
 export declare class WroughtIronBar extends Mesh<WroughtIronBarGeometry, MeshStandardMaterial> {
-    constructor({ barHeight, //
-        barRadius, spikeHeight, spikeRadius, spikeScaleZ, radialSegments, }?: {
-        barHeight?: number | undefined;
-        barRadius?: number | undefined;
-        spikeHeight?: number | undefined;
-        spikeRadius?: number | undefined;
-        spikeScaleZ?: number | undefined;
-        radialSegments?: number | undefined;
-    });
+    readonly barHeight: number;
+    constructor({ color, ...geometryOptions }?: WroughtIronBarOptions);
 }
 
 /**
- * Wrought Iron Bar Geometry, a simple wrought iron bar shape
+ * Wrought-iron fence post — cylinder bar with a decorative spike.
+ *
+ * Local frame: base at Y=0.
  */
 export declare class WroughtIronBarGeometry extends BufferGeometry {
-    constructor({ barHeight, //
-        barRadius, spikeHeight, spikeRadius, spikeScaleZ, radialSegments, }?: {
-        barHeight?: number | undefined;
-        barRadius?: number | undefined;
-        spikeHeight?: number | undefined;
-        spikeRadius?: number | undefined;
-        spikeScaleZ?: number | undefined;
-        radialSegments?: number | undefined;
-    });
+    readonly barHeight: number;
+    constructor({ barHeight, barRadius, spikeHeight, spikeRadius, spikeScaleZ, radialSegments, }?: WroughtIronBarGeometryOptions);
+}
+
+export declare interface WroughtIronBarGeometryOptions {
+    /** Vertical bar height. Defaults to `2`. */
+    barHeight?: number;
+    /** Bar cylinder radius. Defaults to `0.05`. */
+    barRadius?: number;
+    /** Spike cone height. Defaults to `0.3`. */
+    spikeHeight?: number;
+    /** Spike base radius. Defaults to `0.075`. */
+    spikeRadius?: number;
+    /** Spike depth scale on Z. Defaults to `1`. */
+    spikeScaleZ?: number;
+    /** Circumference segments. Defaults to `8`. */
+    radialSegments?: number;
+}
+
+export declare interface WroughtIronBarOptions extends WroughtIronBarGeometryOptions {
+    /** Iron tint. Defaults to `#333333`. */
+    color?: ColorRepresentation;
 }
 
+/**
+ * Wrought-iron fence run prefab.
+ */
 export declare class WroughtIronFence extends Mesh<WroughtIronFenceGeometry, MeshStandardMaterial> {
-    constructor({ count, //
-        spacing, barHeight, barRadius, spikeHeight, spikeRadius, spikeScaleZ, railHeight, railDepth, railOffset, radialSegments, }?: {
-        count?: number | undefined;
-        spacing?: number | undefined;
-        barHeight?: number | undefined;
-        barRadius?: number | undefined;
-        spikeHeight?: number | undefined;
-        spikeRadius?: number | undefined;
-        spikeScaleZ?: number | undefined;
-        railHeight?: number | undefined;
-        railDepth?: number | undefined;
-        railOffset?: number | undefined;
-        radialSegments?: number | undefined;
-    });
+    readonly count: number;
+    constructor({ color, ...geometryOptions }?: WroughtIronFenceOptions);
 }
 
+/**
+ * Wrought-iron fence run — repeated posts with top and bottom rails.
+ *
+ * Local frame: first post at the origin, extending along +X.
+ */
 export declare class WroughtIronFenceGeometry extends BufferGeometry {
-    constructor({ count, //
-        spacing, barHeight, barRadius, spikeHeight, spikeRadius, spikeScaleZ, railHeight, railDepth, railOffset, radialSegments, }?: {
-        count?: number | undefined;
-        spacing?: number | undefined;
-        barHeight?: number | undefined;
-        barRadius?: number | undefined;
-        spikeHeight?: number | undefined;
-        spikeRadius?: number | undefined;
-        spikeScaleZ?: number | undefined;
-        railHeight?: number | undefined;
-        railDepth?: number | undefined;
-        railOffset?: number | undefined;
-        radialSegments?: number | undefined;
-    });
+    readonly count: number;
+    readonly spacing: number;
+    constructor({ count, spacing, barHeight, barRadius, spikeHeight, spikeRadius, spikeScaleZ, railHeight, railDepth, railOffset, radialSegments, }?: WroughtIronFenceGeometryOptions);
+}
+
+export declare interface WroughtIronFenceGeometryOptions {
+    /** Number of posts. Defaults to `20`. */
+    count?: number;
+    /** Center-to-center post spacing. Defaults to `0.4`. */
+    spacing?: number;
+    /** Post bar height. Defaults to `2`. */
+    barHeight?: number;
+    /** Post bar radius. Defaults to `0.05`. */
+    barRadius?: number;
+    /** Post spike height. Defaults to `0.3`. */
+    spikeHeight?: number;
+    /** Post spike radius. Defaults to `0.075`. */
+    spikeRadius?: number;
+    /** Post spike Z scale. Defaults to `1`. */
+    spikeScaleZ?: number;
+    /** Horizontal rail thickness. Defaults to `0.1`. */
+    railHeight?: number;
+    /** Horizontal rail depth. Defaults to `0.05`. */
+    railDepth?: number;
+    /** Top rail offset below the spike tip. Defaults to `0`. */
+    railOffset?: number;
+    /** Post circumference segments. Defaults to `8`. */
+    radialSegments?: number;
+}
+
+export declare interface WroughtIronFenceOptions extends WroughtIronFenceGeometryOptions {
+    /** Iron tint. Defaults to `#333333`. */
+    color?: ColorRepresentation;
+}
+
+export declare interface ZoomClipOptions extends CameraClipTiming {
+    target: Vector3;
+    /** Narrower FOV at the end of the clip (e.g. `35` from `75`). */
+    endFov: number;
+    ease?: EasingFunction;
 }
 
 export { }