opengeometry 2.0.11 → 2.0.14

package/src/examples/shapes.d.ts

@@ -3,8 +3,8 @@ import { Cuboid } from "../shapes/cuboid.js";
 import { Cylinder } from "../shapes/cylinder.js";
 import { Opening } from "../shapes/opening.js";
 import { Polygon } from "../shapes/polygon.js";
-import { Sphere } from "../shapes/sphere.js";
 import { Sweep } from "../shapes/sweep.js";
+import { Sphere } from "../shapes/sphere.js";
 import { Wedge } from "../shapes/wedge.js";
 /**
  * Adds a basic shapes showcase to the provided scene.

package/src/examples/wall-from-offsets.d.ts

@@ -1,26 +1,19 @@
 import * as THREE from "three";
-import { Cuboid } from "../shapes/cuboid.js";
 import { Polyline } from "../primitives/polyline.js";
+import { AnalyticSolid } from "../shapes/analytic-solid.js";
 import { Polygon } from "../shapes/polygon.js";
 export interface WallFromOffsetsOptions {
-    /**
-     * Number of doors to subtract from the extruded wall. Doors are placed at
-     * evenly distributed centerline-segment midpoints. Default `0` (no cuts).
-     */
-    doorCount?: number;
-    /**
-     * Cutter overshoot in millimeters. The debt sheet's `#6a` symptom is at
-     * 1mm; default 1mm so callers exercise the snap-tolerance regime by default
-     * when cuts are enabled.
-     */
-    overshootMm?: number;
+    /** Subtract one exact coextensive through slot. Default `false`. */
+    cutThroughSlot?: boolean;
+    /** Width of the through slot along its centerline segment. Default `0.6`. */
+    slotWidth?: number;
     /**
      * Wall extrusion height in meters. Default `2.6` to match the example HTML.
      */
     height?: number;
 }
 /**
- * Renders a human-readable description for a typed `BooleanError` (or any
+ * Renders a human-readable description for an analytic geometry error (or any
  * other thrown value). Used by the example HTML to surface kernel failures
  * in a status panel without losing the structured payload.
  */
@@ -34,7 +27,7 @@ export declare function createWallFromOffsetsExample(scene: THREE.Scene, options
     rightOffset: import("../primitives/polyline.js").IOffsetResult;
     cutResult: {
         wall: THREE.Object3D;
-        cutters: Cuboid[];
+        cutters: AnalyticSolid[];
     } | null;
     cutError: unknown;
 };

package/src/export/analytic-ifc.d.ts

@@ -0,0 +1,61 @@
+export type IfcPreparedValue = {
+    kind: "Ref";
+    id: number;
+} | {
+    kind: "List";
+    values: IfcPreparedValue[];
+} | {
+    kind: "Real";
+    value: number;
+} | {
+    kind: "Integer";
+    value: number;
+} | {
+    kind: "Text" | "Enum";
+    value: string;
+} | {
+    kind: "Bool";
+    value: boolean;
+} | {
+    kind: "Null" | "Derived";
+};
+export interface AnalyticExchangeBodyV2 {
+    schema_version: 2;
+    revision: string;
+    length_unit: "metre";
+    up_axis: "Z";
+    coordinate_space: "world";
+    representation_type: "AdvancedBrep" | "CSG";
+    quality: {
+        kind: "Analytic";
+    } | {
+        kind: "Approximate";
+        max_error: number;
+    };
+    geometric_tolerance: number;
+    exchange_error_bound: number;
+    validation_level: string;
+    entities: {
+        id: number;
+        entity_type: string;
+        attributes: IfcPreparedValue[];
+    }[];
+    solids: number[];
+    faces: {
+        face: number;
+        key: string;
+        entity: number;
+        provenance: {
+            sources: {
+                entity: string;
+                body: string;
+                key: string;
+                face: number;
+            }[];
+            role: "Authored" | "Preserved" | "Split" | "Cut" | "Coincident";
+            reversed: boolean;
+        };
+    }[];
+}
+/** Serializes Rust-prepared geometry; this function does not fit curves or tessellate surfaces. */
+export declare function analyticIfcText(body: AnalyticExchangeBodyV2, name?: string): string;

package/src/freeform/geometry.d.ts

@@ -78,3 +78,5 @@ export declare class FreeformGeometry {
  * BRep object, or another wrapper exposing BRep accessors.
  */
 export declare function createFreeformGeometry(source: FreeformSource, options?: CreateFreeformGeometryOptions): FreeformGeometry;
+/** Triangulates an explicitly faceted BRep, including its planar face holes. */
+export declare function tessellateFacetedBrep(serialized: string): Float64Array;

package/src/freeform/index.d.ts

@@ -2,4 +2,4 @@
  * Freeform geometry types and helpers for working with raw BRep-backed models.
  */
 export * from "./types.js";
-export { FreeformGeometry, createFreeformGeometry } from "./geometry.js";
+export { FreeformGeometry, createFreeformGeometry, tessellateFacetedBrep } from "./geometry.js";

package/src/operations/analytic-errors.d.ts

@@ -0,0 +1,8 @@
+export type AnalyticGeometryErrorCode = "math" | "invalid_geometry" | "invalid_topology" | "unsupported_geometry" | "ambiguous_profile_alignment" | "coverage_gap" | "singular_parameterization" | "missing_reference" | "unsupported_schema" | "unresolved_intersection" | "unresolved_tessellation" | "limit_exceeded" | "unknown";
+export declare class AnalyticGeometryError extends Error {
+    readonly code: AnalyticGeometryErrorCode;
+    readonly detail: unknown;
+    readonly families?: readonly [string, string];
+    constructor(code: AnalyticGeometryErrorCode, message: string, detail?: unknown);
+}
+export declare function parseAnalyticGeometryError(raw: unknown): AnalyticGeometryError;

package/src/operations/boolean.d.ts

@@ -1,148 +1,16 @@
 import * as THREE from "three";
-import { type CreateFreeformGeometryOptions, type FreeformGeometry } from "../freeform.js";
-/**
- * Accepted operand formats for boolean helpers.
- */
-export type BooleanOperand = string | Record<string, unknown> | {
-    getBrep?: () => unknown;
-    getBrepData?: () => unknown;
-    getBrepSerialized?: () => string;
-};
-/**
- * Kernel-side boolean tuning options.
- *
- * `tolerance` is in **model units** (meters by convention). When omitted, the
- * kernel auto-scales it to `operandsDiagonal * 1e-8` (clamped to a `1e-6`
- * floor in many-subtract). This drives the kernel-side polygon / face math
- * (vertex welding, plane coincidence, AABB enforcement).
- *
- * **NOTE: this tolerance does NOT control boolmesh's internal snap window.**
- * Boolmesh has its own welding tolerance that may treat faces within ~1mm
- * of each other as coincident, regardless of what `tolerance` you pass. If
- * your cutter face sits within about 0.001 m – 0.01 m of a host face you
- * may still hit a `DegenerateTriangle` / `CoincidentFaces` error path.
- *
- * **Recommended cutter overshoot for through-cuts:** `max(hostThickness *
- * 0.05, 0.01)` in model units. See `knowledge/boolean-tolerance-guide.md`.
- *
- * `mergeCoplanarFaces` (default `true`) controls whether the planar pipeline
- * merges coplanar adjacent faces in its output.
- */
-export interface BooleanKernelOptions {
-    tolerance?: number;
-    mergeCoplanarFaces?: boolean;
-}
-/**
- * Rendering options applied to the boolean result mesh.
- *
- * `color`, `opacity`, `transparent`, and `side` override the corresponding
- * fields on the host (LHS) operand's cloned material. Omit them to inherit
- * the host's appearance unchanged.
- */
-export interface BooleanRenderOptions {
+import { AnalyticSolid } from "../shapes/analytic-solid.js";
+/** Rendering and tessellation options applied to an analytic boolean result. */
+export interface BooleanExecutionOptions {
+    deflection?: number;
     color?: THREE.ColorRepresentation;
     opacity?: number;
     transparent?: boolean;
     side?: THREE.Side;
     outline?: boolean;
-    fatOutlines?: boolean;
-    outlineWidth?: number;
-}
-/**
- * Combined kernel and rendering options accepted by boolean helpers.
- */
-export interface BooleanExecutionOptions extends BooleanRenderOptions {
-    kernel?: BooleanKernelOptions;
-}
-/**
- * Structured report returned by the kernel boolean pipeline.
- */
-export interface BooleanReport {
-    operation: string;
-    operand_kind: string;
-    input_face_count: number;
-    input_triangle_count: number;
-    output_face_count: number;
-    output_shell_count: number;
-    empty: boolean;
-}
-interface KernelBooleanResult {
-    brepSerialized: string;
-    geometrySerialized: string;
-    outlineGeometrySerialized: string;
-    reportJson: string;
-}
-/**
- * Renderable result mesh returned by the kernel boolean helpers.
- */
-export declare class BooleanResult extends THREE.Mesh {
-    #private;
-    ogid: string;
-    report: BooleanReport | null;
-    private brepSerialized;
-    private brepData;
-    private outlinePositions;
-    private _outlineEnabled;
-    private _fatOutlines;
-    private _outlineWidth;
-    constructor(kernelResult: KernelBooleanResult, options?: BooleanRenderOptions, host?: BooleanOperand | null);
-    /**
-     * Updates the result mesh's color in place without re-running the boolean
-     * pipeline. Accepts any value Three.js accepts (`number`, hex string, css
-     * color name, or `THREE.Color`). No-op for materials without a `color` field.
-     */
-    set color(value: THREE.ColorRepresentation);
-    get color(): THREE.Color | null;
-    /**
-     * Rebuilds the mesh, cached BRep payload, and outline geometry from the kernel output.
-     */
-    applyKernelResult(kernelResult: KernelBooleanResult, options?: BooleanRenderOptions, sourceMaterial?: THREE.Material | null): void;
-    /**
-     * Returns the parsed BRep object for reuse with scene export or downstream operations.
-     */
-    getBrepData(): Record<string, unknown> | null;
-    /**
-     * Returns the serialized BRep JSON emitted by the kernel boolean operation.
-     */
-    getBrepSerialized(): string;
-    canConvertToFreeform(): boolean;
-    /**
-     * Converts the boolean output into a first-class freeform geometry object so
-     * it can participate in direct face/edge/vertex editing.
-     */
-    toFreeform(options?: CreateFreeformGeometryOptions): FreeformGeometry;
-    set outline(enable: boolean);
-    get outline(): boolean;
-    set fatOutlines(value: boolean);
-    get fatOutlines(): boolean;
-    set outlineWidth(value: number);
-    get outlineWidth(): number;
-    disposeGeometry(): void;
-    private clearOutlineMesh;
 }
-/**
- * Computes a kernel-backed boolean union and returns a renderable result mesh.
- *
- * Accepts wrapper objects directly, including `Solid`, `Cuboid`, `Opening`,
- * and other shapes that expose BRep accessors.
- */
-export declare function booleanUnion(lhs: BooleanOperand, rhs: BooleanOperand, options?: BooleanExecutionOptions): BooleanResult;
-/**
- * Computes a kernel-backed boolean intersection and returns a renderable result mesh.
- */
-export declare function booleanIntersection(lhs: BooleanOperand, rhs: BooleanOperand, options?: BooleanExecutionOptions): BooleanResult;
-/**
- * Computes a kernel-backed boolean subtraction and returns a renderable result mesh.
- *
- * Use this when you want a standalone helper rather than a shape-level
- * convenience method like `opening.subtractFrom(host)`.
- */
-export declare function booleanSubtraction(lhs: BooleanOperand, rhs: BooleanOperand, options?: BooleanExecutionOptions): BooleanResult;
-/**
- * Computes a kernel-backed repeated subtraction using a left-to-right cutter array.
- *
- * This is used by the shape-level `.subtract([...])` helpers so the heavy
- * boolean orchestration stays in the Rust/WASM layer instead of JavaScript.
- */
-export declare function executeBooleanSubtractionMany(lhs: BooleanOperand, cutters: BooleanOperand[], options?: BooleanExecutionOptions): BooleanResult;
-export {};
+export type BooleanOperand = AnalyticSolid;
+export declare function booleanUnion(lhs: AnalyticSolid, rhs: AnalyticSolid, options?: BooleanExecutionOptions): AnalyticSolid;
+export declare function booleanIntersection(lhs: AnalyticSolid, rhs: AnalyticSolid, options?: BooleanExecutionOptions): AnalyticSolid;
+export declare function booleanSubtraction(lhs: AnalyticSolid, rhs: AnalyticSolid, options?: BooleanExecutionOptions): AnalyticSolid;
+export declare function executeBooleanSubtractionMany(lhs: BooleanOperand, cutters: BooleanOperand[], options?: BooleanExecutionOptions): AnalyticSolid;

package/src/operations/index.d.ts

@@ -2,9 +2,7 @@
  * Kernel-backed boolean helpers and renderable result mesh.
  */
 export * from "./boolean.js";
-export * from "./boolean-errors.js";
+export * from "./analytic-errors.js";
 export * from "./extrude.js";
-/**
- * Analytic polyline offset → filled regions (single + group).
- */
+export * from "./loft.js";
 export * from "./offset-regions.js";

package/src/operations/loft.d.ts

@@ -0,0 +1,13 @@
+import * as THREE from "three";
+import { AnalyticSolid, type AnalyticPolygonLoftAlignment } from "../shapes/analytic-solid.js";
+export type PolygonLoftPoint = readonly [number, number, number];
+export interface PolygonLoftOptions {
+    alignment?: AnalyticPolygonLoftAlignment;
+    deflection?: number;
+    color?: THREE.ColorRepresentation;
+}
+/**
+ * Creates a capped ruled solid between two planar polygon sections.
+ * Sections must have equal vertex counts and produce planar side faces.
+ */
+export declare function loftPolygonSections(sections: readonly [readonly PolygonLoftPoint[], readonly PolygonLoftPoint[]], options?: PolygonLoftOptions): AnalyticSolid;

package/src/operations/offset-regions.d.ts

@@ -25,6 +25,42 @@ export interface OffsetRegion {
  * @param miterLimit SVG stroke-miterlimit; corners sharper than this bevel. Default 4.
  */
 export declare function offsetPolylineRegions(centrelineFlat: number[] | Float64Array, width: number, closed: boolean, miterLimit?: number): OffsetRegion[];
+/** An excluded interior ring of a variable inset (an easement island, a
+ *  protected tree pit): its closed ring `[x,y,z, …]` plus one clearance
+ *  distance per hole edge. The inset GROWS the hole by its distances. */
+export interface OffsetHole {
+    ring: number[] | Float64Array;
+    distances: number[] | Float64Array;
+}
+/**
+ * Inset a CLOSED ring inward with one distance per edge (edge i =
+ * `ring[i] → ring[i+1]`; an explicit closing duplicate point is accepted and
+ * stripped, the distance count stays one per unique edge). Built for setback
+ * envelopes: the result is the CLEARANCE-EXACT buildable region — the ring's
+ * interior minus every point within `distances[i]` of edge i's SEGMENT, so
+ * distant lot lines are honoured across notches and corners where distances
+ * differ become circumscribed clearance arcs (conservative). There is no
+ * `miterLimit` parameter, deliberately: miters and bevels only approximate the
+ * clearance arc, and a bevel would claim points inside the required distance.
+ *
+ * `holes` are excluded interior rings, each grown outward by its own per-edge
+ * distances — the region keeps clear of a hole's edges exactly as it keeps
+ * clear of the lot lines, so a hole can split the region or swallow it.
+ *
+ * Returns CW-outer / CCW-hole regions (canonical start vertex), possibly
+ * SEVERAL when a deep inset (or a hole) splits a waisted ring into disjoint
+ * lobes, and an EMPTY array when the inset collapses or the outer ring is
+ * degenerate (< 3 unique points, zero area, self-intersecting). THROWS on
+ * malformed arguments: a distance count that does not match an edge count, a
+ * negative / non-finite distance, or a degenerate hole — those are caller
+ * bugs, not geometry.
+ *
+ * @param ring closed ring points as `[x,y,z, …]` (Y is carried through).
+ * @param distances inward inset distance per edge, metres, each >= 0
+ *                  (0 = the edge stays in place, e.g. lot-line construction).
+ * @param holes excluded interior rings with their own per-edge distances.
+ */
+export declare function offsetRingVariable(ring: number[] | Float64Array, distances: number[] | Float64Array, holes?: OffsetHole[]): OffsetRegion[];
 /** One polyline in an offset group: centreline `[x,y,z, …]`, stroke width, closed flag. */
 export interface OffsetPolyline {
     centreline: number[];

package/src/primitives/analytic-curve.d.ts

@@ -0,0 +1,42 @@
+import * as THREE from "three";
+import { OGAnalyticBrep } from "../../opengeometry/pkg/opengeometry.js";
+import type { AnalyticAccuracy, AnalyticFrame } from "../shapes/analytic-solid.js";
+export type AnalyticCurveOptions = {
+    ogid?: string;
+    frame?: AnalyticFrame;
+    accuracy?: AnalyticAccuracy;
+    startAngle: number;
+    sweepAngle: number;
+    deflection?: number;
+    color?: THREE.ColorRepresentation;
+} & ({
+    kind: "arc";
+    radius: number;
+} | {
+    kind: "ellipticalArc";
+    majorRadius: number;
+    minorRadius: number;
+});
+export interface AnalyticCurveStats {
+    requestedDeflection: number;
+    achievedDeflection: number;
+    segmentCount: number;
+    revision: bigint;
+}
+export declare class AnalyticCurve extends THREE.Group {
+    readonly ogid: string;
+    readonly line: THREE.LineSegments<THREE.BufferGeometry, THREE.LineBasicMaterial>;
+    protected kernel: OGAnalyticBrep;
+    private segmentEdges;
+    private disposed;
+    get color(): THREE.Color;
+    set color(value: THREE.ColorRepresentation);
+    constructor(options: AnalyticCurveOptions);
+    getBrepSerialized(): string;
+    getBrepData(): Record<string, unknown>;
+    protected replaceDefinition(options: AnalyticCurveOptions): AnalyticCurveStats;
+    edgeIdForSegment(segment: number): number | undefined;
+    retessellate(deflection: number): AnalyticCurveStats;
+    dispose(): void;
+    private checkActive;
+}

package/src/primitives/arc.d.ts

@@ -1,65 +1,36 @@
-import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
 import * as THREE from "three";
-/**
- * Construction options for an arc or full-circle primitive.
- */
+import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
+import { AnalyticCurve, type AnalyticCurveStats } from "./analytic-curve.js";
+import type { AnalyticAccuracy } from "../shapes/analytic-solid.js";
 export interface IArcOptions {
+    ogid?: string;
+    center?: Vector3;
+    radius?: number;
+    startAngle?: number;
+    sweepAngle?: number;
+    deflection?: number;
+    accuracy?: AnalyticAccuracy;
+    color?: THREE.ColorRepresentation;
+}
+export type ArcConfigUpdate = Partial<Omit<IArcOptions, "ogid">>;
+interface NormalizedArcOptions {
     ogid?: string;
     center: Vector3;
     radius: number;
     startAngle: number;
-    endAngle: number;
-    segments: number;
-    color: number;
-    fatLines?: boolean;
-    width?: number;
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
-}
-/**
- * Placement updates accepted by `Arc`.
- */
-export interface ArcPlacementOptions {
-    translation?: Vector3;
-    rotation?: Vector3;
-    scale?: Vector3;
+    sweepAngle: number;
+    deflection: number;
+    accuracy?: AnalyticAccuracy;
+    color: THREE.ColorRepresentation;
 }
-/**
- * Partial config payload accepted by `Arc.setConfig(...)`.
- */
-export type ArcConfigUpdate = Partial<Omit<IArcOptions, "translation" | "rotation" | "scale">>;
-/**
- * Alias for `Arc` placement updates.
- */
-export type ArcPlacementUpdate = ArcPlacementOptions;
-/**
- * Arc wrapper backed by the kernel OGArc primitive.
- */
-export declare class Arc extends THREE.Line {
-    ogid: string;
-    options: IArcOptions;
-    private arc;
-    private fatLine;
-    set color(color: number);
+/** Authoritative circular edge with transient deflection tessellation. */
+export declare class Arc extends AnalyticCurve {
+    options: Readonly<NormalizedArcOptions>;
     constructor(options?: IArcOptions);
-    validateOptions(): void;
-    setConfig(options: ArcConfigUpdate): void;
     getAnchor(): Vector3;
-    setPlacement(placement: ArcPlacementUpdate): void;
-    setTransform(translation: Vector3, rotation: Vector3, scale: Vector3): void;
-    setTranslation(translation: Vector3): void;
-    setRotation(rotation: Vector3): void;
-    setScale(scale: Vector3): void;
-    getConfig(): IArcOptions;
-    getPlacement(): import("../editor.js").ParametricPlacement;
-    getEditCapabilities(): import("../editor.js").ParametricEditCapabilities;
-    canConvertToFreeform(): boolean;
-    toFreeform(id?: string): import("../freeform.js").FreeformGeometry;
-    private getCurrentPositions;
-    private updateRenderStyle;
-    private generateGeometry;
-    getBrep(): any;
-    discardGeometry(): void;
-    private writePositionsToGeometry;
+    getConfig(): Readonly<NormalizedArcOptions>;
+    setConfig(update: ArcConfigUpdate): AnalyticCurveStats;
+    getBrep(): Record<string, unknown>;
+    retessellate(deflection: number): AnalyticCurveStats;
 }
+export {};

package/src/primitives/elliptical_arc.d.ts

@@ -0,0 +1,38 @@
+import * as THREE from "three";
+import { Vector3 } from "../../opengeometry/pkg/opengeometry.js";
+import { AnalyticCurve, type AnalyticCurveStats } from "./analytic-curve.js";
+import type { AnalyticAccuracy } from "../shapes/analytic-solid.js";
+export interface IEllipticalArcOptions {
+    ogid?: string;
+    center?: Vector3;
+    majorRadius?: number;
+    minorRadius?: number;
+    startAngle?: number;
+    sweepAngle?: number;
+    deflection?: number;
+    accuracy?: AnalyticAccuracy;
+    color?: THREE.ColorRepresentation;
+}
+export type EllipticalArcConfigUpdate = Partial<Omit<IEllipticalArcOptions, "ogid">>;
+interface NormalizedEllipticalArcOptions {
+    ogid?: string;
+    center: Vector3;
+    majorRadius: number;
+    minorRadius: number;
+    startAngle: number;
+    sweepAngle: number;
+    deflection: number;
+    accuracy?: AnalyticAccuracy;
+    color: THREE.ColorRepresentation;
+}
+/** Authoritative elliptical edge with transient deflection tessellation. */
+export declare class EllipticalArc extends AnalyticCurve {
+    options: Readonly<NormalizedEllipticalArcOptions>;
+    constructor(options?: IEllipticalArcOptions);
+    getAnchor(): Vector3;
+    getConfig(): Readonly<NormalizedEllipticalArcOptions>;
+    setConfig(update: EllipticalArcConfigUpdate): AnalyticCurveStats;
+    getBrep(): Record<string, unknown>;
+    retessellate(deflection: number): AnalyticCurveStats;
+}
+export {};

package/src/primitives/index.d.ts

@@ -6,3 +6,4 @@ export * from './polyline.js';
 export * from './arc.js';
 export * from './rectangle.js';
 export * from './curve.js';
+export * from "./elliptical_arc.js";

package/src/rendering/analytic-lod.d.ts

@@ -0,0 +1,32 @@
+import * as THREE from "three";
+import type { AnalyticSolid, AnalyticTessellationStats } from "../shapes/analytic-solid.js";
+import { AnalyticTessellationWorker } from "./analytic-tessellation.js";
+export declare function deflectionBucket(target: number, previous?: number): number;
+export declare function worldUnitsPerPixel(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, depth: number, physicalHeight: number): number;
+export interface AnalyticLodOptions {
+    fixedDeflection?: number;
+    onUpdate?: (solid: AnalyticSolid, statistics: AnalyticTessellationStats) => void;
+    onError?: (solid: AnalyticSolid, error: Error) => void;
+}
+/** Register authored changes explicitly; camera meshes never refresh a scene's authored BRep snapshots. */
+export declare class AnalyticLodController {
+    private readonly worker;
+    private readonly options;
+    private readonly entries;
+    private readonly cameraState;
+    private lastMotion;
+    private lastSchedule;
+    private initialized;
+    private closed;
+    private refining;
+    private fixedDeflection?;
+    constructor(worker: AnalyticTessellationWorker, options?: AnalyticLodOptions);
+    setDeflection(deflection?: number): void;
+    register(solid: AnalyticSolid): Promise<void>;
+    unregister(solid: AnalyticSolid): Promise<void>;
+    update(camera: THREE.PerspectiveCamera | THREE.OrthographicCamera, physicalHeight: number, now?: number, motion?: boolean): void;
+    /** Explicit export refinement; a resource or precision failure rejects and retains each body's prior mesh. */
+    refine(deflection: number): Promise<void>;
+    dispose(): void;
+}
+export declare function uniformScale(matrix: THREE.Matrix4): number;

package/src/rendering/analytic-tessellation.d.ts

@@ -0,0 +1,32 @@
+export interface AnalyticTessellationData {
+    positions: Float64Array;
+    normals: Float32Array;
+    indices: Uint32Array;
+    triangleFaceIds: Uint32Array;
+    outlinePositions: Float64Array;
+    outlineEdgeIds: Uint32Array;
+    revision: bigint;
+    achievedDeflection: number;
+}
+export declare const GEOMETRY_DEFLECTION_SHARE = 0.75;
+export interface AnalyticWorkerOptions {
+    workerURL: string | URL;
+    kernelURL: string | URL;
+    wasmURL: string | URL;
+}
+export declare class AnalyticTessellationWorker {
+    private readonly worker;
+    private readonly pending;
+    private readonly generations;
+    private readonly ready;
+    private serial;
+    private closed;
+    constructor(options: AnalyticWorkerOptions);
+    setModel(handle: string, serialized: string): Promise<void>;
+    tessellate(handle: string, deflection: number): Promise<AnalyticTessellationData>;
+    cancel(handle: string): number;
+    removeModel(handle: string): Promise<void>;
+    dispose(): void;
+    private send;
+    private fail;
+}

package/src/shapes/analytic-pattern.d.ts

@@ -0,0 +1,36 @@
+import * as THREE from "three";
+import { AnalyticSolid } from "./analytic-solid.js";
+export interface AnalyticPatternInstance {
+    id?: string;
+    matrix: THREE.Matrix4;
+}
+export interface AnalyticPatternHit {
+    pattern: AnalyticPattern;
+    instanceIndex: number;
+    instanceId: string;
+    source: AnalyticSolid;
+    faceId?: number;
+}
+/**
+ * Renders many rigid placements of one authoritative analytic body. The source
+ * owns the BRep; instances own only identity and placement matrices.
+ */
+export declare class AnalyticPattern extends THREE.Group {
+    readonly source: AnalyticSolid;
+    readonly surface: THREE.InstancedMesh<THREE.BufferGeometry, THREE.Material>;
+    readonly instanceIds: readonly string[];
+    private disposed;
+    constructor(source: AnalyticSolid, instances: readonly AnalyticPatternInstance[]);
+    get count(): number;
+    setInstanceMatrix(index: number, matrix: THREE.Matrix4): void;
+    resolveIntersection(intersection: THREE.Intersection): AnalyticPatternHit | undefined;
+    dispose(): void;
+    private checkActive;
+}
+export declare function linearPattern(source: AnalyticSolid, count: number, spacing: THREE.Vector3): AnalyticPattern;
+export declare function rectangularPattern(source: AnalyticSolid, counts: readonly [number, number], spacing: readonly [THREE.Vector3, THREE.Vector3]): AnalyticPattern;
+export declare function circularPattern(source: AnalyticSolid, count: number, radius: number, options?: {
+    startAngle?: number;
+    sweepAngle?: number;
+    rotateInstances?: boolean;
+}): AnalyticPattern;