remesh-threejs 0.2.1 → 0.3.1

package/dist/remesh-threejs.js

@@ -4240,12 +4240,850 @@ function createRemesher(geometry, options = {}) {
   const mesh = NonManifoldMesh.fromBufferGeometry(geometry, options.featureEdges);
   return new AdaptiveRemesher(mesh, options);
 }
+class RepairOperation {
+  constructor(mesh, verbose = false) {
+    this.mesh = mesh;
+    this.verbose = verbose;
+  }
+  /**
+   * Execute the operation (detect + repair).
+   * @returns Operation statistics
+   */
+  execute() {
+    const startTime = performance.now();
+    const defectsFound = this.detect();
+    if (defectsFound === 0) {
+      return {
+        operation: this.getName(),
+        defectsFound: 0,
+        defectsFixed: 0,
+        timeMs: performance.now() - startTime,
+        success: true
+      };
+    }
+    const defectsFixed = this.repair();
+    const timeMs = performance.now() - startTime;
+    const result = {
+      operation: this.getName(),
+      defectsFound,
+      defectsFixed,
+      timeMs,
+      success: defectsFixed === defectsFound
+    };
+    if (defectsFixed < defectsFound) {
+      result.reason = `Only fixed ${defectsFixed}/${defectsFound} defects`;
+    }
+    return result;
+  }
+}
+class IsolatedVertexRepair extends RepairOperation {
+  constructor() {
+    super(...arguments);
+    this.isolatedVertices = [];
+  }
+  detect() {
+    this.isolatedVertices = [];
+    for (const vertex of this.mesh.vertices.values()) {
+      if (!vertex.halfedge || vertex.degree() === 0) {
+        this.isolatedVertices.push(vertex);
+      }
+    }
+    if (this.verbose && this.isolatedVertices.length > 0) {
+      console.log(`Found ${this.isolatedVertices.length} isolated vertices`);
+    }
+    return this.isolatedVertices.length;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const vertex of this.isolatedVertices) {
+      this.mesh.vertices.delete(vertex.id);
+      fixedCount++;
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Removed ${fixedCount} isolated vertices`);
+    }
+    return fixedCount;
+  }
+  getName() {
+    return "Remove Isolated Vertices";
+  }
+  canParallelize() {
+    return this.isolatedVertices.length > 1e3;
+  }
+}
+class DegenerateFaceRepair extends RepairOperation {
+  constructor(mesh, verbose = false, areaThreshold = 1e-10) {
+    super(mesh, verbose);
+    this.degenerateFaces = [];
+    this.areaThreshold = areaThreshold;
+  }
+  detect() {
+    this.degenerateFaces = [];
+    for (const face of this.mesh.faces.values()) {
+      const vertices = face.getVertices();
+      if (!vertices || vertices.length !== 3) continue;
+      const [v0, v1, v2] = vertices;
+      if (v0.id === v1.id || v1.id === v2.id || v2.id === v0.id) {
+        this.degenerateFaces.push(face);
+        continue;
+      }
+      const area = triangleArea(v0.position, v1.position, v2.position);
+      if (area < this.areaThreshold) {
+        this.degenerateFaces.push(face);
+      }
+    }
+    if (this.verbose && this.degenerateFaces.length > 0) {
+      console.log(`Found ${this.degenerateFaces.length} degenerate faces`);
+    }
+    return this.degenerateFaces.length;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const face of this.degenerateFaces) {
+      const halfedges = face.getHalfedges();
+      if (!halfedges) continue;
+      this.mesh.faces.delete(face.id);
+      for (const he of halfedges) {
+        this.mesh.halfedges.delete(he.id);
+        he.edge.allHalfedges = he.edge.allHalfedges.filter((h) => h.id !== he.id);
+      }
+      fixedCount++;
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Removed ${fixedCount} degenerate faces`);
+    }
+    return fixedCount;
+  }
+  getName() {
+    return "Remove Degenerate Faces";
+  }
+  canParallelize() {
+    return this.degenerateFaces.length > 1e3;
+  }
+}
+class DuplicateFaceRepair extends RepairOperation {
+  constructor() {
+    super(...arguments);
+    this.duplicates = /* @__PURE__ */ new Map();
+  }
+  detect() {
+    this.duplicates.clear();
+    const faceMap = /* @__PURE__ */ new Map();
+    for (const face of this.mesh.faces.values()) {
+      const vertices = face.getVertices();
+      if (!vertices) continue;
+      const key = this.makeFaceKey(vertices);
+      if (!faceMap.has(key)) {
+        faceMap.set(key, []);
+      }
+      faceMap.get(key).push(face);
+    }
+    let duplicateCount = 0;
+    for (const [key, faces] of faceMap) {
+      if (faces.length > 1) {
+        this.duplicates.set(key, faces);
+        duplicateCount += faces.length - 1;
+      }
+    }
+    if (this.verbose && duplicateCount > 0) {
+      console.log(`Found ${duplicateCount} duplicate faces in ${this.duplicates.size} groups`);
+    }
+    return duplicateCount;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const faces of this.duplicates.values()) {
+      for (let i = 1; i < faces.length; i++) {
+        const face = faces[i];
+        if (!face) continue;
+        this.mesh.faces.delete(face.id);
+        const halfedges = face.getHalfedges();
+        if (!halfedges) continue;
+        for (const he of halfedges) {
+          this.mesh.halfedges.delete(he.id);
+          he.edge.allHalfedges = he.edge.allHalfedges.filter((h) => h.id !== he.id);
+        }
+        fixedCount++;
+      }
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Removed ${fixedCount} duplicate faces`);
+    }
+    return fixedCount;
+  }
+  /**
+   * Create canonical key from sorted vertex IDs.
+   */
+  makeFaceKey(vertices) {
+    const ids = vertices.map((v) => v.id).sort((a, b) => a - b);
+    return ids.join(",");
+  }
+  getName() {
+    return "Remove Duplicate Faces";
+  }
+  canParallelize() {
+    return false;
+  }
+}
+class NonManifoldEdgeRepair extends RepairOperation {
+  constructor(mesh, verbose = false, strategy = "auto") {
+    super(mesh, verbose);
+    this.nonManifoldEdges = [];
+    this.strategy = strategy;
+  }
+  detect() {
+    this.nonManifoldEdges = [];
+    for (const edge of this.mesh.edges.values()) {
+      if (edge.allHalfedges.length > 2) {
+        this.nonManifoldEdges.push(edge);
+      }
+    }
+    if (this.verbose && this.nonManifoldEdges.length > 0) {
+      console.log(`Found ${this.nonManifoldEdges.length} non-manifold edges`);
+    }
+    return this.nonManifoldEdges.length;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const edge of this.nonManifoldEdges) {
+      if (!this.mesh.edges.has(edge.id)) continue;
+      const repairStrategy = this.determineStrategy(edge);
+      if (repairStrategy === "split") {
+        if (this.splitNonManifoldEdge(edge)) {
+          fixedCount++;
+        }
+      } else {
+        if (this.collapseNonManifoldEdge(edge)) {
+          fixedCount++;
+        }
+      }
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Repaired ${fixedCount} non-manifold edges`);
+    }
+    return fixedCount;
+  }
+  /**
+   * Determine which strategy to use for a specific edge.
+   */
+  determineStrategy(edge) {
+    if (this.strategy !== "auto") {
+      return this.strategy;
+    }
+    const avgEdgeLength = this.computeAverageEdgeLength();
+    const edgeLength = edge.length;
+    return edgeLength > avgEdgeLength ? "split" : "collapse";
+  }
+  /**
+   * Compute average edge length in the mesh.
+   */
+  computeAverageEdgeLength() {
+    let totalLength = 0;
+    let count = 0;
+    for (const edge of this.mesh.edges.values()) {
+      totalLength += edge.length;
+      count++;
+    }
+    return count > 0 ? totalLength / count : 1;
+  }
+  /**
+   * Split a non-manifold edge by duplicating vertices.
+   */
+  splitNonManifoldEdge(edge) {
+    try {
+      const [v0, v1] = edge.getVertices();
+      if (!v0 || !v1) return false;
+      const halfedges = [...edge.allHalfedges];
+      if (halfedges.length <= 2) return false;
+      for (let i = 2; i < halfedges.length; i++) {
+        const he = halfedges[i];
+        if (!he || !he.face) continue;
+        const newVertex = this.mesh.createVertex(v1.position.clone());
+        const faceVertices = he.face.getVertices();
+        if (!faceVertices) continue;
+        const vertexIndices = [];
+        for (const v of faceVertices) {
+          if (v.id === v1.id) {
+            vertexIndices.push(newVertex.id);
+          } else {
+            vertexIndices.push(v.id);
+          }
+        }
+        this.mesh.faces.delete(he.face.id);
+        const vertices = vertexIndices.map((id) => this.mesh.vertices.get(id));
+        if (!vertices[0] || !vertices[1] || !vertices[2]) continue;
+        this.mesh.createFace(vertices[0], vertices[1], vertices[2]);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Collapse a non-manifold edge by removing excess faces.
+   */
+  collapseNonManifoldEdge(edge) {
+    try {
+      const halfedges = [...edge.allHalfedges];
+      if (halfedges.length <= 2) return false;
+      let removedCount = 0;
+      for (let i = 2; i < halfedges.length; i++) {
+        const he = halfedges[i];
+        if (!he || !he.face) continue;
+        this.mesh.faces.delete(he.face.id);
+        const faceHalfedges = he.face.getHalfedges();
+        if (faceHalfedges) {
+          for (const fhe of faceHalfedges) {
+            this.mesh.halfedges.delete(fhe.id);
+            fhe.edge.allHalfedges = fhe.edge.allHalfedges.filter((h) => h.id !== fhe.id);
+          }
+        }
+        removedCount++;
+      }
+      return removedCount > 0;
+    } catch {
+      return false;
+    }
+  }
+  getName() {
+    return "Remove Non-Manifold Edges";
+  }
+  canParallelize() {
+    return this.nonManifoldEdges.length > 100;
+  }
+}
+class HoleFiller extends RepairOperation {
+  constructor(mesh, verbose = false, maxHoleSize = 100, preserveBoundary = false) {
+    super(mesh, verbose);
+    this.holes = [];
+    this.maxHoleSize = maxHoleSize;
+    this.preserveBoundary = preserveBoundary;
+  }
+  detect() {
+    this.holes = [];
+    const boundaryEdges = [];
+    for (const edge of this.mesh.edges.values()) {
+      if (edge.allHalfedges.length === 1) {
+        boundaryEdges.push(edge);
+      }
+    }
+    if (boundaryEdges.length === 0) {
+      return 0;
+    }
+    this.holes = this.extractBoundaryLoops(boundaryEdges);
+    this.holes = this.holes.filter((hole) => hole.vertices.length <= this.maxHoleSize);
+    if (this.verbose && this.holes.length > 0) {
+      console.log(`Found ${this.holes.length} holes`);
+    }
+    return this.holes.length;
+  }
+  repair() {
+    if (this.preserveBoundary) {
+      return 0;
+    }
+    let fixedCount = 0;
+    for (const hole of this.holes) {
+      const triangles = this.triangulateBoundaryLoop(hole);
+      if (triangles.length > 0) {
+        for (const tri of triangles) {
+          try {
+            this.mesh.createFace(tri.v0, tri.v1, tri.v2);
+          } catch {
+            continue;
+          }
+        }
+        fixedCount++;
+      }
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Filled ${fixedCount} holes`);
+    }
+    return fixedCount;
+  }
+  /**
+   * Extract boundary loops from a set of boundary edges.
+   */
+  extractBoundaryLoops(boundaryEdges) {
+    const loops = [];
+    const visited = /* @__PURE__ */ new Set();
+    for (const startEdge of boundaryEdges) {
+      if (visited.has(startEdge.id)) continue;
+      const loop = [];
+      const loopEdges = [];
+      let currentEdge = startEdge;
+      let iterations = 0;
+      const maxIterations = 1e4;
+      do {
+        if (iterations++ > maxIterations) break;
+        visited.add(currentEdge.id);
+        const [v0, v1] = currentEdge.getVertices();
+        if (!v0 || !v1) break;
+        loop.push(v0);
+        loopEdges.push(currentEdge);
+        const nextEdge = this.findNextBoundaryEdge(v1, currentEdge, boundaryEdges);
+        if (!nextEdge || nextEdge === startEdge) {
+          loop.push(v1);
+          break;
+        }
+        currentEdge = nextEdge;
+      } while (currentEdge !== startEdge);
+      if (loop.length >= 3) {
+        loops.push({ vertices: loop, edges: loopEdges });
+      }
+    }
+    return loops;
+  }
+  /**
+   * Find the next boundary edge connected to a vertex.
+   */
+  findNextBoundaryEdge(vertex, currentEdge, boundaryEdges) {
+    for (const edge of boundaryEdges) {
+      if (edge === currentEdge) continue;
+      const [v0, v1] = edge.getVertices();
+      if (!v0 || !v1) continue;
+      if (v0.id === vertex.id || v1.id === vertex.id) {
+        return edge;
+      }
+    }
+    return null;
+  }
+  /**
+   * Triangulate a boundary loop using ear clipping algorithm.
+   */
+  triangulateBoundaryLoop(loop) {
+    const triangles = [];
+    const vertices = [...loop.vertices];
+    let iterations = 0;
+    const maxIterations = vertices.length * vertices.length;
+    while (vertices.length > 3 && iterations++ < maxIterations) {
+      const earIndex = this.findEar(vertices);
+      if (earIndex === -1) {
+        break;
+      }
+      const prev = (earIndex - 1 + vertices.length) % vertices.length;
+      const next = (earIndex + 1) % vertices.length;
+      const v0 = vertices[prev];
+      const v1 = vertices[earIndex];
+      const v2 = vertices[next];
+      if (!v0 || !v1 || !v2) break;
+      triangles.push({ v0, v1, v2 });
+      vertices.splice(earIndex, 1);
+    }
+    if (vertices.length === 3) {
+      const v0 = vertices[0];
+      const v1 = vertices[1];
+      const v2 = vertices[2];
+      if (v0 && v1 && v2) {
+        triangles.push({ v0, v1, v2 });
+      }
+    }
+    return triangles;
+  }
+  /**
+   * Find an "ear" in the polygon (a triangle with no vertices inside).
+   */
+  findEar(vertices) {
+    const n = vertices.length;
+    for (let i = 0; i < n; i++) {
+      const prev = (i - 1 + n) % n;
+      const next = (i + 1) % n;
+      const v0 = vertices[prev];
+      const v1 = vertices[i];
+      const v2 = vertices[next];
+      if (!v0 || !v1 || !v2) continue;
+      const area = triangleArea(v0.position, v1.position, v2.position);
+      if (area < 1e-10) continue;
+      let isEar = true;
+      for (let j = 0; j < n; j++) {
+        if (j === prev || j === i || j === next) continue;
+        const vj = vertices[j];
+        if (!vj) continue;
+        if (isPointInTriangle(vj.position, v0.position, v1.position, v2.position)) {
+          isEar = false;
+          break;
+        }
+      }
+      if (isEar) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  getName() {
+    return "Fill Holes";
+  }
+  canParallelize() {
+    return this.holes.length > 10;
+  }
+}
+class NormalUnifier extends RepairOperation {
+  constructor(mesh, verbose = false, seedFaceIndex = 0) {
+    super(mesh, verbose);
+    this.inconsistentFaces = [];
+    this.seedFaceIndex = seedFaceIndex;
+  }
+  detect() {
+    this.inconsistentFaces = [];
+    const faces = Array.from(this.mesh.faces.values());
+    if (faces.length === 0) return 0;
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    const seedFace = faces[this.seedFaceIndex] || faces[0];
+    if (!seedFace) return 0;
+    queue.push(seedFace);
+    visited.add(seedFace.id);
+    while (queue.length > 0) {
+      const face = queue.shift();
+      const neighbors = this.getNeighborFaces(face);
+      for (const neighbor of neighbors) {
+        const neighborId = neighbor.id;
+        if (visited.has(neighborId)) continue;
+        visited.add(neighborId);
+        const sharedEdge = this.getSharedEdge(face, neighbor);
+        if (sharedEdge && !this.areNormalsConsistent(face, neighbor, sharedEdge)) {
+          this.inconsistentFaces.push(neighbor);
+        }
+        queue.push(neighbor);
+      }
+    }
+    if (this.verbose && this.inconsistentFaces.length > 0) {
+      console.log(`Found ${this.inconsistentFaces.length} faces with inconsistent normals`);
+    }
+    return this.inconsistentFaces.length;
+  }
+  repair() {
+    let fixedCount = 0;
+    for (const face of this.inconsistentFaces) {
+      if (this.flipFaceOrientation(face)) {
+        fixedCount++;
+      }
+    }
+    if (this.verbose && fixedCount > 0) {
+      console.log(`Unified normals for ${fixedCount} faces`);
+    }
+    return fixedCount;
+  }
+  /**
+   * Get faces that share an edge with the given face.
+   */
+  getNeighborFaces(face) {
+    const neighbors = [];
+    const halfedges = face.getHalfedges();
+    if (!halfedges) return neighbors;
+    for (const he of halfedges) {
+      if (he.twin && he.twin.face && he.twin.face !== face) {
+        neighbors.push(he.twin.face);
+      }
+    }
+    return neighbors;
+  }
+  /**
+   * Find the edge shared between two faces.
+   */
+  getSharedEdge(face1, face2) {
+    const halfedges1 = face1.getHalfedges();
+    const halfedges2 = face2.getHalfedges();
+    if (!halfedges1 || !halfedges2) return null;
+    for (const he1 of halfedges1) {
+      for (const he2 of halfedges2) {
+        if (he1.edge === he2.edge) {
+          return he1.edge;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if two faces have consistent normal orientation across their shared edge.
+   */
+  areNormalsConsistent(face1, face2, sharedEdge) {
+    const he1 = this.getHalfedgeInFace(face1, sharedEdge);
+    const he2 = this.getHalfedgeInFace(face2, sharedEdge);
+    if (!he1 || !he2) return true;
+    const [v1_start, v1_end] = this.getHalfedgeVertices(he1);
+    const [v2_start, v2_end] = this.getHalfedgeVertices(he2);
+    if (!v1_start || !v1_end || !v2_start || !v2_end) return true;
+    return v1_start.id === v2_end.id && v1_end.id === v2_start.id;
+  }
+  /**
+   * Get the halfedge in a face that corresponds to a given edge.
+   */
+  getHalfedgeInFace(face, edge) {
+    const halfedges = face.getHalfedges();
+    if (!halfedges) return null;
+    for (const he of halfedges) {
+      if (he.edge === edge) {
+        return he;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get the start and end vertices of a halfedge.
+   */
+  getHalfedgeVertices(he) {
+    var _a;
+    return [he.vertex, ((_a = he.next) == null ? void 0 : _a.vertex) || null];
+  }
+  /**
+   * Flip the orientation of a face by reversing its halfedge order.
+   */
+  flipFaceOrientation(face) {
+    try {
+      const halfedges = face.getHalfedges();
+      if (!halfedges || halfedges.length !== 3) return false;
+      const [he0, he1, he2] = halfedges;
+      const temp0 = he0.next;
+      he0.next = he0.prev;
+      he0.prev = temp0;
+      const temp1 = he1.next;
+      he1.next = he1.prev;
+      he1.prev = temp1;
+      const temp2 = he2.next;
+      he2.next = he2.prev;
+      he2.prev = temp2;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getName() {
+    return "Unify Normals";
+  }
+  canParallelize() {
+    return false;
+  }
+}
+class MeshRepairer {
+  constructor(meshOrGeometry, options) {
+    this.operations = [];
+    if (meshOrGeometry instanceof NonManifoldMesh) {
+      this.mesh = meshOrGeometry;
+    } else {
+      this.mesh = NonManifoldMesh.fromBufferGeometry(meshOrGeometry);
+    }
+    this.options = {
+      useWorkers: (options == null ? void 0 : options.useWorkers) ?? (typeof navigator !== "undefined" && this.mesh.faces.size > ((options == null ? void 0 : options.parallelThreshold) ?? 1e4)),
+      workerCount: (options == null ? void 0 : options.workerCount) ?? (typeof navigator !== "undefined" ? navigator.hardwareConcurrency || 4 : 4),
+      useAcceleration: (options == null ? void 0 : options.useAcceleration) ?? true,
+      parallelThreshold: (options == null ? void 0 : options.parallelThreshold) ?? 1e4,
+      verbose: (options == null ? void 0 : options.verbose) ?? false,
+      validateAfterEach: (options == null ? void 0 : options.validateAfterEach) ?? false
+    };
+    this.stats = {
+      input: {
+        vertices: this.mesh.vertices.size,
+        faces: this.mesh.faces.size,
+        edges: this.mesh.edges.size
+      },
+      output: {
+        vertices: this.mesh.vertices.size,
+        faces: this.mesh.faces.size,
+        edges: this.mesh.edges.size
+      },
+      operations: [],
+      totalTimeMs: 0,
+      success: true,
+      totalDefectsFound: 0,
+      totalDefectsFixed: 0
+    };
+  }
+  /**
+   * Remove isolated vertices (vertices with no faces).
+   * @returns this for chaining
+   */
+  removeIsolatedVertices() {
+    this.operations.push(new IsolatedVertexRepair(this.mesh, this.options.verbose));
+    return this;
+  }
+  /**
+   * Remove zero-area and degenerate triangles.
+   * @param areaThreshold - Minimum area threshold (default: 1e-10)
+   * @returns this for chaining
+   */
+  removeDegenerateFaces(areaThreshold) {
+    this.operations.push(new DegenerateFaceRepair(this.mesh, this.options.verbose, areaThreshold));
+    return this;
+  }
+  /**
+   * Remove duplicate faces with identical vertices.
+   * @returns this for chaining
+   */
+  removeDuplicateFaces() {
+    this.operations.push(new DuplicateFaceRepair(this.mesh, this.options.verbose));
+    return this;
+  }
+  /**
+   * Remove non-manifold edges by splitting or collapsing.
+   * @param strategy - Repair strategy: 'split', 'collapse', or 'auto' (default: 'auto')
+   * @returns this for chaining
+   */
+  removeNonManifoldEdges(strategy) {
+    this.operations.push(new NonManifoldEdgeRepair(this.mesh, this.options.verbose, strategy));
+    return this;
+  }
+  /**
+   * Fill boundary loops (holes) with triangulation.
+   * @param maxHoleSize - Maximum number of edges in a hole to fill (default: 100)
+   * @returns this for chaining
+   */
+  fillHoles(maxHoleSize) {
+    this.operations.push(new HoleFiller(this.mesh, this.options.verbose, maxHoleSize));
+    return this;
+  }
+  /**
+   * Unify face orientations to make normals consistent.
+   * @param seedFaceIndex - Index of the face to use as orientation reference (default: 0)
+   * @returns this for chaining
+   */
+  unifyNormals(seedFaceIndex) {
+    this.operations.push(new NormalUnifier(this.mesh, this.options.verbose, seedFaceIndex));
+    return this;
+  }
+  /**
+   * Run all common repairs in optimal order.
+   * @returns this for chaining
+   */
+  repairAll() {
+    this.removeIsolatedVertices();
+    this.removeDuplicateFaces();
+    this.removeDegenerateFaces();
+    this.fillHoles();
+    this.unifyNormals();
+    return this;
+  }
+  /**
+   * Execute all queued operations.
+   * @returns Repair statistics
+   */
+  execute() {
+    const startTime = performance.now();
+    this.stats.operations = [];
+    this.stats.totalDefectsFound = 0;
+    this.stats.totalDefectsFixed = 0;
+    this.stats.success = true;
+    for (const operation of this.operations) {
+      const opStats = operation.execute();
+      this.stats.operations.push(opStats);
+      this.stats.totalDefectsFound += opStats.defectsFound;
+      this.stats.totalDefectsFixed += opStats.defectsFixed;
+      if (!opStats.success) {
+        this.stats.success = false;
+      }
+      if (this.options.validateAfterEach) {
+        const validation = validateTopology(this.mesh);
+        if (!validation.isValid) {
+          const errors = [...validation.errors, ...validation.warnings];
+          console.warn(`Topology validation failed after ${opStats.operation}:`, errors);
+          this.stats.success = false;
+        }
+      }
+    }
+    this.stats.totalTimeMs = performance.now() - startTime;
+    this.stats.output = {
+      vertices: this.mesh.vertices.size,
+      faces: this.mesh.faces.size,
+      edges: this.mesh.edges.size
+    };
+    this.operations = [];
+    return this.stats;
+  }
+  /**
+   * Get current statistics.
+   */
+  getStats() {
+    return this.stats;
+  }
+  /**
+   * Get the repaired mesh.
+   */
+  getMesh() {
+    return this.mesh;
+  }
+  /**
+   * Export to BufferGeometry.
+   */
+  toBufferGeometry() {
+    return exportBufferGeometry(this.mesh);
+  }
+  /**
+   * Validate the mesh after repairs.
+   */
+  validate() {
+    const validation = validateTopology(this.mesh);
+    return {
+      isValid: validation.isValid,
+      errors: [
+        ...validation.errors.map((e) => e.message),
+        ...validation.warnings.map((w) => w.message)
+      ]
+    };
+  }
+}
+function repairMesh(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.repairAll().execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function removeIsolatedVertices(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.removeIsolatedVertices().execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function removeDegenerateFaces(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.removeDegenerateFaces(options == null ? void 0 : options.areaThreshold).execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function removeDuplicateFaces(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.removeDuplicateFaces().execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function removeNonManifoldEdges(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.removeNonManifoldEdges(options == null ? void 0 : options.strategy).execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function fillHoles(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.fillHoles(options == null ? void 0 : options.maxHoleSize).execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
+function unifyNormals(geometry, options) {
+  const repairer = new MeshRepairer(geometry, options);
+  const stats = repairer.unifyNormals(options == null ? void 0 : options.seedFaceIndex).execute();
+  return {
+    geometry: repairer.toBufferGeometry(),
+    stats
+  };
+}
 export {
   AdaptiveRemesher,
   BVH,
   BufferGeometryExporter,
   BufferGeometryImporter,
   DEFAULT_REMESH_OPTIONS,
+  DegenerateFaceRepair,
+  DuplicateFaceRepair,
   Edge,
   EdgeContractor,
   EdgeFlipper,
@@ -4254,9 +5092,15 @@ export {
   Face,
   FeatureSkeleton,
   Halfedge,
+  HoleFiller,
+  IsolatedVertexRepair,
   ManifoldAnalyzer,
+  MeshRepairer,
+  NonManifoldEdgeRepair,
   NonManifoldMesh,
+  NormalUnifier,
   QualityMetrics,
+  RepairOperation,
   SkeletonBuilder,
   SkeletonConstraints,
   SkeletonSegment,
@@ -4304,6 +5148,7 @@ export {
   exportClassificationGeometry,
   exportQualityGeometry,
   exportSkeletonGeometry,
+  fillHoles,
   flipEdge,
   fromVector3,
   getHighValenceVertices,
@@ -4336,6 +5181,11 @@ export {
   reclassifyVertices,
   relocateVertex,
   remesh,
+  removeDegenerateFaces,
+  removeDuplicateFaces,
+  removeIsolatedVertices,
+  removeNonManifoldEdges,
+  repairMesh,
   scale,
   smoothAllVertices,
   smoothVertex,
@@ -4350,6 +5200,7 @@ export {
   triangleInradius,
   triangleNormal,
   triangleQuality,
+  unifyNormals,
   validateGeometry,
   validateTopology
 };