okgeometry-api 1.4.0 → 1.6.0

package/package.json

@@ -1,47 +1,48 @@
-{
-  "name": "okgeometry-api",
-  "version": "1.4.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",
-    "prepublishOnly": "npm run build"
-  },
-  "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.6.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",
+    "prepublishOnly": "npm run build"
+  },
+  "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

@@ -2235,6 +2235,138 @@ export class Mesh {
     );
   }
 
+  /**
+   * Union many meshes into a single mesh in ONE WASM call.
+   *
+   * Substantially faster than chaining pairwise `union()` calls: every input
+   * crosses the JS/WASM boundary once, intermediate results never round-trip
+   * through buffers, mutually disjoint inputs are concatenated instead of
+   * run through CSG, and overlapping inputs are merged smallest-first.
+   *
+   * Requires all inputs to be closed volumes.
+   * @param meshes - Meshes to union (order does not affect the result)
+   * @param options - Optional safety overrides
+   * @returns New mesh containing the combined volume of all inputs
+   */
+  static unionAll(meshes: Mesh[], options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const inputs = meshes
+      .filter((mesh) => mesh.faceCount > 0)
+      .map((mesh) => Mesh.normalizeClosedVolumeOrientation(mesh));
+    if (inputs.length === 0) return Mesh.emptyMesh();
+    if (inputs.length === 1) return Mesh.cloneMesh(inputs[0]);
+
+    const openCount = inputs.reduce((count, mesh) => count + (mesh.isClosedVolume() ? 0 : 1), 0);
+    if (openCount > 0) {
+      throw new Error(
+        `Boolean unionAll requires all inputs to be closed volumes (${openCount} of ${inputs.length} inputs are open). `
+        + "Close or cap the open meshes before calling unionAll().",
+      );
+    }
+
+    Mesh.enforceBatchBooleanLimits("unionAll", inputs, options);
+
+    const flags = inputs.every((mesh) => mesh._trustedBooleanInput) ? "trustedInput" : "";
+    const result = wasm.mesh_boolean_union_all(Mesh.packMeshes(inputs), flags);
+    return Mesh.decodeBatchBooleanResult("unionAll", result);
+  }
+
+  /**
+   * Subtract many cutter meshes from this mesh in ONE WASM call.
+   *
+   * The kernel culls cutters that miss this mesh's bounds, unions mutually
+   * overlapping cutters, combines disjoint cutters into one multi-shell
+   * operand, and performs a single CSG subtraction — instead of N pairwise
+   * subtractions that re-process the shrinking host every time.
+   *
+   * The fast batched path requires this mesh and all cutters to be closed
+   * volumes; open-mesh combinations fall back to sequential pairwise
+   * `subtract()` (which carries the split-based open-host trim semantics).
+   * @param others - Cutter meshes to subtract
+   * @param options - Optional safety overrides
+   * @returns New mesh with all cutter volumes removed from this
+   */
+  subtractAll(others: Mesh[], options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    if (this.faceCount === 0) return Mesh.emptyMesh();
+    const host = Mesh.normalizeClosedVolumeOrientation(this);
+    const cutters = others
+      .filter((mesh) => mesh.faceCount > 0)
+      .map((mesh) => Mesh.normalizeClosedVolumeOrientation(mesh));
+    if (cutters.length === 0) return Mesh.cloneMesh(host);
+    if (cutters.length === 1) return host.subtract(cutters[0], options);
+
+    if (cutters.some((mesh) => !mesh.isClosedVolume())) {
+      // Open cutters carry per-pair trim/error semantics — sequential only.
+      return cutters.reduce((acc: Mesh, cutter) => acc.subtract(cutter, options), host);
+    }
+
+    // Cheap bounds cull before crossing into WASM at all.
+    const hostBounds = Mesh.computeRawBounds(host);
+    const relevant = cutters.filter((cutter) => {
+      const cutterBounds = Mesh.computeRawBounds(cutter);
+      const contactTol = Mesh.booleanContactTolerance(hostBounds, cutterBounds);
+      return Mesh.boundsOverlap(hostBounds, cutterBounds, contactTol);
+    });
+    if (relevant.length === 0) return Mesh.cloneMesh(host);
+
+    Mesh.enforceBatchBooleanLimits("subtractAll", [host, ...relevant], options);
+
+    const flags = host._trustedBooleanInput && relevant.every((mesh) => mesh._trustedBooleanInput)
+      ? "trustedInput"
+      : "";
+
+    if (!host.isClosedVolume()) {
+      // Open host + closed cutters: batched surface trim. One pass over the
+      // host with all cutters at once — replaces the sequential pairwise
+      // fold, which re-split (and degraded) the growing host once per cutter.
+      const result = wasm.mesh_surface_difference_all(Mesh.packMeshes([host, ...relevant]), flags);
+      return Mesh.decodeBatchBooleanResult("subtractAll", result);
+    }
+
+    const result = wasm.mesh_boolean_difference_all(Mesh.packMeshes([host, ...relevant]), flags);
+    return Mesh.decodeBatchBooleanResult("subtractAll", result);
+  }
+
+  private static enforceBatchBooleanLimits(
+    operation: string,
+    inputs: Mesh[],
+    options?: MeshBooleanOptions,
+  ): void {
+    if (options?.allowUnsafe) return;
+    const limits = Mesh.resolveBooleanLimits(options?.limits);
+    let combinedInputFaces = 0;
+    for (const mesh of inputs) {
+      if (mesh.faceCount > limits.maxInputFacesPerMesh) {
+        throw new Error(
+          `Boolean ${operation} blocked by safety limits `
+          + `(input faces=${mesh.faceCount} > maxInputFacesPerMesh=${limits.maxInputFacesPerMesh}). `
+          + "Simplify inputs, run in a Worker, or pass allowUnsafe: true to force execution.",
+        );
+      }
+      combinedInputFaces += mesh.faceCount;
+    }
+    if (combinedInputFaces > limits.maxCombinedInputFaces) {
+      throw new Error(
+        `Boolean ${operation} blocked by safety limits `
+        + `(combined faces=${combinedInputFaces} > maxCombinedInputFaces=${limits.maxCombinedInputFaces}). `
+        + "Simplify inputs, run in a Worker, or pass allowUnsafe: true to force execution.",
+      );
+    }
+  }
+
+  private static decodeBatchBooleanResult(operation: string, result: Float64Array): Mesh {
+    if (result.length === 0) {
+      throw new Error(`Boolean ${operation} failed and returned an invalid mesh buffer.`);
+    }
+    const vertexCount = result[0];
+    if (!Number.isFinite(vertexCount) || vertexCount < 0) {
+      throw new Error(`Boolean ${operation} failed and returned a corrupt mesh buffer.`);
+    }
+    if (vertexCount === 0) return Mesh.emptyMesh();
+    return Mesh.fromTrustedBuffer(result);
+  }
+
   private splitWithMesh(other: Mesh, options?: MeshBooleanOptions): MeshSplitResult {
     ensureInit();