okgeometry-api 1.20.0 → 1.21.0

package/package.json

@@ -1,59 +1,59 @@
-{
-  "name": "okgeometry-api",
-  "version": "1.20.0",
-  "description": "Geometry engine API for AEC applications - NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist/",
-    "src/"
-  ],
-  "scripts": {
-    "build:wasm": "node -e \"require('fs').rmSync('wasm',{recursive:true,force:true})\" && cd .. && wasm-pack build --target web --out-dir okgeometry-api/wasm",
-    "sync:wasm-bindings": "node scripts/sync-wasm-bindings.mjs",
-    "inline-wasm": "tsx scripts/inline-wasm.ts",
-    "build": "npm run build:wasm && npm run sync:wasm-bindings && npm run inline-wasm && tsc",
-    "bench:boolean-heavy": "npm run build && tsx scripts/bench-boolean-heavy.ts",
-    "bench:boolean-ab": "npm run build && tsx scripts/bench-boolean-ab.ts",
-    "bench:boolean-batch": "npm run build && tsx scripts/bench-boolean-batch.ts",
-    "bench:boolean-matrix": "tsx scripts/bench-boolean-matrix.ts",
-    "smoke:brep-boolean": "tsx scripts/smoke-brep-boolean.ts",
-    "prepublishOnly": "npm run build",
-    "smoke:brep-parametric": "tsx scripts/smoke-brep-parametric.ts",
-    "smoke:brep-from-mesh": "tsx scripts/smoke-brep-from-mesh.ts",
-    "smoke:brep-faces": "tsx scripts/smoke-brep-faces.ts",
-    "smoke:curve-intersections": "tsx scripts/smoke-curve-intersections.ts",
-    "smoke:brep-intersections": "tsx scripts/smoke-brep-intersections.ts",
-    "smoke:brep-sheet-boolean": "tsx scripts/smoke-brep-sheet-boolean.ts",
-    "smoke:geometry-boolean": "tsx scripts/smoke-geometry-boolean.ts",
-    "smoke:curve-region": "tsx scripts/smoke-curve-region.ts",
-    "smoke:sculpt": "tsx scripts/smoke-sculpt.ts"
-  },
-  "keywords": [
-    "geometry",
-    "wasm",
-    "nurbs",
-    "mesh",
-    "boolean",
-    "cad",
-    "aec",
-    "3d"
-  ],
-  "author": "Mostafa El Ayoubi",
-  "license": "Proprietary License",
-  "repository": {
-    "type": "git",
-    "url": "https://www.orkestra.online"
-  },
-  "devDependencies": {
-    "tsx": "^4.7.0",
-    "typescript": "^5.4.0"
-  }
-}
+{
+  "name": "okgeometry-api",
+  "version": "1.21.0",
+  "description": "Geometry engine API for AEC applications - NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "scripts": {
+    "build:wasm": "node -e \"require('fs').rmSync('wasm',{recursive:true,force:true})\" && cd .. && wasm-pack build --target web --out-dir okgeometry-api/wasm",
+    "sync:wasm-bindings": "node scripts/sync-wasm-bindings.mjs",
+    "inline-wasm": "tsx scripts/inline-wasm.ts",
+    "build": "npm run build:wasm && npm run sync:wasm-bindings && npm run inline-wasm && tsc",
+    "bench:boolean-heavy": "npm run build && tsx scripts/bench-boolean-heavy.ts",
+    "bench:boolean-ab": "npm run build && tsx scripts/bench-boolean-ab.ts",
+    "bench:boolean-batch": "npm run build && tsx scripts/bench-boolean-batch.ts",
+    "bench:boolean-matrix": "tsx scripts/bench-boolean-matrix.ts",
+    "smoke:brep-boolean": "tsx scripts/smoke-brep-boolean.ts",
+    "prepublishOnly": "npm run build",
+    "smoke:brep-parametric": "tsx scripts/smoke-brep-parametric.ts",
+    "smoke:brep-from-mesh": "tsx scripts/smoke-brep-from-mesh.ts",
+    "smoke:brep-faces": "tsx scripts/smoke-brep-faces.ts",
+    "smoke:curve-intersections": "tsx scripts/smoke-curve-intersections.ts",
+    "smoke:brep-intersections": "tsx scripts/smoke-brep-intersections.ts",
+    "smoke:brep-sheet-boolean": "tsx scripts/smoke-brep-sheet-boolean.ts",
+    "smoke:geometry-boolean": "tsx scripts/smoke-geometry-boolean.ts",
+    "smoke:curve-region": "tsx scripts/smoke-curve-region.ts",
+    "smoke:sculpt": "tsx scripts/smoke-sculpt.ts"
+  },
+  "keywords": [
+    "geometry",
+    "wasm",
+    "nurbs",
+    "mesh",
+    "boolean",
+    "cad",
+    "aec",
+    "3d"
+  ],
+  "author": "Mostafa El Ayoubi",
+  "license": "Proprietary License",
+  "repository": {
+    "type": "git",
+    "url": "https://www.orkestra.online"
+  },
+  "devDependencies": {
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
+  }
+}

package/src/Mesh.ts

@@ -230,6 +230,92 @@ function shouldFallbackFromWorkerFailure(error: unknown): boolean {
   return code === "worker_unavailable" || code === "worker_crashed" || code === "worker_protocol";
 }
 
+/**
+ * Full mesh health report. Counts are on proximity-welded topology, so
+ * coincident-but-distinct seam vertices (geometrically watertight) are not
+ * mis-reported as open. `isWatertight` = closed 2-manifold with no degenerate
+ * or duplicate faces.
+ */
+export interface MeshDiagnostics {
+  vertexCount: number;
+  triangleCount: number;
+  weldedVertexCount: number;
+  boundaryEdges: number;
+  nonManifoldEdges: number;
+  boundaryLoops: number;
+  degenerateTriangles: number;
+  duplicateTriangles: number;
+  unreferencedVertices: number;
+  connectedComponents: number;
+  isClosed: boolean;
+  isManifold: boolean;
+  signedVolume: number;
+  isWatertight: boolean;
+}
+
+/** Which geometry-preserving repair steps to run. */
+export interface MeshRepairOptions {
+  weld?: boolean;
+  removeDegenerate?: boolean;
+  removeDuplicate?: boolean;
+  fillHoles?: boolean;
+  fixWinding?: boolean;
+  removeUnreferenced?: boolean;
+  /** `<= 0` = auto from bbox diagonal. */
+  weldTolerance?: number;
+  /** Skip holes whose boundary loop exceeds this many edges (`0` = fill all). */
+  maxHoleEdges?: number;
+}
+
+/** Result of {@link Mesh.repair}. */
+export interface MeshRepairResult {
+  mesh: Mesh;
+  before: MeshDiagnostics;
+  after: MeshDiagnostics;
+  weldedVertices: number;
+  removedTriangles: number;
+  filledHoles: number;
+}
+
+/** Result of {@link Mesh.makeWatertight}. */
+export interface MakeWatertightResult {
+  mesh: Mesh;
+  before: MeshDiagnostics;
+  after: MeshDiagnostics;
+  /** `'repair'` = closed by geometry-preserving repair; `'remesh'` = voxel remesh fallback. */
+  method: "repair" | "remesh";
+  /** Effective voxel resolution when `method === 'remesh'` (0 otherwise). */
+  effectiveResolution: number;
+}
+
+/** Parse the fixed 13-value diagnostic block at `offset` in a WASM result. */
+function parseMeshDiagnostics(r: ArrayLike<number>, offset: number): MeshDiagnostics {
+  const boundaryEdges = Math.round(r[offset + 3] ?? 0);
+  const nonManifoldEdges = Math.round(r[offset + 4] ?? 0);
+  const degenerateTriangles = Math.round(r[offset + 6] ?? 0);
+  const duplicateTriangles = Math.round(r[offset + 7] ?? 0);
+  const isClosed = (r[offset + 10] ?? 0) > 0.5;
+  return {
+    vertexCount: Math.round(r[offset] ?? 0),
+    triangleCount: Math.round(r[offset + 1] ?? 0),
+    weldedVertexCount: Math.round(r[offset + 2] ?? 0),
+    boundaryEdges,
+    nonManifoldEdges,
+    boundaryLoops: Math.round(r[offset + 5] ?? 0),
+    degenerateTriangles,
+    duplicateTriangles,
+    unreferencedVertices: Math.round(r[offset + 8] ?? 0),
+    connectedComponents: Math.round(r[offset + 9] ?? 0),
+    isClosed,
+    isManifold: (r[offset + 11] ?? 0) > 0.5,
+    signedVolume: r[offset + 12] ?? 0,
+    isWatertight:
+      isClosed && nonManifoldEdges === 0 && degenerateTriangles === 0 && duplicateTriangles === 0,
+  };
+}
+
+const MESH_DIAG_LEN = 13;
+
 /**
  * Buffer-backed triangle mesh with GPU-ready accessors.
  * All geometry lives in a Float64Array from WASM.
@@ -3702,6 +3788,114 @@ export class Mesh {
     };
   }
 
+  /**
+   * Full mesh health report (open/closed, boundary & non-manifold edge counts,
+   * boundary loops, degenerate / duplicate faces, orphan vertices, signed
+   * volume, watertight verdict). Computed on proximity-welded topology.
+   */
+  diagnostics(): MeshDiagnostics {
+    ensureInit();
+    const r = wasm.mesh_repair_diagnostics(this._vertexCount, this._buffer);
+    return parseMeshDiagnostics(r, 0);
+  }
+
+  /**
+   * Flat 3D endpoints of every open boundary edge, six values per segment
+   * (`[x0,y0,z0, x1,y1,z1, ...]`). Empty when the mesh is closed. Drives the
+   * red "open edge" highlight.
+   */
+  boundaryEdgeSegments(): Float64Array {
+    ensureInit();
+    return wasm.mesh_boundary_edge_segments(this._vertexCount, this._buffer);
+  }
+
+  /**
+   * Geometry-preserving repair: weld coincident vertices, drop degenerate /
+   * duplicate triangles, remove orphan vertices, make winding consistent +
+   * outward, and fill holes by triangulating their boundary loops. Returns the
+   * repaired mesh plus before/after diagnostics.
+   */
+  repair(options: MeshRepairOptions = {}): MeshRepairResult {
+    ensureInit();
+    const bit = (on: boolean | undefined, dflt: boolean, mask: number) =>
+      (on ?? dflt) ? mask : 0;
+    const flags =
+      bit(options.weld, true, 1) |
+      bit(options.removeDegenerate, true, 2) |
+      bit(options.removeDuplicate, true, 4) |
+      bit(options.fillHoles, true, 8) |
+      bit(options.fixWinding, true, 16) |
+      bit(options.removeUnreferenced, true, 32);
+    const r = wasm.mesh_repair(
+      this._vertexCount,
+      this._buffer,
+      flags,
+      options.weldTolerance ?? 0,
+      options.maxHoleEdges ?? 0,
+    );
+    const before = parseMeshDiagnostics(r, 0);
+    const after = parseMeshDiagnostics(r, MESH_DIAG_LEN);
+    const base = MESH_DIAG_LEN * 2;
+    const weldedVertices = Math.round(r[base] ?? 0);
+    const removedTriangles = Math.round(r[base + 1] ?? 0);
+    const filledHoles = Math.round(r[base + 2] ?? 0);
+    const meshBuffer = (r as Float64Array).slice(base + 3);
+    return {
+      mesh: Mesh.fromTrustedBuffer(meshBuffer),
+      before,
+      after,
+      weldedVertices,
+      removedTriangles,
+      filledHoles,
+    };
+  }
+
+  /**
+   * Rebuild as a guaranteed-watertight solid via generalized-winding-number
+   * voxel remeshing. `resolution` = voxels along the longest axis (`0` = 64
+   * default, auto-capped by a work budget); `iso` = winding threshold
+   * (`<=0`/`>=1` → 0.5). Always closes arbitrary open / non-manifold /
+   * self-intersecting soup, at the cost of fine detail.
+   */
+  voxelRemesh(resolution = 0, iso = 0.5): Mesh {
+    ensureInit();
+    const r = wasm.mesh_voxel_remesh(
+      this._vertexCount,
+      this._buffer,
+      Math.max(0, Math.floor(resolution)),
+      iso,
+    );
+    return Mesh.fromTrustedBuffer(r as Float64Array);
+  }
+
+  /**
+   * Layered "make watertight": first geometry-preserving {@link repair}; if
+   * that closes the mesh it is returned (`method: 'repair'`). Otherwise fall
+   * back to {@link voxelRemesh} (`method: 'remesh'`). Always returns a solid.
+   */
+  makeWatertight(options: { resolution?: number; iso?: number } = {}): MakeWatertightResult {
+    ensureInit();
+    const r = wasm.mesh_make_watertight(
+      this._vertexCount,
+      this._buffer,
+      Math.max(0, Math.floor(options.resolution ?? 0)),
+      options.iso ?? 0.5,
+    );
+    const before = parseMeshDiagnostics(r, 0);
+    const after = parseMeshDiagnostics(r, MESH_DIAG_LEN);
+    const base = MESH_DIAG_LEN * 2;
+    const method = (r[base] ?? 0) < 0.5 ? "repair" : "remesh";
+    const effectiveResolution = Math.round(r[base + 1] ?? 0);
+    const meshBuffer = (r as Float64Array).slice(base + 2);
+    return {
+      mesh: Mesh.fromTrustedBuffer(meshBuffer),
+      before,
+      after,
+      method,
+      effectiveResolution,
+    };
+  }
+
   /**
    * Get a logical planar face by its planar-face index.
    */

package/src/index.ts

@@ -90,6 +90,10 @@ export type {
   MeshBooleanErrorCode,
   MeshBooleanErrorPayload,
   MeshBooleanProgressEvent,
+  MeshDiagnostics,
+  MeshRepairOptions,
+  MeshRepairResult,
+  MakeWatertightResult,
 } from "./Mesh.js";
 export { intersect } from "./Geometry.js";