okgeometry-api 1.26.1 → 1.27.0

package/src/mesh-boolean.worker.ts

@@ -1,5 +1,6 @@
 import { init, isInitialized } from "./engine.js";
-import { Mesh } from "./Mesh.js";
+import { Mesh } from "./Mesh.js";
+import { Point } from "./Point.js";
 import type {
   MeshBooleanErrorPayload,
   MeshBooleanWorkerErrorResponse,
@@ -33,8 +34,8 @@ function isCancelled(jobId: number, cancelView: Int32Array | undefined): boolean
   return cancelledJobs.has(jobId) || readCancelRequested(cancelView);
 }
 
-workerGlobal.__okgeometry_boolean_should_cancel = () =>
-  readCancelRequested(workerGlobal.__okgeometryBooleanCancelFlag ?? undefined);
+workerGlobal.__okgeometry_boolean_should_cancel = () =>
+  readCancelRequested(workerGlobal.__okgeometryBooleanCancelFlag ?? undefined);
 
 function toErrorMessage(error: unknown): string {
   if (error instanceof Error) return error.message;
@@ -46,25 +47,97 @@ function makeError(code: MeshBooleanErrorPayload["code"], message: string, detai
   return { code, message, details };
 }
 
-function postError(jobId: number, payload: MeshBooleanErrorPayload): void {
-  const response: MeshBooleanWorkerErrorResponse = {
-    kind: "mesh-boolean-result",
-    jobId,
-    ok: false,
-    error: payload,
-  };
-  workerScope.postMessage(response);
-}
-
-function postSuccess(jobId: number, buffer: ArrayBuffer): void {
-  const response: MeshBooleanWorkerSuccessResponse = {
-    kind: "mesh-boolean-result",
-    jobId,
-    ok: true,
-    buffer,
-  };
-  workerScope.postMessage(response, [buffer]);
-}
+function postError(jobId: number, payload: MeshBooleanErrorPayload): void {
+  const response: MeshBooleanWorkerErrorResponse = {
+    kind: "mesh-boolean-result",
+    jobId,
+    ok: false,
+    error: payload,
+  };
+  workerScope.postMessage(response);
+}
+
+function postSuccess(
+  jobId: number,
+  buffer: ArrayBuffer,
+  meta?: Record<string, string | number | boolean>,
+): void {
+  const response: MeshBooleanWorkerSuccessResponse = {
+    kind: "mesh-boolean-result",
+    jobId,
+    ok: true,
+    buffer,
+    meta,
+  };
+  workerScope.postMessage(response, [buffer]);
+}
+
+/** Heavy kernel jobs (KERNEL-PERF-ARC lever 4) — see protocol for shapes. */
+function runHeavyOperation(message: {
+  operation: string;
+  buffers: ArrayBuffer[];
+  trusted?: boolean[];
+  params?: { resolution?: number; iso?: number; distance?: number };
+  options: { allowUnsafe?: boolean; limits?: unknown; debugForceFaceID?: boolean };
+}): { buffer: ArrayBuffer; meta?: Record<string, string | number | boolean> } {
+  const meshes = () =>
+    message.buffers.map((buf, i) =>
+      Mesh.fromBuffer(new Float64Array(buf), {
+        trustedBooleanInput: message.trusted?.[i],
+      }),
+    );
+  const options = {
+    allowUnsafe: message.options.allowUnsafe ?? true,
+    limits: message.options.limits as never,
+    debugForceFaceID: message.options.debugForceFaceID,
+  };
+  const params = message.params ?? {};
+
+  switch (message.operation) {
+    case "unionAll": {
+      const result = Mesh.unionAll(meshes(), options);
+      return { buffer: new Float64Array(result.rawBuffer).buffer };
+    }
+    case "differenceAll": {
+      const [host, ...cutters] = meshes();
+      const result = host.subtractAll(cutters, options);
+      return { buffer: new Float64Array(result.rawBuffer).buffer };
+    }
+    case "makeWatertight": {
+      const [mesh] = meshes();
+      const r = mesh.makeWatertight({
+        resolution: params.resolution,
+        iso: params.iso,
+      });
+      return {
+        buffer: new Float64Array(r.mesh.rawBuffer).buffer,
+        meta: { method: r.method, effectiveResolution: r.effectiveResolution },
+      };
+    }
+    case "voxelRemesh": {
+      const [mesh] = meshes();
+      const result = mesh.voxelRemesh(params.resolution ?? 0, params.iso ?? 0.5);
+      return { buffer: new Float64Array(result.rawBuffer).buffer };
+    }
+    case "chamferEdges": {
+      const mesh = Mesh.fromBuffer(new Float64Array(message.buffers[0]), {
+        trustedBooleanInput: message.trusted?.[0],
+      });
+      const flat = new Float64Array(message.buffers[1]);
+      const edges: Array<{ a: Point; b: Point }> = [];
+      for (let i = 0; i + 5 < flat.length; i += 6) {
+        edges.push({
+          a: new Point(flat[i], flat[i + 1], flat[i + 2]),
+          b: new Point(flat[i + 3], flat[i + 4], flat[i + 5]),
+        });
+      }
+      const result = mesh.chamferEdges(edges, params.distance ?? 0);
+      return { buffer: new Float64Array(result.rawBuffer).buffer };
+    }
+    default:
+      throw new Error(`Unknown heavy operation: ${message.operation}`);
+  }
+}
 
 async function ensureWorkerInit(): Promise<void> {
   if (isInitialized()) return;
@@ -82,25 +155,66 @@ workerScope.addEventListener("message", async (event: MessageEvent<MeshBooleanWo
     cancelledJobs.add(message.jobId);
     return;
   }
-
-  if (message.kind !== "mesh-boolean-request") return;
-  const jobId = message.jobId;
-  const cancelView = message.cancelBuffer ? new Int32Array(message.cancelBuffer) : undefined;
-
-  if (isCancelled(jobId, cancelView)) {
-    postError(jobId, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
-    cancelledJobs.delete(jobId);
-    return;
-  }
+
+  if (message.kind === "mesh-heavy-request") {
+    const jobId = message.jobId;
+    const cancelView = message.cancelBuffer ? new Int32Array(message.cancelBuffer) : undefined;
+    if (isCancelled(jobId, cancelView)) {
+      postError(jobId, makeError("worker_aborted", `${message.operation} aborted.`));
+      cancelledJobs.delete(jobId);
+      return;
+    }
+    try {
+      await ensureWorkerInit();
+      if (isCancelled(jobId, cancelView)) {
+        postError(jobId, makeError("worker_aborted", `${message.operation} aborted.`));
+        cancelledJobs.delete(jobId);
+        return;
+      }
+      workerGlobal.__okgeometryBooleanCancelFlag = cancelView ?? null;
+      const { buffer, meta } = runHeavyOperation(message);
+      if (isCancelled(jobId, cancelView)) {
+        postError(jobId, makeError("worker_aborted", `${message.operation} aborted.`));
+        cancelledJobs.delete(jobId);
+        return;
+      }
+      postSuccess(jobId, buffer, meta);
+    } catch (error) {
+      const details = toErrorMessage(error);
+      const cancelled = isCancelled(jobId, cancelView) || details.toLowerCase().includes("cancel");
+      postError(
+        jobId,
+        makeError(
+          cancelled ? "worker_aborted" : "kernel_error",
+          cancelled ? `${message.operation} aborted.` : `${message.operation} failed.`,
+          cancelled ? undefined : details,
+        ),
+      );
+    } finally {
+      workerGlobal.__okgeometryBooleanCancelFlag = null;
+      cancelledJobs.delete(jobId);
+    }
+    return;
+  }
+
+  if (message.kind !== "mesh-boolean-request") return;
+  const jobId = message.jobId;
+  const cancelView = message.cancelBuffer ? new Int32Array(message.cancelBuffer) : undefined;
+
+  if (isCancelled(jobId, cancelView)) {
+    postError(jobId, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
+    cancelledJobs.delete(jobId);
+    return;
+  }
 
   try {
-    await ensureWorkerInit();
-
-    if (isCancelled(jobId, cancelView)) {
-      postError(jobId, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
-      cancelledJobs.delete(jobId);
-      return;
-    }
+    await ensureWorkerInit();
+
+    if (isCancelled(jobId, cancelView)) {
+      postError(jobId, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
+      cancelledJobs.delete(jobId);
+      return;
+    }
 
     workerGlobal.__okgeometryBooleanCancelFlag = cancelView ?? null;
 
@@ -124,23 +238,23 @@ workerScope.addEventListener("message", async (event: MessageEvent<MeshBooleanWo
     } else {
       result = meshA.intersect(meshB, options);
     }
-
-    if (isCancelled(jobId, cancelView)) {
-      postError(jobId, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
-      cancelledJobs.delete(jobId);
-      return;
-    }
-
-    const payload = new Float64Array(result.rawBuffer);
-    postSuccess(jobId, payload.buffer);
-  } catch (error) {
-    const details = toErrorMessage(error);
-    const cancelled = isCancelled(jobId, cancelView) || details.toLowerCase().includes("cancel");
-    postError(
-      jobId,
-      makeError(
-        cancelled ? "worker_aborted" : "kernel_error",
-        cancelled ? `Boolean ${message.operation} aborted.` : `Boolean ${message.operation} failed.`,
+
+    if (isCancelled(jobId, cancelView)) {
+      postError(jobId, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
+      cancelledJobs.delete(jobId);
+      return;
+    }
+
+    const payload = new Float64Array(result.rawBuffer);
+    postSuccess(jobId, payload.buffer);
+  } catch (error) {
+    const details = toErrorMessage(error);
+    const cancelled = isCancelled(jobId, cancelView) || details.toLowerCase().includes("cancel");
+    postError(
+      jobId,
+      makeError(
+        cancelled ? "worker_aborted" : "kernel_error",
+        cancelled ? `Boolean ${message.operation} aborted.` : `Boolean ${message.operation} failed.`,
         cancelled ? undefined : details,
       ),
     );

package/src/wasm-active.ts

@@ -0,0 +1,31 @@
+/**
+ * Mutable indirection over the active wasm bindings module
+ * (KERNEL-PERF-ARC lever 3).
+ *
+ * The engine ships two artifacts with an identical export surface: the
+ * standard single-thread build and an optional rayon-threaded build
+ * (atomics + shared memory) loaded only on cross-origin-isolated pages.
+ * All geometry classes call through `wasm` here, which resolves to the
+ * active module at call time; `initThreads()` swaps the module BEFORE any
+ * geometry exists (enforced in engine.ts), so per-instance state (stored
+ * meshes, sculpt sessions) never spans instances.
+ */
+import * as standard from "./wasm-bindings.js";
+
+type WasmModule = typeof standard;
+
+let active: WasmModule = standard;
+
+export function setActiveWasmModule(module: WasmModule): void {
+  active = module;
+}
+
+export function getActiveWasmModule(): WasmModule {
+  return active;
+}
+
+/** Property access resolves through the ACTIVE module at call time. */
+export const wasm: WasmModule = new Proxy(Object.create(null) as WasmModule, {
+  get: (_target, key) => (active as unknown as Record<PropertyKey, unknown>)[key],
+  has: (_target, key) => key in (active as object),
+});