remesh-threejs 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,2505 @@
+/**
+ * remesh-threejs
+ *
+ * TypeScript library for adaptive remeshing of non-manifold surfaces using Three.js.
+ * Based on the EUROGRAPHICS 2008 paper "Adaptive Remeshing of Non-Manifold Surfaces"
+ * by Zilske, Lamecker, and Zachow.
+ *
+ * @packageDocumentation
+ */
+
+import { BufferGeometry } from 'three';
+import { Vector3 } from 'three';
+
+/**
+ * Axis-Aligned Bounding Box.
+ */
+export declare interface AABB {
+    min: Vec3;
+    max: Vec3;
+}
+
+/**
+ * Adaptive remeshing algorithm for non-manifold surfaces.
+ *
+ * Based on the EUROGRAPHICS 2008 paper "Adaptive Remeshing of Non-Manifold Surfaces"
+ * by Zilske, Lamecker, and Zachow.
+ */
+export declare class AdaptiveRemesher {
+    private mesh;
+    private skeleton;
+    private constraints;
+    private options;
+    private state;
+    constructor(mesh: NonManifoldMesh, options?: RemeshOptions);
+    /**
+     * Runs one iteration of the remeshing algorithm.
+     *
+     * Each iteration performs:
+     * 1. Split long edges
+     * 2. Collapse short edges
+     * 3. Flip edges for Delaunay
+     * 4. Smooth vertex positions
+     */
+    iterate(): RemeshingState;
+    /**
+     * Runs multiple iterations until convergence or max iterations.
+     */
+    run(maxIterations?: number): RemeshStats;
+    /**
+     * Checks if the remeshing has converged.
+     */
+    hasConverged(): boolean;
+    /**
+     * Gets the current mesh.
+     */
+    getMesh(): NonManifoldMesh;
+    /**
+     * Gets the skeleton (if built).
+     */
+    getSkeleton(): FeatureSkeleton | null;
+    /**
+     * Gets the current quality stats.
+     */
+    getQuality(): MeshQualityStats;
+    /**
+     * Gets the current state.
+     */
+    getState(): RemeshingState;
+    /**
+     * Exports the mesh to BufferGeometry.
+     */
+    toBufferGeometry(): BufferGeometry;
+}
+
+/**
+ * Adds two vectors.
+ */
+export declare function add(a: Vec3, b: Vec3): Vec3;
+
+/**
+ * Analyzes a BufferGeometry for manifoldness.
+ *
+ * @param geometry - The geometry to analyze
+ * @returns Analysis result
+ */
+export declare function analyzeManifold(geometry: BufferGeometry): ManifoldAnalysisResult;
+
+/**
+ * Analyzes a NonManifoldMesh for manifoldness.
+ *
+ * @param mesh - The mesh to analyze
+ * @returns Analysis result
+ */
+export declare function analyzeMesh(mesh: NonManifoldMesh): ManifoldAnalysisResult;
+
+/**
+ * Computes the angle at a vertex in a triangle.
+ */
+export declare function angleAtVertex(v0: Vec3, vertex: Vec3, v1: Vec3): number;
+
+/**
+ * Computes the angle between two vectors in radians.
+ */
+export declare function angleBetween(a: Vec3, b: Vec3): number;
+
+/**
+ * Computes the barycentric coordinates of a point with respect to a triangle.
+ */
+export declare function barycentricCoordinates(point: Vec3, v0: Vec3, v1: Vec3, v2: Vec3): {
+    u: number;
+    v: number;
+    w: number;
+} | null;
+
+/**
+ * Utility class for exporting meshes with various options.
+ */
+export declare class BufferGeometryExporter {
+    private options;
+    constructor(options?: ExportOptions);
+    /**
+     * Exports a NonManifoldMesh to BufferGeometry.
+     */
+    export(mesh: NonManifoldMesh): BufferGeometry;
+    /**
+     * Exports skeleton edges as LineSegments geometry.
+     */
+    exportSkeleton(mesh: NonManifoldMesh): BufferGeometry;
+    /**
+     * Exports with vertex classification colors.
+     */
+    exportClassification(mesh: NonManifoldMesh): BufferGeometry;
+    /**
+     * Exports with quality visualization colors.
+     */
+    exportQuality(mesh: NonManifoldMesh): BufferGeometry;
+    /**
+     * Sets whether to compute normals.
+     */
+    setComputeNormals(enabled: boolean): this;
+    /**
+     * Sets whether to use smooth normals.
+     */
+    setSmoothNormals(enabled: boolean): this;
+}
+
+/**
+ * Utility class for importing BufferGeometry with additional features.
+ */
+export declare class BufferGeometryImporter {
+    private options;
+    constructor(options?: ImportOptions);
+    /**
+     * Imports a BufferGeometry into a NonManifoldMesh.
+     */
+    import(geometry: BufferGeometry): NonManifoldMesh;
+    /**
+     * Validates a BufferGeometry without importing.
+     */
+    validate(geometry: BufferGeometry): ValidationResult;
+    /**
+     * Sets feature edges to preserve during remeshing.
+     */
+    setFeatureEdges(edges: FeatureEdge[]): this;
+    /**
+     * Enables or disables validation.
+     */
+    setValidation(enabled: boolean): this;
+}
+
+/**
+ * Builds the skeleton from a mesh.
+ */
+export declare function buildSkeleton(mesh: NonManifoldMesh): SkeletonBuildResult;
+
+/**
+ * Bounding Volume Hierarchy for fast spatial queries on triangle meshes.
+ */
+export declare class BVH {
+    private root;
+    private triangles;
+    private maxLeafSize;
+    /**
+     * Creates a new BVH.
+     *
+     * @param maxLeafSize - Maximum number of triangles per leaf node
+     */
+    constructor(maxLeafSize?: number);
+    /**
+     * Builds the BVH from an array of triangles.
+     *
+     * @param triangles - Array of triangles to build from
+     */
+    build(triangles: Triangle[]): void;
+    /**
+     * Recursively builds a BVH node.
+     */
+    private buildNode;
+    /**
+     * Finds the closest point on the mesh to a query point.
+     *
+     * @param point - The query point
+     * @returns The closest point result, or null if no triangles
+     */
+    closestPoint(point: Vec3): ClosestPointResult | null;
+    /**
+     * Finds all triangles intersecting a sphere.
+     *
+     * @param center - Center of the sphere
+     * @param radius - Radius of the sphere
+     * @returns Array of triangle indices
+     */
+    queryRadius(center: Vec3, radius: number): number[];
+    /**
+     * Gets the total number of triangles.
+     */
+    get triangleCount(): number;
+    /**
+     * Gets a triangle by index.
+     */
+    getTriangle(index: number): Triangle | undefined;
+}
+
+/**
+ * Checks if an edge can be contracted.
+ *
+ * An edge can be contracted if:
+ * 1. Neither endpoint is a fixed vertex (branching or non-manifold other)
+ * 2. Contracting won't create invalid topology
+ * 3. The edge is not the only edge connecting two regions
+ */
+export declare function canContractEdge(edge: Edge): boolean;
+
+/**
+ * Determines if an edge can be flipped (only manifold edges can be flipped).
+ */
+export declare function canFlipEdge(type: EdgeType): boolean;
+
+/**
+ * Checks if an edge can be flipped.
+ *
+ * An edge can be flipped if:
+ * 1. It has exactly 2 adjacent faces (not boundary, not non-manifold)
+ * 2. It is not a skeleton edge
+ * 3. Both endpoint vertices have degree > 1
+ * 4. The quadrilateral formed is convex
+ */
+export declare function canFlipEdgeGeometric(edge: Edge): boolean;
+
+/**
+ * Determines if a vertex type allows free movement in 3D space.
+ */
+export declare function canMoveFreely(type: VertexType): boolean;
+
+/**
+ * Statistics about vertex classification.
+ */
+export declare interface ClassificationStats {
+    /** Number of manifold vertices */
+    manifold: number;
+    /** Number of open-book vertices */
+    openBook: number;
+    /** Number of skeleton branching vertices */
+    skeletonBranching: number;
+    /** Number of other non-manifold vertices */
+    nonManifoldOther: number;
+    /** Total vertex count */
+    total: number;
+}
+
+/**
+ * Classifies all vertices in a mesh based on their neighborhood topology.
+ *
+ * @param mesh - The mesh to classify
+ * @returns Classification statistics
+ */
+export declare function classifyAllVertices(mesh: NonManifoldMesh): ClassificationStats;
+
+/**
+ * Classifies a single vertex based on its neighborhood.
+ *
+ * Vertex classification:
+ * - Manifold: Star homeomorphic to disk, can move freely in 3D
+ * - OpenBook: On exactly 2 skeleton edges (like pages of a book)
+ * - SkeletonBranching: On 1 or >2 skeleton edges, position is fixed
+ * - NonManifoldOther: Other non-manifold configurations
+ *
+ * @param vertex - The vertex to classify
+ * @returns The vertex type
+ */
+export declare function classifyVertex(vertex: Vertex): VertexType;
+
+/**
+ * Result of a closest point query.
+ */
+export declare interface ClosestPointResult {
+    point: Vec3;
+    distance: number;
+    triangleIndex: number;
+}
+
+/**
+ * Computes quality statistics for a mesh.
+ */
+export declare function computeMeshQuality(mesh: NonManifoldMesh, poorQualityThreshold?: number): MeshQualityStats;
+
+/**
+ * Computes the target position for a vertex using tangential smoothing.
+ * This projects the barycenter of neighbors onto the tangent plane.
+ */
+export declare function computeTangentialSmoothing(vertex: Vertex): Vec3 | null;
+
+/**
+ * Computes the target edge length based on mesh bounding box.
+ */
+export declare function computeTargetEdgeLength(mesh: NonManifoldMesh, numTargetVertices?: number): number;
+
+/**
+ * Computes the aspect ratio of a triangle (longest / shortest edge).
+ */
+export declare function computeTriangleAspectRatio(face: Face): number | null;
+
+/**
+ * Result of constraining a vertex movement.
+ */
+export declare interface ConstrainedPosition {
+    /** The constrained position */
+    position: Vec3;
+    /** Whether the movement was constrained */
+    wasConstrained: boolean;
+    /** The segment the vertex is constrained to (if applicable) */
+    segment?: SkeletonSegment;
+    /** Distance the position was moved during constraint */
+    constraintDistance: number;
+}
+
+/**
+ * Contracts an edge, merging its two endpoints into one vertex.
+ *
+ * The resulting vertex position depends on vertex types:
+ * - If one is fixed and one is movable: keep the fixed position
+ * - If both are movable: use midpoint
+ * - If one is on skeleton: use skeleton-constrained position
+ */
+export declare function contractEdge(mesh: NonManifoldMesh, edge: Edge): EdgeContractionResult;
+
+/**
+ * Contracts all edges shorter than a threshold.
+ */
+export declare function contractShortEdges(mesh: NonManifoldMesh, minLength: number): {
+    contractCount: number;
+    removedVertices: number;
+};
+
+/**
+ * Computes the cotangent of the angle at a vertex in a triangle.
+ * Used for computing Laplacian weights.
+ */
+export declare function cotangent(v0: Vec3, vertex: Vec3, v1: Vec3): number;
+
+/**
+ * Creates a BVH from a NonManifoldMesh.
+ */
+export declare function createBVHFromMesh(mesh: {
+    getFaces(): Array<{
+        getVertices(): [{
+            position: Vec3;
+        }, {
+            position: Vec3;
+        }, {
+            position: Vec3;
+        }] | null;
+    }>;
+}): BVH;
+
+/**
+ * Creates a branded EdgeId from a number.
+ */
+export declare function createEdgeId(id: number): EdgeId;
+
+/**
+ * Creates a branded FaceId from a number.
+ */
+export declare function createFaceId(id: number): FaceId;
+
+/**
+ * Creates a branded HalfedgeId from a number.
+ */
+export declare function createHalfedgeId(id: number): HalfedgeId;
+
+/**
+ * Creates a remesher from a BufferGeometry.
+ */
+export declare function createRemesher(geometry: BufferGeometry, options?: RemeshOptions): AdaptiveRemesher;
+
+/**
+ * Creates a branded SegmentId from a number.
+ */
+export declare function createSegmentId(id: number): SegmentId;
+
+/**
+ * Creates and builds a skeleton for a mesh.
+ */
+export declare function createSkeleton(mesh: NonManifoldMesh): FeatureSkeleton;
+
+/**
+ * Creates skeleton constraints for a mesh.
+ */
+export declare function createSkeletonConstraints(skeleton: FeatureSkeleton): SkeletonConstraints;
+
+/**
+ * Creates a spatial hash from an array of items with positions.
+ *
+ * @param items - Array of items with position getter
+ * @param getPosition - Function to get the position of an item
+ * @param cellSize - Optional cell size (auto-computed if not provided)
+ */
+export declare function createSpatialHash<T>(items: T[], getPosition: (item: T) => Vec3, cellSize?: number): SpatialHash<T>;
+
+/**
+ * Creates a branded VertexId from a number.
+ */
+export declare function createVertexId(id: number): VertexId;
+
+/**
+ * Computes the cross product of two vectors.
+ */
+export declare function cross(a: Vec3, b: Vec3): Vec3;
+
+/**
+ * Default remeshing options.
+ */
+export declare const DEFAULT_REMESH_OPTIONS: Required<Omit<RemeshOptions, 'targetEdgeLength' | 'featureEdges'>>;
+
+/**
+ * Computes the Euclidean distance between two points.
+ */
+export declare function distance(a: Vec3, b: Vec3): number;
+
+/**
+ * Computes the squared distance between two points.
+ */
+export declare function distanceSquared(a: Vec3, b: Vec3): number;
+
+/**
+ * Computes the dot product of two vectors.
+ */
+export declare function dot(a: Vec3, b: Vec3): number;
+
+/**
+ * Represents an undirected edge in the mesh.
+ * For non-manifold meshes, an edge can have more than 2 halfedges.
+ */
+export declare class Edge {
+    /**
+     * Unique identifier for this edge.
+     */
+    readonly id: EdgeId;
+    /**
+     * One of the halfedges comprising this edge (used for traversal).
+     */
+    halfedge: Halfedge;
+    /**
+     * All halfedges associated with this edge.
+     * For manifold edges, this contains exactly 2 halfedges.
+     * For non-manifold edges, this contains more than 2 halfedges.
+     */
+    allHalfedges: Halfedge[];
+    /**
+     * The intrinsic length of this edge.
+     * This may differ from the Euclidean distance after edge operations.
+     */
+    length: number;
+    /**
+     * Classification of this edge.
+     */
+    type: EdgeType;
+    /**
+     * Whether this edge is part of any path in a network.
+     */
+    isInPath: boolean;
+    constructor(
+    /**
+     * Unique identifier for this edge.
+     */
+    id: EdgeId, 
+    /**
+     * One of the halfedges.
+     */
+    halfedge: Halfedge, 
+    /**
+     * Initial edge length.
+     */
+    length: number);
+    /**
+     * Adds a halfedge to this edge.
+     */
+    addHalfedge(halfedge: Halfedge): void;
+    /**
+     * Gets the number of halfedges (indicates non-manifoldness).
+     * 2 = manifold, >2 = non-manifold, 1 = boundary
+     */
+    getHalfedgeCount(): number;
+    /**
+     * Updates the edge type based on the number of incident faces.
+     */
+    updateType(): void;
+    /**
+     * Gets the number of faces incident to this edge.
+     */
+    getFaceCount(): number;
+    /**
+     * Gets both vertices of this edge.
+     * Returns [v0, v1] where v0 is the source of halfedge and v1 is the target.
+     */
+    getVertices(): [Vertex, Vertex] | [null, null];
+    /**
+     * Gets all faces adjacent to this edge.
+     * For manifold edges, returns up to 2 faces.
+     * For non-manifold edges, returns all incident faces.
+     */
+    getFaces(): Face[];
+    /**
+     * Gets both faces adjacent to this edge (for manifold edges).
+     * Returns [f0, f1] where f0 is the face of halfedge and f1 is the face of twin.
+     * Either face can be null for boundary edges.
+     */
+    getTwoFaces(): [Face | null, Face | null];
+    /**
+     * Checks if this edge is on the boundary (has only one adjacent face).
+     */
+    isBoundary(): boolean;
+    /**
+     * Checks if this edge is non-manifold (has more than 2 adjacent faces).
+     */
+    isNonManifold(): boolean;
+    /**
+     * Checks if this edge is part of the feature skeleton.
+     */
+    isSkeletonEdge(): boolean;
+    /**
+     * Checks if this edge can be flipped.
+     * An edge can be flipped if:
+     * 1. It has exactly two adjacent faces (manifold, not skeleton)
+     * 2. Both endpoints have degree > 1
+     * 3. The quadrilateral formed is convex (checked separately)
+     */
+    canFlip(): boolean;
+    /**
+     * Gets the other vertex of this edge (given one vertex).
+     */
+    getOtherVertex(v: Vertex): Vertex | null;
+    /**
+     * Marks this edge as a feature edge.
+     */
+    markAsFeature(): void;
+}
+
+/**
+ * Result of an edge contraction operation.
+ */
+export declare interface EdgeContractionResult {
+    /** Whether the contraction was successful */
+    success: boolean;
+    /** Reason for failure (if any) */
+    reason?: string;
+    /** The remaining vertex after contraction */
+    remainingVertex?: Vertex;
+    /** Faces that were removed */
+    removedFaces?: Face[];
+}
+
+/**
+ * Edge contraction operation handler.
+ */
+export declare class EdgeContractor {
+    private mesh;
+    constructor(mesh: NonManifoldMesh);
+    /**
+     * Contracts an edge.
+     */
+    contract(edge: Edge): EdgeContractionResult;
+    /**
+     * Checks if an edge can be contracted.
+     */
+    canContract(edge: Edge): boolean;
+    /**
+     * Contracts all edges shorter than a threshold.
+     */
+    contractShortEdges(minLength: number): {
+        contractCount: number;
+        removedVertices: number;
+    };
+    /**
+     * Checks if an edge should be contracted based on target length.
+     */
+    shouldContract(edge: Edge, targetLength: number, minRatio?: number): boolean;
+}
+
+/**
+ * Edge flip operation handler.
+ */
+export declare class EdgeFlipper {
+    private mesh;
+    constructor(mesh: NonManifoldMesh);
+    /**
+     * Flips an edge.
+     */
+    flip(edge: Edge): EdgeFlipResult;
+    /**
+     * Checks if an edge can be flipped.
+     */
+    canFlip(edge: Edge): boolean;
+    /**
+     * Checks if an edge satisfies the Delaunay condition.
+     */
+    isDelaunay(edge: Edge): boolean;
+    /**
+     * Makes the mesh Delaunay by flipping non-Delaunay edges.
+     */
+    makeDelaunay(maxIterations?: number): number;
+}
+
+/**
+ * Result of an edge flip operation.
+ */
+export declare interface EdgeFlipResult {
+    /** Whether the flip was successful */
+    success: boolean;
+    /** Reason for failure (if any) */
+    reason?: string;
+    /** The new edge length after flip */
+    newLength?: number;
+}
+
+/**
+ * Unique identifier for an edge in the mesh.
+ */
+export declare type EdgeId = number & {
+    readonly __brand: 'EdgeId';
+};
+
+/**
+ * Result of an edge split operation.
+ */
+export declare interface EdgeSplitResult {
+    /** Whether the split was successful */
+    success: boolean;
+    /** Reason for failure (if any) */
+    reason?: string;
+    /** The new vertex created at the midpoint */
+    newVertex?: Vertex;
+    /** The new edges created */
+    newEdges?: Edge[];
+    /** The new faces created */
+    newFaces?: Face[];
+}
+
+/**
+ * Edge split operation handler.
+ */
+export declare class EdgeSplitter {
+    private mesh;
+    constructor(mesh: NonManifoldMesh);
+    /**
+     * Splits an edge at the midpoint.
+     */
+    split(edge: Edge, ratio?: number): EdgeSplitResult;
+    /**
+     * Splits all edges longer than a threshold.
+     */
+    splitLongEdges(maxLength: number): {
+        splitCount: number;
+        newVertices: Vertex[];
+    };
+    /**
+     * Checks if an edge should be split based on target length.
+     */
+    shouldSplit(edge: Edge, targetLength: number, maxRatio?: number): boolean;
+}
+
+/**
+ * Classification of an edge based on its incident faces.
+ *
+ * - Manifold: Exactly 2 incident faces
+ * - NonManifold: More than 2 incident faces (seam edge)
+ * - Feature: User-defined feature edge that should be preserved
+ * - Boundary: Only 1 incident face (mesh boundary)
+ */
+export declare enum EdgeType {
+    /** Edge with exactly 2 incident faces - standard manifold edge */
+    Manifold = "manifold",
+    /** Edge with more than 2 incident faces - non-manifold seam */
+    NonManifold = "non_manifold",
+    /** User-defined feature edge that should be preserved */
+    Feature = "feature",
+    /** Edge with only 1 incident face - boundary edge */
+    Boundary = "boundary"
+}
+
+/**
+ * Exports a NonManifoldMesh to a Three.js BufferGeometry.
+ *
+ * @param mesh - The mesh to export
+ * @param options - Export options
+ * @returns The exported BufferGeometry
+ */
+export declare function exportBufferGeometry(mesh: NonManifoldMesh, options?: ExportOptions): BufferGeometry;
+
+/**
+ * Creates a colored mesh geometry for visualizing vertex classification.
+ *
+ * @param mesh - The mesh to visualize
+ * @returns BufferGeometry with vertex colors based on classification
+ */
+export declare function exportClassificationGeometry(mesh: NonManifoldMesh): BufferGeometry;
+
+/**
+ * Options for exporting a mesh to BufferGeometry.
+ */
+export declare interface ExportOptions {
+    /**
+     * Whether to compute vertex normals.
+     * @default true
+     */
+    computeNormals?: boolean;
+    /**
+     * Whether to use smooth (averaged) normals.
+     * If false, uses flat (per-face) normals.
+     * @default true
+     */
+    smoothNormals?: boolean;
+    /**
+     * Angle threshold (in radians) for smooth normals.
+     * Edges with angles greater than this will have split normals.
+     * @default Math.PI / 3 (60 degrees)
+     */
+    smoothAngle?: number;
+    /**
+     * Whether to include UV coordinates if available.
+     * @default false
+     */
+    includeUVs?: boolean;
+}
+
+/**
+ * Creates a mesh geometry with face colors based on triangle quality.
+ *
+ * @param mesh - The mesh to visualize
+ * @returns BufferGeometry with vertex colors representing quality
+ */
+export declare function exportQualityGeometry(mesh: NonManifoldMesh): BufferGeometry;
+
+/**
+ * Exports only skeleton edges as a LineSegments geometry.
+ *
+ * @param mesh - The mesh to export skeleton from
+ * @returns BufferGeometry suitable for THREE.LineSegments
+ */
+export declare function exportSkeletonGeometry(mesh: NonManifoldMesh): BufferGeometry;
+
+/**
+ * Represents a triangular face in the mesh.
+ * A face is defined by three halfedges forming a loop.
+ */
+export declare class Face {
+    /**
+     * Unique identifier for this face.
+     */
+    readonly id: FaceId;
+    /**
+     * One of the three halfedges bounding this face.
+     * The other two can be found by following next pointers.
+     */
+    halfedge: Halfedge;
+    /**
+     * Whether this face is marked (e.g., for selection or processing).
+     */
+    isMarked: boolean;
+    constructor(
+    /**
+     * Unique identifier for this face.
+     */
+    id: FaceId, 
+    /**
+     * One of the bounding halfedges.
+     */
+    halfedge: Halfedge);
+    /**
+     * Gets all three vertices of this face.
+     * Returns vertices in counter-clockwise order.
+     */
+    getVertices(): [Vertex, Vertex, Vertex] | null;
+    /**
+     * Gets all three halfedges of this face.
+     * Returns halfedges in counter-clockwise order.
+     */
+    getHalfedges(): [Halfedge, Halfedge, Halfedge] | null;
+    /**
+     * Iterates over the three halfedges of this face.
+     *
+     * @param callback - Function called for each halfedge
+     */
+    forEachHalfedge(callback: (halfedge: Halfedge) => void): void;
+    /**
+     * Iterates over the three vertices of this face.
+     *
+     * @param callback - Function called for each vertex
+     */
+    forEachVertex(callback: (vertex: Vertex) => void): void;
+    /**
+     * Computes the centroid (center of mass) of this face.
+     * Returns null if vertices cannot be retrieved.
+     */
+    getCentroid(): {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+    /**
+     * Computes the normal vector of this face.
+     * Uses the cross product of two edges.
+     * Returns null if vertices cannot be retrieved.
+     */
+    getNormal(): {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+    /**
+     * Computes the area of this face.
+     * Returns null if vertices cannot be retrieved.
+     */
+    getArea(): number | null;
+    /**
+     * Computes the quality of this triangle.
+     * Quality is measured as 2 * inradius / circumradius (ranges from 0 to 1).
+     * A value of 1 indicates an equilateral triangle.
+     * Returns null if vertices cannot be retrieved.
+     */
+    getQuality(): number | null;
+    /**
+     * Checks if this face contains a given vertex.
+     */
+    containsVertex(vertex: Vertex): boolean;
+    /**
+     * Gets the halfedge opposite to a given vertex.
+     * Returns null if the vertex is not part of this face.
+     */
+    getOppositeHalfedge(vertex: Vertex): Halfedge | null;
+    /**
+     * Checks if this face is degenerate (has zero or near-zero area).
+     */
+    isDegenerate(epsilon?: number): boolean;
+}
+
+/**
+ * Unique identifier for a face in the mesh.
+ */
+export declare type FaceId = number & {
+    readonly __brand: 'FaceId';
+};
+
+/**
+ * Configuration options for the adaptive remeshing algorithm.
+ */
+/**
+ * Feature edge specification as a pair of vertex indices.
+ */
+export declare type FeatureEdge = [number, number];
+
+/**
+ * Represents the feature skeleton of a mesh.
+ * The skeleton consists of non-manifold edges, boundary edges, and feature edges.
+ */
+export declare class FeatureSkeleton {
+    /** The mesh this skeleton belongs to */
+    readonly mesh: NonManifoldMesh;
+    /** All segments in the skeleton */
+    segments: Map<SegmentId, SkeletonSegment>;
+    /** All skeleton edges */
+    private skeletonEdges;
+    /** All branching vertices */
+    private branchingVertices;
+    /** All open-book vertices */
+    private openBookVertices;
+    /** Map from vertex to its segment (for open-book vertices) */
+    private vertexToSegment;
+    /** Whether the skeleton has been built */
+    private isBuilt;
+    constructor(mesh: NonManifoldMesh);
+    /**
+     * Builds the skeleton from the mesh.
+     */
+    build(): void;
+    /**
+     * Applies a build result to this skeleton.
+     */
+    private applyBuildResult;
+    /**
+     * Rebuilds the skeleton. Call after topology changes.
+     */
+    rebuild(): void;
+    /**
+     * Gets all segments.
+     */
+    getSegments(): SkeletonSegment[];
+    /**
+     * Gets a segment by ID.
+     */
+    getSegment(id: SegmentId): SkeletonSegment | undefined;
+    /**
+     * Gets the segment containing a vertex.
+     * Only works for open-book vertices.
+     */
+    getSegmentForVertex(vertex: Vertex): SkeletonSegment | undefined;
+    /**
+     * Gets all skeleton edges.
+     */
+    getSkeletonEdges(): Edge[];
+    /**
+     * Gets all branching vertices.
+     */
+    getBranchingVertices(): Vertex[];
+    /**
+     * Gets all open-book vertices.
+     */
+    getOpenBookVertices(): Vertex[];
+    /**
+     * Gets the number of segments.
+     */
+    get segmentCount(): number;
+    /**
+     * Gets the number of skeleton edges.
+     */
+    get skeletonEdgeCount(): number;
+    /**
+     * Gets the number of branching vertices.
+     */
+    get branchingVertexCount(): number;
+    /**
+     * Gets the number of open-book vertices.
+     */
+    get openBookVertexCount(): number;
+    /**
+     * Checks if the skeleton has been built.
+     */
+    get built(): boolean;
+    /**
+     * Projects a point onto the skeleton.
+     * Returns the closest point on any segment.
+     */
+    projectPoint(point: Vec3): {
+        point: Vec3;
+        segment: SkeletonSegment;
+        parameter: number;
+        distance: number;
+    } | null;
+    /**
+     * Checks if a vertex is on the skeleton.
+     */
+    isVertexOnSkeleton(vertex: Vertex): boolean;
+    /**
+     * Checks if an edge is on the skeleton.
+     */
+    isEdgeOnSkeleton(edge: Edge): boolean;
+    /**
+     * Gets all vertices on the skeleton.
+     */
+    getAllSkeletonVertices(): Vertex[];
+    /**
+     * Computes the total length of the skeleton.
+     */
+    getTotalLength(): number;
+    /**
+     * Gets statistics about the skeleton.
+     */
+    getStats(): {
+        segmentCount: number;
+        skeletonEdgeCount: number;
+        branchingVertexCount: number;
+        openBookVertexCount: number;
+        totalLength: number;
+        closedLoopCount: number;
+    };
+}
+
+/**
+ * Flips an edge in the mesh.
+ *
+ * Before flip (edge connects vA to vB):
+ *
+ *         vC
+ *        /|\
+ *       / | \
+ *      /  |  \
+ *     / f0|   \
+ *   vA----|----vB
+ *     \ f1|   /
+ *      \  |  /
+ *       \ | /
+ *        \|/
+ *        vD
+ *
+ * After flip (edge connects vC to vD):
+ *
+ *         vC
+ *        / \
+ *       / f0\
+ *      /     \
+ *     /       \
+ *   vA---------vB
+ *     \       /
+ *      \  f1 /
+ *       \   /
+ *        \ /
+ *        vD
+ */
+export declare function flipEdge(_mesh: NonManifoldMesh, edge: Edge): EdgeFlipResult;
+
+/**
+ * Converts a Three.js Vector3 to a Vec3 interface.
+ */
+export declare function fromVector3(v: Vector3): Vec3;
+
+/**
+ * Gets vertices with high valence (many incident edges).
+ */
+export declare function getHighValenceVertices(mesh: NonManifoldMesh, maxValence?: number): Vertex[];
+
+/**
+ * Gets edges that are too long (should be split).
+ */
+export declare function getLongEdges(mesh: NonManifoldMesh, targetLength: number, maxRatio?: number): Edge[];
+
+/**
+ * Gets vertices with low valence (few incident edges).
+ */
+export declare function getLowValenceVertices(mesh: NonManifoldMesh, minValence?: number): Vertex[];
+
+/**
+ * Gets all manifold vertices.
+ */
+export declare function getManifoldVertices(mesh: NonManifoldMesh): Vertex[];
+
+/**
+ * Gets all non-manifold vertices (open-book + branching + other).
+ */
+export declare function getNonManifoldVertices(mesh: NonManifoldMesh): Vertex[];
+
+/**
+ * Gets all open-book vertices.
+ */
+export declare function getOpenBookVertices(mesh: NonManifoldMesh): Vertex[];
+
+/**
+ * Gets faces with quality below a threshold.
+ */
+export declare function getPoorQualityFaces(mesh: NonManifoldMesh, threshold?: number): Face[];
+
+/**
+ * Gets edges that are too short (should be collapsed).
+ */
+export declare function getShortEdges(mesh: NonManifoldMesh, targetLength: number, minRatio?: number): Edge[];
+
+/**
+ * Gets all skeleton branching vertices.
+ */
+export declare function getSkeletonBranchingVertices(mesh: NonManifoldMesh): Vertex[];
+
+/**
+ * Gets all vertices of a specific type.
+ *
+ * @param mesh - The mesh to search
+ * @param type - The vertex type to find
+ * @returns Array of vertices matching the type
+ */
+export declare function getVerticesByType(mesh: NonManifoldMesh, type: VertexType): Vertex[];
+
+/**
+ * Represents a halfedge in the mesh.
+ * A halfedge is a directed edge from one vertex to another.
+ */
+export declare class Halfedge {
+    /**
+     * Unique identifier for this halfedge.
+     */
+    readonly id: HalfedgeId;
+    /**
+     * The vertex this halfedge points to (target vertex).
+     */
+    vertex: Vertex;
+    /**
+     * The opposite halfedge (same edge, opposite direction).
+     * For non-manifold edges, this points to one of potentially many twins.
+     */
+    twin: Halfedge | null;
+    /**
+     * The next halfedge in the face loop (counter-clockwise).
+     */
+    next: Halfedge | null;
+    /**
+     * The previous halfedge in the face loop.
+     */
+    prev: Halfedge | null;
+    /**
+     * The face this halfedge belongs to (null for boundary halfedges).
+     */
+    face: Face | null;
+    /**
+     * The parent undirected edge.
+     */
+    edge: Edge;
+    constructor(
+    /**
+     * Unique identifier for this halfedge.
+     */
+    id: HalfedgeId, 
+    /**
+     * The vertex this halfedge points to.
+     */
+    vertex: Vertex, 
+    /**
+     * The parent edge.
+     */
+    edge: Edge);
+    /**
+     * Gets the source vertex of this halfedge (the vertex it starts from).
+     * This is the target vertex of the twin halfedge.
+     */
+    getSourceVertex(): Vertex | null;
+    /**
+     * Gets the target vertex of this halfedge.
+     */
+    getTargetVertex(): Vertex;
+    /**
+     * Checks if this halfedge is on the boundary (has no face).
+     */
+    isBoundary(): boolean;
+    /**
+     * Gets the opposite halfedge in the same face (two edges away).
+     * For a triangle, this is the edge opposite to this halfedge's source vertex.
+     */
+    getOppositeHalfedge(): Halfedge | null;
+    /**
+     * Gets the vertex opposite to this halfedge in its face.
+     * For a triangle, this is the vertex not on this halfedge.
+     */
+    getOppositeVertex(): Vertex | null;
+    /**
+     * Computes the vector along this halfedge (from source to target).
+     * Returns null if source vertex is not available.
+     */
+    getVector(): {
+        x: number;
+        y: number;
+        z: number;
+    } | null;
+}
+
+/**
+ * Unique identifier for a halfedge in the mesh.
+ */
+export declare type HalfedgeId = number & {
+    readonly __brand: 'HalfedgeId';
+};
+
+/**
+ * Imports a Three.js BufferGeometry into a NonManifoldMesh.
+ *
+ * @param geometry - The input geometry
+ * @param options - Import options
+ * @returns The imported mesh
+ * @throws Error if geometry is invalid and validation is enabled
+ */
+export declare function importBufferGeometry(geometry: BufferGeometry, options?: ImportOptions): NonManifoldMesh;
+
+/**
+ * Options for importing a BufferGeometry.
+ */
+export declare interface ImportOptions {
+    /**
+     * User-defined feature edges to preserve.
+     * Each edge is specified as a pair of vertex indices.
+     */
+    featureEdges?: FeatureEdge[];
+    /**
+     * Whether to validate the geometry before importing.
+     * @default true
+     */
+    validate?: boolean;
+    /**
+     * Whether to merge duplicate vertices.
+     * @default false
+     */
+    mergeVertices?: boolean;
+    /**
+     * Tolerance for merging vertices.
+     * @default 1e-6
+     */
+    mergeTolerance?: number;
+}
+
+/**
+ * Checks if an edge satisfies the Delaunay condition.
+ * An edge is Delaunay if the sum of opposite angles is <= 180 degrees.
+ */
+export declare function isDelaunay(edge: Edge): boolean;
+
+/**
+ * Quick check if a geometry is manifold.
+ *
+ * @param geometry - The geometry to check
+ * @returns True if the geometry is manifold
+ */
+export declare function isManifold(geometry: BufferGeometry): boolean;
+
+/**
+ * Checks if a point lies inside a triangle (using barycentric coordinates).
+ */
+export declare function isPointInTriangle(point: Vec3, v0: Vec3, v1: Vec3, v2: Vec3): boolean;
+
+/**
+ * Determines if a vertex type has a fixed position.
+ */
+export declare function isPositionFixed(type: VertexType): boolean;
+
+/**
+ * Checks if the quadrilateral formed by two adjacent triangles is convex.
+ * Used to determine if an edge can be flipped.
+ *
+ * @param v0 - First vertex of the shared edge
+ * @param v1 - Second vertex of the shared edge
+ * @param v2 - Opposite vertex in first triangle
+ * @param v3 - Opposite vertex in second triangle
+ */
+export declare function isQuadConvex(v0: Vec3, v1: Vec3, v2: Vec3, v3: Vec3): boolean;
+
+/**
+ * Determines if a vertex type is constrained to a skeleton segment.
+ */
+export declare function isSkeletonConstrained(type: VertexType): boolean;
+
+/**
+ * Determines if an edge type is part of the feature skeleton.
+ */
+export declare function isSkeletonEdge(type: EdgeType): boolean;
+
+/**
+ * Quick check if mesh topology is valid.
+ */
+export declare function isTopologyValid(mesh: NonManifoldMesh): boolean;
+
+/**
+ * Computes the length of a vector.
+ */
+declare function length_2(v: Vec3): number;
+export { length_2 as length }
+
+/**
+ * Computes the squared length of a vector.
+ */
+export declare function lengthSquared(v: Vec3): number;
+
+/**
+ * Linearly interpolates between two vectors.
+ */
+export declare function lerp(a: Vec3, b: Vec3, t: number): Vec3;
+
+/**
+ * Performs Delaunay flips on the mesh.
+ * Returns the number of flips performed.
+ */
+export declare function makeDelaunay(mesh: NonManifoldMesh, maxIterations?: number): number;
+
+/**
+ * Result of manifold analysis.
+ */
+export declare interface ManifoldAnalysisResult {
+    /** Whether the mesh is manifold */
+    isManifold: boolean;
+    /** Whether the mesh has boundary edges */
+    hasBoundary: boolean;
+    /** Total number of vertices */
+    vertexCount: number;
+    /** Total number of edges */
+    edgeCount: number;
+    /** Total number of faces */
+    faceCount: number;
+    /** Number of manifold edges */
+    manifoldEdgeCount: number;
+    /** Number of non-manifold edges */
+    nonManifoldEdgeCount: number;
+    /** Number of boundary edges */
+    boundaryEdgeCount: number;
+    /** Number of manifold vertices */
+    manifoldVertexCount: number;
+    /** Number of non-manifold vertices */
+    nonManifoldVertexCount: number;
+    /** Detailed info about non-manifold edges */
+    nonManifoldEdges: NonManifoldEdgeInfo[];
+    /** Detailed info about non-manifold vertices */
+    nonManifoldVertices: NonManifoldVertexInfo[];
+    /** Euler characteristic (V - E + F) */
+    eulerCharacteristic: number;
+    /** Average vertex degree */
+    averageVertexDegree: number;
+}
+
+/**
+ * Class for analyzing mesh manifoldness with caching.
+ */
+export declare class ManifoldAnalyzer {
+    private mesh;
+    private cachedResult;
+    /**
+     * Loads a geometry for analysis.
+     */
+    load(geometry: BufferGeometry): this;
+    /**
+     * Loads an existing mesh for analysis.
+     */
+    loadMesh(mesh: NonManifoldMesh): this;
+    /**
+     * Gets the analysis result (cached).
+     */
+    analyze(): ManifoldAnalysisResult;
+    /**
+     * Checks if the mesh is manifold.
+     */
+    isManifold(): boolean;
+    /**
+     * Checks if the mesh has boundary.
+     */
+    hasBoundary(): boolean;
+    /**
+     * Gets non-manifold edges.
+     */
+    getNonManifoldEdges(): NonManifoldEdgeInfo[];
+    /**
+     * Gets non-manifold vertices.
+     */
+    getNonManifoldVertices(): NonManifoldVertexInfo[];
+    /**
+     * Gets the underlying mesh.
+     */
+    getMesh(): NonManifoldMesh | null;
+    /**
+     * Clears cached results.
+     */
+    clearCache(): this;
+}
+
+/**
+ * Quality statistics for a mesh.
+ */
+export declare interface MeshQualityStats {
+    /** Minimum triangle quality (0 to 1) */
+    minQuality: number;
+    /** Maximum triangle quality (0 to 1) */
+    maxQuality: number;
+    /** Average triangle quality (0 to 1) */
+    averageQuality: number;
+    /** Standard deviation of triangle quality */
+    stdDevQuality: number;
+    /** Number of triangles with quality below threshold */
+    poorQualityCount: number;
+    /** Minimum edge length */
+    minEdgeLength: number;
+    /** Maximum edge length */
+    maxEdgeLength: number;
+    /** Average edge length */
+    averageEdgeLength: number;
+    /** Minimum triangle area */
+    minArea: number;
+    /** Maximum triangle area */
+    maxArea: number;
+    /** Total surface area */
+    totalArea: number;
+}
+
+/**
+ * Computes the midpoint between two points.
+ */
+export declare function midpoint(a: Vec3, b: Vec3): Vec3;
+
+/**
+ * Information about a non-manifold edge.
+ */
+export declare interface NonManifoldEdgeInfo {
+    /** Index of the edge */
+    edgeId: number;
+    /** Indices of the two vertices */
+    vertexIndices: [number, number];
+    /** Number of incident faces */
+    faceCount: number;
+    /** Positions of the edge endpoints */
+    positions: [{
+        x: number;
+        y: number;
+        z: number;
+    }, {
+        x: number;
+        y: number;
+        z: number;
+    }];
+}
+
+/**
+ * Represents a non-manifold mesh using an extended halfedge data structure.
+ * Supports edges with more than 2 incident faces (non-manifold seams).
+ */
+export declare class NonManifoldMesh {
+    vertices: Map<VertexId, Vertex>;
+    edges: Map<EdgeId, Edge>;
+    halfedges: Map<HalfedgeId, Halfedge>;
+    faces: Map<FaceId, Face>;
+    private nextVertexId;
+    private nextEdgeId;
+    private nextHalfedgeId;
+    private nextFaceId;
+    /** Map from vertex pair key to edge for fast lookup */
+    private edgeMap;
+    /**
+     * Creates a non-manifold mesh from a Three.js BufferGeometry.
+     *
+     * @param geometry - The input geometry (must be indexed triangles)
+     * @param featureEdges - Optional user-defined feature edges to preserve
+     */
+    static fromBufferGeometry(geometry: BufferGeometry, featureEdges?: FeatureEdge[]): NonManifoldMesh;
+    /**
+     * Gets or creates an edge between two vertices.
+     */
+    private getOrCreateEdge;
+    /**
+     * Creates a canonical key for an edge between two vertices.
+     */
+    private makeEdgeKey;
+    /**
+     * Sets up twin halfedge relationships.
+     * For non-manifold edges (>2 halfedges), creates a circular twin chain.
+     */
+    private setupTwinHalfedges;
+    /**
+     * Sets up twin relationships for non-manifold edges.
+     * Groups halfedges by direction and pairs them appropriately.
+     */
+    private setupNonManifoldTwins;
+    /**
+     * Marks user-defined feature edges.
+     */
+    markFeatureEdges(featureEdges: FeatureEdge[]): void;
+    /**
+     * Classifies all vertices based on their neighborhood topology.
+     */
+    classifyVertices(): void;
+    /**
+     * Classifies a single vertex based on its neighborhood.
+     */
+    private classifyVertex;
+    /**
+     * Exports the mesh to a Three.js BufferGeometry.
+     */
+    toBufferGeometry(): BufferGeometry;
+    /**
+     * Gets all vertices in the mesh.
+     */
+    getVertices(): Vertex[];
+    /**
+     * Gets all edges in the mesh.
+     */
+    getEdges(): Edge[];
+    /**
+     * Gets all faces in the mesh.
+     */
+    getFaces(): Face[];
+    /**
+     * Gets all halfedges in the mesh.
+     */
+    getHalfedges(): Halfedge[];
+    /**
+     * Gets the vertex count.
+     */
+    get vertexCount(): number;
+    /**
+     * Gets the edge count.
+     */
+    get edgeCount(): number;
+    /**
+     * Gets the face count.
+     */
+    get faceCount(): number;
+    /**
+     * Gets the halfedge count.
+     */
+    get halfedgeCount(): number;
+    /**
+     * Gets all non-manifold edges.
+     */
+    getNonManifoldEdges(): Edge[];
+    /**
+     * Gets all boundary edges.
+     */
+    getBoundaryEdges(): Edge[];
+    /**
+     * Gets all feature edges.
+     */
+    getFeatureEdges(): Edge[];
+    /**
+     * Gets all skeleton edges (non-manifold + boundary + feature).
+     */
+    getSkeletonEdges(): Edge[];
+    /**
+     * Checks if the mesh is manifold (no non-manifold edges).
+     */
+    isManifold(): boolean;
+    /**
+     * Checks if the mesh has boundaries.
+     */
+    hasBoundary(): boolean;
+    /**
+     * Gets a vertex by ID.
+     */
+    getVertex(id: VertexId): Vertex | undefined;
+    /**
+     * Gets an edge by ID.
+     */
+    getEdge(id: EdgeId): Edge | undefined;
+    /**
+     * Gets a face by ID.
+     */
+    getFace(id: FaceId): Face | undefined;
+    /**
+     * Gets a halfedge by ID.
+     */
+    getHalfedge(id: HalfedgeId): Halfedge | undefined;
+    /**
+     * Gets the edge between two vertices (if it exists).
+     */
+    getEdgeBetween(v0: Vertex, v1: Vertex): Edge | undefined;
+    /**
+     * Creates a new vertex and adds it to the mesh.
+     */
+    createVertex(position: Vector3): Vertex;
+    /**
+     * Creates a new face from three vertices.
+     * Also creates the necessary halfedges and edges.
+     */
+    createFace(v0: Vertex, v1: Vertex, v2: Vertex): Face;
+    /**
+     * Computes mesh statistics.
+     */
+    getStats(): {
+        vertexCount: number;
+        edgeCount: number;
+        faceCount: number;
+        nonManifoldEdgeCount: number;
+        boundaryEdgeCount: number;
+        featureEdgeCount: number;
+        eulerCharacteristic: number;
+    };
+}
+
+/**
+ * Information about a non-manifold vertex.
+ */
+export declare interface NonManifoldVertexInfo {
+    /** Index of the vertex */
+    vertexId: number;
+    /** Position of the vertex */
+    position: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** Classification type */
+    type: VertexType;
+    /** Number of incident skeleton edges */
+    skeletonEdgeCount: number;
+}
+
+/**
+ * Normalizes a vector to unit length.
+ * Returns a zero vector if the input has zero length.
+ */
+export declare function normalize(v: Vec3): Vec3;
+
+/**
+ * Projects a point onto a line defined by two points.
+ * Returns the closest point on the line to the given point.
+ */
+export declare function projectPointOnLine(point: Vec3, lineStart: Vec3, lineEnd: Vec3): Vec3;
+
+/**
+ * Projects a point onto a line segment defined by two endpoints.
+ * Returns the closest point on the segment to the given point.
+ */
+export declare function projectPointOnSegment(point: Vec3, segStart: Vec3, segEnd: Vec3): Vec3;
+
+/**
+ * Quality metrics utility class.
+ */
+export declare class QualityMetrics {
+    private mesh;
+    constructor(mesh: NonManifoldMesh);
+    /**
+     * Computes overall mesh quality statistics.
+     */
+    computeStats(poorQualityThreshold?: number): MeshQualityStats;
+    /**
+     * Gets poor quality faces.
+     */
+    getPoorQualityFaces(threshold?: number): Face[];
+    /**
+     * Gets long edges that should be split.
+     */
+    getLongEdges(targetLength: number, maxRatio?: number): Edge[];
+    /**
+     * Gets short edges that should be collapsed.
+     */
+    getShortEdges(targetLength: number, minRatio?: number): Edge[];
+    /**
+     * Computes target edge length.
+     */
+    computeTargetEdgeLength(numTargetVertices?: number): number;
+    /**
+     * Gets high valence vertices.
+     */
+    getHighValenceVertices(maxValence?: number): Vertex[];
+    /**
+     * Gets low valence vertices.
+     */
+    getLowValenceVertices(minValence?: number): Vertex[];
+}
+
+/**
+ * Reclassifies all vertices in a mesh.
+ * Call this after topology changes.
+ */
+export declare function reclassifyVertices(mesh: NonManifoldMesh): void;
+
+/**
+ * Relocates a vertex to a target position, respecting constraints.
+ */
+export declare function relocateVertex(_mesh: NonManifoldMesh, vertex: Vertex, targetPosition: Vec3, constraints?: SkeletonConstraints): VertexRelocationResult;
+
+/**
+ * Simple function to remesh a BufferGeometry.
+ */
+export declare function remesh(geometry: BufferGeometry, options?: RemeshOptions): {
+    geometry: BufferGeometry;
+    stats: RemeshStats;
+};
+
+/**
+ * State during remeshing iteration.
+ */
+declare interface RemeshingState {
+    iteration: number;
+    edgeSplits: number;
+    edgeContractions: number;
+    edgeFlips: number;
+    vertexRelocations: number;
+    quality: MeshQualityStats;
+}
+
+/**
+ * Options for the adaptive remeshing algorithm.
+ */
+export declare interface RemeshOptions {
+    /**
+     * Number of remeshing iterations to perform.
+     * More iterations generally produce higher quality results.
+     * @default 5
+     */
+    iterations?: number;
+    /**
+     * Target edge length for the remeshed surface.
+     * If not specified, computed automatically based on mesh bounding box.
+     */
+    targetEdgeLength?: number;
+    /**
+     * User-defined feature edges that should be preserved.
+     * Each edge is specified as a pair of vertex indices from the input geometry.
+     * These edges will be included in the feature skeleton.
+     */
+    featureEdges?: FeatureEdge[];
+    /**
+     * Whether to preserve boundary edges.
+     * When true, boundary edges are included in the skeleton and preserved.
+     * @default true
+     */
+    preserveBoundary?: boolean;
+    /**
+     * Minimum allowed edge length as a fraction of targetEdgeLength.
+     * Edges shorter than this will be collapsed.
+     * @default 0.4
+     */
+    minEdgeLengthRatio?: number;
+    /**
+     * Maximum allowed edge length as a fraction of targetEdgeLength.
+     * Edges longer than this will be split.
+     * @default 1.333
+     */
+    maxEdgeLengthRatio?: number;
+    /**
+     * Minimum allowed triangle quality (0 to 1).
+     * Triangles with quality below this threshold are prioritized for improvement.
+     * Quality is measured as the ratio of inscribed to circumscribed circle radii.
+     * @default 0.3
+     */
+    minTriangleQuality?: number;
+    /**
+     * Maximum angle deviation from original surface (in radians).
+     * Vertices are not relocated if it would cause normals to deviate more than this.
+     * @default Math.PI / 6 (30 degrees)
+     */
+    maxNormalDeviation?: number;
+    /**
+     * Use spatial acceleration structures for large meshes.
+     * Recommended for meshes with more than 50K triangles.
+     * @default true
+     */
+    useAcceleration?: boolean;
+    /**
+     * Process mesh in chunks of this size.
+     * Set to 0 to disable chunking.
+     * Useful for very large meshes to manage memory usage.
+     * @default 0
+     */
+    chunkSize?: number;
+    /**
+     * Maximum memory budget in MB.
+     * Set to 0 for unlimited.
+     * When exceeded, algorithm will attempt to reduce memory usage.
+     * @default 0
+     */
+    memoryBudget?: number;
+    /**
+     * Enable verbose logging during remeshing.
+     * @default false
+     */
+    verbose?: boolean;
+}
+
+/**
+ * Result of the remeshing operation.
+ */
+export declare interface RemeshResult {
+    /** Statistics about the remeshing operation */
+    stats: RemeshStats;
+}
+
+/**
+ * Statistics returned after remeshing completes.
+ */
+export declare interface RemeshStats {
+    /** Number of vertices in the input mesh */
+    inputVertices: number;
+    /** Number of faces in the input mesh */
+    inputFaces: number;
+    /** Number of vertices in the output mesh */
+    outputVertices: number;
+    /** Number of faces in the output mesh */
+    outputFaces: number;
+    /** Number of iterations performed */
+    iterations: number;
+    /** Final average triangle quality (0 to 1) */
+    finalQuality: number;
+    /** Number of non-manifold edges detected */
+    nonManifoldEdges: number;
+    /** Number of skeleton edges (non-manifold + feature + boundary) */
+    skeletonEdges: number;
+    /** Number of edge flips performed */
+    edgeFlips: number;
+    /** Number of edge splits performed */
+    edgeSplits: number;
+    /** Number of edge contractions performed */
+    edgeContractions: number;
+    /** Number of vertex relocations performed */
+    vertexRelocations: number;
+    /** Total processing time in milliseconds */
+    processingTimeMs: number;
+}
+
+/**
+ * Multiplies a vector by a scalar.
+ */
+export declare function scale(v: Vec3, s: number): Vec3;
+
+/**
+ * Unique identifier for a skeleton segment.
+ */
+export declare type SegmentId = number & {
+    readonly __brand: 'SegmentId';
+};
+
+/**
+ * Builds the feature skeleton from a mesh.
+ * The skeleton consists of non-manifold edges, boundary edges, and feature edges.
+ */
+export declare class SkeletonBuilder {
+    private mesh;
+    private nextSegmentId;
+    constructor(mesh: NonManifoldMesh);
+    /**
+     * Builds the skeleton and returns the result.
+     */
+    build(): SkeletonBuildResult;
+    /**
+     * Builds segments from skeleton edges.
+     * A segment is a path between two branching vertices.
+     */
+    private buildSegments;
+    /**
+     * Gets skeleton edges incident to a vertex.
+     */
+    private getIncidentSkeletonEdges;
+    /**
+     * Traces a segment from a starting vertex and edge.
+     */
+    private traceSegment;
+    /**
+     * Traces a closed loop starting from an edge.
+     */
+    private traceClosedLoop;
+    /**
+     * Gets the next skeleton edge from a vertex, excluding the current edge.
+     */
+    private getNextSkeletonEdge;
+    /**
+     * Creates a new segment ID.
+     */
+    private createSegmentId;
+}
+
+/**
+ * Result of skeleton building.
+ */
+export declare interface SkeletonBuildResult {
+    /** All segments in the skeleton */
+    segments: SkeletonSegment[];
+    /** All skeleton edges */
+    skeletonEdges: Edge[];
+    /** All branching vertices (endpoints of segments) */
+    branchingVertices: Vertex[];
+    /** All open-book vertices (interior of segments) */
+    openBookVertices: Vertex[];
+}
+
+/**
+ * Determines movement constraints for vertices based on their type.
+ */
+export declare class SkeletonConstraints {
+    private skeleton;
+    constructor(skeleton: FeatureSkeleton);
+    /**
+     * Constrains a target position based on vertex type.
+     *
+     * - Manifold vertices: Can move freely (no constraint)
+     * - Open-book vertices: Constrained to their skeleton segment
+     * - Branching vertices: Fixed (cannot move)
+     *
+     * @param vertex - The vertex to constrain
+     * @param targetPosition - The desired target position
+     * @returns The constrained position
+     */
+    constrainPosition(vertex: Vertex, targetPosition: Vec3): ConstrainedPosition;
+    /**
+     * Constrains a position to a skeleton segment.
+     */
+    private constrainToSegment;
+    /**
+     * Checks if a vertex can move freely.
+     */
+    canMoveFreely(vertex: Vertex): boolean;
+    /**
+     * Checks if a vertex is fixed (cannot move).
+     */
+    isFixed(vertex: Vertex): boolean;
+    /**
+     * Checks if a vertex is constrained to a segment.
+     */
+    isConstrainedToSegment(vertex: Vertex): boolean;
+    /**
+     * Gets the segment a vertex is constrained to.
+     */
+    getConstraintSegment(vertex: Vertex): SkeletonSegment | undefined;
+    /**
+     * Computes the allowed movement direction for a vertex.
+     * For open-book vertices, this is the tangent direction of the segment.
+     */
+    getAllowedDirection(vertex: Vertex): Vec3 | null;
+}
+
+/**
+ * Represents a segment of the feature skeleton.
+ * A segment is a path of skeleton edges between two branching vertices.
+ */
+export declare class SkeletonSegment {
+    /**
+     * Unique identifier for this segment.
+     */
+    readonly id: SegmentId;
+    /**
+     * Vertices along this segment, in order from start to end.
+     * Includes the endpoint branching vertices.
+     */
+    vertices: Vertex[];
+    /**
+     * Edges along this segment, in order.
+     */
+    edges: Edge[];
+    /**
+     * Whether this segment forms a closed loop.
+     */
+    isClosed: boolean;
+    /**
+     * Total arc length of this segment.
+     */
+    private _totalLength;
+    /**
+     * Cumulative lengths at each vertex (for parameterization).
+     */
+    private _cumulativeLengths;
+    constructor(
+    /**
+     * Unique identifier for this segment.
+     */
+    id: SegmentId);
+    /**
+     * Gets the start vertex of this segment.
+     */
+    get startVertex(): Vertex | undefined;
+    /**
+     * Gets the end vertex of this segment.
+     */
+    get endVertex(): Vertex | undefined;
+    /**
+     * Gets the total arc length of this segment.
+     */
+    get totalLength(): number;
+    /**
+     * Gets the number of vertices in this segment.
+     */
+    get vertexCount(): number;
+    /**
+     * Gets the number of edges in this segment.
+     */
+    get edgeCount(): number;
+    /**
+     * Adds a vertex to the end of the segment.
+     */
+    addVertex(vertex: Vertex): void;
+    /**
+     * Adds an edge to the segment.
+     */
+    addEdge(edge: Edge): void;
+    /**
+     * Recomputes the total length and cumulative lengths.
+     */
+    recomputeLengths(): void;
+    /**
+     * Gets the parameter t (0 to 1) for a vertex index.
+     */
+    getParameterAtVertex(index: number): number;
+    /**
+     * Gets the position at a parameter t along the segment.
+     *
+     * @param t - Parameter from 0 (start) to 1 (end)
+     * @returns The interpolated position
+     */
+    getPositionAt(t: number): Vec3 | null;
+    /**
+     * Projects a point onto this segment.
+     * Returns the closest point on the segment and its parameter.
+     */
+    projectPoint(point: Vec3): {
+        point: Vec3;
+        parameter: number;
+        distance: number;
+    } | null;
+    /**
+     * Gets the vertex at a specific index.
+     */
+    getVertex(index: number): Vertex | undefined;
+    /**
+     * Gets the edge at a specific index.
+     */
+    getEdge(index: number): Edge | undefined;
+    /**
+     * Checks if a vertex is part of this segment.
+     */
+    containsVertex(vertex: Vertex): boolean;
+    /**
+     * Checks if an edge is part of this segment.
+     */
+    containsEdge(edge: Edge): boolean;
+    /**
+     * Gets the index of a vertex in this segment.
+     */
+    indexOfVertex(vertex: Vertex): number;
+    /**
+     * Iterates over vertices in this segment.
+     */
+    forEachVertex(callback: (vertex: Vertex, index: number) => void): void;
+    /**
+     * Iterates over edges in this segment.
+     */
+    forEachEdge(callback: (edge: Edge, index: number) => void): void;
+    /**
+     * Creates a copy of this segment.
+     */
+    clone(newId: SegmentId): SkeletonSegment;
+}
+
+/**
+ * Applies tangential smoothing to all relocatable vertices.
+ */
+export declare function smoothAllVertices(mesh: NonManifoldMesh, constraints?: SkeletonConstraints, dampingFactor?: number): {
+    smoothedCount: number;
+    totalDistance: number;
+};
+
+/**
+ * Applies tangential smoothing to a vertex.
+ */
+export declare function smoothVertex(mesh: NonManifoldMesh, vertex: Vertex, constraints?: SkeletonConstraints, dampingFactor?: number): VertexRelocationResult;
+
+/**
+ * A spatial hash grid for fast neighbor queries.
+ * Uses a 3D hash grid to accelerate proximity searches.
+ *
+ * @template T - The type of items stored in the hash
+ */
+export declare class SpatialHash<T> {
+    private cells;
+    private cellSize;
+    private itemPositions;
+    /**
+     * Creates a new spatial hash with the specified cell size.
+     *
+     * @param cellSize - The size of each cell in the grid
+     */
+    constructor(cellSize: number);
+    /**
+     * Computes the cell key for a position.
+     */
+    private getCellKey;
+    /**
+     * Computes the cell indices for a position.
+     */
+    private getCellIndices;
+    /**
+     * Inserts an item at the specified position.
+     *
+     * @param item - The item to insert
+     * @param position - The 3D position of the item
+     */
+    insert(item: T, position: Vec3): void;
+    /**
+     * Removes an item from the hash.
+     *
+     * @param item - The item to remove
+     * @returns True if the item was found and removed
+     */
+    remove(item: T): boolean;
+    /**
+     * Updates an item's position in the hash.
+     *
+     * @param item - The item to update
+     * @param newPosition - The new position
+     */
+    update(item: T, newPosition: Vec3): void;
+    /**
+     * Queries all items within a radius of a point.
+     *
+     * @param center - The center point of the query
+     * @param radius - The search radius
+     * @returns Array of items within the radius
+     */
+    queryRadius(center: Vec3, radius: number): T[];
+    /**
+     * Queries the k nearest neighbors to a point.
+     *
+     * @param center - The center point of the query
+     * @param k - The number of neighbors to find
+     * @param maxRadius - Optional maximum search radius
+     * @returns Array of the k nearest items, sorted by distance
+     */
+    queryKNearest(center: Vec3, k: number, maxRadius?: number): T[];
+    /**
+     * Clears all items from the hash.
+     */
+    clear(): void;
+    /**
+     * Gets the number of items in the hash.
+     */
+    get size(): number;
+    /**
+     * Gets the number of non-empty cells.
+     */
+    get cellCount(): number;
+    /**
+     * Gets the position of an item.
+     */
+    getPosition(item: T): Vec3 | undefined;
+    /**
+     * Checks if an item is in the hash.
+     */
+    has(item: T): boolean;
+    /**
+     * Iterates over all items in the hash.
+     */
+    [Symbol.iterator](): Iterator<T>;
+    /**
+     * Gets all items in the hash.
+     */
+    getAll(): T[];
+}
+
+/**
+ * Splits an edge at its midpoint.
+ *
+ * Before split:
+ *        vC
+ *       /|\
+ *      / | \
+ *     /  |  \
+ *    / f0|   \
+ *   vA---e---vB
+ *    \ f1|   /
+ *     \  |  /
+ *      \ | /
+ *       \|/
+ *        vD
+ *
+ * After split (new vertex vM at midpoint):
+ *        vC
+ *       /|\
+ *      / | \
+ *     /  |  \
+ *    / f0|f2 \
+ *   vA--vM---vB
+ *    \ f1|f3 /
+ *     \  |  /
+ *      \ | /
+ *       \|/
+ *        vD
+ */
+export declare function splitEdge(mesh: NonManifoldMesh, edge: Edge, splitRatio?: number): EdgeSplitResult;
+
+/**
+ * Splits all edges longer than a threshold.
+ */
+export declare function splitLongEdges(mesh: NonManifoldMesh, maxLength: number): {
+    splitCount: number;
+    newVertices: Vertex[];
+};
+
+/**
+ * Subtracts vector b from vector a.
+ */
+export declare function subtract(a: Vec3, b: Vec3): Vec3;
+
+/**
+ * Extracts the numeric value from a branded ID.
+ */
+export declare function toNumber(id: VertexId | EdgeId | HalfedgeId | FaceId | SegmentId): number;
+
+/**
+ * Result of topology validation.
+ */
+export declare interface TopologyValidationResult {
+    /** Whether the mesh topology is valid */
+    isValid: boolean;
+    /** List of errors found */
+    errors: ValidationError[];
+    /** List of warnings */
+    warnings: ValidationError[];
+}
+
+/**
+ * Class for topology validation.
+ */
+export declare class TopologyValidator {
+    private mesh;
+    constructor(mesh: NonManifoldMesh);
+    /**
+     * Validates the mesh topology.
+     */
+    validate(): TopologyValidationResult;
+    /**
+     * Quick check if topology is valid.
+     */
+    isValid(): boolean;
+    /**
+     * Gets all errors.
+     */
+    getErrors(): ValidationError[];
+    /**
+     * Gets all warnings.
+     */
+    getWarnings(): ValidationError[];
+}
+
+/**
+ * A triangle primitive for BVH.
+ */
+export declare interface Triangle {
+    v0: Vec3;
+    v1: Vec3;
+    v2: Vec3;
+    data?: unknown;
+}
+
+/**
+ * Computes the area of a triangle given three vertices.
+ */
+export declare function triangleArea(v0: Vec3, v1: Vec3, v2: Vec3): number;
+
+/**
+ * Computes the centroid of a triangle.
+ */
+export declare function triangleCentroid(v0: Vec3, v1: Vec3, v2: Vec3): Vec3;
+
+/**
+ * Computes the circumcenter of a triangle.
+ * Returns the center of the circumscribed circle.
+ */
+export declare function triangleCircumcenter(v0: Vec3, v1: Vec3, v2: Vec3): Vec3 | null;
+
+/**
+ * Computes the circumradius of a triangle.
+ */
+export declare function triangleCircumradius(v0: Vec3, v1: Vec3, v2: Vec3): number | null;
+
+/**
+ * Computes the inradius of a triangle.
+ */
+export declare function triangleInradius(v0: Vec3, v1: Vec3, v2: Vec3): number | null;
+
+/**
+ * Computes the normal of a triangle given three vertices.
+ * Returns a normalized vector perpendicular to the triangle.
+ */
+export declare function triangleNormal(v0: Vec3, v1: Vec3, v2: Vec3): Vec3;
+
+/**
+ * Computes the quality of a triangle (2 * inradius / circumradius).
+ * Returns a value between 0 and 1, where 1 is an equilateral triangle.
+ */
+export declare function triangleQuality(v0: Vec3, v1: Vec3, v2: Vec3): number;
+
+/**
+ * Validates a BufferGeometry for import.
+ *
+ * @param geometry - The geometry to validate
+ * @returns Validation result with errors and warnings
+ */
+export declare function validateGeometry(geometry: BufferGeometry): ValidationResult;
+
+/**
+ * Validates the topology of a mesh.
+ *
+ * @param mesh - The mesh to validate
+ * @returns Validation result
+ */
+export declare function validateTopology(mesh: NonManifoldMesh): TopologyValidationResult;
+
+/**
+ * A validation error.
+ */
+export declare interface ValidationError {
+    /** Type of the error */
+    type: string;
+    /** Human-readable message */
+    message: string;
+    /** Related element IDs */
+    elementIds?: number[];
+}
+
+/**
+ * Result of geometry validation.
+ */
+export declare interface ValidationResult {
+    /** Whether the geometry is valid */
+    isValid: boolean;
+    /** List of validation errors */
+    errors: string[];
+    /** List of validation warnings */
+    warnings: string[];
+}
+
+/**
+ * A simple 3D vector interface for internal computations.
+ */
+export declare interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+
+/**
+ * Represents a vertex in the mesh.
+ * Stores position, classification, and a reference to one outgoing halfedge.
+ */
+export declare class Vertex {
+    /**
+     * Unique identifier for this vertex.
+     */
+    readonly id: VertexId;
+    /**
+     * 3D position of this vertex.
+     */
+    readonly position: Vector3;
+    /**
+     * One outgoing halfedge from this vertex.
+     * All outgoing halfedges can be found by following next/twin pointers.
+     */
+    halfedge: Halfedge | null;
+    /**
+     * Classification of this vertex based on neighborhood topology.
+     * Determines movement constraints during remeshing.
+     */
+    type: VertexType;
+    /**
+     * Whether this vertex is marked (e.g., for selection or processing).
+     */
+    isMarked: boolean;
+    constructor(
+    /**
+     * Unique identifier for this vertex.
+     */
+    id: VertexId, 
+    /**
+     * 3D position of this vertex.
+     */
+    position: Vector3);
+    /**
+     * Gets the degree of this vertex (number of incident edges).
+     * Returns null if the vertex has no incident halfedge.
+     */
+    degree(): number | null;
+    /**
+     * Iterates over all outgoing halfedges from this vertex.
+     *
+     * @param callback - Function called for each outgoing halfedge
+     */
+    forEachOutgoingHalfedge(callback: (halfedge: Halfedge) => void): void;
+    /**
+     * Collects all outgoing halfedges from this vertex into an array.
+     *
+     * @returns Array of outgoing halfedges
+     */
+    getOutgoingHalfedges(): Halfedge[];
+    /**
+     * Iterates over all neighboring vertices.
+     *
+     * @param callback - Function called for each neighboring vertex
+     */
+    forEachNeighbor(callback: (vertex: Vertex) => void): void;
+    /**
+     * Collects all neighboring vertices into an array.
+     *
+     * @returns Array of neighboring vertices
+     */
+    getNeighbors(): Vertex[];
+    /**
+     * Checks if this vertex is on the boundary of the mesh.
+     * A vertex is on the boundary if any of its incident halfedges has no face.
+     */
+    isBoundary(): boolean;
+    /**
+     * Checks if this vertex can move freely during remeshing.
+     * Only manifold vertices can move freely in 3D space.
+     */
+    canMoveFreely(): boolean;
+    /**
+     * Checks if this vertex is constrained to a skeleton segment.
+     * OpenBook vertices can only move along their skeleton segment.
+     */
+    isSkeletonConstrained(): boolean;
+    /**
+     * Checks if this vertex has a fixed position.
+     * Branching and other non-manifold vertices cannot move.
+     */
+    isPositionFixed(): boolean;
+    /**
+     * Checks if this vertex is part of the feature skeleton.
+     */
+    isOnSkeleton(): boolean;
+}
+
+/**
+ * Class for vertex classification operations.
+ */
+export declare class VertexClassifier {
+    private mesh;
+    constructor(mesh: NonManifoldMesh);
+    /**
+     * Classifies all vertices and returns statistics.
+     */
+    classifyAll(): ClassificationStats;
+    /**
+     * Gets vertices of a specific type.
+     */
+    getByType(type: VertexType): Vertex[];
+    /**
+     * Gets all manifold vertices.
+     */
+    getManifold(): Vertex[];
+    /**
+     * Gets all non-manifold vertices.
+     */
+    getNonManifold(): Vertex[];
+    /**
+     * Reclassifies all vertices.
+     */
+    reclassify(): void;
+}
+
+/**
+ * Branded types for mesh elements to ensure type safety.
+ * These prevent accidentally mixing up different ID types.
+ */
+/**
+ * Unique identifier for a vertex in the mesh.
+ */
+export declare type VertexId = number & {
+    readonly __brand: 'VertexId';
+};
+
+/**
+ * Result of a vertex relocation operation.
+ */
+export declare interface VertexRelocationResult {
+    /** Whether the relocation was successful */
+    success: boolean;
+    /** Reason for failure (if any) */
+    reason?: string;
+    /** The new position */
+    newPosition?: Vec3;
+    /** Whether the position was constrained */
+    wasConstrained?: boolean;
+    /** Distance moved */
+    distanceMoved?: number;
+}
+
+/**
+ * Vertex relocation operation handler.
+ */
+export declare class VertexRelocator {
+    private mesh;
+    private constraints;
+    constructor(mesh: NonManifoldMesh, constraints?: SkeletonConstraints);
+    /**
+     * Sets the skeleton constraints.
+     */
+    setConstraints(constraints: SkeletonConstraints): void;
+    /**
+     * Relocates a vertex to a target position.
+     */
+    relocate(vertex: Vertex, targetPosition: Vec3): VertexRelocationResult;
+    /**
+     * Applies tangential smoothing to a vertex.
+     */
+    smooth(vertex: Vertex, dampingFactor?: number): VertexRelocationResult;
+    /**
+     * Applies tangential smoothing to all relocatable vertices.
+     */
+    smoothAll(dampingFactor?: number): {
+        smoothedCount: number;
+        totalDistance: number;
+    };
+    /**
+     * Checks if a vertex can be relocated.
+     */
+    canRelocate(vertex: Vertex): boolean;
+}
+
+/**
+ * Classification types for vertices and edges in non-manifold meshes.
+ * Based on the EUROGRAPHICS 2008 paper "Adaptive Remeshing of Non-Manifold Surfaces".
+ */
+/**
+ * Classification of a vertex based on its neighborhood topology.
+ *
+ * - Manifold: Star homeomorphic to disk, can move freely in 3D
+ * - OpenBook: On exactly 2 skeleton edges (like pages of a book), constrained to skeleton
+ * - SkeletonBranching: On 1 or >2 skeleton edges, position is fixed
+ * - NonManifoldOther: Other non-manifold configurations, position is fixed
+ */
+export declare enum VertexType {
+    /** Vertex with manifold neighborhood - can move freely in 3D */
+    Manifold = "manifold",
+    /** Vertex on exactly 2 skeleton edges (open-book) - constrained to skeleton segment */
+    OpenBook = "open_book",
+    /** Vertex on 1 or >2 skeleton edges - position is fixed */
+    SkeletonBranching = "skeleton_branching",
+    /** Other non-manifold vertex type - position is fixed */
+    NonManifoldOther = "non_manifold_other"
+}
+
+export { }