okgeometry-api 1.1.20 → 1.1.22

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,sh5tCAAsh5tC,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,0yquCAA0yquC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.1.20",
+  "version": "1.1.22",
   "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

@@ -181,12 +181,18 @@ export interface MeshBooleanReproOptions {
   includeResult?: boolean;
   debugOptions?: MeshBooleanDebugOptions;
 }
-
-/**
- * Buffer-backed triangle mesh with GPU-ready accessors.
- * All geometry lives in a Float64Array from WASM.
- *
- * Buffer format: [vertexCount, x1,y1,z1, ..., i1,i2,i3, ...]
+
+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";
+}
+
+/**
+ * Buffer-backed triangle mesh with GPU-ready accessors.
+ * All geometry lives in a Float64Array from WASM.
+ *
+ * Buffer format: [vertexCount, x1,y1,z1, ..., i1,i2,i3, ...]
  */
 export class Mesh {
   private _buffer: Float64Array;
@@ -1807,50 +1813,80 @@ export class Mesh {
   /**
    * Compute boolean union in a dedicated Web Worker (non-blocking).
    * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
-   */
-  async unionAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
-    const result = await runMeshBooleanInWorkerPool(
-      "union",
-      this._buffer,
-      other._buffer,
-      this._trustedBooleanInput,
-      other._trustedBooleanInput,
-      options,
-    );
-    return Mesh.fromTrustedBuffer(result);
-  }
+   */
+  async unionAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
+    try {
+      const result = await runMeshBooleanInWorkerPool(
+        "union",
+        this._buffer,
+        other._buffer,
+        this._trustedBooleanInput,
+        other._trustedBooleanInput,
+        options,
+      );
+      return Mesh.fromTrustedBuffer(result);
+    } catch (error) {
+      if (!shouldFallbackFromWorkerFailure(error)) throw error;
+      console.warn("Mesh.unionAsync worker failed; falling back to main-thread boolean.", error);
+      return this.union(other, {
+        allowUnsafe: options?.allowUnsafe ?? true,
+        limits: options?.limits,
+        debugForceFaceID: options?.debugForceFaceID,
+      });
+    }
+  }
 
-  /**
-   * Compute boolean subtraction in a dedicated Web Worker (non-blocking).
-   * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
-   */
-  async subtractAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
-    const result = await runMeshBooleanInWorkerPool(
-      "subtraction",
-      this._buffer,
-      other._buffer,
-      this._trustedBooleanInput,
-      other._trustedBooleanInput,
-      options,
-    );
-    return Mesh.fromTrustedBuffer(result);
-  }
+  /**
+   * Compute boolean subtraction in a dedicated Web Worker (non-blocking).
+   * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
+   */
+  async subtractAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
+    try {
+      const result = await runMeshBooleanInWorkerPool(
+        "subtraction",
+        this._buffer,
+        other._buffer,
+        this._trustedBooleanInput,
+        other._trustedBooleanInput,
+        options,
+      );
+      return Mesh.fromTrustedBuffer(result);
+    } catch (error) {
+      if (!shouldFallbackFromWorkerFailure(error)) throw error;
+      console.warn("Mesh.subtractAsync worker failed; falling back to main-thread boolean.", error);
+      return this.subtract(other, {
+        allowUnsafe: options?.allowUnsafe ?? true,
+        limits: options?.limits,
+        debugForceFaceID: options?.debugForceFaceID,
+      });
+    }
+  }
 
-  /**
-   * Compute boolean intersection in a dedicated Web Worker (non-blocking).
-   * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
-   */
-  async intersectAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
-    const result = await runMeshBooleanInWorkerPool(
-      "intersection",
-      this._buffer,
-      other._buffer,
-      this._trustedBooleanInput,
-      other._trustedBooleanInput,
-      options,
-    );
-    return Mesh.fromTrustedBuffer(result);
-  }
+  /**
+   * Compute boolean intersection in a dedicated Web Worker (non-blocking).
+   * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
+   */
+  async intersectAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
+    try {
+      const result = await runMeshBooleanInWorkerPool(
+        "intersection",
+        this._buffer,
+        other._buffer,
+        this._trustedBooleanInput,
+        other._trustedBooleanInput,
+        options,
+      );
+      return Mesh.fromTrustedBuffer(result);
+    } catch (error) {
+      if (!shouldFallbackFromWorkerFailure(error)) throw error;
+      console.warn("Mesh.intersectAsync worker failed; falling back to main-thread boolean.", error);
+      return this.intersect(other, {
+        allowUnsafe: options?.allowUnsafe ?? true,
+        limits: options?.limits,
+        debugForceFaceID: options?.debugForceFaceID,
+      });
+    }
+  }
 
   // ── Intersection queries ───────────────────────────────────────