okgeometry-api 1.1.11 → 1.1.13

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,0s3wDAA0s3wD,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,sthyDAAsthyD,CAAC"}

package/dist/wasm-bindings.js

@@ -1688,7 +1688,7 @@ export function version() {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg___okgeometry_boolean_should_cancel_172c0bc0a108e762: function () {
+        __wbg___okgeometry_boolean_should_cancel_9b2919fd8513410f: function () {
             const ret = globalThis.__okgeometry_boolean_should_cancel();
             return ret;
         },

package/package.json

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

@@ -17,24 +17,24 @@ import {
   disposeMeshBooleanWorkerPools,
   runMeshBooleanInWorkerPool,
 } from "./mesh-boolean.pool.js";
-import { MeshBooleanExecutionError } from "./mesh-boolean.protocol.js";
-import type {
-  MeshBooleanAsyncOptions,
-  MeshBooleanLimits,
-  MeshBooleanOptions,
-} from "./mesh-boolean.protocol.js";
+import { MeshBooleanExecutionError } from "./mesh-boolean.protocol.js";
+import type {
+  MeshBooleanAsyncOptions,
+  MeshBooleanLimits,
+  MeshBooleanOptions,
+} from "./mesh-boolean.protocol.js";
 import * as wasm from "./wasm-bindings.js";
 import { mesh_topology_metrics } from "./wasm-bindings.js";
 
 export { MeshBooleanExecutionError };
-export type {
-  MeshBooleanAsyncOptions,
-  MeshBooleanLimits,
-  MeshBooleanOptions,
-  MeshBooleanErrorCode,
-  MeshBooleanErrorPayload,
-  MeshBooleanProgressEvent,
-} from "./mesh-boolean.protocol.js";
+export type {
+  MeshBooleanAsyncOptions,
+  MeshBooleanLimits,
+  MeshBooleanOptions,
+  MeshBooleanErrorCode,
+  MeshBooleanErrorPayload,
+  MeshBooleanProgressEvent,
+} from "./mesh-boolean.protocol.js";
 
 export interface PlanarRectangle {
   corners: [Point, Point, Point, Point];

package/src/mesh-boolean.pool.ts

@@ -1,36 +1,36 @@
-import {
-  MeshBooleanExecutionError,
-  type MeshBooleanAsyncOptions,
-  type MeshBooleanErrorPayload,
-  type MeshBooleanOperation,
-  type MeshBooleanOptions,
-  type MeshBooleanProgressEvent,
-  type MeshBooleanWorkerRequest,
-  type MeshBooleanWorkerResponse,
-} from "./mesh-boolean.protocol.js";
+import {
+  MeshBooleanExecutionError,
+  type MeshBooleanAsyncOptions,
+  type MeshBooleanErrorPayload,
+  type MeshBooleanOperation,
+  type MeshBooleanOptions,
+  type MeshBooleanProgressEvent,
+  type MeshBooleanWorkerRequest,
+  type MeshBooleanWorkerResponse,
+} from "./mesh-boolean.protocol.js";
 
 interface PoolAcquireOptions {
   size?: number;
   workerFactory?: () => Worker;
 }
 
-interface BooleanJob {
-  id: number;
-  operation: MeshBooleanOperation;
-  options: MeshBooleanOptions;
-  onProgress?: (event: MeshBooleanProgressEvent) => void;
-  signal?: AbortSignal;
-  timeoutMs?: number;
-  bufferA: ArrayBuffer;
+interface BooleanJob {
+  id: number;
+  operation: MeshBooleanOperation;
+  options: MeshBooleanOptions;
+  onProgress?: (event: MeshBooleanProgressEvent) => void;
+  signal?: AbortSignal;
+  timeoutMs?: number;
+  bufferA: ArrayBuffer;
   bufferB: ArrayBuffer;
   trustedInputA: boolean;
   trustedInputB: boolean;
   cancelView?: Int32Array;
-  timeoutToken?: number;
-  abortHandler?: () => void;
-  resolve: (value: Float64Array) => void;
-  reject: (reason: Error) => void;
-}
+  timeoutToken?: number;
+  abortHandler?: () => void;
+  resolve: (value: Float64Array) => void;
+  reject: (reason: Error) => void;
+}
 
 interface WorkerSlot {
   id: number;
@@ -127,22 +127,22 @@ export class MeshBooleanWorkerPool {
       const job: BooleanJob = {
         id: jobId,
         operation,
-        options: {
-          allowUnsafe: options?.allowUnsafe ?? true,
-          limits: options?.limits,
-          debugForceFaceID: options?.debugForceFaceID,
-        },
-        onProgress: options?.onProgress,
-        signal: options?.signal,
-        timeoutMs: options?.timeoutMs,
-        bufferA: new Float64Array(bufferA).buffer,
+        options: {
+          allowUnsafe: options?.allowUnsafe ?? true,
+          limits: options?.limits,
+          debugForceFaceID: options?.debugForceFaceID,
+        },
+        onProgress: options?.onProgress,
+        signal: options?.signal,
+        timeoutMs: options?.timeoutMs,
+        bufferA: new Float64Array(bufferA).buffer,
         bufferB: new Float64Array(bufferB).buffer,
-        trustedInputA,
-        trustedInputB,
-        cancelView: createCancellationView(),
-        resolve,
-        reject,
-      };
+        trustedInputA,
+        trustedInputB,
+        cancelView: createCancellationView(),
+        resolve,
+        reject,
+      };
 
       if (job.signal?.aborted) {
         this.rejectJob(job, rejectPayload("worker_aborted", `Boolean ${operation} aborted.`));
@@ -239,9 +239,9 @@ export class MeshBooleanWorkerPool {
         continue;
       }
 
-      slot.currentJobId = job.id;
-      this.running.set(job.id, job);
-      this.emitProgress(job, "running", slot.id);
+      slot.currentJobId = job.id;
+      this.running.set(job.id, job);
+      this.emitProgress(job, "running", slot.id);
 
       if (job.timeoutMs !== undefined && Number.isFinite(job.timeoutMs) && job.timeoutMs > 0) {
         job.timeoutToken = setTimeout(() => {
@@ -300,18 +300,18 @@ export class MeshBooleanWorkerPool {
       return;
     }
 
-    if (data.ok) {
-      this.finishRunningJob(slot, job, undefined, new Float64Array(data.buffer));
-      return;
-    }
-
-    this.finishRunningJob(
-      slot,
-      job,
-      new MeshBooleanExecutionError(data.error),
-      undefined,
-    );
-  }
+    if (data.ok) {
+      this.finishRunningJob(slot, job, undefined, new Float64Array(data.buffer));
+      return;
+    }
+
+    this.finishRunningJob(
+      slot,
+      job,
+      new MeshBooleanExecutionError(data.error),
+      undefined,
+    );
+  }
 
   private failWorker(slot: WorkerSlot, payload: MeshBooleanErrorPayload): void {
     const jobId = slot.currentJobId;
@@ -371,18 +371,18 @@ export class MeshBooleanWorkerPool {
     this.dispatch();
   }
 
-  private finishRunningJob(
-    slot: WorkerSlot,
-    job: BooleanJob,
-    error: Error | undefined,
-    result: Float64Array | undefined,
-  ): void {
-    this.running.delete(job.id);
-    slot.currentJobId = null;
-    this.cleanupJob(job);
-
-    if (error) {
-      job.reject(error);
+  private finishRunningJob(
+    slot: WorkerSlot,
+    job: BooleanJob,
+    error: Error | undefined,
+    result: Float64Array | undefined,
+  ): void {
+    this.running.delete(job.id);
+    slot.currentJobId = null;
+    this.cleanupJob(job);
+
+    if (error) {
+      job.reject(error);
     } else if (result) {
       job.resolve(result);
     } else {
@@ -410,15 +410,15 @@ export class MeshBooleanWorkerPool {
   }
 
   private emitProgress(job: BooleanJob, stage: MeshBooleanProgressEvent["stage"], workerId?: number): void {
-    if (!job.onProgress) return;
-    job.onProgress({
-      stage,
-      jobId: job.id,
-      workerId,
-      queueSize: this.queue.length,
-    });
-  }
-}
+    if (!job.onProgress) return;
+    job.onProgress({
+      stage,
+      jobId: job.id,
+      workerId,
+      queueSize: this.queue.length,
+    });
+  }
+}
 
 let defaultPoolSizeOverride: number | undefined;
 const defaultPools = new Map<number, MeshBooleanWorkerPool>();

package/src/mesh-boolean.protocol.ts

@@ -36,14 +36,14 @@ export interface MeshBooleanErrorPayload {
   details?: string;
 }
 
-export type MeshBooleanJobStage = "queued" | "running" | "completed";
-
-export interface MeshBooleanProgressEvent {
-  stage: MeshBooleanJobStage;
-  jobId: number;
-  workerId?: number;
-  queueSize: number;
-}
+export type MeshBooleanJobStage = "queued" | "running" | "completed";
+
+export interface MeshBooleanProgressEvent {
+  stage: MeshBooleanJobStage;
+  jobId: number;
+  workerId?: number;
+  queueSize: number;
+}
 
 export interface MeshBooleanAsyncOptions extends MeshBooleanOptions {
   /**
@@ -62,11 +62,11 @@ export interface MeshBooleanAsyncOptions extends MeshBooleanOptions {
    * Override worker pool size for this call.
    */
   poolSize?: number;
-  /**
-   * Observe coarse-grained job stage changes.
-   */
-  onProgress?: (event: MeshBooleanProgressEvent) => void;
-}
+  /**
+   * Observe coarse-grained job stage changes.
+   */
+  onProgress?: (event: MeshBooleanProgressEvent) => void;
+}
 
 export interface MeshBooleanWorkerRequest {
   kind: "mesh-boolean-request";
@@ -92,21 +92,19 @@ export interface MeshBooleanWorkerCancel {
 
 export type MeshBooleanWorkerInbound = MeshBooleanWorkerRequest | MeshBooleanWorkerCancel;
 
-export interface MeshBooleanWorkerSuccessResponse {
-  kind: "mesh-boolean-result";
-  jobId: number;
-  ok: true;
-  buffer: ArrayBuffer;
-  elapsedMs: number;
-}
+export interface MeshBooleanWorkerSuccessResponse {
+  kind: "mesh-boolean-result";
+  jobId: number;
+  ok: true;
+  buffer: ArrayBuffer;
+}
 
-export interface MeshBooleanWorkerErrorResponse {
-  kind: "mesh-boolean-result";
-  jobId: number;
-  ok: false;
-  error: MeshBooleanErrorPayload;
-  elapsedMs: number;
-}
+export interface MeshBooleanWorkerErrorResponse {
+  kind: "mesh-boolean-result";
+  jobId: number;
+  ok: false;
+  error: MeshBooleanErrorPayload;
+}
 
 export type MeshBooleanWorkerResponse = MeshBooleanWorkerSuccessResponse | MeshBooleanWorkerErrorResponse;
 

package/src/mesh-boolean.worker.ts

@@ -33,15 +33,8 @@ function isCancelled(jobId: number, cancelView: Int32Array | undefined): boolean
   return cancelledJobs.has(jobId) || readCancelRequested(cancelView);
 }
 
-workerGlobal.__okgeometry_boolean_should_cancel = () =>
-  readCancelRequested(workerGlobal.__okgeometryBooleanCancelFlag ?? undefined);
-
-function nowMs(): number {
-  if (typeof performance !== "undefined" && typeof performance.now === "function") {
-    return performance.now();
-  }
-  return Date.now();
-}
+workerGlobal.__okgeometry_boolean_should_cancel = () =>
+  readCancelRequested(workerGlobal.__okgeometryBooleanCancelFlag ?? undefined);
 
 function toErrorMessage(error: unknown): string {
   if (error instanceof Error) return error.message;
@@ -53,27 +46,25 @@ function makeError(code: MeshBooleanErrorPayload["code"], message: string, detai
   return { code, message, details };
 }
 
-function postError(jobId: number, startedAt: number, payload: MeshBooleanErrorPayload): void {
-  const response: MeshBooleanWorkerErrorResponse = {
-    kind: "mesh-boolean-result",
-    jobId,
-    ok: false,
-    error: payload,
-    elapsedMs: Math.max(0, nowMs() - startedAt),
-  };
-  workerScope.postMessage(response);
-}
-
-function postSuccess(jobId: number, startedAt: number, buffer: ArrayBuffer): void {
-  const response: MeshBooleanWorkerSuccessResponse = {
-    kind: "mesh-boolean-result",
-    jobId,
-    ok: true,
-    buffer,
-    elapsedMs: Math.max(0, nowMs() - startedAt),
-  };
-  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): void {
+  const response: MeshBooleanWorkerSuccessResponse = {
+    kind: "mesh-boolean-result",
+    jobId,
+    ok: true,
+    buffer,
+  };
+  workerScope.postMessage(response, [buffer]);
+}
 
 async function ensureWorkerInit(): Promise<void> {
   if (isInitialized()) return;
@@ -91,26 +82,25 @@ workerScope.addEventListener("message", async (event: MessageEvent<MeshBooleanWo
     cancelledJobs.add(message.jobId);
     return;
   }
-
-  if (message.kind !== "mesh-boolean-request") return;
-  const startedAt = nowMs();
-  const jobId = message.jobId;
-  const cancelView = message.cancelBuffer ? new Int32Array(message.cancelBuffer) : undefined;
-
-  if (isCancelled(jobId, cancelView)) {
-    postError(jobId, startedAt, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
-    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, startedAt, 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;
 
@@ -134,24 +124,23 @@ workerScope.addEventListener("message", async (event: MessageEvent<MeshBooleanWo
     } else {
       result = meshA.intersect(meshB, options);
     }
-
-    if (isCancelled(jobId, cancelView)) {
-      postError(jobId, startedAt, makeError("worker_aborted", `Boolean ${message.operation} aborted.`));
-      cancelledJobs.delete(jobId);
-      return;
-    }
-
-    const payload = new Float64Array(result.rawBuffer);
-    postSuccess(jobId, startedAt, payload.buffer);
-  } catch (error) {
-    const details = toErrorMessage(error);
-    const cancelled = isCancelled(jobId, cancelView) || details.toLowerCase().includes("cancel");
-    postError(
-      jobId,
-      startedAt,
-      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,
       ),
     );