three-low-poly 0.9.25 → 0.9.27

package/dist/index.d.ts

@@ -8,6 +8,7 @@ import { ExtrudeGeometry } from 'three';
 import { Group } from 'three';
 import { InstancedMesh } from 'three';
 import { Material } from 'three';
+import { MaterialEventMap } from 'three';
 import { Mesh } from 'three';
 import { MeshBasicMaterial } from 'three';
 import { MeshLambertMaterial } from 'three';
@@ -16,7 +17,7 @@ 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 { ParametricGeometry } from 'three/addons/geometries/ParametricGeometry.js';
 import { PerspectiveCamera } from 'three';
 import { Plane } from 'three';
 import { PlaneGeometry } from 'three';
@@ -25,6 +26,7 @@ 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';
@@ -68,7 +70,7 @@ import { Vector3 } from 'three';
  *     instancedMesh.geometry.setAttribute("instanceColor", new THREE.InstancedBufferAttribute(colors, 3));
  * ```
  */
-export declare function addInstanceColor(material: Material): Material;
+export declare function addInstanceColor(material: Material): Material< MaterialEventMap>;
 
 /**
  * Utility function to add noise-based vertex displacement to an existing Three.js material.
@@ -170,6 +172,122 @@ export declare function appendSphericalCurve(sphereRadiusX: number, sphereRadius
 
 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.
  *
@@ -441,57 +559,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 {
@@ -503,6 +657,22 @@ export declare enum BoxSide {
     BACK = "back"
 }
 
+/**
+ * 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 function buildArchedDiamondLatticeCameParts({ width, rectHeight, archHeight, centerY, grid, leadThickness: barT, leadDepth: barD, clipInset, }: ArchedDiamondLatticePartOptions): BoxGeometry[];
+
+/** 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).
@@ -522,20 +692,38 @@ 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 {
@@ -755,37 +943,52 @@ export declare interface CameraTransitionOptions {
 }
 
 /**
- * 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;
 }
 
 /**
@@ -879,6 +1082,12 @@ export declare interface ClipRuntime {
 /** 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;
@@ -1230,20 +1439,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.
@@ -1366,8 +1598,7 @@ export declare function diamondLatticeCellFromCount(width: number, height: numbe
 export declare function diamondLatticeCornerSpan(width: number, height: number): number;
 
 /**
- * Axis-aligned diamond lattice — north/south vertices share a vertical axis,
- * east/west share a horizontal axis (`<>` not `><`).
+ * Axis-aligned diamond lattice
  */
 export declare interface DiamondLatticeGrid {
     /** Horizontal half-diagonal of each quarrel (east–west point spacing). */
@@ -1402,17 +1633,15 @@ declare interface DiamondLatticePartOptions {
     leadDepth: number;
 }
 
-/** @deprecated Use {@link diamondLatticeGridFromCells}. */
-export declare function diamondLatticeSpacingFromGrid(width: number, height: number, cellsX: number, cellsY: number): {
-    plus45: number;
-    minus45: 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 and optional
- * glass share `z = 0`. Pair with a scene-owned backing plane behind the wall.
+ * 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 DiamondLatticeWindow extends Group {
     readonly lattice: Mesh<DiamondLatticeWindowGeometry, MeshStandardMaterial>;
@@ -1420,7 +1649,7 @@ export declare class DiamondLatticeWindow extends Group {
     readonly cellsX: number;
     readonly cellsY: number;
     readonly fittedGrid: DiamondLatticeGrid;
-    constructor({ leadColor, glass, glassColor, glassEmissive, glassEmissiveIntensity, ...geometryOptions }?: DiamondLatticeWindowOptions);
+    constructor({ leadColor, glass, glassColor, glassEmissive, glassEmissiveIntensity, centerY, leadDepth, ...geometryOptions }?: DiamondLatticeWindowOptions);
 }
 
 /**
@@ -1459,7 +1688,7 @@ declare interface DiamondLatticeWindowOptions extends DiamondLatticeWindowGeomet
     /** Lead + outer frame tint. Defaults to `#0c0f14`. */
     leadColor?: ColorRepresentation;
     /**
-     * Optional glass pane coplanar with the lattice (same Z center).
+     * 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;
@@ -1760,26 +1989,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: {
@@ -1861,13 +2106,17 @@ export declare function findClosestPoint(point: Vector3, mesh: Mesh): Vector3;
  */
 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);
 }
 
 /**
@@ -1917,13 +2166,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;
 }
 
 /**
@@ -1946,22 +2219,38 @@ export declare interface FlythroughClipOptions extends CameraClipTiming {
     ease?: EasingFunction;
 }
 
-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;
-    });
+/**
+ * Gear shape prefab.
+ */
+export declare class Gear extends Mesh<GearGeometry, MeshStandardMaterial> {
+    constructor({ color, ...geometryOptions }?: GearOptions);
 }
 
 /**
- * Extrude geometry of Gear Shape.
+ * Extruded gear profile with center hole.
  */
 export declare class GearGeometry extends ExtrudeGeometry {
-    constructor(sides?: number, innerRadius?: number, outerRadius?: number, holeSides?: number, holeRadius?: number, depth?: number);
+    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 {
@@ -2227,32 +2516,51 @@ export declare interface HangingLanternOptions extends HangingLanternGeometryOpt
     lampOpacity?: 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;
-    });
+/**
+ * Heart shape prefab.
+ */
+export declare class Heart extends Mesh<HeartGeometry, MeshStandardMaterial> {
+    constructor({ color, emissive, emissiveIntensity, ...geometryOptions }?: HeartOptions);
 }
 
 /**
- * Extrude geometry of Heart Shape.
+ * 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 {
@@ -2274,10 +2582,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 {
@@ -2292,28 +2618,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;
 }
 
 /**
@@ -2330,6 +2670,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.
@@ -2371,7 +2714,7 @@ export declare class JarGeometry extends BufferGeometry {
  */
 export declare class Lantern extends Mesh<LanternGeometry, MeshStandardMaterial[]> {
     readonly lampCenterY: number;
-    constructor(heightOrOptions?: number | LanternOptions, baseWidth?: number);
+    constructor({ color, lampColor, lampEmissiveIntensity, lampOpacity, inner, ...geometryOptions }?: LanternOptions);
 }
 
 /**
@@ -2645,79 +2988,84 @@ 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;
 }
 
 /**
@@ -2812,17 +3160,37 @@ 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 {
@@ -3379,20 +3747,55 @@ declare interface RingLatticeWindowOptions {
     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> {
@@ -3426,7 +3829,7 @@ declare interface RowOfBooksByScalesOptions<T extends Material = Material> {
     source: RandomSource;
 }
 
-declare interface RowOfBooksOptions<T extends Material = Material> {
+export declare interface RowOfBooksOptions<T extends Material = Material> {
     coverMaterial: T;
     pagesMaterial: T;
     count?: number;
@@ -3441,6 +3844,51 @@ declare interface RowOfBooksOptions<T extends Material = Material> {
     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;
+}
+
 /**
  * SceneTransition provides smooth animated transitions between Three.js scenes.
  *
@@ -3846,6 +4294,49 @@ 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.
@@ -3895,35 +4386,48 @@ export declare interface StaircaseOptions extends StaircaseGeometryOptions {
     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 {
@@ -4042,29 +4546,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;
 }
 
 /**
@@ -4094,14 +4631,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 {
@@ -4126,60 +4664,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;
 }
 
 /**
@@ -4302,18 +4840,40 @@ export declare interface WallSconceOptions extends WallSconceGeometryOptions {
     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;
 }
 
 /**
@@ -4404,65 +4964,91 @@ export declare interface WobbleClipOptions extends CameraClipTiming {
     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 {