remesh-threejs 0.2.0

package/dist/remesh-threejs.js

@@ -0,0 +1,4338 @@
+import { Vector3, BufferGeometry, BufferAttribute } from "three";
+function createVertexId(id) {
+  return id;
+}
+function createEdgeId(id) {
+  return id;
+}
+function createHalfedgeId(id) {
+  return id;
+}
+function createFaceId(id) {
+  return id;
+}
+function createSegmentId(id) {
+  return id;
+}
+function toNumber(id) {
+  return id;
+}
+var VertexType = /* @__PURE__ */ ((VertexType2) => {
+  VertexType2["Manifold"] = "manifold";
+  VertexType2["OpenBook"] = "open_book";
+  VertexType2["SkeletonBranching"] = "skeleton_branching";
+  VertexType2["NonManifoldOther"] = "non_manifold_other";
+  return VertexType2;
+})(VertexType || {});
+var EdgeType = /* @__PURE__ */ ((EdgeType2) => {
+  EdgeType2["Manifold"] = "manifold";
+  EdgeType2["NonManifold"] = "non_manifold";
+  EdgeType2["Feature"] = "feature";
+  EdgeType2["Boundary"] = "boundary";
+  return EdgeType2;
+})(EdgeType || {});
+function canMoveFreely(type) {
+  return type === "manifold";
+}
+function isSkeletonConstrained(type) {
+  return type === "open_book";
+}
+function isPositionFixed(type) {
+  return type === "skeleton_branching" || type === "non_manifold_other";
+}
+function isSkeletonEdge(type) {
+  return type === "non_manifold" || type === "feature" || type === "boundary";
+}
+function canFlipEdge$1(type) {
+  return type === "manifold";
+}
+const DEFAULT_REMESH_OPTIONS = {
+  iterations: 5,
+  preserveBoundary: true,
+  minEdgeLengthRatio: 0.4,
+  maxEdgeLengthRatio: 1.333,
+  minTriangleQuality: 0.3,
+  maxNormalDeviation: Math.PI / 6,
+  useAcceleration: true,
+  chunkSize: 0,
+  memoryBudget: 0,
+  verbose: false
+};
+const MAX_ITERATIONS = 1e4;
+class Vertex {
+  constructor(id, position) {
+    this.id = id;
+    this.position = position;
+    this.halfedge = null;
+    this.type = VertexType.Manifold;
+    this.isMarked = false;
+  }
+  /**
+   * Gets the degree of this vertex (number of incident edges).
+   * Returns null if the vertex has no incident halfedge.
+   */
+  degree() {
+    if (!this.halfedge) {
+      return null;
+    }
+    let count = 0;
+    let current = this.halfedge;
+    do {
+      count++;
+      if (!current.twin || !current.twin.next) {
+        break;
+      }
+      current = current.twin.next;
+      if (count > MAX_ITERATIONS) {
+        throw new Error(`Vertex ${this.id}: degree calculation exceeded maximum iterations`);
+      }
+    } while (current !== this.halfedge);
+    return count;
+  }
+  /**
+   * Iterates over all outgoing halfedges from this vertex.
+   *
+   * @param callback - Function called for each outgoing halfedge
+   */
+  forEachOutgoingHalfedge(callback) {
+    if (!this.halfedge) {
+      return;
+    }
+    let current = this.halfedge;
+    let iterationCount = 0;
+    do {
+      callback(current);
+      if (!current.twin || !current.twin.next) {
+        break;
+      }
+      current = current.twin.next;
+      iterationCount++;
+      if (iterationCount > MAX_ITERATIONS) {
+        throw new Error(`Vertex ${this.id}: halfedge iteration exceeded maximum iterations`);
+      }
+    } while (current !== this.halfedge);
+  }
+  /**
+   * Collects all outgoing halfedges from this vertex into an array.
+   *
+   * @returns Array of outgoing halfedges
+   */
+  getOutgoingHalfedges() {
+    const halfedges = [];
+    this.forEachOutgoingHalfedge((he) => halfedges.push(he));
+    return halfedges;
+  }
+  /**
+   * Iterates over all neighboring vertices.
+   *
+   * @param callback - Function called for each neighboring vertex
+   */
+  forEachNeighbor(callback) {
+    this.forEachOutgoingHalfedge((he) => {
+      callback(he.vertex);
+    });
+  }
+  /**
+   * Collects all neighboring vertices into an array.
+   *
+   * @returns Array of neighboring vertices
+   */
+  getNeighbors() {
+    const neighbors = [];
+    this.forEachNeighbor((v) => neighbors.push(v));
+    return neighbors;
+  }
+  /**
+   * 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() {
+    if (!this.halfedge) {
+      return true;
+    }
+    let hasBoundaryHalfedge = false;
+    this.forEachOutgoingHalfedge((he) => {
+      if (!he.face) {
+        hasBoundaryHalfedge = true;
+      }
+    });
+    return hasBoundaryHalfedge;
+  }
+  /**
+   * Checks if this vertex can move freely during remeshing.
+   * Only manifold vertices can move freely in 3D space.
+   */
+  canMoveFreely() {
+    return this.type === VertexType.Manifold;
+  }
+  /**
+   * Checks if this vertex is constrained to a skeleton segment.
+   * OpenBook vertices can only move along their skeleton segment.
+   */
+  isSkeletonConstrained() {
+    return this.type === VertexType.OpenBook;
+  }
+  /**
+   * Checks if this vertex has a fixed position.
+   * Branching and other non-manifold vertices cannot move.
+   */
+  isPositionFixed() {
+    return this.type === VertexType.SkeletonBranching || this.type === VertexType.NonManifoldOther;
+  }
+  /**
+   * Checks if this vertex is part of the feature skeleton.
+   */
+  isOnSkeleton() {
+    return this.type !== VertexType.Manifold;
+  }
+}
+class Halfedge {
+  constructor(id, vertex, edge) {
+    this.id = id;
+    this.twin = null;
+    this.next = null;
+    this.prev = null;
+    this.face = null;
+    this.vertex = vertex;
+    this.edge = edge;
+  }
+  /**
+   * Gets the source vertex of this halfedge (the vertex it starts from).
+   * This is the target vertex of the twin halfedge.
+   */
+  getSourceVertex() {
+    var _a;
+    return ((_a = this.twin) == null ? void 0 : _a.vertex) ?? null;
+  }
+  /**
+   * Gets the target vertex of this halfedge.
+   */
+  getTargetVertex() {
+    return this.vertex;
+  }
+  /**
+   * Checks if this halfedge is on the boundary (has no face).
+   */
+  isBoundary() {
+    return this.face === null;
+  }
+  /**
+   * 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() {
+    var _a;
+    return ((_a = this.next) == null ? void 0 : _a.next) ?? null;
+  }
+  /**
+   * Gets the vertex opposite to this halfedge in its face.
+   * For a triangle, this is the vertex not on this halfedge.
+   */
+  getOppositeVertex() {
+    var _a;
+    return ((_a = this.next) == null ? void 0 : _a.vertex) ?? null;
+  }
+  /**
+   * Computes the vector along this halfedge (from source to target).
+   * Returns null if source vertex is not available.
+   */
+  getVector() {
+    const source = this.getSourceVertex();
+    if (!source) {
+      return null;
+    }
+    return {
+      x: this.vertex.position.x - source.position.x,
+      y: this.vertex.position.y - source.position.y,
+      z: this.vertex.position.z - source.position.z
+    };
+  }
+}
+class Edge {
+  constructor(id, halfedge, length2) {
+    this.id = id;
+    this.allHalfedges = [];
+    this.type = EdgeType.Manifold;
+    this.isInPath = false;
+    this.halfedge = halfedge;
+    this.length = length2;
+    this.allHalfedges.push(halfedge);
+  }
+  /**
+   * Adds a halfedge to this edge.
+   */
+  addHalfedge(halfedge) {
+    this.allHalfedges.push(halfedge);
+    this.updateType();
+  }
+  /**
+   * Gets the number of halfedges (indicates non-manifoldness).
+   * 2 = manifold, >2 = non-manifold, 1 = boundary
+   */
+  getHalfedgeCount() {
+    return this.allHalfedges.length;
+  }
+  /**
+   * Updates the edge type based on the number of incident faces.
+   */
+  updateType() {
+    const faceCount = this.getFaceCount();
+    if (faceCount === 0) {
+      this.type = EdgeType.Boundary;
+    } else if (faceCount === 1) {
+      this.type = EdgeType.Boundary;
+    } else if (faceCount === 2) {
+      if (this.type !== EdgeType.Feature) {
+        this.type = EdgeType.Manifold;
+      }
+    } else {
+      this.type = EdgeType.NonManifold;
+    }
+  }
+  /**
+   * Gets the number of faces incident to this edge.
+   */
+  getFaceCount() {
+    let count = 0;
+    for (const he of this.allHalfedges) {
+      if (he.face !== null) {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Gets both vertices of this edge.
+   * Returns [v0, v1] where v0 is the source of halfedge and v1 is the target.
+   */
+  getVertices() {
+    const v0 = this.halfedge.getSourceVertex();
+    const v1 = this.halfedge.getTargetVertex();
+    if (!v0) {
+      return [null, null];
+    }
+    return [v0, v1];
+  }
+  /**
+   * Gets all faces adjacent to this edge.
+   * For manifold edges, returns up to 2 faces.
+   * For non-manifold edges, returns all incident faces.
+   */
+  getFaces() {
+    const faces = [];
+    for (const he of this.allHalfedges) {
+      if (he.face !== null) {
+        faces.push(he.face);
+      }
+    }
+    return faces;
+  }
+  /**
+   * 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() {
+    var _a;
+    const f0 = this.halfedge.face;
+    const f1 = ((_a = this.halfedge.twin) == null ? void 0 : _a.face) ?? null;
+    return [f0, f1];
+  }
+  /**
+   * Checks if this edge is on the boundary (has only one adjacent face).
+   */
+  isBoundary() {
+    return this.type === EdgeType.Boundary;
+  }
+  /**
+   * Checks if this edge is non-manifold (has more than 2 adjacent faces).
+   */
+  isNonManifold() {
+    return this.type === EdgeType.NonManifold;
+  }
+  /**
+   * Checks if this edge is part of the feature skeleton.
+   */
+  isSkeletonEdge() {
+    return this.type === EdgeType.NonManifold || this.type === EdgeType.Feature || this.type === EdgeType.Boundary;
+  }
+  /**
+   * 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() {
+    if (this.type !== EdgeType.Manifold) {
+      return false;
+    }
+    if (this.getFaceCount() !== 2) {
+      return false;
+    }
+    const [v0, v1] = this.getVertices();
+    if (!v0 || !v1) {
+      return false;
+    }
+    const degree0 = v0.degree();
+    const degree1 = v1.degree();
+    if (degree0 === null || degree1 === null || degree0 <= 1 || degree1 <= 1) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Gets the other vertex of this edge (given one vertex).
+   */
+  getOtherVertex(v) {
+    const [v0, v1] = this.getVertices();
+    if (!v0 || !v1) {
+      return null;
+    }
+    if (v.id === v0.id) {
+      return v1;
+    } else if (v.id === v1.id) {
+      return v0;
+    }
+    return null;
+  }
+  /**
+   * Marks this edge as a feature edge.
+   */
+  markAsFeature() {
+    if (this.type === EdgeType.Manifold) {
+      this.type = EdgeType.Feature;
+    }
+  }
+}
+class Face {
+  constructor(id, halfedge) {
+    this.id = id;
+    this.isMarked = false;
+    this.halfedge = halfedge;
+  }
+  /**
+   * Gets all three vertices of this face.
+   * Returns vertices in counter-clockwise order.
+   */
+  getVertices() {
+    const he0 = this.halfedge;
+    const he1 = he0.next;
+    const he2 = he1 == null ? void 0 : he1.next;
+    if (!he1 || !he2) {
+      return null;
+    }
+    return [he0.vertex, he1.vertex, he2.vertex];
+  }
+  /**
+   * Gets all three halfedges of this face.
+   * Returns halfedges in counter-clockwise order.
+   */
+  getHalfedges() {
+    const he0 = this.halfedge;
+    const he1 = he0.next;
+    const he2 = he1 == null ? void 0 : he1.next;
+    if (!he1 || !he2) {
+      return null;
+    }
+    return [he0, he1, he2];
+  }
+  /**
+   * Iterates over the three halfedges of this face.
+   *
+   * @param callback - Function called for each halfedge
+   */
+  forEachHalfedge(callback) {
+    const halfedges = this.getHalfedges();
+    if (!halfedges) {
+      return;
+    }
+    for (const he of halfedges) {
+      callback(he);
+    }
+  }
+  /**
+   * Iterates over the three vertices of this face.
+   *
+   * @param callback - Function called for each vertex
+   */
+  forEachVertex(callback) {
+    const vertices = this.getVertices();
+    if (!vertices) {
+      return;
+    }
+    for (const v of vertices) {
+      callback(v);
+    }
+  }
+  /**
+   * Computes the centroid (center of mass) of this face.
+   * Returns null if vertices cannot be retrieved.
+   */
+  getCentroid() {
+    const vertices = this.getVertices();
+    if (!vertices) {
+      return null;
+    }
+    const [v0, v1, v2] = vertices;
+    return {
+      x: (v0.position.x + v1.position.x + v2.position.x) / 3,
+      y: (v0.position.y + v1.position.y + v2.position.y) / 3,
+      z: (v0.position.z + v1.position.z + v2.position.z) / 3
+    };
+  }
+  /**
+   * Computes the normal vector of this face.
+   * Uses the cross product of two edges.
+   * Returns null if vertices cannot be retrieved.
+   */
+  getNormal() {
+    const vertices = this.getVertices();
+    if (!vertices) {
+      return null;
+    }
+    const [v0, v1, v2] = vertices;
+    const e1x = v1.position.x - v0.position.x;
+    const e1y = v1.position.y - v0.position.y;
+    const e1z = v1.position.z - v0.position.z;
+    const e2x = v2.position.x - v0.position.x;
+    const e2y = v2.position.y - v0.position.y;
+    const e2z = v2.position.z - v0.position.z;
+    const nx = e1y * e2z - e1z * e2y;
+    const ny = e1z * e2x - e1x * e2z;
+    const nz = e1x * e2y - e1y * e2x;
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (len < 1e-10) {
+      return { x: 0, y: 0, z: 1 };
+    }
+    return {
+      x: nx / len,
+      y: ny / len,
+      z: nz / len
+    };
+  }
+  /**
+   * Computes the area of this face.
+   * Returns null if vertices cannot be retrieved.
+   */
+  getArea() {
+    const vertices = this.getVertices();
+    if (!vertices) {
+      return null;
+    }
+    const [v0, v1, v2] = vertices;
+    const e1x = v1.position.x - v0.position.x;
+    const e1y = v1.position.y - v0.position.y;
+    const e1z = v1.position.z - v0.position.z;
+    const e2x = v2.position.x - v0.position.x;
+    const e2y = v2.position.y - v0.position.y;
+    const e2z = v2.position.z - v0.position.z;
+    const cx = e1y * e2z - e1z * e2y;
+    const cy = e1z * e2x - e1x * e2z;
+    const cz = e1x * e2y - e1y * e2x;
+    return Math.sqrt(cx * cx + cy * cy + cz * cz) / 2;
+  }
+  /**
+   * 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() {
+    const vertices = this.getVertices();
+    if (!vertices) {
+      return null;
+    }
+    const [v0, v1, v2] = vertices;
+    const a = Math.sqrt(
+      Math.pow(v1.position.x - v2.position.x, 2) + Math.pow(v1.position.y - v2.position.y, 2) + Math.pow(v1.position.z - v2.position.z, 2)
+    );
+    const b = Math.sqrt(
+      Math.pow(v0.position.x - v2.position.x, 2) + Math.pow(v0.position.y - v2.position.y, 2) + Math.pow(v0.position.z - v2.position.z, 2)
+    );
+    const c = Math.sqrt(
+      Math.pow(v0.position.x - v1.position.x, 2) + Math.pow(v0.position.y - v1.position.y, 2) + Math.pow(v0.position.z - v1.position.z, 2)
+    );
+    const s = (a + b + c) / 2;
+    const areaSquared = s * (s - a) * (s - b) * (s - c);
+    if (areaSquared <= 0) {
+      return 0;
+    }
+    const area = Math.sqrt(areaSquared);
+    const inradius = area / s;
+    const circumradius = a * b * c / (4 * area);
+    if (circumradius < 1e-10) {
+      return 0;
+    }
+    const quality = 2 * inradius / circumradius;
+    return Math.max(0, Math.min(1, quality));
+  }
+  /**
+   * Checks if this face contains a given vertex.
+   */
+  containsVertex(vertex) {
+    const vertices = this.getVertices();
+    if (!vertices) {
+      return false;
+    }
+    return vertices.some((v) => v.id === vertex.id);
+  }
+  /**
+   * Gets the halfedge opposite to a given vertex.
+   * Returns null if the vertex is not part of this face.
+   */
+  getOppositeHalfedge(vertex) {
+    const halfedges = this.getHalfedges();
+    if (!halfedges) {
+      return null;
+    }
+    for (const he of halfedges) {
+      const source = he.getSourceVertex();
+      if (source && source.id !== vertex.id && he.vertex.id !== vertex.id) {
+        return he;
+      }
+    }
+    return null;
+  }
+  /**
+   * Checks if this face is degenerate (has zero or near-zero area).
+   */
+  isDegenerate(epsilon = 1e-10) {
+    const area = this.getArea();
+    return area === null || area < epsilon;
+  }
+}
+class NonManifoldMesh {
+  constructor() {
+    this.vertices = /* @__PURE__ */ new Map();
+    this.edges = /* @__PURE__ */ new Map();
+    this.halfedges = /* @__PURE__ */ new Map();
+    this.faces = /* @__PURE__ */ new Map();
+    this.nextVertexId = 0;
+    this.nextEdgeId = 0;
+    this.nextHalfedgeId = 0;
+    this.nextFaceId = 0;
+    this.edgeMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 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, featureEdges) {
+    const mesh = new NonManifoldMesh();
+    const positions = geometry.attributes["position"];
+    if (!positions) {
+      throw new Error("Geometry must have a position attribute");
+    }
+    const indices = geometry.index;
+    if (!indices) {
+      throw new Error("Geometry must be indexed");
+    }
+    const numVertices = positions.count;
+    const numFaces = indices.count / 3;
+    if (indices.count % 3 !== 0) {
+      throw new Error("Geometry must be triangulated (indices count must be divisible by 3)");
+    }
+    for (let i = 0; i < numVertices; i++) {
+      const x = positions.getX(i);
+      const y = positions.getY(i);
+      const z = positions.getZ(i);
+      const vertex = new Vertex(createVertexId(mesh.nextVertexId++), new Vector3(x, y, z));
+      mesh.vertices.set(vertex.id, vertex);
+    }
+    for (let i = 0; i < numFaces; i++) {
+      const i0 = indices.getX(i * 3 + 0);
+      const i1 = indices.getX(i * 3 + 1);
+      const i2 = indices.getX(i * 3 + 2);
+      const v0 = mesh.vertices.get(createVertexId(i0));
+      const v1 = mesh.vertices.get(createVertexId(i1));
+      const v2 = mesh.vertices.get(createVertexId(i2));
+      if (!v0 || !v1 || !v2) {
+        throw new Error(`Vertex not found in face ${i}: ${i0}, ${i1}, ${i2}`);
+      }
+      const edge01 = mesh.getOrCreateEdge(i0, i1);
+      const edge12 = mesh.getOrCreateEdge(i1, i2);
+      const edge20 = mesh.getOrCreateEdge(i2, i0);
+      const face = new Face(createFaceId(mesh.nextFaceId++), null);
+      mesh.faces.set(face.id, face);
+      const he01 = new Halfedge(createHalfedgeId(mesh.nextHalfedgeId++), v1, edge01);
+      const he12 = new Halfedge(createHalfedgeId(mesh.nextHalfedgeId++), v2, edge12);
+      const he20 = new Halfedge(createHalfedgeId(mesh.nextHalfedgeId++), v0, edge20);
+      mesh.halfedges.set(he01.id, he01);
+      mesh.halfedges.set(he12.id, he12);
+      mesh.halfedges.set(he20.id, he20);
+      edge01.addHalfedge(he01);
+      edge12.addHalfedge(he12);
+      edge20.addHalfedge(he20);
+      he01.next = he12;
+      he12.next = he20;
+      he20.next = he01;
+      he01.prev = he20;
+      he12.prev = he01;
+      he20.prev = he12;
+      he01.face = face;
+      he12.face = face;
+      he20.face = face;
+      face.halfedge = he01;
+      if (!v0.halfedge) v0.halfedge = he01;
+      if (!v1.halfedge) v1.halfedge = he12;
+      if (!v2.halfedge) v2.halfedge = he20;
+      edge01.halfedge = he01;
+      edge12.halfedge = he12;
+      edge20.halfedge = he20;
+    }
+    mesh.setupTwinHalfedges();
+    if (featureEdges && featureEdges.length > 0) {
+      mesh.markFeatureEdges(featureEdges);
+    }
+    mesh.classifyVertices();
+    return mesh;
+  }
+  /**
+   * Gets or creates an edge between two vertices.
+   */
+  getOrCreateEdge(v0Id, v1Id) {
+    const key = this.makeEdgeKey(v0Id, v1Id);
+    let edge = this.edgeMap.get(key);
+    if (!edge) {
+      const v0 = this.vertices.get(createVertexId(v0Id));
+      const v1 = this.vertices.get(createVertexId(v1Id));
+      if (!v0 || !v1) {
+        throw new Error(`Vertex not found: ${v0Id} or ${v1Id}`);
+      }
+      const dx = v1.position.x - v0.position.x;
+      const dy = v1.position.y - v0.position.y;
+      const dz = v1.position.z - v0.position.z;
+      const length2 = Math.sqrt(dx * dx + dy * dy + dz * dz);
+      edge = new Edge(createEdgeId(this.nextEdgeId++), null, length2);
+      edge.allHalfedges = [];
+      this.edgeMap.set(key, edge);
+      this.edges.set(edge.id, edge);
+    }
+    return edge;
+  }
+  /**
+   * Creates a canonical key for an edge between two vertices.
+   */
+  makeEdgeKey(v0Id, v1Id) {
+    return v0Id < v1Id ? `${v0Id},${v1Id}` : `${v1Id},${v0Id}`;
+  }
+  /**
+   * Sets up twin halfedge relationships.
+   * For non-manifold edges (>2 halfedges), creates a circular twin chain.
+   */
+  setupTwinHalfedges() {
+    var _a;
+    for (const edge of this.edges.values()) {
+      const halfedges = edge.allHalfedges;
+      const count = halfedges.length;
+      if (count === 0) {
+        continue;
+      }
+      if (count === 1) {
+        halfedges[0].twin = null;
+        edge.type = EdgeType.Boundary;
+      } else if (count === 2) {
+        halfedges[0].twin = halfedges[1];
+        halfedges[1].twin = halfedges[0];
+        edge.type = EdgeType.Manifold;
+      } else {
+        this.setupNonManifoldTwins(edge, halfedges);
+        edge.type = EdgeType.NonManifold;
+      }
+    }
+    for (const he of this.halfedges.values()) {
+      if (he.twin !== null) {
+        const vertex = (_a = he.prev) == null ? void 0 : _a.vertex;
+        if (vertex) {
+          vertex.halfedge = he;
+        }
+      }
+    }
+  }
+  /**
+   * Sets up twin relationships for non-manifold edges.
+   * Groups halfedges by direction and pairs them appropriately.
+   */
+  setupNonManifoldTwins(edge, halfedges) {
+    const [v0, v1] = edge.getVertices();
+    if (!v0 || !v1) return;
+    const toV0 = [];
+    const toV1 = [];
+    for (const he of halfedges) {
+      if (he.vertex.id === v0.id) {
+        toV0.push(he);
+      } else {
+        toV1.push(he);
+      }
+    }
+    const minCount = Math.min(toV0.length, toV1.length);
+    for (let i = 0; i < minCount; i++) {
+      toV0[i].twin = toV1[i];
+      toV1[i].twin = toV0[i];
+    }
+    for (let i = minCount; i < toV0.length; i++) {
+      toV0[i].twin = null;
+    }
+    for (let i = minCount; i < toV1.length; i++) {
+      toV1[i].twin = null;
+    }
+  }
+  /**
+   * Marks user-defined feature edges.
+   */
+  markFeatureEdges(featureEdges) {
+    for (const [v0, v1] of featureEdges) {
+      const key = this.makeEdgeKey(v0, v1);
+      const edge = this.edgeMap.get(key);
+      if (edge && edge.type === EdgeType.Manifold) {
+        edge.markAsFeature();
+      }
+    }
+  }
+  /**
+   * Classifies all vertices based on their neighborhood topology.
+   */
+  classifyVertices() {
+    for (const vertex of this.vertices.values()) {
+      vertex.type = this.classifyVertex(vertex);
+    }
+  }
+  /**
+   * Classifies a single vertex based on its neighborhood.
+   */
+  classifyVertex(vertex) {
+    let skeletonEdgeCount = 0;
+    vertex.forEachOutgoingHalfedge((he) => {
+      if (he.edge.isSkeletonEdge()) {
+        skeletonEdgeCount++;
+      }
+    });
+    if (skeletonEdgeCount === 0) {
+      return VertexType.Manifold;
+    } else if (skeletonEdgeCount === 2) {
+      return VertexType.OpenBook;
+    } else {
+      return VertexType.SkeletonBranching;
+    }
+  }
+  /**
+   * Exports the mesh to a Three.js BufferGeometry.
+   */
+  toBufferGeometry() {
+    const geometry = new Vector3.constructor();
+    return geometry;
+  }
+  /**
+   * Gets all vertices in the mesh.
+   */
+  getVertices() {
+    return Array.from(this.vertices.values());
+  }
+  /**
+   * Gets all edges in the mesh.
+   */
+  getEdges() {
+    return Array.from(this.edges.values());
+  }
+  /**
+   * Gets all faces in the mesh.
+   */
+  getFaces() {
+    return Array.from(this.faces.values());
+  }
+  /**
+   * Gets all halfedges in the mesh.
+   */
+  getHalfedges() {
+    return Array.from(this.halfedges.values());
+  }
+  /**
+   * Gets the vertex count.
+   */
+  get vertexCount() {
+    return this.vertices.size;
+  }
+  /**
+   * Gets the edge count.
+   */
+  get edgeCount() {
+    return this.edges.size;
+  }
+  /**
+   * Gets the face count.
+   */
+  get faceCount() {
+    return this.faces.size;
+  }
+  /**
+   * Gets the halfedge count.
+   */
+  get halfedgeCount() {
+    return this.halfedges.size;
+  }
+  /**
+   * Gets all non-manifold edges.
+   */
+  getNonManifoldEdges() {
+    return this.getEdges().filter((e) => e.type === EdgeType.NonManifold);
+  }
+  /**
+   * Gets all boundary edges.
+   */
+  getBoundaryEdges() {
+    return this.getEdges().filter((e) => e.type === EdgeType.Boundary);
+  }
+  /**
+   * Gets all feature edges.
+   */
+  getFeatureEdges() {
+    return this.getEdges().filter((e) => e.type === EdgeType.Feature);
+  }
+  /**
+   * Gets all skeleton edges (non-manifold + boundary + feature).
+   */
+  getSkeletonEdges() {
+    return this.getEdges().filter((e) => e.isSkeletonEdge());
+  }
+  /**
+   * Checks if the mesh is manifold (no non-manifold edges).
+   */
+  isManifold() {
+    return this.getNonManifoldEdges().length === 0;
+  }
+  /**
+   * Checks if the mesh has boundaries.
+   */
+  hasBoundary() {
+    return this.getBoundaryEdges().length > 0;
+  }
+  /**
+   * Gets a vertex by ID.
+   */
+  getVertex(id) {
+    return this.vertices.get(id);
+  }
+  /**
+   * Gets an edge by ID.
+   */
+  getEdge(id) {
+    return this.edges.get(id);
+  }
+  /**
+   * Gets a face by ID.
+   */
+  getFace(id) {
+    return this.faces.get(id);
+  }
+  /**
+   * Gets a halfedge by ID.
+   */
+  getHalfedge(id) {
+    return this.halfedges.get(id);
+  }
+  /**
+   * Gets the edge between two vertices (if it exists).
+   */
+  getEdgeBetween(v0, v1) {
+    const key = this.makeEdgeKey(v0.id, v1.id);
+    return this.edgeMap.get(key);
+  }
+  /**
+   * Creates a new vertex and adds it to the mesh.
+   */
+  createVertex(position) {
+    const vertex = new Vertex(createVertexId(this.nextVertexId++), position);
+    this.vertices.set(vertex.id, vertex);
+    return vertex;
+  }
+  /**
+   * Creates a new face from three vertices.
+   * Also creates the necessary halfedges and edges.
+   */
+  createFace(v0, v1, v2) {
+    const edge01 = this.getOrCreateEdge(v0.id, v1.id);
+    const edge12 = this.getOrCreateEdge(v1.id, v2.id);
+    const edge20 = this.getOrCreateEdge(v2.id, v0.id);
+    const face = new Face(createFaceId(this.nextFaceId++), null);
+    this.faces.set(face.id, face);
+    const he01 = new Halfedge(createHalfedgeId(this.nextHalfedgeId++), v1, edge01);
+    const he12 = new Halfedge(createHalfedgeId(this.nextHalfedgeId++), v2, edge12);
+    const he20 = new Halfedge(createHalfedgeId(this.nextHalfedgeId++), v0, edge20);
+    this.halfedges.set(he01.id, he01);
+    this.halfedges.set(he12.id, he12);
+    this.halfedges.set(he20.id, he20);
+    edge01.addHalfedge(he01);
+    edge12.addHalfedge(he12);
+    edge20.addHalfedge(he20);
+    he01.next = he12;
+    he12.next = he20;
+    he20.next = he01;
+    he01.prev = he20;
+    he12.prev = he01;
+    he20.prev = he12;
+    he01.face = face;
+    he12.face = face;
+    he20.face = face;
+    face.halfedge = he01;
+    if (!v0.halfedge) v0.halfedge = he01;
+    if (!v1.halfedge) v1.halfedge = he12;
+    if (!v2.halfedge) v2.halfedge = he20;
+    edge01.halfedge = he01;
+    edge12.halfedge = he12;
+    edge20.halfedge = he20;
+    return face;
+  }
+  /**
+   * Computes mesh statistics.
+   */
+  getStats() {
+    const nonManifoldEdgeCount = this.getNonManifoldEdges().length;
+    const boundaryEdgeCount = this.getBoundaryEdges().length;
+    const featureEdgeCount = this.getFeatureEdges().length;
+    const eulerCharacteristic = this.vertexCount - this.edgeCount + this.faceCount;
+    return {
+      vertexCount: this.vertexCount,
+      edgeCount: this.edgeCount,
+      faceCount: this.faceCount,
+      nonManifoldEdgeCount,
+      boundaryEdgeCount,
+      featureEdgeCount,
+      eulerCharacteristic
+    };
+  }
+}
+function distanceSquared(a, b) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const dz = b.z - a.z;
+  return dx * dx + dy * dy + dz * dz;
+}
+function distance(a, b) {
+  return Math.sqrt(distanceSquared(a, b));
+}
+function dot(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z;
+}
+function cross(a, b) {
+  return {
+    x: a.y * b.z - a.z * b.y,
+    y: a.z * b.x - a.x * b.z,
+    z: a.x * b.y - a.y * b.x
+  };
+}
+function length(v) {
+  return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+}
+function lengthSquared(v) {
+  return v.x * v.x + v.y * v.y + v.z * v.z;
+}
+function normalize(v) {
+  const len = length(v);
+  if (len < 1e-10) {
+    return { x: 0, y: 0, z: 0 };
+  }
+  return {
+    x: v.x / len,
+    y: v.y / len,
+    z: v.z / len
+  };
+}
+function add(a, b) {
+  return {
+    x: a.x + b.x,
+    y: a.y + b.y,
+    z: a.z + b.z
+  };
+}
+function subtract(a, b) {
+  return {
+    x: a.x - b.x,
+    y: a.y - b.y,
+    z: a.z - b.z
+  };
+}
+function scale(v, s) {
+  return {
+    x: v.x * s,
+    y: v.y * s,
+    z: v.z * s
+  };
+}
+function lerp(a, b, t) {
+  return {
+    x: a.x + (b.x - a.x) * t,
+    y: a.y + (b.y - a.y) * t,
+    z: a.z + (b.z - a.z) * t
+  };
+}
+function midpoint(a, b) {
+  return {
+    x: (a.x + b.x) / 2,
+    y: (a.y + b.y) / 2,
+    z: (a.z + b.z) / 2
+  };
+}
+function angleBetween(a, b) {
+  const lenA = length(a);
+  const lenB = length(b);
+  if (lenA < 1e-10 || lenB < 1e-10) {
+    return 0;
+  }
+  const cosAngle = dot(a, b) / (lenA * lenB);
+  return Math.acos(Math.max(-1, Math.min(1, cosAngle)));
+}
+function projectPointOnLine(point, lineStart, lineEnd) {
+  const lineDir = subtract(lineEnd, lineStart);
+  const lineLengthSq = lengthSquared(lineDir);
+  if (lineLengthSq < 1e-10) {
+    return { ...lineStart };
+  }
+  const t = dot(subtract(point, lineStart), lineDir) / lineLengthSq;
+  return add(lineStart, scale(lineDir, t));
+}
+function projectPointOnSegment(point, segStart, segEnd) {
+  const lineDir = subtract(segEnd, segStart);
+  const lineLengthSq = lengthSquared(lineDir);
+  if (lineLengthSq < 1e-10) {
+    return { ...segStart };
+  }
+  const t = Math.max(0, Math.min(1, dot(subtract(point, segStart), lineDir) / lineLengthSq));
+  return add(segStart, scale(lineDir, t));
+}
+function triangleArea(v0, v1, v2) {
+  const e1 = subtract(v1, v0);
+  const e2 = subtract(v2, v0);
+  const crossProduct = cross(e1, e2);
+  return length(crossProduct) / 2;
+}
+function triangleNormal(v0, v1, v2) {
+  const e1 = subtract(v1, v0);
+  const e2 = subtract(v2, v0);
+  return normalize(cross(e1, e2));
+}
+function triangleCentroid$1(v0, v1, v2) {
+  return {
+    x: (v0.x + v1.x + v2.x) / 3,
+    y: (v0.y + v1.y + v2.y) / 3,
+    z: (v0.z + v1.z + v2.z) / 3
+  };
+}
+function triangleCircumcenter(v0, v1, v2) {
+  const a = subtract(v1, v0);
+  const b = subtract(v2, v0);
+  const crossAB = cross(a, b);
+  const denom = 2 * lengthSquared(crossAB);
+  if (denom < 1e-10) {
+    return null;
+  }
+  const aLenSq = lengthSquared(a);
+  const bLenSq = lengthSquared(b);
+  const term1 = scale(cross(crossAB, a), bLenSq);
+  const term2 = scale(cross(b, crossAB), aLenSq);
+  const circumcenterOffset = scale(add(term1, term2), 1 / denom);
+  return add(v0, circumcenterOffset);
+}
+function triangleCircumradius(v0, v1, v2) {
+  const a = distance(v1, v2);
+  const b = distance(v0, v2);
+  const c = distance(v0, v1);
+  const area = triangleArea(v0, v1, v2);
+  if (area < 1e-10) {
+    return null;
+  }
+  return a * b * c / (4 * area);
+}
+function triangleInradius(v0, v1, v2) {
+  const a = distance(v1, v2);
+  const b = distance(v0, v2);
+  const c = distance(v0, v1);
+  const s = (a + b + c) / 2;
+  const area = triangleArea(v0, v1, v2);
+  if (s < 1e-10) {
+    return null;
+  }
+  return area / s;
+}
+function triangleQuality(v0, v1, v2) {
+  const inr = triangleInradius(v0, v1, v2);
+  const circumr = triangleCircumradius(v0, v1, v2);
+  if (inr === null || circumr === null || circumr < 1e-10) {
+    return 0;
+  }
+  return Math.max(0, Math.min(1, 2 * inr / circumr));
+}
+function isPointInTriangle(point, v0, v1, v2) {
+  const e0 = subtract(v1, v0);
+  const e1 = subtract(v2, v0);
+  const e2 = subtract(point, v0);
+  const d00 = dot(e0, e0);
+  const d01 = dot(e0, e1);
+  const d11 = dot(e1, e1);
+  const d20 = dot(e2, e0);
+  const d21 = dot(e2, e1);
+  const denom = d00 * d11 - d01 * d01;
+  if (Math.abs(denom) < 1e-10) {
+    return false;
+  }
+  const v = (d11 * d20 - d01 * d21) / denom;
+  const w = (d00 * d21 - d01 * d20) / denom;
+  const u = 1 - v - w;
+  return u >= 0 && v >= 0 && w >= 0;
+}
+function barycentricCoordinates(point, v0, v1, v2) {
+  const e0 = subtract(v1, v0);
+  const e1 = subtract(v2, v0);
+  const e2 = subtract(point, v0);
+  const d00 = dot(e0, e0);
+  const d01 = dot(e0, e1);
+  const d11 = dot(e1, e1);
+  const d20 = dot(e2, e0);
+  const d21 = dot(e2, e1);
+  const denom = d00 * d11 - d01 * d01;
+  if (Math.abs(denom) < 1e-10) {
+    return null;
+  }
+  const v = (d11 * d20 - d01 * d21) / denom;
+  const w = (d00 * d21 - d01 * d20) / denom;
+  const u = 1 - v - w;
+  return { u, v, w };
+}
+function isQuadConvex(v0, v1, v2, v3) {
+  const n1 = triangleNormal(v0, v1, v2);
+  const n2 = triangleNormal(v0, v3, v1);
+  const normal = normalize(add(n1, n2));
+  let tangent;
+  if (Math.abs(normal.x) < 0.9) {
+    tangent = normalize(cross(normal, { x: 1, y: 0, z: 0 }));
+  } else {
+    tangent = normalize(cross(normal, { x: 0, y: 1, z: 0 }));
+  }
+  const bitangent = cross(normal, tangent);
+  const project = (v) => ({
+    x: dot(v, tangent),
+    y: dot(v, bitangent)
+  });
+  const p0 = project(v0);
+  const p1 = project(v1);
+  const p2 = project(v2);
+  const p3 = project(v3);
+  const cross2D = (a, b) => a.x * b.y - a.y * b.x;
+  const d01 = { x: p1.x - p0.x, y: p1.y - p0.y };
+  const d02 = { x: p2.x - p0.x, y: p2.y - p0.y };
+  const d03 = { x: p3.x - p0.x, y: p3.y - p0.y };
+  const sign2 = cross2D(d01, d02);
+  const sign3 = cross2D(d01, d03);
+  if (sign2 * sign3 >= 0) {
+    return false;
+  }
+  const d23 = { x: p3.x - p2.x, y: p3.y - p2.y };
+  const d20 = { x: p0.x - p2.x, y: p0.y - p2.y };
+  const d21 = { x: p1.x - p2.x, y: p1.y - p2.y };
+  const sign0 = cross2D(d23, d20);
+  const sign1 = cross2D(d23, d21);
+  return sign0 * sign1 < 0;
+}
+function fromVector3(v) {
+  return { x: v.x, y: v.y, z: v.z };
+}
+function cotangent(v0, vertex, v1) {
+  const e0 = subtract(v0, vertex);
+  const e1 = subtract(v1, vertex);
+  const cosAngle = dot(e0, e1);
+  const sinAngle = length(cross(e0, e1));
+  if (Math.abs(sinAngle) < 1e-10) {
+    return 0;
+  }
+  return cosAngle / sinAngle;
+}
+function angleAtVertex(v0, vertex, v1) {
+  const e0 = subtract(v0, vertex);
+  const e1 = subtract(v1, vertex);
+  return angleBetween(e0, e1);
+}
+class SkeletonSegment {
+  constructor(id) {
+    this.id = id;
+    this.vertices = [];
+    this.edges = [];
+    this.isClosed = false;
+    this._totalLength = 0;
+    this._cumulativeLengths = [];
+  }
+  /**
+   * Gets the start vertex of this segment.
+   */
+  get startVertex() {
+    return this.vertices[0];
+  }
+  /**
+   * Gets the end vertex of this segment.
+   */
+  get endVertex() {
+    return this.vertices[this.vertices.length - 1];
+  }
+  /**
+   * Gets the total arc length of this segment.
+   */
+  get totalLength() {
+    return this._totalLength;
+  }
+  /**
+   * Gets the number of vertices in this segment.
+   */
+  get vertexCount() {
+    return this.vertices.length;
+  }
+  /**
+   * Gets the number of edges in this segment.
+   */
+  get edgeCount() {
+    return this.edges.length;
+  }
+  /**
+   * Adds a vertex to the end of the segment.
+   */
+  addVertex(vertex) {
+    if (this.vertices.length > 0) {
+      const lastVertex = this.vertices[this.vertices.length - 1];
+      const edgeLength = distance(
+        { x: lastVertex.position.x, y: lastVertex.position.y, z: lastVertex.position.z },
+        { x: vertex.position.x, y: vertex.position.y, z: vertex.position.z }
+      );
+      this._totalLength += edgeLength;
+    }
+    this._cumulativeLengths.push(this._totalLength);
+    this.vertices.push(vertex);
+  }
+  /**
+   * Adds an edge to the segment.
+   */
+  addEdge(edge) {
+    this.edges.push(edge);
+  }
+  /**
+   * Recomputes the total length and cumulative lengths.
+   */
+  recomputeLengths() {
+    this._totalLength = 0;
+    this._cumulativeLengths = [0];
+    for (let i = 1; i < this.vertices.length; i++) {
+      const v0 = this.vertices[i - 1];
+      const v1 = this.vertices[i];
+      const len = distance(
+        { x: v0.position.x, y: v0.position.y, z: v0.position.z },
+        { x: v1.position.x, y: v1.position.y, z: v1.position.z }
+      );
+      this._totalLength += len;
+      this._cumulativeLengths.push(this._totalLength);
+    }
+  }
+  /**
+   * Gets the parameter t (0 to 1) for a vertex index.
+   */
+  getParameterAtVertex(index) {
+    if (this._totalLength === 0 || index < 0 || index >= this.vertices.length) {
+      return 0;
+    }
+    return (this._cumulativeLengths[index] ?? 0) / this._totalLength;
+  }
+  /**
+   * 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) {
+    if (this.vertices.length === 0) {
+      return null;
+    }
+    if (this.vertices.length === 1) {
+      const v = this.vertices[0];
+      return { x: v.position.x, y: v.position.y, z: v.position.z };
+    }
+    t = Math.max(0, Math.min(1, t));
+    const targetLength = t * this._totalLength;
+    for (let i = 1; i < this.vertices.length; i++) {
+      const prevLen = this._cumulativeLengths[i - 1] ?? 0;
+      const currLen = this._cumulativeLengths[i] ?? 0;
+      if (targetLength <= currLen) {
+        const v0 = this.vertices[i - 1];
+        const v1 = this.vertices[i];
+        const edgeLength = currLen - prevLen;
+        if (edgeLength < 1e-10) {
+          return { x: v0.position.x, y: v0.position.y, z: v0.position.z };
+        }
+        const localT = (targetLength - prevLen) / edgeLength;
+        return lerp(
+          { x: v0.position.x, y: v0.position.y, z: v0.position.z },
+          { x: v1.position.x, y: v1.position.y, z: v1.position.z },
+          localT
+        );
+      }
+    }
+    const lastV = this.vertices[this.vertices.length - 1];
+    return { x: lastV.position.x, y: lastV.position.y, z: lastV.position.z };
+  }
+  /**
+   * Projects a point onto this segment.
+   * Returns the closest point on the segment and its parameter.
+   */
+  projectPoint(point) {
+    if (this.vertices.length === 0) {
+      return null;
+    }
+    if (this.vertices.length === 1) {
+      const v = this.vertices[0];
+      const pos = { x: v.position.x, y: v.position.y, z: v.position.z };
+      return {
+        point: pos,
+        parameter: 0,
+        distance: distance(point, pos)
+      };
+    }
+    let bestPoint = null;
+    let bestParam = 0;
+    let bestDist = Infinity;
+    for (let i = 1; i < this.vertices.length; i++) {
+      const v0 = this.vertices[i - 1];
+      const v1 = this.vertices[i];
+      const p0 = { x: v0.position.x, y: v0.position.y, z: v0.position.z };
+      const p1 = { x: v1.position.x, y: v1.position.y, z: v1.position.z };
+      const projected = projectPointOnSegment(point, p0, p1);
+      const dist = distance(point, projected);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestPoint = projected;
+        const prevLen = this._cumulativeLengths[i - 1] ?? 0;
+        const currLen = this._cumulativeLengths[i] ?? 0;
+        const edgeLength = currLen - prevLen;
+        if (edgeLength < 1e-10) {
+          bestParam = prevLen / this._totalLength;
+        } else {
+          const localDist = distance(p0, projected);
+          bestParam = (prevLen + localDist) / this._totalLength;
+        }
+      }
+    }
+    if (!bestPoint) {
+      return null;
+    }
+    return {
+      point: bestPoint,
+      parameter: bestParam,
+      distance: bestDist
+    };
+  }
+  /**
+   * Gets the vertex at a specific index.
+   */
+  getVertex(index) {
+    return this.vertices[index];
+  }
+  /**
+   * Gets the edge at a specific index.
+   */
+  getEdge(index) {
+    return this.edges[index];
+  }
+  /**
+   * Checks if a vertex is part of this segment.
+   */
+  containsVertex(vertex) {
+    return this.vertices.some((v) => v.id === vertex.id);
+  }
+  /**
+   * Checks if an edge is part of this segment.
+   */
+  containsEdge(edge) {
+    return this.edges.some((e) => e.id === edge.id);
+  }
+  /**
+   * Gets the index of a vertex in this segment.
+   */
+  indexOfVertex(vertex) {
+    return this.vertices.findIndex((v) => v.id === vertex.id);
+  }
+  /**
+   * Iterates over vertices in this segment.
+   */
+  forEachVertex(callback) {
+    this.vertices.forEach(callback);
+  }
+  /**
+   * Iterates over edges in this segment.
+   */
+  forEachEdge(callback) {
+    this.edges.forEach(callback);
+  }
+  /**
+   * Creates a copy of this segment.
+   */
+  clone(newId) {
+    const segment = new SkeletonSegment(newId);
+    segment.vertices = [...this.vertices];
+    segment.edges = [...this.edges];
+    segment.isClosed = this.isClosed;
+    segment._totalLength = this._totalLength;
+    segment._cumulativeLengths = [...this._cumulativeLengths];
+    return segment;
+  }
+}
+class SkeletonBuilder {
+  constructor(mesh) {
+    this.nextSegmentId = 0;
+    this.mesh = mesh;
+  }
+  /**
+   * Builds the skeleton and returns the result.
+   */
+  build() {
+    const skeletonEdges = this.mesh.getSkeletonEdges();
+    const branchingVertices = [];
+    const openBookVertices = [];
+    for (const vertex of this.mesh.getVertices()) {
+      if (vertex.type === VertexType.SkeletonBranching) {
+        branchingVertices.push(vertex);
+      } else if (vertex.type === VertexType.OpenBook) {
+        openBookVertices.push(vertex);
+      }
+    }
+    const segments = this.buildSegments(skeletonEdges, branchingVertices);
+    return {
+      segments,
+      skeletonEdges,
+      branchingVertices,
+      openBookVertices
+    };
+  }
+  /**
+   * Builds segments from skeleton edges.
+   * A segment is a path between two branching vertices.
+   */
+  buildSegments(skeletonEdges, branchingVertices) {
+    const segments = [];
+    const visitedEdges = /* @__PURE__ */ new Set();
+    const branchingIds = new Set(branchingVertices.map((v) => v.id));
+    for (const startVertex of branchingVertices) {
+      const incidentEdges = this.getIncidentSkeletonEdges(startVertex, skeletonEdges);
+      for (const startEdge of incidentEdges) {
+        if (visitedEdges.has(startEdge.id)) {
+          continue;
+        }
+        const segment = this.traceSegment(startVertex, startEdge, branchingIds, visitedEdges);
+        if (segment) {
+          segments.push(segment);
+        }
+      }
+    }
+    for (const edge of skeletonEdges) {
+      if (visitedEdges.has(edge.id)) {
+        continue;
+      }
+      const segment = this.traceClosedLoop(edge, visitedEdges);
+      if (segment) {
+        segments.push(segment);
+      }
+    }
+    return segments;
+  }
+  /**
+   * Gets skeleton edges incident to a vertex.
+   */
+  getIncidentSkeletonEdges(vertex, skeletonEdges) {
+    const skeletonEdgeSet = new Set(skeletonEdges.map((e) => e.id));
+    const result = [];
+    vertex.forEachOutgoingHalfedge((he) => {
+      if (skeletonEdgeSet.has(he.edge.id)) {
+        if (!result.some((e) => e.id === he.edge.id)) {
+          result.push(he.edge);
+        }
+      }
+    });
+    return result;
+  }
+  /**
+   * Traces a segment from a starting vertex and edge.
+   */
+  traceSegment(startVertex, startEdge, branchingIds, visitedEdges) {
+    var _a, _b;
+    const segment = new SkeletonSegment(this.createSegmentId());
+    segment.addVertex(startVertex);
+    let currentVertex = startVertex;
+    let currentEdge = startEdge;
+    while (currentEdge && !visitedEdges.has(currentEdge.id)) {
+      visitedEdges.add(currentEdge.id);
+      segment.addEdge(currentEdge);
+      const nextVertex = currentEdge.getOtherVertex(currentVertex);
+      if (!nextVertex) {
+        break;
+      }
+      segment.addVertex(nextVertex);
+      currentVertex = nextVertex;
+      if (branchingIds.has(currentVertex.id)) {
+        break;
+      }
+      currentEdge = this.getNextSkeletonEdge(currentVertex, currentEdge, visitedEdges);
+    }
+    if (segment.vertices.length > 2 && ((_a = segment.startVertex) == null ? void 0 : _a.id) === ((_b = segment.endVertex) == null ? void 0 : _b.id)) {
+      segment.isClosed = true;
+      segment.vertices.pop();
+    }
+    segment.recomputeLengths();
+    return segment;
+  }
+  /**
+   * Traces a closed loop starting from an edge.
+   */
+  traceClosedLoop(startEdge, visitedEdges) {
+    const [v0, v1] = startEdge.getVertices();
+    if (!v0 || !v1) {
+      return null;
+    }
+    const segment = new SkeletonSegment(this.createSegmentId());
+    segment.addVertex(v0);
+    segment.addEdge(startEdge);
+    segment.addVertex(v1);
+    visitedEdges.add(startEdge.id);
+    let currentVertex = v1;
+    let currentEdge = this.getNextSkeletonEdge(currentVertex, startEdge, visitedEdges);
+    while (currentEdge && !visitedEdges.has(currentEdge.id)) {
+      visitedEdges.add(currentEdge.id);
+      segment.addEdge(currentEdge);
+      const nextVertex = currentEdge.getOtherVertex(currentVertex);
+      if (!nextVertex) {
+        break;
+      }
+      if (nextVertex.id === v0.id) {
+        segment.isClosed = true;
+        break;
+      }
+      segment.addVertex(nextVertex);
+      currentVertex = nextVertex;
+      currentEdge = this.getNextSkeletonEdge(currentVertex, currentEdge, visitedEdges);
+    }
+    segment.recomputeLengths();
+    return segment;
+  }
+  /**
+   * Gets the next skeleton edge from a vertex, excluding the current edge.
+   */
+  getNextSkeletonEdge(vertex, currentEdge, visitedEdges) {
+    let result = null;
+    vertex.forEachOutgoingHalfedge((he) => {
+      if (he.edge.id !== currentEdge.id && he.edge.isSkeletonEdge() && !visitedEdges.has(he.edge.id)) {
+        result = he.edge;
+      }
+    });
+    return result;
+  }
+  /**
+   * Creates a new segment ID.
+   */
+  createSegmentId() {
+    return createSegmentId(this.nextSegmentId++);
+  }
+}
+function buildSkeleton(mesh) {
+  const builder = new SkeletonBuilder(mesh);
+  return builder.build();
+}
+class FeatureSkeleton {
+  constructor(mesh) {
+    this.segments = /* @__PURE__ */ new Map();
+    this.skeletonEdges = [];
+    this.branchingVertices = [];
+    this.openBookVertices = [];
+    this.vertexToSegment = /* @__PURE__ */ new Map();
+    this.isBuilt = false;
+    this.mesh = mesh;
+  }
+  /**
+   * Builds the skeleton from the mesh.
+   */
+  build() {
+    const builder = new SkeletonBuilder(this.mesh);
+    const result = builder.build();
+    this.applyBuildResult(result);
+    this.isBuilt = true;
+  }
+  /**
+   * Applies a build result to this skeleton.
+   */
+  applyBuildResult(result) {
+    this.segments.clear();
+    this.vertexToSegment.clear();
+    for (const segment of result.segments) {
+      this.segments.set(segment.id, segment);
+      for (let i = 1; i < segment.vertices.length - 1; i++) {
+        const vertex = segment.vertices[i];
+        if (vertex) {
+          this.vertexToSegment.set(vertex.id, segment);
+        }
+      }
+    }
+    this.skeletonEdges = result.skeletonEdges;
+    this.branchingVertices = result.branchingVertices;
+    this.openBookVertices = result.openBookVertices;
+  }
+  /**
+   * Rebuilds the skeleton. Call after topology changes.
+   */
+  rebuild() {
+    this.build();
+  }
+  /**
+   * Gets all segments.
+   */
+  getSegments() {
+    return Array.from(this.segments.values());
+  }
+  /**
+   * Gets a segment by ID.
+   */
+  getSegment(id) {
+    return this.segments.get(id);
+  }
+  /**
+   * Gets the segment containing a vertex.
+   * Only works for open-book vertices.
+   */
+  getSegmentForVertex(vertex) {
+    return this.vertexToSegment.get(vertex.id);
+  }
+  /**
+   * Gets all skeleton edges.
+   */
+  getSkeletonEdges() {
+    return this.skeletonEdges;
+  }
+  /**
+   * Gets all branching vertices.
+   */
+  getBranchingVertices() {
+    return this.branchingVertices;
+  }
+  /**
+   * Gets all open-book vertices.
+   */
+  getOpenBookVertices() {
+    return this.openBookVertices;
+  }
+  /**
+   * Gets the number of segments.
+   */
+  get segmentCount() {
+    return this.segments.size;
+  }
+  /**
+   * Gets the number of skeleton edges.
+   */
+  get skeletonEdgeCount() {
+    return this.skeletonEdges.length;
+  }
+  /**
+   * Gets the number of branching vertices.
+   */
+  get branchingVertexCount() {
+    return this.branchingVertices.length;
+  }
+  /**
+   * Gets the number of open-book vertices.
+   */
+  get openBookVertexCount() {
+    return this.openBookVertices.length;
+  }
+  /**
+   * Checks if the skeleton has been built.
+   */
+  get built() {
+    return this.isBuilt;
+  }
+  /**
+   * Projects a point onto the skeleton.
+   * Returns the closest point on any segment.
+   */
+  projectPoint(point) {
+    let bestResult = null;
+    for (const segment of this.segments.values()) {
+      const projection = segment.projectPoint(point);
+      if (projection && (!bestResult || projection.distance < bestResult.distance)) {
+        bestResult = {
+          point: projection.point,
+          segment,
+          parameter: projection.parameter,
+          distance: projection.distance
+        };
+      }
+    }
+    return bestResult;
+  }
+  /**
+   * Checks if a vertex is on the skeleton.
+   */
+  isVertexOnSkeleton(vertex) {
+    return vertex.isOnSkeleton();
+  }
+  /**
+   * Checks if an edge is on the skeleton.
+   */
+  isEdgeOnSkeleton(edge) {
+    return edge.isSkeletonEdge();
+  }
+  /**
+   * Gets all vertices on the skeleton.
+   */
+  getAllSkeletonVertices() {
+    return [...this.branchingVertices, ...this.openBookVertices];
+  }
+  /**
+   * Computes the total length of the skeleton.
+   */
+  getTotalLength() {
+    let total = 0;
+    for (const segment of this.segments.values()) {
+      total += segment.totalLength;
+    }
+    return total;
+  }
+  /**
+   * Gets statistics about the skeleton.
+   */
+  getStats() {
+    let closedLoopCount = 0;
+    for (const segment of this.segments.values()) {
+      if (segment.isClosed) {
+        closedLoopCount++;
+      }
+    }
+    return {
+      segmentCount: this.segmentCount,
+      skeletonEdgeCount: this.skeletonEdgeCount,
+      branchingVertexCount: this.branchingVertexCount,
+      openBookVertexCount: this.openBookVertexCount,
+      totalLength: this.getTotalLength(),
+      closedLoopCount
+    };
+  }
+}
+function createSkeleton(mesh) {
+  const skeleton = new FeatureSkeleton(mesh);
+  skeleton.build();
+  return skeleton;
+}
+class SkeletonConstraints {
+  constructor(skeleton) {
+    this.skeleton = skeleton;
+  }
+  /**
+   * 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, targetPosition) {
+    switch (vertex.type) {
+      case VertexType.Manifold:
+        return {
+          position: targetPosition,
+          wasConstrained: false,
+          constraintDistance: 0
+        };
+      case VertexType.OpenBook:
+        return this.constrainToSegment(vertex, targetPosition);
+      case VertexType.SkeletonBranching:
+      case VertexType.NonManifoldOther:
+        return {
+          position: {
+            x: vertex.position.x,
+            y: vertex.position.y,
+            z: vertex.position.z
+          },
+          wasConstrained: true,
+          constraintDistance: distance(targetPosition, {
+            x: vertex.position.x,
+            y: vertex.position.y,
+            z: vertex.position.z
+          })
+        };
+      default:
+        return {
+          position: targetPosition,
+          wasConstrained: false,
+          constraintDistance: 0
+        };
+    }
+  }
+  /**
+   * Constrains a position to a skeleton segment.
+   */
+  constrainToSegment(vertex, targetPosition) {
+    const segment = this.skeleton.getSegmentForVertex(vertex);
+    if (!segment) {
+      const projection2 = this.skeleton.projectPoint(targetPosition);
+      if (projection2) {
+        return {
+          position: projection2.point,
+          wasConstrained: true,
+          segment: projection2.segment,
+          constraintDistance: projection2.distance
+        };
+      }
+      return {
+        position: {
+          x: vertex.position.x,
+          y: vertex.position.y,
+          z: vertex.position.z
+        },
+        wasConstrained: true,
+        constraintDistance: distance(targetPosition, {
+          x: vertex.position.x,
+          y: vertex.position.y,
+          z: vertex.position.z
+        })
+      };
+    }
+    const projection = segment.projectPoint(targetPosition);
+    if (!projection) {
+      return {
+        position: {
+          x: vertex.position.x,
+          y: vertex.position.y,
+          z: vertex.position.z
+        },
+        wasConstrained: true,
+        segment,
+        constraintDistance: 0
+      };
+    }
+    return {
+      position: projection.point,
+      wasConstrained: true,
+      segment,
+      constraintDistance: projection.distance
+    };
+  }
+  /**
+   * Checks if a vertex can move freely.
+   */
+  canMoveFreely(vertex) {
+    return vertex.type === VertexType.Manifold;
+  }
+  /**
+   * Checks if a vertex is fixed (cannot move).
+   */
+  isFixed(vertex) {
+    return vertex.type === VertexType.SkeletonBranching || vertex.type === VertexType.NonManifoldOther;
+  }
+  /**
+   * Checks if a vertex is constrained to a segment.
+   */
+  isConstrainedToSegment(vertex) {
+    return vertex.type === VertexType.OpenBook;
+  }
+  /**
+   * Gets the segment a vertex is constrained to.
+   */
+  getConstraintSegment(vertex) {
+    if (vertex.type !== VertexType.OpenBook) {
+      return void 0;
+    }
+    return this.skeleton.getSegmentForVertex(vertex);
+  }
+  /**
+   * Computes the allowed movement direction for a vertex.
+   * For open-book vertices, this is the tangent direction of the segment.
+   */
+  getAllowedDirection(vertex) {
+    if (vertex.type !== VertexType.OpenBook) {
+      return null;
+    }
+    const segment = this.skeleton.getSegmentForVertex(vertex);
+    if (!segment || segment.vertices.length < 2) {
+      return null;
+    }
+    const idx = segment.indexOfVertex(vertex);
+    if (idx < 0) {
+      return null;
+    }
+    let p0;
+    let p1;
+    if (idx === 0) {
+      const v0 = segment.vertices[0];
+      const v1 = segment.vertices[1];
+      p0 = { x: v0.position.x, y: v0.position.y, z: v0.position.z };
+      p1 = { x: v1.position.x, y: v1.position.y, z: v1.position.z };
+    } else if (idx === segment.vertices.length - 1) {
+      const v0 = segment.vertices[idx - 1];
+      const v1 = segment.vertices[idx];
+      p0 = { x: v0.position.x, y: v0.position.y, z: v0.position.z };
+      p1 = { x: v1.position.x, y: v1.position.y, z: v1.position.z };
+    } else {
+      const vPrev = segment.vertices[idx - 1];
+      const vNext = segment.vertices[idx + 1];
+      p0 = { x: vPrev.position.x, y: vPrev.position.y, z: vPrev.position.z };
+      p1 = { x: vNext.position.x, y: vNext.position.y, z: vNext.position.z };
+    }
+    const dx = p1.x - p0.x;
+    const dy = p1.y - p0.y;
+    const dz = p1.z - p0.z;
+    const len = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (len < 1e-10) {
+      return null;
+    }
+    return {
+      x: dx / len,
+      y: dy / len,
+      z: dz / len
+    };
+  }
+}
+function createSkeletonConstraints(skeleton) {
+  return new SkeletonConstraints(skeleton);
+}
+function validateGeometry(geometry) {
+  const errors = [];
+  const warnings = [];
+  const positions = geometry.attributes["position"];
+  if (!positions) {
+    errors.push("Geometry must have a position attribute");
+    return { isValid: false, errors, warnings };
+  }
+  const indices = geometry.index;
+  if (!indices) {
+    errors.push("Geometry must be indexed");
+    return { isValid: false, errors, warnings };
+  }
+  if (indices.count % 3 !== 0) {
+    errors.push(`Index count (${indices.count}) must be divisible by 3 for triangle mesh`);
+  }
+  const numVertices = positions.count;
+  for (let i = 0; i < indices.count; i++) {
+    const index = indices.getX(i);
+    if (index < 0 || index >= numVertices) {
+      errors.push(`Invalid index ${index} at position ${i} (vertex count: ${numVertices})`);
+      break;
+    }
+  }
+  let degenerateCount = 0;
+  const numFaces = indices.count / 3;
+  for (let i = 0; i < numFaces; i++) {
+    const i0 = indices.getX(i * 3);
+    const i1 = indices.getX(i * 3 + 1);
+    const i2 = indices.getX(i * 3 + 2);
+    if (i0 === i1 || i1 === i2 || i2 === i0) {
+      degenerateCount++;
+    }
+  }
+  if (degenerateCount > 0) {
+    warnings.push(`Found ${degenerateCount} degenerate triangle(s) with repeated vertices`);
+  }
+  let invalidPositionCount = 0;
+  for (let i = 0; i < numVertices; i++) {
+    const x = positions.getX(i);
+    const y = positions.getY(i);
+    const z = positions.getZ(i);
+    if (!isFinite(x) || !isFinite(y) || !isFinite(z)) {
+      invalidPositionCount++;
+    }
+  }
+  if (invalidPositionCount > 0) {
+    errors.push(`Found ${invalidPositionCount} vertex position(s) with NaN or Infinity values`);
+  }
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function importBufferGeometry(geometry, options = {}) {
+  const { featureEdges, validate = true } = options;
+  if (validate) {
+    const validation = validateGeometry(geometry);
+    if (!validation.isValid) {
+      throw new Error(`Invalid geometry: ${validation.errors.join("; ")}`);
+    }
+  }
+  return NonManifoldMesh.fromBufferGeometry(geometry, featureEdges);
+}
+class BufferGeometryImporter {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Imports a BufferGeometry into a NonManifoldMesh.
+   */
+  import(geometry) {
+    return importBufferGeometry(geometry, this.options);
+  }
+  /**
+   * Validates a BufferGeometry without importing.
+   */
+  validate(geometry) {
+    return validateGeometry(geometry);
+  }
+  /**
+   * Sets feature edges to preserve during remeshing.
+   */
+  setFeatureEdges(edges) {
+    this.options.featureEdges = edges;
+    return this;
+  }
+  /**
+   * Enables or disables validation.
+   */
+  setValidation(enabled) {
+    this.options.validate = enabled;
+    return this;
+  }
+}
+function exportBufferGeometry(mesh, options = {}) {
+  const { computeNormals = true, smoothNormals = true } = options;
+  const geometry = new BufferGeometry();
+  const faces = mesh.getFaces();
+  if (faces.length === 0) {
+    return geometry;
+  }
+  const vertices = mesh.getVertices();
+  const vertexIndexMap = /* @__PURE__ */ new Map();
+  vertices.forEach((v, i) => {
+    vertexIndexMap.set(v.id, i);
+  });
+  const positions = new Float32Array(vertices.length * 3);
+  vertices.forEach((v, i) => {
+    positions[i * 3] = v.position.x;
+    positions[i * 3 + 1] = v.position.y;
+    positions[i * 3 + 2] = v.position.z;
+  });
+  const indices = [];
+  for (const face of faces) {
+    const verts = face.getVertices();
+    if (!verts) continue;
+    const [v0, v1, v2] = verts;
+    const i0 = vertexIndexMap.get(v0.id);
+    const i1 = vertexIndexMap.get(v1.id);
+    const i2 = vertexIndexMap.get(v2.id);
+    if (i0 !== void 0 && i1 !== void 0 && i2 !== void 0) {
+      indices.push(i0, i1, i2);
+    }
+  }
+  geometry.setAttribute("position", new BufferAttribute(positions, 3));
+  geometry.setIndex(indices);
+  if (computeNormals) {
+    if (smoothNormals) {
+      computeSmoothNormals(geometry, mesh, vertexIndexMap);
+    } else {
+      geometry.computeVertexNormals();
+    }
+  }
+  return geometry;
+}
+function computeSmoothNormals(geometry, mesh, vertexIndexMap) {
+  const vertices = mesh.getVertices();
+  const normals = new Float32Array(vertices.length * 3);
+  const normalCounts = new Uint32Array(vertices.length);
+  for (const face of mesh.getFaces()) {
+    const faceNormal = face.getNormal();
+    if (!faceNormal) continue;
+    const verts = face.getVertices();
+    if (!verts) continue;
+    for (const v of verts) {
+      const idx = vertexIndexMap.get(v.id);
+      if (idx === void 0) continue;
+      const baseIdx = idx * 3;
+      normals[baseIdx] = (normals[baseIdx] ?? 0) + faceNormal.x;
+      normals[baseIdx + 1] = (normals[baseIdx + 1] ?? 0) + faceNormal.y;
+      normals[baseIdx + 2] = (normals[baseIdx + 2] ?? 0) + faceNormal.z;
+      normalCounts[idx] = (normalCounts[idx] ?? 0) + 1;
+    }
+  }
+  for (let i = 0; i < vertices.length; i++) {
+    const count = normalCounts[i] ?? 0;
+    if (count === 0) continue;
+    const baseIdx = i * 3;
+    const nx = (normals[baseIdx] ?? 0) / count;
+    const ny = (normals[baseIdx + 1] ?? 0) / count;
+    const nz = (normals[baseIdx + 2] ?? 0) / count;
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+    if (len > 1e-10) {
+      normals[i * 3] = nx / len;
+      normals[i * 3 + 1] = ny / len;
+      normals[i * 3 + 2] = nz / len;
+    } else {
+      normals[i * 3] = 0;
+      normals[i * 3 + 1] = 1;
+      normals[i * 3 + 2] = 0;
+    }
+  }
+  geometry.setAttribute("normal", new BufferAttribute(normals, 3));
+}
+function exportSkeletonGeometry(mesh) {
+  const geometry = new BufferGeometry();
+  const skeletonEdges = mesh.getSkeletonEdges();
+  if (skeletonEdges.length === 0) {
+    return geometry;
+  }
+  const positions = new Float32Array(skeletonEdges.length * 6);
+  let offset = 0;
+  for (const edge of skeletonEdges) {
+    const [v0, v1] = edge.getVertices();
+    if (!v0 || !v1) continue;
+    positions[offset++] = v0.position.x;
+    positions[offset++] = v0.position.y;
+    positions[offset++] = v0.position.z;
+    positions[offset++] = v1.position.x;
+    positions[offset++] = v1.position.y;
+    positions[offset++] = v1.position.z;
+  }
+  geometry.setAttribute("position", new BufferAttribute(positions.slice(0, offset), 3));
+  return geometry;
+}
+function exportClassificationGeometry(mesh) {
+  const baseGeometry = exportBufferGeometry(mesh, { computeNormals: true });
+  const vertices = mesh.getVertices();
+  const colors = new Float32Array(vertices.length * 3);
+  const vertexIndexMap = /* @__PURE__ */ new Map();
+  vertices.forEach((v, i) => {
+    vertexIndexMap.set(v.id, i);
+  });
+  for (const vertex of vertices) {
+    const idx = vertexIndexMap.get(vertex.id);
+    if (idx === void 0) continue;
+    let r = 0, g = 0, b = 0;
+    switch (vertex.type) {
+      case "manifold":
+        r = 0.2;
+        g = 0.8;
+        b = 0.2;
+        break;
+      case "open_book":
+        r = 0.2;
+        g = 0.4;
+        b = 0.9;
+        break;
+      case "skeleton_branching":
+        r = 0.9;
+        g = 0.2;
+        b = 0.2;
+        break;
+      case "non_manifold_other":
+        r = 0.9;
+        g = 0.2;
+        b = 0.9;
+        break;
+    }
+    colors[idx * 3] = r;
+    colors[idx * 3 + 1] = g;
+    colors[idx * 3 + 2] = b;
+  }
+  baseGeometry.setAttribute("color", new BufferAttribute(colors, 3));
+  return baseGeometry;
+}
+function exportQualityGeometry(mesh) {
+  const faces = mesh.getFaces();
+  if (faces.length === 0) {
+    return new BufferGeometry();
+  }
+  const positions = new Float32Array(faces.length * 9);
+  const colors = new Float32Array(faces.length * 9);
+  const normals = new Float32Array(faces.length * 9);
+  let offset = 0;
+  for (const face of faces) {
+    const verts = face.getVertices();
+    const normal = face.getNormal();
+    const quality = face.getQuality() ?? 0;
+    if (!verts || !normal) continue;
+    const r = quality < 0.5 ? 1 : 2 - quality * 2;
+    const g = quality < 0.5 ? quality * 2 : 1;
+    const b = 0.1;
+    for (const v of verts) {
+      positions[offset] = v.position.x;
+      positions[offset + 1] = v.position.y;
+      positions[offset + 2] = v.position.z;
+      colors[offset] = r;
+      colors[offset + 1] = g;
+      colors[offset + 2] = b;
+      normals[offset] = normal.x;
+      normals[offset + 1] = normal.y;
+      normals[offset + 2] = normal.z;
+      offset += 3;
+    }
+  }
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", new BufferAttribute(positions.slice(0, offset), 3));
+  geometry.setAttribute("color", new BufferAttribute(colors.slice(0, offset), 3));
+  geometry.setAttribute("normal", new BufferAttribute(normals.slice(0, offset), 3));
+  return geometry;
+}
+class BufferGeometryExporter {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Exports a NonManifoldMesh to BufferGeometry.
+   */
+  export(mesh) {
+    return exportBufferGeometry(mesh, this.options);
+  }
+  /**
+   * Exports skeleton edges as LineSegments geometry.
+   */
+  exportSkeleton(mesh) {
+    return exportSkeletonGeometry(mesh);
+  }
+  /**
+   * Exports with vertex classification colors.
+   */
+  exportClassification(mesh) {
+    return exportClassificationGeometry(mesh);
+  }
+  /**
+   * Exports with quality visualization colors.
+   */
+  exportQuality(mesh) {
+    return exportQualityGeometry(mesh);
+  }
+  /**
+   * Sets whether to compute normals.
+   */
+  setComputeNormals(enabled) {
+    this.options.computeNormals = enabled;
+    return this;
+  }
+  /**
+   * Sets whether to use smooth normals.
+   */
+  setSmoothNormals(enabled) {
+    this.options.smoothNormals = enabled;
+    return this;
+  }
+}
+class SpatialHash {
+  /**
+   * Creates a new spatial hash with the specified cell size.
+   *
+   * @param cellSize - The size of each cell in the grid
+   */
+  constructor(cellSize) {
+    this.cells = /* @__PURE__ */ new Map();
+    this.itemPositions = /* @__PURE__ */ new Map();
+    if (cellSize <= 0) {
+      throw new Error("Cell size must be positive");
+    }
+    this.cellSize = cellSize;
+  }
+  /**
+   * Computes the cell key for a position.
+   */
+  getCellKey(x, y, z) {
+    const ix = Math.floor(x / this.cellSize);
+    const iy = Math.floor(y / this.cellSize);
+    const iz = Math.floor(z / this.cellSize);
+    return `${ix},${iy},${iz}`;
+  }
+  /**
+   * Computes the cell indices for a position.
+   */
+  getCellIndices(x, y, z) {
+    return [
+      Math.floor(x / this.cellSize),
+      Math.floor(y / this.cellSize),
+      Math.floor(z / this.cellSize)
+    ];
+  }
+  /**
+   * Inserts an item at the specified position.
+   *
+   * @param item - The item to insert
+   * @param position - The 3D position of the item
+   */
+  insert(item, position) {
+    const key = this.getCellKey(position.x, position.y, position.z);
+    let cell = this.cells.get(key);
+    if (!cell) {
+      cell = [];
+      this.cells.set(key, cell);
+    }
+    cell.push(item);
+    this.itemPositions.set(item, position);
+  }
+  /**
+   * Removes an item from the hash.
+   *
+   * @param item - The item to remove
+   * @returns True if the item was found and removed
+   */
+  remove(item) {
+    const position = this.itemPositions.get(item);
+    if (!position) {
+      return false;
+    }
+    const key = this.getCellKey(position.x, position.y, position.z);
+    const cell = this.cells.get(key);
+    if (cell) {
+      const index = cell.indexOf(item);
+      if (index !== -1) {
+        cell.splice(index, 1);
+        if (cell.length === 0) {
+          this.cells.delete(key);
+        }
+      }
+    }
+    this.itemPositions.delete(item);
+    return true;
+  }
+  /**
+   * Updates an item's position in the hash.
+   *
+   * @param item - The item to update
+   * @param newPosition - The new position
+   */
+  update(item, newPosition) {
+    this.remove(item);
+    this.insert(item, newPosition);
+  }
+  /**
+   * 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, radius) {
+    const results = [];
+    const radiusSquared = radius * radius;
+    const minCell = this.getCellIndices(center.x - radius, center.y - radius, center.z - radius);
+    const maxCell = this.getCellIndices(center.x + radius, center.y + radius, center.z + radius);
+    for (let ix = minCell[0]; ix <= maxCell[0]; ix++) {
+      for (let iy = minCell[1]; iy <= maxCell[1]; iy++) {
+        for (let iz = minCell[2]; iz <= maxCell[2]; iz++) {
+          const key = `${ix},${iy},${iz}`;
+          const cell = this.cells.get(key);
+          if (cell) {
+            for (const item of cell) {
+              const pos = this.itemPositions.get(item);
+              if (pos) {
+                const dx = pos.x - center.x;
+                const dy = pos.y - center.y;
+                const dz = pos.z - center.z;
+                const distSq = dx * dx + dy * dy + dz * dz;
+                if (distSq <= radiusSquared) {
+                  results.push(item);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * 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, k, maxRadius) {
+    let radius = this.cellSize;
+    let results = [];
+    while (results.length < k) {
+      if (maxRadius !== void 0 && radius > maxRadius) {
+        break;
+      }
+      results = [];
+      const candidates = this.queryRadius(center, radius);
+      for (const item of candidates) {
+        const pos = this.itemPositions.get(item);
+        if (pos) {
+          const dx = pos.x - center.x;
+          const dy = pos.y - center.y;
+          const dz = pos.z - center.z;
+          results.push({ item, distSq: dx * dx + dy * dy + dz * dz });
+        }
+      }
+      radius *= 2;
+    }
+    results.sort((a, b) => a.distSq - b.distSq);
+    return results.slice(0, k).map((r) => r.item);
+  }
+  /**
+   * Clears all items from the hash.
+   */
+  clear() {
+    this.cells.clear();
+    this.itemPositions.clear();
+  }
+  /**
+   * Gets the number of items in the hash.
+   */
+  get size() {
+    return this.itemPositions.size;
+  }
+  /**
+   * Gets the number of non-empty cells.
+   */
+  get cellCount() {
+    return this.cells.size;
+  }
+  /**
+   * Gets the position of an item.
+   */
+  getPosition(item) {
+    return this.itemPositions.get(item);
+  }
+  /**
+   * Checks if an item is in the hash.
+   */
+  has(item) {
+    return this.itemPositions.has(item);
+  }
+  /**
+   * Iterates over all items in the hash.
+   */
+  *[Symbol.iterator]() {
+    for (const item of this.itemPositions.keys()) {
+      yield item;
+    }
+  }
+  /**
+   * Gets all items in the hash.
+   */
+  getAll() {
+    return Array.from(this.itemPositions.keys());
+  }
+}
+function createSpatialHash(items, getPosition, cellSize) {
+  let computedCellSize = cellSize;
+  if (computedCellSize === void 0 && items.length > 1) {
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    for (const item of items) {
+      const pos = getPosition(item);
+      minX = Math.min(minX, pos.x);
+      minY = Math.min(minY, pos.y);
+      minZ = Math.min(minZ, pos.z);
+      maxX = Math.max(maxX, pos.x);
+      maxY = Math.max(maxY, pos.y);
+      maxZ = Math.max(maxZ, pos.z);
+    }
+    const diagonal = Math.sqrt((maxX - minX) ** 2 + (maxY - minY) ** 2 + (maxZ - minZ) ** 2);
+    computedCellSize = diagonal / Math.sqrt(items.length);
+  }
+  const hash = new SpatialHash(computedCellSize ?? 1);
+  for (const item of items) {
+    hash.insert(item, getPosition(item));
+  }
+  return hash;
+}
+function triangleBounds(tri) {
+  return {
+    min: {
+      x: Math.min(tri.v0.x, tri.v1.x, tri.v2.x),
+      y: Math.min(tri.v0.y, tri.v1.y, tri.v2.y),
+      z: Math.min(tri.v0.z, tri.v1.z, tri.v2.z)
+    },
+    max: {
+      x: Math.max(tri.v0.x, tri.v1.x, tri.v2.x),
+      y: Math.max(tri.v0.y, tri.v1.y, tri.v2.y),
+      z: Math.max(tri.v0.z, tri.v1.z, tri.v2.z)
+    }
+  };
+}
+function mergeBounds(a, b) {
+  return {
+    min: {
+      x: Math.min(a.min.x, b.min.x),
+      y: Math.min(a.min.y, b.min.y),
+      z: Math.min(a.min.z, b.min.z)
+    },
+    max: {
+      x: Math.max(a.max.x, b.max.x),
+      y: Math.max(a.max.y, b.max.y),
+      z: Math.max(a.max.z, b.max.z)
+    }
+  };
+}
+function triangleCentroid(tri) {
+  return {
+    x: (tri.v0.x + tri.v1.x + tri.v2.x) / 3,
+    y: (tri.v0.y + tri.v1.y + tri.v2.y) / 3,
+    z: (tri.v0.z + tri.v1.z + tri.v2.z) / 3
+  };
+}
+function pointToAABBDistanceSquared(point, box) {
+  let distSq = 0;
+  if (point.x < box.min.x) {
+    distSq += (box.min.x - point.x) ** 2;
+  } else if (point.x > box.max.x) {
+    distSq += (point.x - box.max.x) ** 2;
+  }
+  if (point.y < box.min.y) {
+    distSq += (box.min.y - point.y) ** 2;
+  } else if (point.y > box.max.y) {
+    distSq += (point.y - box.max.y) ** 2;
+  }
+  if (point.z < box.min.z) {
+    distSq += (box.min.z - point.z) ** 2;
+  } else if (point.z > box.max.z) {
+    distSq += (point.z - box.max.z) ** 2;
+  }
+  return distSq;
+}
+function closestPointOnTriangle(point, tri) {
+  const a = tri.v0;
+  const b = tri.v1;
+  const c = tri.v2;
+  const ab = { x: b.x - a.x, y: b.y - a.y, z: b.z - a.z };
+  const ac = { x: c.x - a.x, y: c.y - a.y, z: c.z - a.z };
+  const ap = { x: point.x - a.x, y: point.y - a.y, z: point.z - a.z };
+  const d1 = ab.x * ap.x + ab.y * ap.y + ab.z * ap.z;
+  const d2 = ac.x * ap.x + ac.y * ap.y + ac.z * ap.z;
+  if (d1 <= 0 && d2 <= 0) return a;
+  const bp = { x: point.x - b.x, y: point.y - b.y, z: point.z - b.z };
+  const d3 = ab.x * bp.x + ab.y * bp.y + ab.z * bp.z;
+  const d4 = ac.x * bp.x + ac.y * bp.y + ac.z * bp.z;
+  if (d3 >= 0 && d4 <= d3) return b;
+  const vc = d1 * d4 - d3 * d2;
+  if (vc <= 0 && d1 >= 0 && d3 <= 0) {
+    const v2 = d1 / (d1 - d3);
+    return { x: a.x + v2 * ab.x, y: a.y + v2 * ab.y, z: a.z + v2 * ab.z };
+  }
+  const cp = { x: point.x - c.x, y: point.y - c.y, z: point.z - c.z };
+  const d5 = ab.x * cp.x + ab.y * cp.y + ab.z * cp.z;
+  const d6 = ac.x * cp.x + ac.y * cp.y + ac.z * cp.z;
+  if (d6 >= 0 && d5 <= d6) return c;
+  const vb = d5 * d2 - d1 * d6;
+  if (vb <= 0 && d2 >= 0 && d6 <= 0) {
+    const w2 = d2 / (d2 - d6);
+    return { x: a.x + w2 * ac.x, y: a.y + w2 * ac.y, z: a.z + w2 * ac.z };
+  }
+  const va = d3 * d6 - d5 * d4;
+  if (va <= 0 && d4 - d3 >= 0 && d5 - d6 >= 0) {
+    const w2 = (d4 - d3) / (d4 - d3 + (d5 - d6));
+    return {
+      x: b.x + w2 * (c.x - b.x),
+      y: b.y + w2 * (c.y - b.y),
+      z: b.z + w2 * (c.z - b.z)
+    };
+  }
+  const denom = 1 / (va + vb + vc);
+  const v = vb * denom;
+  const w = vc * denom;
+  return {
+    x: a.x + ab.x * v + ac.x * w,
+    y: a.y + ab.y * v + ac.y * w,
+    z: a.z + ab.z * v + ac.z * w
+  };
+}
+class BVH {
+  /**
+   * Creates a new BVH.
+   *
+   * @param maxLeafSize - Maximum number of triangles per leaf node
+   */
+  constructor(maxLeafSize = 4) {
+    this.root = null;
+    this.triangles = [];
+    this.maxLeafSize = maxLeafSize;
+  }
+  /**
+   * Builds the BVH from an array of triangles.
+   *
+   * @param triangles - Array of triangles to build from
+   */
+  build(triangles) {
+    this.triangles = triangles;
+    if (triangles.length === 0) {
+      this.root = null;
+      return;
+    }
+    const indices = triangles.map((_, i) => i);
+    this.root = this.buildNode(indices);
+  }
+  /**
+   * Recursively builds a BVH node.
+   */
+  buildNode(indices) {
+    let bounds = triangleBounds(this.triangles[indices[0]]);
+    for (let i = 1; i < indices.length; i++) {
+      bounds = mergeBounds(bounds, triangleBounds(this.triangles[indices[i]]));
+    }
+    if (indices.length <= this.maxLeafSize) {
+      return { bounds, triangleIndices: indices };
+    }
+    const extents = {
+      x: bounds.max.x - bounds.min.x,
+      y: bounds.max.y - bounds.min.y,
+      z: bounds.max.z - bounds.min.z
+    };
+    let axis = "x";
+    if (extents.y > extents.x && extents.y > extents.z) axis = "y";
+    else if (extents.z > extents.x && extents.z > extents.y) axis = "z";
+    const centroids = indices.map((i) => ({
+      index: i,
+      centroid: triangleCentroid(this.triangles[i])
+    }));
+    centroids.sort((a, b) => a.centroid[axis] - b.centroid[axis]);
+    const mid = Math.floor(centroids.length / 2);
+    const leftIndices = centroids.slice(0, mid).map((c) => c.index);
+    const rightIndices = centroids.slice(mid).map((c) => c.index);
+    if (leftIndices.length === 0 || rightIndices.length === 0) {
+      return { bounds, triangleIndices: indices };
+    }
+    return {
+      bounds,
+      left: this.buildNode(leftIndices),
+      right: this.buildNode(rightIndices)
+    };
+  }
+  /**
+   * 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) {
+    if (!this.root || this.triangles.length === 0) {
+      return null;
+    }
+    let bestResult = null;
+    let bestDistSq = Infinity;
+    const stack = [this.root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      const boxDistSq = pointToAABBDistanceSquared(point, node.bounds);
+      if (boxDistSq >= bestDistSq) {
+        continue;
+      }
+      if (node.triangleIndices) {
+        for (const idx of node.triangleIndices) {
+          const tri = this.triangles[idx];
+          const closest = closestPointOnTriangle(point, tri);
+          const distSq = distanceSquared(point, closest);
+          if (distSq < bestDistSq) {
+            bestDistSq = distSq;
+            bestResult = {
+              point: closest,
+              distance: Math.sqrt(distSq),
+              triangleIndex: idx
+            };
+          }
+        }
+      } else {
+        if (node.left && node.right) {
+          const leftDist = pointToAABBDistanceSquared(point, node.left.bounds);
+          const rightDist = pointToAABBDistanceSquared(point, node.right.bounds);
+          if (leftDist < rightDist) {
+            stack.push(node.right);
+            stack.push(node.left);
+          } else {
+            stack.push(node.left);
+            stack.push(node.right);
+          }
+        } else if (node.left) {
+          stack.push(node.left);
+        } else if (node.right) {
+          stack.push(node.right);
+        }
+      }
+    }
+    return bestResult;
+  }
+  /**
+   * 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, radius) {
+    const results = [];
+    const radiusSq = radius * radius;
+    if (!this.root) {
+      return results;
+    }
+    const stack = [this.root];
+    while (stack.length > 0) {
+      const node = stack.pop();
+      const boxDistSq = pointToAABBDistanceSquared(center, node.bounds);
+      if (boxDistSq > radiusSq) {
+        continue;
+      }
+      if (node.triangleIndices) {
+        for (const idx of node.triangleIndices) {
+          const tri = this.triangles[idx];
+          const closest = closestPointOnTriangle(center, tri);
+          const distSq = distanceSquared(center, closest);
+          if (distSq <= radiusSq) {
+            results.push(idx);
+          }
+        }
+      } else {
+        if (node.left) stack.push(node.left);
+        if (node.right) stack.push(node.right);
+      }
+    }
+    return results;
+  }
+  /**
+   * Gets the total number of triangles.
+   */
+  get triangleCount() {
+    return this.triangles.length;
+  }
+  /**
+   * Gets a triangle by index.
+   */
+  getTriangle(index) {
+    return this.triangles[index];
+  }
+}
+function createBVHFromMesh(mesh) {
+  const triangles = [];
+  for (const face of mesh.getFaces()) {
+    const verts = face.getVertices();
+    if (!verts) continue;
+    triangles.push({
+      v0: { x: verts[0].position.x, y: verts[0].position.y, z: verts[0].position.z },
+      v1: { x: verts[1].position.x, y: verts[1].position.y, z: verts[1].position.z },
+      v2: { x: verts[2].position.x, y: verts[2].position.y, z: verts[2].position.z }
+    });
+  }
+  const bvh = new BVH();
+  bvh.build(triangles);
+  return bvh;
+}
+function analyzeManifold(geometry) {
+  const mesh = NonManifoldMesh.fromBufferGeometry(geometry);
+  return analyzeMesh(mesh);
+}
+function analyzeMesh(mesh) {
+  const edges = mesh.getEdges();
+  const vertices = mesh.getVertices();
+  let manifoldEdgeCount = 0;
+  let nonManifoldEdgeCount = 0;
+  let boundaryEdgeCount = 0;
+  const nonManifoldEdges = [];
+  for (const edge of edges) {
+    switch (edge.type) {
+      case EdgeType.Manifold:
+      case EdgeType.Feature:
+        manifoldEdgeCount++;
+        break;
+      case EdgeType.NonManifold:
+        nonManifoldEdgeCount++;
+        nonManifoldEdges.push(extractEdgeInfo(edge));
+        break;
+      case EdgeType.Boundary:
+        boundaryEdgeCount++;
+        break;
+    }
+  }
+  let manifoldVertexCount = 0;
+  let nonManifoldVertexCount = 0;
+  let totalDegree = 0;
+  const nonManifoldVertices = [];
+  for (const vertex of vertices) {
+    const degree = vertex.degree() ?? 0;
+    totalDegree += degree;
+    if (vertex.type === VertexType.Manifold) {
+      manifoldVertexCount++;
+    } else {
+      nonManifoldVertexCount++;
+      nonManifoldVertices.push(extractVertexInfo(vertex));
+    }
+  }
+  const averageVertexDegree = vertices.length > 0 ? totalDegree / vertices.length : 0;
+  const eulerCharacteristic = mesh.vertexCount - mesh.edgeCount + mesh.faceCount;
+  return {
+    isManifold: nonManifoldEdgeCount === 0,
+    hasBoundary: boundaryEdgeCount > 0,
+    vertexCount: mesh.vertexCount,
+    edgeCount: mesh.edgeCount,
+    faceCount: mesh.faceCount,
+    manifoldEdgeCount,
+    nonManifoldEdgeCount,
+    boundaryEdgeCount,
+    manifoldVertexCount,
+    nonManifoldVertexCount,
+    nonManifoldEdges,
+    nonManifoldVertices,
+    eulerCharacteristic,
+    averageVertexDegree
+  };
+}
+function extractEdgeInfo(edge) {
+  const [v0, v1] = edge.getVertices();
+  return {
+    edgeId: edge.id,
+    vertexIndices: [v0 ? v0.id : -1, v1 ? v1.id : -1],
+    faceCount: edge.getFaceCount(),
+    positions: [
+      v0 ? { x: v0.position.x, y: v0.position.y, z: v0.position.z } : { x: 0, y: 0, z: 0 },
+      v1 ? { x: v1.position.x, y: v1.position.y, z: v1.position.z } : { x: 0, y: 0, z: 0 }
+    ]
+  };
+}
+function extractVertexInfo(vertex) {
+  let skeletonEdgeCount = 0;
+  vertex.forEachOutgoingHalfedge((he) => {
+    if (he.edge.isSkeletonEdge()) {
+      skeletonEdgeCount++;
+    }
+  });
+  return {
+    vertexId: vertex.id,
+    position: { x: vertex.position.x, y: vertex.position.y, z: vertex.position.z },
+    type: vertex.type,
+    skeletonEdgeCount
+  };
+}
+function isManifold(geometry) {
+  const mesh = NonManifoldMesh.fromBufferGeometry(geometry);
+  return mesh.isManifold();
+}
+class ManifoldAnalyzer {
+  constructor() {
+    this.mesh = null;
+    this.cachedResult = null;
+  }
+  /**
+   * Loads a geometry for analysis.
+   */
+  load(geometry) {
+    this.mesh = NonManifoldMesh.fromBufferGeometry(geometry);
+    this.cachedResult = null;
+    return this;
+  }
+  /**
+   * Loads an existing mesh for analysis.
+   */
+  loadMesh(mesh) {
+    this.mesh = mesh;
+    this.cachedResult = null;
+    return this;
+  }
+  /**
+   * Gets the analysis result (cached).
+   */
+  analyze() {
+    if (!this.mesh) {
+      throw new Error("No mesh loaded. Call load() first.");
+    }
+    if (!this.cachedResult) {
+      this.cachedResult = analyzeMesh(this.mesh);
+    }
+    return this.cachedResult;
+  }
+  /**
+   * Checks if the mesh is manifold.
+   */
+  isManifold() {
+    return this.analyze().isManifold;
+  }
+  /**
+   * Checks if the mesh has boundary.
+   */
+  hasBoundary() {
+    return this.analyze().hasBoundary;
+  }
+  /**
+   * Gets non-manifold edges.
+   */
+  getNonManifoldEdges() {
+    return this.analyze().nonManifoldEdges;
+  }
+  /**
+   * Gets non-manifold vertices.
+   */
+  getNonManifoldVertices() {
+    return this.analyze().nonManifoldVertices;
+  }
+  /**
+   * Gets the underlying mesh.
+   */
+  getMesh() {
+    return this.mesh;
+  }
+  /**
+   * Clears cached results.
+   */
+  clearCache() {
+    this.cachedResult = null;
+    return this;
+  }
+}
+function classifyAllVertices(mesh) {
+  const stats = {
+    manifold: 0,
+    openBook: 0,
+    skeletonBranching: 0,
+    nonManifoldOther: 0,
+    total: 0
+  };
+  for (const vertex of mesh.getVertices()) {
+    vertex.type = classifyVertex(vertex);
+    stats.total++;
+    switch (vertex.type) {
+      case VertexType.Manifold:
+        stats.manifold++;
+        break;
+      case VertexType.OpenBook:
+        stats.openBook++;
+        break;
+      case VertexType.SkeletonBranching:
+        stats.skeletonBranching++;
+        break;
+      case VertexType.NonManifoldOther:
+        stats.nonManifoldOther++;
+        break;
+    }
+  }
+  return stats;
+}
+function classifyVertex(vertex) {
+  let skeletonEdgeCount = 0;
+  let totalEdgeCount = 0;
+  let hasBoundary = false;
+  let hasNonManifold = false;
+  vertex.forEachOutgoingHalfedge((he) => {
+    totalEdgeCount++;
+    if (he.edge.isSkeletonEdge()) {
+      skeletonEdgeCount++;
+    }
+    if (he.edge.isBoundary()) {
+      hasBoundary = true;
+    }
+    if (he.edge.isNonManifold()) {
+      hasNonManifold = true;
+    }
+  });
+  if (totalEdgeCount === 0) {
+    return VertexType.Manifold;
+  }
+  if (hasNonManifold) {
+    if (skeletonEdgeCount === 2) {
+      return VertexType.OpenBook;
+    } else if (skeletonEdgeCount === 1 || skeletonEdgeCount > 2) {
+      return VertexType.SkeletonBranching;
+    }
+    return VertexType.NonManifoldOther;
+  }
+  if (hasBoundary) {
+    if (skeletonEdgeCount === 2) {
+      return VertexType.OpenBook;
+    } else if (skeletonEdgeCount === 1 || skeletonEdgeCount > 2) {
+      return VertexType.SkeletonBranching;
+    }
+  }
+  if (skeletonEdgeCount === 0) {
+    return VertexType.Manifold;
+  }
+  if (skeletonEdgeCount === 2) {
+    return VertexType.OpenBook;
+  }
+  return VertexType.SkeletonBranching;
+}
+function getVerticesByType(mesh, type) {
+  return mesh.getVertices().filter((v) => v.type === type);
+}
+function getManifoldVertices(mesh) {
+  return getVerticesByType(mesh, VertexType.Manifold);
+}
+function getOpenBookVertices(mesh) {
+  return getVerticesByType(mesh, VertexType.OpenBook);
+}
+function getSkeletonBranchingVertices(mesh) {
+  return getVerticesByType(mesh, VertexType.SkeletonBranching);
+}
+function getNonManifoldVertices(mesh) {
+  return mesh.getVertices().filter((v) => v.type !== VertexType.Manifold);
+}
+function reclassifyVertices(mesh) {
+  mesh.classifyVertices();
+}
+class VertexClassifier {
+  constructor(mesh) {
+    this.mesh = mesh;
+  }
+  /**
+   * Classifies all vertices and returns statistics.
+   */
+  classifyAll() {
+    return classifyAllVertices(this.mesh);
+  }
+  /**
+   * Gets vertices of a specific type.
+   */
+  getByType(type) {
+    return getVerticesByType(this.mesh, type);
+  }
+  /**
+   * Gets all manifold vertices.
+   */
+  getManifold() {
+    return getManifoldVertices(this.mesh);
+  }
+  /**
+   * Gets all non-manifold vertices.
+   */
+  getNonManifold() {
+    return getNonManifoldVertices(this.mesh);
+  }
+  /**
+   * Reclassifies all vertices.
+   */
+  reclassify() {
+    reclassifyVertices(this.mesh);
+  }
+}
+function validateTopology(mesh) {
+  const errors = [];
+  const warnings = [];
+  validateVertices(mesh, errors);
+  validateEdges(mesh, errors, warnings);
+  validateFaces(mesh, errors, warnings);
+  validateHalfedgeConnectivity(mesh, errors);
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateVertices(mesh, errors, _warnings) {
+  for (const vertex of mesh.getVertices()) {
+    if (vertex.halfedge) {
+      if (!mesh.getHalfedge(vertex.halfedge.id)) {
+        errors.push({
+          type: "invalid_vertex_halfedge",
+          message: `Vertex ${vertex.id} references non-existent halfedge ${vertex.halfedge.id}`,
+          elementIds: [vertex.id]
+        });
+      }
+    }
+    if (!isFinite(vertex.position.x) || !isFinite(vertex.position.y) || !isFinite(vertex.position.z)) {
+      errors.push({
+        type: "invalid_vertex_position",
+        message: `Vertex ${vertex.id} has invalid position`,
+        elementIds: [vertex.id]
+      });
+    }
+  }
+}
+function validateEdges(mesh, errors, warnings) {
+  for (const edge of mesh.getEdges()) {
+    if (edge.allHalfedges.length === 0) {
+      errors.push({
+        type: "edge_no_halfedges",
+        message: `Edge ${edge.id} has no halfedges`,
+        elementIds: [edge.id]
+      });
+      continue;
+    }
+    if (!mesh.getHalfedge(edge.halfedge.id)) {
+      errors.push({
+        type: "invalid_edge_halfedge",
+        message: `Edge ${edge.id} references non-existent halfedge`,
+        elementIds: [edge.id]
+      });
+    }
+    if (edge.length <= 0 || !isFinite(edge.length)) {
+      warnings.push({
+        type: "invalid_edge_length",
+        message: `Edge ${edge.id} has invalid length: ${edge.length}`,
+        elementIds: [edge.id]
+      });
+    }
+    for (const he of edge.allHalfedges) {
+      if (he.edge.id !== edge.id) {
+        errors.push({
+          type: "halfedge_edge_mismatch",
+          message: `Halfedge ${he.id} in edge ${edge.id} references different edge ${he.edge.id}`,
+          elementIds: [edge.id, he.id]
+        });
+      }
+    }
+  }
+}
+function validateFaces(mesh, errors, warnings) {
+  var _a;
+  for (const face of mesh.getFaces()) {
+    if (!face.halfedge) {
+      errors.push({
+        type: "face_no_halfedge",
+        message: `Face ${face.id} has no halfedge`,
+        elementIds: [face.id]
+      });
+      continue;
+    }
+    if (!mesh.getHalfedge(face.halfedge.id)) {
+      errors.push({
+        type: "invalid_face_halfedge",
+        message: `Face ${face.id} references non-existent halfedge`,
+        elementIds: [face.id]
+      });
+      continue;
+    }
+    const halfedges = face.getHalfedges();
+    if (!halfedges) {
+      errors.push({
+        type: "face_invalid_loop",
+        message: `Face ${face.id} has invalid halfedge loop`,
+        elementIds: [face.id]
+      });
+      continue;
+    }
+    for (const he of halfedges) {
+      if (((_a = he.face) == null ? void 0 : _a.id) !== face.id) {
+        errors.push({
+          type: "halfedge_face_mismatch",
+          message: `Halfedge ${he.id} in face ${face.id} references different face`,
+          elementIds: [face.id, he.id]
+        });
+      }
+    }
+    if (face.isDegenerate()) {
+      warnings.push({
+        type: "degenerate_face",
+        message: `Face ${face.id} is degenerate (near-zero area)`,
+        elementIds: [face.id]
+      });
+    }
+  }
+}
+function validateHalfedgeConnectivity(mesh, errors, _warnings) {
+  for (const he of mesh.getHalfedges()) {
+    if (!he.next) {
+      errors.push({
+        type: "halfedge_no_next",
+        message: `Halfedge ${he.id} has no next pointer`,
+        elementIds: [he.id]
+      });
+    } else if (!mesh.getHalfedge(he.next.id)) {
+      errors.push({
+        type: "halfedge_invalid_next",
+        message: `Halfedge ${he.id} has invalid next pointer`,
+        elementIds: [he.id]
+      });
+    }
+    if (!he.prev) {
+      errors.push({
+        type: "halfedge_no_prev",
+        message: `Halfedge ${he.id} has no prev pointer`,
+        elementIds: [he.id]
+      });
+    } else if (!mesh.getHalfedge(he.prev.id)) {
+      errors.push({
+        type: "halfedge_invalid_prev",
+        message: `Halfedge ${he.id} has invalid prev pointer`,
+        elementIds: [he.id]
+      });
+    }
+    if (he.next && he.next.prev !== he) {
+      errors.push({
+        type: "halfedge_next_prev_mismatch",
+        message: `Halfedge ${he.id}: next.prev does not point back`,
+        elementIds: [he.id]
+      });
+    }
+    if (he.prev && he.prev.next !== he) {
+      errors.push({
+        type: "halfedge_prev_next_mismatch",
+        message: `Halfedge ${he.id}: prev.next does not point back`,
+        elementIds: [he.id]
+      });
+    }
+    if (he.twin) {
+      if (!mesh.getHalfedge(he.twin.id)) {
+        errors.push({
+          type: "halfedge_invalid_twin",
+          message: `Halfedge ${he.id} has invalid twin pointer`,
+          elementIds: [he.id]
+        });
+      } else if (he.twin.twin !== he) {
+        errors.push({
+          type: "halfedge_twin_mismatch",
+          message: `Halfedge ${he.id}: twin.twin does not point back`,
+          elementIds: [he.id]
+        });
+      }
+    }
+    if (!mesh.getVertex(he.vertex.id)) {
+      errors.push({
+        type: "halfedge_invalid_vertex",
+        message: `Halfedge ${he.id} references non-existent vertex`,
+        elementIds: [he.id]
+      });
+    }
+    if (!mesh.getEdge(he.edge.id)) {
+      errors.push({
+        type: "halfedge_invalid_edge",
+        message: `Halfedge ${he.id} references non-existent edge`,
+        elementIds: [he.id]
+      });
+    }
+  }
+}
+function isTopologyValid(mesh) {
+  return validateTopology(mesh).isValid;
+}
+class TopologyValidator {
+  constructor(mesh) {
+    this.mesh = mesh;
+  }
+  /**
+   * Validates the mesh topology.
+   */
+  validate() {
+    return validateTopology(this.mesh);
+  }
+  /**
+   * Quick check if topology is valid.
+   */
+  isValid() {
+    return isTopologyValid(this.mesh);
+  }
+  /**
+   * Gets all errors.
+   */
+  getErrors() {
+    return this.validate().errors;
+  }
+  /**
+   * Gets all warnings.
+   */
+  getWarnings() {
+    return this.validate().warnings;
+  }
+}
+function canFlipEdge(edge) {
+  if (edge.isSkeletonEdge()) {
+    return false;
+  }
+  if (!edge.canFlip()) {
+    return false;
+  }
+  const quad = getQuadVertices(edge);
+  if (!quad) {
+    return false;
+  }
+  return isQuadConvex(quad.v0, quad.v1, quad.v2, quad.v3);
+}
+function getQuadVertices(edge) {
+  const h = edge.halfedge;
+  const hTwin = h.twin;
+  if (!hTwin || !h.face || !hTwin.face) {
+    return null;
+  }
+  const hNext = h.next;
+  const hTwinNext = hTwin.next;
+  if (!hNext || !hTwinNext) {
+    return null;
+  }
+  const v0 = hTwin.vertex;
+  const v1 = h.vertex;
+  const v2 = hNext.vertex;
+  const v3 = hTwinNext.vertex;
+  return {
+    v0: { x: v0.position.x, y: v0.position.y, z: v0.position.z },
+    v1: { x: v1.position.x, y: v1.position.y, z: v1.position.z },
+    v2: { x: v2.position.x, y: v2.position.y, z: v2.position.z },
+    v3: { x: v3.position.x, y: v3.position.y, z: v3.position.z }
+  };
+}
+function flipEdge(_mesh, edge) {
+  if (!canFlipEdge(edge)) {
+    return { success: false, reason: "Edge cannot be flipped" };
+  }
+  const h = edge.halfedge;
+  const hTwin = h.twin;
+  if (!hTwin) {
+    return { success: false, reason: "Edge has no twin" };
+  }
+  const hNext = h.next;
+  const hPrev = h.prev;
+  const hTwinNext = hTwin.next;
+  const hTwinPrev = hTwin.prev;
+  const vA = hTwin.vertex;
+  const vB = h.vertex;
+  const vC = hNext.vertex;
+  const vD = hTwinNext.vertex;
+  const f0 = h.face;
+  const f1 = hTwin.face;
+  if (!f0 || !f1) {
+    return { success: false, reason: "Missing faces" };
+  }
+  const newLength = distance(
+    { x: vC.position.x, y: vC.position.y, z: vC.position.z },
+    { x: vD.position.x, y: vD.position.y, z: vD.position.z }
+  );
+  edge.length = newLength;
+  h.vertex = vD;
+  hTwin.vertex = vC;
+  h.next = hTwinPrev;
+  h.prev = hNext;
+  hTwinPrev.next = hNext;
+  hTwinPrev.prev = h;
+  hNext.next = h;
+  hNext.prev = hTwinPrev;
+  hTwin.next = hPrev;
+  hTwin.prev = hTwinNext;
+  hPrev.next = hTwinNext;
+  hPrev.prev = hTwin;
+  hTwinNext.next = hTwin;
+  hTwinNext.prev = hPrev;
+  h.face = f0;
+  hTwinPrev.face = f0;
+  hNext.face = f0;
+  hTwin.face = f1;
+  hPrev.face = f1;
+  hTwinNext.face = f1;
+  f0.halfedge = h;
+  f1.halfedge = hTwin;
+  if (vA.halfedge === h) {
+    vA.halfedge = hTwinNext;
+  }
+  if (vB.halfedge === hTwin) {
+    vB.halfedge = hNext;
+  }
+  return { success: true, newLength };
+}
+function isDelaunay(edge) {
+  const h = edge.halfedge;
+  const hTwin = h.twin;
+  if (!hTwin || !h.face || !hTwin.face) {
+    return true;
+  }
+  const quad = getQuadVertices(edge);
+  if (!quad) {
+    return true;
+  }
+  const angle0 = computeAngle(quad.v2, quad.v0, quad.v1);
+  const angle1 = computeAngle(quad.v3, quad.v0, quad.v1);
+  return angle0 + angle1 <= Math.PI + 1e-10;
+}
+function computeAngle(v0, v1, v2) {
+  const dx1 = v1.x - v0.x;
+  const dy1 = v1.y - v0.y;
+  const dz1 = v1.z - v0.z;
+  const dx2 = v2.x - v0.x;
+  const dy2 = v2.y - v0.y;
+  const dz2 = v2.z - v0.z;
+  const dot2 = dx1 * dx2 + dy1 * dy2 + dz1 * dz2;
+  const len1 = Math.sqrt(dx1 * dx1 + dy1 * dy1 + dz1 * dz1);
+  const len2 = Math.sqrt(dx2 * dx2 + dy2 * dy2 + dz2 * dz2);
+  if (len1 < 1e-10 || len2 < 1e-10) {
+    return 0;
+  }
+  const cosAngle = Math.max(-1, Math.min(1, dot2 / (len1 * len2)));
+  return Math.acos(cosAngle);
+}
+function makeDelaunay(mesh, maxIterations) {
+  const edges = mesh.getEdges();
+  const maxIter = maxIterations ?? edges.length * 10;
+  let flipCount = 0;
+  let iteration = 0;
+  while (iteration < maxIter) {
+    iteration++;
+    let flippedAny = false;
+    for (const edge of edges) {
+      if (!isDelaunay(edge) && canFlipEdge(edge)) {
+        const result = flipEdge(mesh, edge);
+        if (result.success) {
+          flipCount++;
+          flippedAny = true;
+        }
+      }
+    }
+    if (!flippedAny) {
+      break;
+    }
+  }
+  return flipCount;
+}
+class EdgeFlipper {
+  constructor(mesh) {
+    this.mesh = mesh;
+  }
+  /**
+   * Flips an edge.
+   */
+  flip(edge) {
+    return flipEdge(this.mesh, edge);
+  }
+  /**
+   * Checks if an edge can be flipped.
+   */
+  canFlip(edge) {
+    return canFlipEdge(edge);
+  }
+  /**
+   * Checks if an edge satisfies the Delaunay condition.
+   */
+  isDelaunay(edge) {
+    return isDelaunay(edge);
+  }
+  /**
+   * Makes the mesh Delaunay by flipping non-Delaunay edges.
+   */
+  makeDelaunay(maxIterations) {
+    return makeDelaunay(this.mesh, maxIterations);
+  }
+}
+function splitEdge(mesh, edge, splitRatio = 0.5) {
+  const [v0, v1] = edge.getVertices();
+  if (!v0 || !v1) {
+    return { success: false, reason: "Edge has no vertices" };
+  }
+  const p0 = { x: v0.position.x, y: v0.position.y, z: v0.position.z };
+  const p1 = { x: v1.position.x, y: v1.position.y, z: v1.position.z };
+  const mid = {
+    x: p0.x + (p1.x - p0.x) * splitRatio,
+    y: p0.y + (p1.y - p0.y) * splitRatio,
+    z: p0.z + (p1.z - p0.z) * splitRatio
+  };
+  const newVertex = mesh.createVertex(new Vector3(mid.x, mid.y, mid.z));
+  if (edge.isSkeletonEdge()) ;
+  const newEdges = [];
+  const newFaces = [];
+  const faces = edge.getFaces();
+  if (faces.length === 0) {
+    return { success: true, newVertex, newEdges: [], newFaces: [] };
+  }
+  for (const face of faces) {
+    if (!face) continue;
+    const halfedges = face.getHalfedges();
+    if (!halfedges) continue;
+    let edgeHe = null;
+    for (const he of halfedges) {
+      if (he.edge.id === edge.id) {
+        edgeHe = he;
+        break;
+      }
+    }
+    if (!edgeHe) continue;
+    splitFaceAtEdge(mesh, face, edgeHe, newVertex, newEdges, newFaces);
+  }
+  edge.length = edge.length * splitRatio;
+  mesh.classifyVertices();
+  return { success: true, newVertex, newEdges, newFaces };
+}
+function splitFaceAtEdge(mesh, _face, edgeHe, newVertex, _newEdges, newFaces) {
+  const heNext = edgeHe.next;
+  const vOpposite = heNext.vertex;
+  const vTarget = edgeHe.vertex;
+  const newFace = mesh.createFace(newVertex, vTarget, vOpposite);
+  newFaces.push(newFace);
+  edgeHe.vertex = newVertex;
+  if (!newVertex.halfedge) {
+    newVertex.halfedge = edgeHe;
+  }
+}
+function splitLongEdges(mesh, maxLength) {
+  const newVertices = [];
+  let splitCount = 0;
+  const edgesToSplit = [];
+  for (const edge of mesh.getEdges()) {
+    if (edge.length > maxLength) {
+      edgesToSplit.push(edge);
+    }
+  }
+  for (const edge of edgesToSplit) {
+    const result = splitEdge(mesh, edge);
+    if (result.success && result.newVertex) {
+      splitCount++;
+      newVertices.push(result.newVertex);
+    }
+  }
+  return { splitCount, newVertices };
+}
+class EdgeSplitter {
+  constructor(mesh) {
+    this.mesh = mesh;
+  }
+  /**
+   * Splits an edge at the midpoint.
+   */
+  split(edge, ratio = 0.5) {
+    return splitEdge(this.mesh, edge, ratio);
+  }
+  /**
+   * Splits all edges longer than a threshold.
+   */
+  splitLongEdges(maxLength) {
+    return splitLongEdges(this.mesh, maxLength);
+  }
+  /**
+   * Checks if an edge should be split based on target length.
+   */
+  shouldSplit(edge, targetLength, maxRatio = 1.333) {
+    return edge.length > targetLength * maxRatio;
+  }
+}
+function canContractEdge(edge) {
+  const [v0, v1] = edge.getVertices();
+  if (!v0 || !v1) {
+    return false;
+  }
+  if (v0.type === VertexType.SkeletonBranching || v0.type === VertexType.NonManifoldOther) {
+    if (v1.type === VertexType.SkeletonBranching || v1.type === VertexType.NonManifoldOther) {
+      return false;
+    }
+  }
+  if (v1.type === VertexType.SkeletonBranching || v1.type === VertexType.NonManifoldOther) ;
+  if (!checkLinkCondition(v0, v1)) {
+    return false;
+  }
+  return true;
+}
+function checkLinkCondition(v0, v1) {
+  const link0 = /* @__PURE__ */ new Set();
+  const link1 = /* @__PURE__ */ new Set();
+  v0.forEachNeighbor((v) => {
+    link0.add(v.id);
+  });
+  v1.forEachNeighbor((v) => {
+    link1.add(v.id);
+  });
+  let commonCount = 0;
+  for (const id of link0) {
+    if (id !== v0.id && id !== v1.id && link1.has(id)) {
+      commonCount++;
+    }
+  }
+  const faces = getSharedFaces(v0, v1);
+  const expectedCommon = faces.length;
+  return commonCount <= expectedCommon;
+}
+function getSharedFaces(v0, v1) {
+  const faces0 = /* @__PURE__ */ new Set();
+  const sharedFaces = [];
+  v0.forEachOutgoingHalfedge((he) => {
+    if (he.face) {
+      faces0.add(he.face.id);
+    }
+  });
+  v1.forEachOutgoingHalfedge((he) => {
+    if (he.face && faces0.has(he.face.id)) {
+      sharedFaces.push(he.face);
+    }
+  });
+  return sharedFaces;
+}
+function contractEdge(mesh, edge) {
+  var _a;
+  if (!canContractEdge(edge)) {
+    return { success: false, reason: "Edge cannot be contracted" };
+  }
+  const [v0, v1] = edge.getVertices();
+  if (!v0 || !v1) {
+    return { success: false, reason: "Edge has no vertices" };
+  }
+  const { keepVertex, removeVertex, newPosition } = determineContractionResult(v0, v1);
+  keepVertex.position.set(newPosition.x, newPosition.y, newPosition.z);
+  const removedFaces = getSharedFaces(v0, v1);
+  redirectHalfedges(removeVertex, keepVertex);
+  for (const face of removedFaces) {
+    mesh.faces.delete(face.id);
+  }
+  mesh.edges.delete(edge.id);
+  for (const he of edge.allHalfedges) {
+    mesh.halfedges.delete(he.id);
+  }
+  mesh.vertices.delete(removeVertex.id);
+  if (keepVertex.halfedge && !mesh.halfedges.has(keepVertex.halfedge.id)) {
+    for (const he of mesh.halfedges.values()) {
+      if (((_a = he.getSourceVertex()) == null ? void 0 : _a.id) === keepVertex.id) {
+        keepVertex.halfedge = he;
+        break;
+      }
+    }
+  }
+  mesh.classifyVertices();
+  return { success: true, remainingVertex: keepVertex, removedFaces };
+}
+function determineContractionResult(v0, v1) {
+  const priority = (v) => {
+    switch (v.type) {
+      case VertexType.SkeletonBranching:
+      case VertexType.NonManifoldOther:
+        return 3;
+      case VertexType.OpenBook:
+        return 2;
+      case VertexType.Manifold:
+        return 1;
+      default:
+        return 0;
+    }
+  };
+  const p0 = priority(v0);
+  const p1 = priority(v1);
+  let keepVertex;
+  let removeVertex;
+  let newPosition;
+  if (p0 >= p1) {
+    keepVertex = v0;
+    removeVertex = v1;
+  } else {
+    keepVertex = v1;
+    removeVertex = v0;
+  }
+  if (keepVertex.type === VertexType.SkeletonBranching || keepVertex.type === VertexType.NonManifoldOther) {
+    newPosition = {
+      x: keepVertex.position.x,
+      y: keepVertex.position.y,
+      z: keepVertex.position.z
+    };
+  } else if (keepVertex.type === VertexType.OpenBook && removeVertex.type === VertexType.Manifold) {
+    newPosition = {
+      x: keepVertex.position.x,
+      y: keepVertex.position.y,
+      z: keepVertex.position.z
+    };
+  } else {
+    newPosition = midpoint(
+      { x: v0.position.x, y: v0.position.y, z: v0.position.z },
+      { x: v1.position.x, y: v1.position.y, z: v1.position.z }
+    );
+  }
+  return { keepVertex, removeVertex, newPosition };
+}
+function redirectHalfedges(fromVertex, toVertex) {
+  fromVertex.forEachOutgoingHalfedge((he) => {
+    if (he.twin) {
+      he.twin.vertex = toVertex;
+    }
+  });
+}
+function contractShortEdges(mesh, minLength) {
+  let contractCount = 0;
+  let removedVertices = 0;
+  let edgesToContract = [];
+  for (const edge of mesh.getEdges()) {
+    if (edge.length < minLength && canContractEdge(edge)) {
+      edgesToContract.push(edge);
+    }
+  }
+  while (edgesToContract.length > 0) {
+    const edge = edgesToContract.pop();
+    if (!mesh.edges.has(edge.id) || !canContractEdge(edge)) {
+      continue;
+    }
+    const result = contractEdge(mesh, edge);
+    if (result.success) {
+      contractCount++;
+      removedVertices++;
+    }
+  }
+  return { contractCount, removedVertices };
+}
+class EdgeContractor {
+  constructor(mesh) {
+    this.mesh = mesh;
+  }
+  /**
+   * Contracts an edge.
+   */
+  contract(edge) {
+    return contractEdge(this.mesh, edge);
+  }
+  /**
+   * Checks if an edge can be contracted.
+   */
+  canContract(edge) {
+    return canContractEdge(edge);
+  }
+  /**
+   * Contracts all edges shorter than a threshold.
+   */
+  contractShortEdges(minLength) {
+    return contractShortEdges(this.mesh, minLength);
+  }
+  /**
+   * Checks if an edge should be contracted based on target length.
+   */
+  shouldContract(edge, targetLength, minRatio = 0.4) {
+    return edge.length < targetLength * minRatio;
+  }
+}
+function computeTangentialSmoothing(vertex) {
+  const neighbors = vertex.getNeighbors();
+  if (neighbors.length === 0) {
+    return null;
+  }
+  let cx = 0, cy = 0, cz = 0;
+  for (const n of neighbors) {
+    cx += n.position.x;
+    cy += n.position.y;
+    cz += n.position.z;
+  }
+  cx /= neighbors.length;
+  cy /= neighbors.length;
+  cz /= neighbors.length;
+  const barycenter = { x: cx, y: cy, z: cz };
+  const normal = computeVertexNormal(vertex);
+  if (!normal) {
+    return barycenter;
+  }
+  const vertexPos = { x: vertex.position.x, y: vertex.position.y, z: vertex.position.z };
+  const toBarycenter = subtract(barycenter, vertexPos);
+  const normalComponent = scale(normal, dot(toBarycenter, normal));
+  const tangentComponent = subtract(toBarycenter, normalComponent);
+  return add(vertexPos, tangentComponent);
+}
+function computeVertexNormal(vertex) {
+  let nx = 0, ny = 0, nz = 0;
+  let count = 0;
+  vertex.forEachOutgoingHalfedge((he) => {
+    if (he.face) {
+      const faceNormal = he.face.getNormal();
+      if (faceNormal) {
+        nx += faceNormal.x;
+        ny += faceNormal.y;
+        nz += faceNormal.z;
+        count++;
+      }
+    }
+  });
+  if (count === 0) {
+    return null;
+  }
+  return normalize({ x: nx / count, y: ny / count, z: nz / count });
+}
+function relocateVertex(_mesh, vertex, targetPosition, constraints) {
+  if (vertex.type === VertexType.SkeletonBranching || vertex.type === VertexType.NonManifoldOther) {
+    return { success: false, reason: "Vertex is fixed" };
+  }
+  const currentPos = { x: vertex.position.x, y: vertex.position.y, z: vertex.position.z };
+  let finalPosition = targetPosition;
+  let wasConstrained = false;
+  if (constraints) {
+    const constrained = constraints.constrainPosition(vertex, targetPosition);
+    finalPosition = constrained.position;
+    wasConstrained = constrained.wasConstrained;
+  }
+  if (!isValidRelocation(vertex, finalPosition)) {
+    return { success: false, reason: "Relocation would create invalid geometry" };
+  }
+  vertex.position.set(finalPosition.x, finalPosition.y, finalPosition.z);
+  updateIncidentEdgeLengths(vertex);
+  const distanceMoved = distance(currentPos, finalPosition);
+  return {
+    success: true,
+    newPosition: finalPosition,
+    wasConstrained,
+    distanceMoved
+  };
+}
+function isValidRelocation(vertex, newPosition) {
+  const originalPos = { x: vertex.position.x, y: vertex.position.y, z: vertex.position.z };
+  vertex.position.set(newPosition.x, newPosition.y, newPosition.z);
+  let isValid = true;
+  vertex.forEachOutgoingHalfedge((he) => {
+    if (he.face) {
+      const area = he.face.getArea();
+      if (area !== null && area < 1e-10) {
+        isValid = false;
+      }
+    }
+  });
+  vertex.position.set(originalPos.x, originalPos.y, originalPos.z);
+  return isValid;
+}
+function updateIncidentEdgeLengths(vertex) {
+  vertex.forEachOutgoingHalfedge((he) => {
+    const source = he.getSourceVertex();
+    if (source) {
+      he.edge.length = distance(
+        { x: source.position.x, y: source.position.y, z: source.position.z },
+        { x: he.vertex.position.x, y: he.vertex.position.y, z: he.vertex.position.z }
+      );
+    }
+  });
+}
+function smoothVertex(mesh, vertex, constraints, dampingFactor = 0.5) {
+  const target = computeTangentialSmoothing(vertex);
+  if (!target) {
+    return { success: false, reason: "Cannot compute smoothing target" };
+  }
+  const currentPos = { x: vertex.position.x, y: vertex.position.y, z: vertex.position.z };
+  const dampedTarget = {
+    x: currentPos.x + (target.x - currentPos.x) * dampingFactor,
+    y: currentPos.y + (target.y - currentPos.y) * dampingFactor,
+    z: currentPos.z + (target.z - currentPos.z) * dampingFactor
+  };
+  return relocateVertex(mesh, vertex, dampedTarget, constraints);
+}
+function smoothAllVertices(mesh, constraints, dampingFactor = 0.5) {
+  let smoothedCount = 0;
+  let totalDistance = 0;
+  for (const vertex of mesh.getVertices()) {
+    if (vertex.type === VertexType.Manifold || vertex.type === VertexType.OpenBook) {
+      const result = smoothVertex(mesh, vertex, constraints, dampingFactor);
+      if (result.success) {
+        smoothedCount++;
+        totalDistance += result.distanceMoved ?? 0;
+      }
+    }
+  }
+  return { smoothedCount, totalDistance };
+}
+class VertexRelocator {
+  constructor(mesh, constraints) {
+    this.constraints = null;
+    this.mesh = mesh;
+    this.constraints = constraints ?? null;
+  }
+  /**
+   * Sets the skeleton constraints.
+   */
+  setConstraints(constraints) {
+    this.constraints = constraints;
+  }
+  /**
+   * Relocates a vertex to a target position.
+   */
+  relocate(vertex, targetPosition) {
+    return relocateVertex(this.mesh, vertex, targetPosition, this.constraints ?? void 0);
+  }
+  /**
+   * Applies tangential smoothing to a vertex.
+   */
+  smooth(vertex, dampingFactor = 0.5) {
+    return smoothVertex(this.mesh, vertex, this.constraints ?? void 0, dampingFactor);
+  }
+  /**
+   * Applies tangential smoothing to all relocatable vertices.
+   */
+  smoothAll(dampingFactor = 0.5) {
+    return smoothAllVertices(this.mesh, this.constraints ?? void 0, dampingFactor);
+  }
+  /**
+   * Checks if a vertex can be relocated.
+   */
+  canRelocate(vertex) {
+    return vertex.type === VertexType.Manifold || vertex.type === VertexType.OpenBook;
+  }
+}
+function computeMeshQuality(mesh, poorQualityThreshold = 0.3) {
+  const faces = mesh.getFaces();
+  const edges = mesh.getEdges();
+  const qualities = [];
+  const areas = [];
+  for (const face of faces) {
+    const quality = face.getQuality();
+    if (quality !== null) {
+      qualities.push(quality);
+    }
+    const area = face.getArea();
+    if (area !== null) {
+      areas.push(area);
+    }
+  }
+  const edgeLengths = edges.map((e) => e.length);
+  const minQuality = qualities.length > 0 ? Math.min(...qualities) : 0;
+  const maxQuality = qualities.length > 0 ? Math.max(...qualities) : 0;
+  const averageQuality = qualities.length > 0 ? qualities.reduce((a, b) => a + b, 0) / qualities.length : 0;
+  const variance = qualities.length > 0 ? qualities.reduce((sum, q) => sum + Math.pow(q - averageQuality, 2), 0) / qualities.length : 0;
+  const stdDevQuality = Math.sqrt(variance);
+  const poorQualityCount = qualities.filter((q) => q < poorQualityThreshold).length;
+  const minEdgeLength = edgeLengths.length > 0 ? Math.min(...edgeLengths) : 0;
+  const maxEdgeLength = edgeLengths.length > 0 ? Math.max(...edgeLengths) : 0;
+  const averageEdgeLength = edgeLengths.length > 0 ? edgeLengths.reduce((a, b) => a + b, 0) / edgeLengths.length : 0;
+  const minArea = areas.length > 0 ? Math.min(...areas) : 0;
+  const maxArea = areas.length > 0 ? Math.max(...areas) : 0;
+  const totalArea = areas.reduce((a, b) => a + b, 0);
+  return {
+    minQuality,
+    maxQuality,
+    averageQuality,
+    stdDevQuality,
+    poorQualityCount,
+    minEdgeLength,
+    maxEdgeLength,
+    averageEdgeLength,
+    minArea,
+    maxArea,
+    totalArea
+  };
+}
+function getPoorQualityFaces(mesh, threshold = 0.3) {
+  return mesh.getFaces().filter((face) => {
+    const quality = face.getQuality();
+    return quality !== null && quality < threshold;
+  });
+}
+function getLongEdges(mesh, targetLength, maxRatio = 1.333) {
+  const maxLength = targetLength * maxRatio;
+  return mesh.getEdges().filter((e) => e.length > maxLength);
+}
+function getShortEdges(mesh, targetLength, minRatio = 0.4) {
+  const minLength = targetLength * minRatio;
+  return mesh.getEdges().filter((e) => e.length < minLength);
+}
+function computeTargetEdgeLength(mesh, numTargetVertices) {
+  const vertices = mesh.getVertices();
+  if (vertices.length === 0) {
+    return 1;
+  }
+  let minX = Infinity, minY = Infinity, minZ = Infinity;
+  let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+  for (const v of vertices) {
+    minX = Math.min(minX, v.position.x);
+    minY = Math.min(minY, v.position.y);
+    minZ = Math.min(minZ, v.position.z);
+    maxX = Math.max(maxX, v.position.x);
+    maxY = Math.max(maxY, v.position.y);
+    maxZ = Math.max(maxZ, v.position.z);
+  }
+  const diagonal = Math.sqrt(
+    Math.pow(maxX - minX, 2) + Math.pow(maxY - minY, 2) + Math.pow(maxZ - minZ, 2)
+  );
+  if (numTargetVertices !== void 0 && numTargetVertices > 0) {
+    const stats = computeMeshQuality(mesh);
+    if (stats.totalArea > 0) {
+      return Math.sqrt(stats.totalArea / (2 * numTargetVertices));
+    }
+  }
+  return diagonal / Math.sqrt(vertices.length);
+}
+function computeTriangleAspectRatio(face) {
+  const halfedges = face.getHalfedges();
+  if (!halfedges) {
+    return null;
+  }
+  const lengths = halfedges.map((he) => he.edge.length);
+  const minLen = Math.min(...lengths);
+  const maxLen = Math.max(...lengths);
+  if (minLen < 1e-10) {
+    return Infinity;
+  }
+  return maxLen / minLen;
+}
+function getHighValenceVertices(mesh, maxValence = 8) {
+  return mesh.getVertices().filter((v) => {
+    const degree = v.degree();
+    return degree !== null && degree > maxValence;
+  });
+}
+function getLowValenceVertices(mesh, minValence = 4) {
+  return mesh.getVertices().filter((v) => {
+    const degree = v.degree();
+    return degree !== null && degree < minValence;
+  });
+}
+class QualityMetrics {
+  constructor(mesh) {
+    this.mesh = mesh;
+  }
+  /**
+   * Computes overall mesh quality statistics.
+   */
+  computeStats(poorQualityThreshold = 0.3) {
+    return computeMeshQuality(this.mesh, poorQualityThreshold);
+  }
+  /**
+   * Gets poor quality faces.
+   */
+  getPoorQualityFaces(threshold = 0.3) {
+    return getPoorQualityFaces(this.mesh, threshold);
+  }
+  /**
+   * Gets long edges that should be split.
+   */
+  getLongEdges(targetLength, maxRatio = 1.333) {
+    return getLongEdges(this.mesh, targetLength, maxRatio);
+  }
+  /**
+   * Gets short edges that should be collapsed.
+   */
+  getShortEdges(targetLength, minRatio = 0.4) {
+    return getShortEdges(this.mesh, targetLength, minRatio);
+  }
+  /**
+   * Computes target edge length.
+   */
+  computeTargetEdgeLength(numTargetVertices) {
+    return computeTargetEdgeLength(this.mesh, numTargetVertices);
+  }
+  /**
+   * Gets high valence vertices.
+   */
+  getHighValenceVertices(maxValence = 8) {
+    return getHighValenceVertices(this.mesh, maxValence);
+  }
+  /**
+   * Gets low valence vertices.
+   */
+  getLowValenceVertices(minValence = 4) {
+    return getLowValenceVertices(this.mesh, minValence);
+  }
+}
+class AdaptiveRemesher {
+  constructor(mesh, options = {}) {
+    this.skeleton = null;
+    this.constraints = null;
+    this.mesh = mesh;
+    const targetEdgeLength = options.targetEdgeLength ?? computeTargetEdgeLength(mesh);
+    this.options = {
+      ...DEFAULT_REMESH_OPTIONS,
+      ...options,
+      targetEdgeLength
+    };
+    this.state = {
+      iteration: 0,
+      edgeSplits: 0,
+      edgeContractions: 0,
+      edgeFlips: 0,
+      vertexRelocations: 0,
+      quality: computeMeshQuality(mesh)
+    };
+    if (!mesh.isManifold()) {
+      this.skeleton = createSkeleton(mesh);
+      this.constraints = createSkeletonConstraints(this.skeleton);
+    }
+  }
+  /**
+   * 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() {
+    this.state.iteration++;
+    const targetLength = this.options.targetEdgeLength;
+    const minLength = targetLength * this.options.minEdgeLengthRatio;
+    const maxLength = targetLength * this.options.maxEdgeLengthRatio;
+    const splitResult = splitLongEdges(this.mesh, maxLength);
+    this.state.edgeSplits += splitResult.splitCount;
+    const contractResult = contractShortEdges(this.mesh, minLength);
+    this.state.edgeContractions += contractResult.contractCount;
+    const flipCount = makeDelaunay(this.mesh);
+    this.state.edgeFlips += flipCount;
+    const smoothResult = smoothAllVertices(this.mesh, this.constraints ?? void 0, 0.5);
+    this.state.vertexRelocations += smoothResult.smoothedCount;
+    if (this.skeleton && (splitResult.splitCount > 0 || contractResult.contractCount > 0)) {
+      this.skeleton.rebuild();
+    }
+    this.state.quality = computeMeshQuality(this.mesh, this.options.minTriangleQuality);
+    if (this.options.verbose) {
+      console.warn(
+        `Iteration ${this.state.iteration}: splits=${splitResult.splitCount}, contractions=${contractResult.contractCount}, flips=${flipCount}, smoothed=${smoothResult.smoothedCount}, avgQuality=${this.state.quality.averageQuality.toFixed(3)}`
+      );
+    }
+    return { ...this.state };
+  }
+  /**
+   * Runs multiple iterations until convergence or max iterations.
+   */
+  run(maxIterations) {
+    const iterations = maxIterations ?? this.options.iterations;
+    const startTime = Date.now();
+    const inputStats = {
+      vertices: this.mesh.vertexCount,
+      faces: this.mesh.faceCount
+    };
+    for (let i = 0; i < iterations; i++) {
+      const prevQuality = this.state.quality.averageQuality;
+      this.iterate();
+      const qualityImprovement = this.state.quality.averageQuality - prevQuality;
+      if (Math.abs(qualityImprovement) < 1e-3 && i > 0) {
+        if (this.options.verbose) {
+          console.warn(`Converged after ${i + 1} iterations`);
+        }
+        break;
+      }
+    }
+    const processingTimeMs = Date.now() - startTime;
+    return {
+      inputVertices: inputStats.vertices,
+      inputFaces: inputStats.faces,
+      outputVertices: this.mesh.vertexCount,
+      outputFaces: this.mesh.faceCount,
+      iterations: this.state.iteration,
+      finalQuality: this.state.quality.averageQuality,
+      nonManifoldEdges: this.mesh.getNonManifoldEdges().length,
+      skeletonEdges: this.mesh.getSkeletonEdges().length,
+      edgeFlips: this.state.edgeFlips,
+      edgeSplits: this.state.edgeSplits,
+      edgeContractions: this.state.edgeContractions,
+      vertexRelocations: this.state.vertexRelocations,
+      processingTimeMs
+    };
+  }
+  /**
+   * Checks if the remeshing has converged.
+   */
+  hasConverged() {
+    return this.state.quality.averageQuality > 0.9 || this.state.quality.poorQualityCount === 0;
+  }
+  /**
+   * Gets the current mesh.
+   */
+  getMesh() {
+    return this.mesh;
+  }
+  /**
+   * Gets the skeleton (if built).
+   */
+  getSkeleton() {
+    return this.skeleton;
+  }
+  /**
+   * Gets the current quality stats.
+   */
+  getQuality() {
+    return this.state.quality;
+  }
+  /**
+   * Gets the current state.
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Exports the mesh to BufferGeometry.
+   */
+  toBufferGeometry() {
+    return exportBufferGeometry(this.mesh);
+  }
+}
+function remesh(geometry, options = {}) {
+  const mesh = NonManifoldMesh.fromBufferGeometry(geometry, options.featureEdges);
+  const remesher = new AdaptiveRemesher(mesh, options);
+  const stats = remesher.run();
+  const outputGeometry = remesher.toBufferGeometry();
+  return { geometry: outputGeometry, stats };
+}
+function createRemesher(geometry, options = {}) {
+  const mesh = NonManifoldMesh.fromBufferGeometry(geometry, options.featureEdges);
+  return new AdaptiveRemesher(mesh, options);
+}
+export {
+  AdaptiveRemesher,
+  BVH,
+  BufferGeometryExporter,
+  BufferGeometryImporter,
+  DEFAULT_REMESH_OPTIONS,
+  Edge,
+  EdgeContractor,
+  EdgeFlipper,
+  EdgeSplitter,
+  EdgeType,
+  Face,
+  FeatureSkeleton,
+  Halfedge,
+  ManifoldAnalyzer,
+  NonManifoldMesh,
+  QualityMetrics,
+  SkeletonBuilder,
+  SkeletonConstraints,
+  SkeletonSegment,
+  SpatialHash,
+  TopologyValidator,
+  Vertex,
+  VertexClassifier,
+  VertexRelocator,
+  VertexType,
+  add,
+  analyzeManifold,
+  analyzeMesh,
+  angleAtVertex,
+  angleBetween,
+  barycentricCoordinates,
+  buildSkeleton,
+  canContractEdge,
+  canFlipEdge$1 as canFlipEdge,
+  canFlipEdge as canFlipEdgeGeometric,
+  canMoveFreely,
+  classifyAllVertices,
+  classifyVertex,
+  computeMeshQuality,
+  computeTangentialSmoothing,
+  computeTargetEdgeLength,
+  computeTriangleAspectRatio,
+  contractEdge,
+  contractShortEdges,
+  cotangent,
+  createBVHFromMesh,
+  createEdgeId,
+  createFaceId,
+  createHalfedgeId,
+  createRemesher,
+  createSegmentId,
+  createSkeleton,
+  createSkeletonConstraints,
+  createSpatialHash,
+  createVertexId,
+  cross,
+  distance,
+  distanceSquared,
+  dot,
+  exportBufferGeometry,
+  exportClassificationGeometry,
+  exportQualityGeometry,
+  exportSkeletonGeometry,
+  flipEdge,
+  fromVector3,
+  getHighValenceVertices,
+  getLongEdges,
+  getLowValenceVertices,
+  getManifoldVertices,
+  getNonManifoldVertices,
+  getOpenBookVertices,
+  getPoorQualityFaces,
+  getShortEdges,
+  getSkeletonBranchingVertices,
+  getVerticesByType,
+  importBufferGeometry,
+  isDelaunay,
+  isManifold,
+  isPointInTriangle,
+  isPositionFixed,
+  isQuadConvex,
+  isSkeletonConstrained,
+  isSkeletonEdge,
+  isTopologyValid,
+  length,
+  lengthSquared,
+  lerp,
+  makeDelaunay,
+  midpoint,
+  normalize,
+  projectPointOnLine,
+  projectPointOnSegment,
+  reclassifyVertices,
+  relocateVertex,
+  remesh,
+  scale,
+  smoothAllVertices,
+  smoothVertex,
+  splitEdge,
+  splitLongEdges,
+  subtract,
+  toNumber,
+  triangleArea,
+  triangleCentroid$1 as triangleCentroid,
+  triangleCircumcenter,
+  triangleCircumradius,
+  triangleInradius,
+  triangleNormal,
+  triangleQuality,
+  validateGeometry,
+  validateTopology
+};
+//# sourceMappingURL=remesh-threejs.js.map