okgeometry-api 1.37.0 → 1.38.0

package/dist/wasm-base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,sow2GAAsow2G,CAAC"}
+{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,8hq3GAA8hq3G,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.37.0",
+  "version": "1.38.0",
   "description": "Geometry engine API for AEC applications - NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",

package/src/Mesh.ts

@@ -3260,6 +3260,63 @@ export class Mesh {
    * If the surface does not fully cut through the solid, the produced side(s)
    * will not be closed — verify with `isClosedVolume()` on the side you keep.
    */
+  /**
+   * Async `splitSolidBySurface` on the worker pool — off the UI thread, with
+   * the sync safety limits lifted (worker jobs default `allowUnsafe`). Used for
+   * the capped solid − surface split on high-poly imported scans, which would
+   * otherwise freeze the main thread for tens of seconds. Falls back to the
+   * synchronous path only on a worker INFRASTRUCTURE failure.
+   */
+  async splitSolidBySurfaceAsync(
+    surface: Mesh,
+    options?: MeshBooleanAsyncOptions,
+  ): Promise<MeshSplitResult> {
+    try {
+      const { buffer, meta } = await runMeshHeavyInWorkerPool(
+        "solidSplitBySurface",
+        [this._buffer, surface._buffer],
+        {
+          ...options,
+          trusted: [this._trustedBooleanInput, surface._trustedBooleanInput],
+          allowUnsafe: options?.allowUnsafe ?? true,
+        },
+      );
+      const packed = new Float64Array(buffer);
+      const readSide = (off: number): { side: Mesh[]; next: number } => {
+        const count = Math.max(0, Math.round(packed[off] ?? 0));
+        let cursor = off + 1;
+        const side: Mesh[] = [];
+        for (let i = 0; i < count; i++) {
+          const len = Math.max(0, Math.round(packed[cursor] ?? 0));
+          cursor += 1;
+          side.push(Mesh.fromTrustedBuffer(packed.slice(cursor, cursor + len)));
+          cursor += len;
+        }
+        return { side, next: cursor };
+      };
+      const outside = readSide(0);
+      const inside = readSide(outside.next);
+      const classification =
+        (meta?.classification as "volume" | "surface" | undefined) ?? "surface";
+      return {
+        outside: outside.side,
+        inside: inside.side,
+        all: [...outside.side, ...inside.side],
+        classification,
+      };
+    } catch (error) {
+      if (!shouldFallbackFromWorkerFailure(error)) throw error;
+      console.warn(
+        "Mesh.splitSolidBySurfaceAsync worker failed; falling back to main thread.",
+        error,
+      );
+      return this.splitSolidBySurface(surface, {
+        ...options,
+        allowUnsafe: options?.allowUnsafe ?? true,
+      });
+    }
+  }
+
   splitSolidBySurface(surface: Mesh, options?: MeshBooleanOptions): MeshSplitResult {
     ensureInit();
     if (this.faceCount === 0) {

package/src/mesh-boolean.protocol.ts

@@ -154,6 +154,7 @@ export type MeshHeavyOperation =
   | "filletEdges"
   | "brepBoolean"
   | "split"
+  | "solidSplitBySurface"
   | "diagnostics"
   | "repair"
   | "importStl";

package/src/mesh-boolean.worker.ts

@@ -208,6 +208,29 @@ function runHeavyOperation(message: {
         meta: { classification: r.classification ?? "volume" },
       };
     }
+    case "solidSplitBySurface": {
+      const [solid, surface] = meshes();
+      const r = solid.splitSolidBySurface(surface, options);
+      // Same two-side packing as "split".
+      const packSide = (side: Mesh[]): number =>
+        side.reduce((n, m) => n + 1 + m.rawBuffer.length, 1);
+      const total = packSide(r.outside) + packSide(r.inside);
+      const out = new Float64Array(total);
+      let off = 0;
+      for (const side of [r.outside, r.inside]) {
+        out[off++] = side.length;
+        for (const m of side) {
+          const raw = m.rawBuffer;
+          out[off++] = raw.length;
+          out.set(raw, off);
+          off += raw.length;
+        }
+      }
+      return {
+        buffer: out.buffer as ArrayBuffer,
+        meta: { classification: r.classification ?? "surface" },
+      };
+    }
     case "importStl": {
       // buffers[0] carries the RAW STL FILE BYTES, length-prefixed and padded
       // into an f64-aligned payload: [byteLength] then the bytes from offset 8