okgeometry-api 1.21.0 → 1.22.0

package/package.json

@@ -1,59 +1,60 @@
-{
-  "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"
-  }
-}
+{
+  "name": "okgeometry-api",
+  "version": "1.22.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",
+    "smoke:offset-chamfer": "tsx scripts/smoke-offset-chamfer.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

@@ -3809,6 +3809,43 @@ export class Mesh {
     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 +

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