okgeometry-api 1.33.0 → 1.34.0

package/package.json

@@ -1,69 +1,69 @@
-{
-  "name": "okgeometry-api",
-  "version": "1.33.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",
-    "smoke:rebuild": "tsx scripts/smoke-rebuild.ts",
-    "smoke:mesh-residency": "tsx scripts/smoke-mesh-residency.ts",
-    "build:wasm-threaded": "node scripts/build-threaded.mjs",
-    "smoke:browser-threaded": "node scripts/browser-smoke-threaded.mjs",
-    "smoke:browser-heavy": "node scripts/browser-smoke-heavy-worker.mjs",
-    "smoke:thicken": "tsx scripts/smoke-thicken.ts",
-    "bench:thicken": "tsx scripts/bench-thicken.ts",
-    "smoke:sweep": "tsx scripts/smoke-sweep.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",
-    "playwright": "^1.49.0"
-  }
-}
+{
+  "name": "okgeometry-api",
+  "version": "1.34.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",
+    "smoke:rebuild": "tsx scripts/smoke-rebuild.ts",
+    "smoke:mesh-residency": "tsx scripts/smoke-mesh-residency.ts",
+    "build:wasm-threaded": "node scripts/build-threaded.mjs",
+    "smoke:browser-threaded": "node scripts/browser-smoke-threaded.mjs",
+    "smoke:browser-heavy": "node scripts/browser-smoke-heavy-worker.mjs",
+    "smoke:thicken": "tsx scripts/smoke-thicken.ts",
+    "bench:thicken": "tsx scripts/bench-thicken.ts",
+    "smoke:sweep": "tsx scripts/smoke-sweep.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",
+    "playwright": "^1.49.0"
+  }
+}

package/src/Brep.ts

@@ -2,10 +2,12 @@ import { ensureInit } from "./engine.js";
 import { Point } from "./Point.js";
 import { Vec3 } from "./Vec3.js";
 import { Plane } from "./Plane.js";
-import { Mesh, type MeshBooleanOptions } from "./Mesh.js";
+import { Mesh, type MeshBooleanOptions, shouldFallbackFromWorkerFailure } from "./Mesh.js";
 import { Polyline } from "./Polyline.js";
 import { NurbsCurve } from "./NurbsCurve.js";
 import { NurbsSurface } from "./NurbsSurface.js";
+import { MeshBooleanExecutionError, type MeshBooleanAsyncOptions } from "./mesh-boolean.protocol.js";
+import { runMeshHeavyInWorkerPool } from "./mesh-boolean.pool.js";
 import { wasm } from "./wasm-active.js";
 
 /** Options for Brep boolean operations. */
@@ -26,6 +28,13 @@ export interface BrepParametricBooleanOptions {
   tolerance?: number;
 }
 
+/**
+ * Options for the ASYNC parametric Brep booleans: the parametric options
+ * plus the worker-pool controls (signal, timeout, progress, pool sizing).
+ */
+export type BrepParametricBooleanAsyncOptions = BrepParametricBooleanOptions &
+  Omit<MeshBooleanAsyncOptions, "limits" | "allowUnsafe" | "debugForceFaceID">;
+
 /** Options for mesh → BREP conversion ({@link Brep.fromMesh}). */
 export interface MeshToBrepConversionOptions {
   /**
@@ -1125,6 +1134,62 @@ export class Brep {
     return this.runParametricBoolean(other, "intersect", options);
   }
 
+  private async runParametricBooleanAsync(
+    other: Brep | Mesh,
+    op: "union" | "subtract" | "intersect",
+    options?: BrepParametricBooleanAsyncOptions,
+  ): Promise<Brep> {
+    ensureInit();
+    const rhs = Brep.resolveParametricOperand(other);
+    try {
+      const { meta } = await runMeshHeavyInWorkerPool("brepBoolean", [], {
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs,
+        workerFactory: options?.workerFactory,
+        poolSize: options?.poolSize,
+        onProgress: options?.onProgress,
+        params: {
+          brepA: this.json,
+          brepB: rhs.json,
+          brepOp: op,
+          tolerance: options?.tolerance,
+        },
+      });
+      const json = meta?.brepJson;
+      if (typeof json !== "string" || json.length === 0) {
+        throw new MeshBooleanExecutionError({
+          code: "worker_protocol",
+          message: `Brep.${op}BrepAsync worker returned no result body.`,
+        });
+      }
+      return new Brep(json);
+    } catch (error) {
+      if (!shouldFallbackFromWorkerFailure(error)) throw error;
+      console.warn(`Brep.${op}BrepAsync worker failed; falling back to main-thread boolean.`, error);
+      return this.runParametricBoolean(other, op, options);
+    }
+  }
+
+  /**
+   * {@link unionBrep} on the worker pool (non-blocking). Worker
+   * INFRASTRUCTURE failures fall back to the synchronous main-thread path;
+   * kernel-level failures propagate (they would fail again on the main
+   * thread).
+   */
+  unionBrepAsync(other: Brep | Mesh, options?: BrepParametricBooleanAsyncOptions): Promise<Brep> {
+    return this.runParametricBooleanAsync(other, "union", options);
+  }
+
+  /** {@link subtractBrep} on the worker pool (non-blocking). See {@link unionBrepAsync}. */
+  subtractBrepAsync(other: Brep | Mesh, options?: BrepParametricBooleanAsyncOptions): Promise<Brep> {
+    return this.runParametricBooleanAsync(other, "subtract", options);
+  }
+
+  /** {@link intersectBrep} on the worker pool (non-blocking). See {@link unionBrepAsync}. */
+  intersectBrepAsync(other: Brep | Mesh, options?: BrepParametricBooleanAsyncOptions): Promise<Brep> {
+    return this.runParametricBooleanAsync(other, "intersect", options);
+  }
+
   // ── Mesh → BREP and solid ÷ sheet split ──
 
   /**

package/src/Mesh.ts

@@ -275,7 +275,13 @@ export interface MeshCurveSplitOptions extends MeshBooleanOptions {
   curveSegments?: number;
 }
 
-function shouldFallbackFromWorkerFailure(error: unknown): boolean {
+/**
+ * Whether an async worker failure should fall back to the synchronous
+ * main-thread path: only worker INFRASTRUCTURE failures qualify — a
+ * kernel-level error would fail again on the main thread and must
+ * propagate instead. Shared by the Mesh and Brep async wrappers.
+ */
+export function shouldFallbackFromWorkerFailure(error: unknown): boolean {
   if (!error || typeof error !== "object") return false;
   const code = "code" in error ? error.code : undefined;
   return code === "worker_unavailable" || code === "worker_crashed" || code === "worker_protocol";

package/src/mesh-boolean.protocol.ts

@@ -129,13 +129,15 @@ export class MeshBooleanExecutionError extends Error {
 //
 // Multi-second kernel operations beyond pairwise booleans run on the same
 // worker pool: batch booleans, watertight repair, voxel remesh, solid edge
-// chamfer. Buffers are op-specific:
+// chamfer, parametric BREP booleans. Buffers are op-specific:
 //   unionAll:       [mesh0, mesh1, ...]
 //   differenceAll:  [host, cutter0, cutter1, ...]
 //   makeWatertight: [mesh]
 //   voxelRemesh:    [mesh]
 //   chamferEdges:   [mesh, edgeSegments] (flat [ax,ay,az,bx,by,bz] per edge)
 //   filletEdges:    [mesh, edgeSegments] (same layout, radius + segments in params)
+//   brepBoolean:    [] (both operands ride `params` as BREP JSON strings;
+//                   the result BREP JSON returns in the response `meta`)
 
 export type MeshHeavyOperation =
   | "unionAll"
@@ -143,7 +145,8 @@ export type MeshHeavyOperation =
   | "makeWatertight"
   | "voxelRemesh"
   | "chamferEdges"
-  | "filletEdges";
+  | "filletEdges"
+  | "brepBoolean";
 
 export interface MeshHeavyParams {
   resolution?: number;
@@ -151,6 +154,14 @@ export interface MeshHeavyParams {
   distance?: number;
   radius?: number;
   segments?: number;
+  /** brepBoolean: operand A as BREP JSON. */
+  brepA?: string;
+  /** brepBoolean: operand B as BREP JSON. */
+  brepB?: string;
+  /** brepBoolean: which parametric boolean to run. */
+  brepOp?: "union" | "subtract" | "intersect";
+  /** brepBoolean: absolute geometric tolerance (default 1e-6). */
+  tolerance?: number;
 }
 
 export interface MeshHeavyWorkerRequest {

package/src/mesh-boolean.worker.ts

@@ -1,4 +1,5 @@
 import { init, isInitialized } from "./engine.js";
+import { Brep } from "./Brep.js";
 import { Mesh } from "./Mesh.js";
 import { Point } from "./Point.js";
 import type {
@@ -77,7 +78,17 @@ function runHeavyOperation(message: {
   operation: string;
   buffers: ArrayBuffer[];
   trusted?: boolean[];
-  params?: { resolution?: number; iso?: number; distance?: number; radius?: number; segments?: number };
+  params?: {
+    resolution?: number;
+    iso?: number;
+    distance?: number;
+    radius?: number;
+    segments?: number;
+    brepA?: string;
+    brepB?: string;
+    brepOp?: "union" | "subtract" | "intersect";
+    tolerance?: number;
+  };
   options: { allowUnsafe?: boolean; limits?: unknown; debugForceFaceID?: boolean };
 }): { buffer: ArrayBuffer; meta?: Record<string, string | number | boolean> } {
   const meshes = () =>
@@ -134,6 +145,24 @@ function runHeavyOperation(message: {
       const result = mesh.chamferEdges(edges, params.distance ?? 0);
       return { buffer: new Float64Array(result.rawBuffer).buffer };
     }
+    case "brepBoolean": {
+      // Parametric BREP boolean: operands ride params as JSON strings; the
+      // result BREP JSON returns via meta (the buffer channel stays empty).
+      const { brepA, brepB, brepOp } = params;
+      if (!brepA || !brepB || !brepOp) {
+        throw new Error("brepBoolean requires brepA, brepB and brepOp params");
+      }
+      const a = Brep.fromJson(brepA);
+      const b = Brep.fromJson(brepB);
+      const opts = params.tolerance !== undefined ? { tolerance: params.tolerance } : undefined;
+      const result =
+        brepOp === "union"
+          ? a.unionBrep(b, opts)
+          : brepOp === "subtract"
+            ? a.subtractBrep(b, opts)
+            : a.intersectBrep(b, opts);
+      return { buffer: new ArrayBuffer(0), meta: { brepJson: result.toJson() } };
+    }
     case "filletEdges": {
       const mesh = Mesh.fromBuffer(new Float64Array(message.buffers[0]), {
         trustedBooleanInput: message.trusted?.[0],