okgeometry-api 1.20.0 → 1.22.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,151 @@ 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);
+  }
+
+  /**
+   * Chamfer feature edges of this closed solid. Each entry in `edges` is one
+   * picked segment `{ a, b }` on a feature edge; the kernel expands it to the
+   * full chain separating the same two smooth face groups (a straight box
+   * edge, or a whole tessellated rim loop from a single pick). `distance` is
+   * the setback along each adjacent face, Rhino-style. Convex edges cut a
+   * flat; concave edges fill the notch. The result is watertight.
+   *
+   * Throws for open meshes, smooth (non-feature) picks, or when the distance
+   * exceeds what the adjacent faces allow.
+   */
+  chamferEdges(
+    edges: Array<{ a: Point | Vec3; b: Point | Vec3 }>,
+    distance: number,
+  ): Mesh {
+    ensureInit();
+    if (edges.length === 0) {
+      throw new Error("Mesh.chamferEdges() requires at least one edge");
+    }
+    const edgeBuf = new Float64Array(edges.length * 6);
+    edges.forEach((edge, i) => {
+      edgeBuf[i * 6] = edge.a.x;
+      edgeBuf[i * 6 + 1] = edge.a.y;
+      edgeBuf[i * 6 + 2] = edge.a.z;
+      edgeBuf[i * 6 + 3] = edge.b.x;
+      edgeBuf[i * 6 + 4] = edge.b.y;
+      edgeBuf[i * 6 + 5] = edge.b.z;
+    });
+    const r = wasm.mesh_chamfer_edges(this._vertexCount, this._buffer, edgeBuf, distance);
+    if (!r.length) {
+      throw new Error(
+        `Mesh.chamferEdges() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return Mesh.fromTrustedBuffer(r as Float64Array);
+  }
+
+  /**
+   * 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/NurbsCurve.ts

@@ -394,32 +394,9 @@ export class NurbsCurve {
     );
   }
 
-  /**
-   * Offset this curve by a distance.
-   * Note: NURBS offset is approximated by sampling and offsetting as polyline.
-   * @param distance - Offset distance
-   * @param normal - Reference normal for determining offset direction
-   * @param samples - Number of sample points (default 64)
-   * @param arcSamples - Number of samples per exact arc segment in the returned polyline(s)
-   * @param options - Offset options such as join style
-   * @returns Offset polyline approximation
-   */
-  offset(
-    distance: number,
-    normal?: Vec3,
-    samples = 64,
-    arcSamples = 32,
-    options: CurveOffsetOptions = {},
-  ): Polyline {
-    const results = this.offsetAll(distance, normal, samples, arcSamples, options);
-    if (results.length === 1) return results[0];
-    if (results.length === 0) {
-      throw new Error("NurbsCurve.offset() collapsed and produced no valid result polylines");
-    }
-    throw new Error(
-      `NurbsCurve.offset() produced ${results.length} result polylines. Use NurbsCurve.offsetAll() instead.`,
-    );
-  }
+  // NOTE: `offset()` (exact NURBS offset, kernel-refit to tolerance) lives
+  // further down next to `data`. The former sampled-polyline `offset()` was
+  // replaced by it; the sampled multi-result path remains as `offsetAll()`.
 
   /**
    * Offset this curve by a distance and return every sampled result polyline.
@@ -566,6 +543,38 @@ export class NurbsCurve {
     return NurbsCurve.fromData(buf);
   }
 
+  /**
+   * Offset this planar curve by `distance` within the plane with the given
+   * `normal`. Positive distance offsets toward `normal × tangent` (the same
+   * convention as Polyline/PolyCurve offsets). The result is refit to
+   * `tolerance` (default 1e-6) against the exact offset locus; rational
+   * curves (exact arcs) offset exactly. Closed curves stay closed.
+   *
+   * Throws for non-planar or kinked curves, or when the offset cannot reach
+   * tolerance (for example offsetting inward past the curvature radius).
+   */
+  offset(
+    distance: number,
+    normal: Vec3 = Vec3.Z,
+    options: { tolerance?: number } = {},
+  ): NurbsCurve {
+    ensureInit();
+    const buf = wasm.nurbs_curve_offset(
+      this.data,
+      distance,
+      normal.x,
+      normal.y,
+      normal.z,
+      options.tolerance ?? 1e-6,
+    );
+    if (buf.length < 2) {
+      throw new Error(
+        `NurbsCurve.offset() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return NurbsCurve.fromData(buf);
+  }
+
   /**
    * Get internal WASM data buffer.
    * For advanced use cases requiring direct WASM interop.

package/src/NurbsSurface.ts

@@ -312,6 +312,26 @@ export class NurbsSurface implements Surface {
     return this._data;
   }
 
+  /**
+   * Offset this surface by `distance` along its oriented normal field,
+   * refit to `tolerance` (default 1e-4) against the exact offset. Rational
+   * surfaces (cylinders, spheres, revolves) offset exactly; closed seams
+   * stay closed and degenerate poles stay degenerate.
+   *
+   * Throws for creased surfaces or when the offset cannot reach tolerance
+   * (for example offsetting inward past the curvature radius).
+   */
+  offset(distance: number, options: { tolerance?: number } = {}): NurbsSurface {
+    ensureInit();
+    const buf = wasm.nurbs_surface_offset(this.data, distance, options.tolerance ?? 1e-4);
+    if (buf.length < 4) {
+      throw new Error(
+        `NurbsSurface.offset() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return NurbsSurface.fromData(buf);
+  }
+
   // ── Analytic queries ──
 
   /**

package/src/Polyline.ts

@@ -240,6 +240,51 @@ export class Polyline {
     return PolyCurve.fromSegmentData(buf);
   }
 
+  /**
+   * Chamfer corners of this polyline with straight cuts of the given
+   * setback distance (clamped per corner to half the shorter adjacent
+   * segment). Closed polylines (duplicated end point) chamfer every corner
+   * including the seam and stay closed; open polylines never touch their
+   * endpoints. `options.corners` selects vertex indices to chamfer
+   * (indices into the unique point list, seam duplicate excluded).
+   */
+  chamfer(distance: number, options: { corners?: number[] } = {}): Polyline {
+    ensureInit();
+    const pts = this.points;
+    if (pts.length < 3) {
+      throw new Error("Polyline.chamfer() requires at least 3 points");
+    }
+    const first = pts[0];
+    const last = pts[pts.length - 1];
+    const closed =
+      pts.length >= 4 &&
+      Math.abs(first.x - last.x) < 1e-10 &&
+      Math.abs(first.y - last.y) < 1e-10 &&
+      Math.abs(first.z - last.z) < 1e-10;
+    const unique = closed ? pts.slice(0, -1) : pts;
+    const coords = new Float64Array(unique.length * 3);
+    unique.forEach((p, i) => {
+      coords[i * 3] = p.x;
+      coords[i * 3 + 1] = p.y;
+      coords[i * 3 + 2] = p.z;
+    });
+    const cornerBuf = new Float64Array(options.corners ?? []);
+    const buf = wasm.chamfer_polyline_corners(coords, closed, distance, cornerBuf);
+    if (buf.length < 6) {
+      throw new Error(
+        `Polyline.chamfer() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    const out: Point[] = [];
+    for (let i = 0; i + 2 < buf.length; i += 3) {
+      out.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
+    }
+    if (closed && out.length > 0) {
+      out.push(out[0]);
+    }
+    return new Polyline(out);
+  }
+
   /**
    * Convert this polyline to a PolyCurve (line segments only).
    * @returns PolyCurve with Line segments connecting consecutive points

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";