okgeometry-api 0.5.8 → 1.0.0

package/src/mesh-boolean.pool.ts

@@ -14,16 +14,18 @@ interface PoolAcquireOptions {
   workerFactory?: () => Worker;
 }
 
-interface BooleanJob {
-  id: number;
-  operation: MeshBooleanOperation;
-  options: MeshBooleanOptions;
+interface BooleanJob {
+  id: number;
+  operation: MeshBooleanOperation;
+  options: MeshBooleanOptions;
   onProgress?: (event: MeshBooleanProgressEvent) => void;
   signal?: AbortSignal;
-  timeoutMs?: number;
-  bufferA: ArrayBuffer;
-  bufferB: ArrayBuffer;
-  cancelView?: Int32Array;
+  timeoutMs?: number;
+  bufferA: ArrayBuffer;
+  bufferB: ArrayBuffer;
+  trustedInputA: boolean;
+  trustedInputB: boolean;
+  cancelView?: Int32Array;
   timeoutToken?: number;
   abortHandler?: () => void;
   resolve: (value: Float64Array) => void;
@@ -102,12 +104,14 @@ export class MeshBooleanWorkerPool {
     return this.disposed;
   }
 
-  run(
-    operation: MeshBooleanOperation,
-    bufferA: Float64Array,
-    bufferB: Float64Array,
-    options?: MeshBooleanAsyncOptions,
-  ): Promise<Float64Array> {
+  run(
+    operation: MeshBooleanOperation,
+    bufferA: Float64Array,
+    bufferB: Float64Array,
+    trustedInputA: boolean,
+    trustedInputB: boolean,
+    options?: MeshBooleanAsyncOptions,
+  ): Promise<Float64Array> {
     if (this.disposed) {
       return Promise.reject(
         new MeshBooleanExecutionError(
@@ -123,19 +127,21 @@ export class MeshBooleanWorkerPool {
       const job: BooleanJob = {
         id: jobId,
         operation,
-        options: {
-          allowUnsafe: options?.allowUnsafe ?? true,
-          limits: options?.limits,
-          backend: options?.backend,
-        },
+        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,
-        cancelView: createCancellationView(),
-        resolve,
-        reject,
+        bufferA: new Float64Array(bufferA).buffer,
+        bufferB: new Float64Array(bufferB).buffer,
+        trustedInputA,
+        trustedInputB,
+        cancelView: createCancellationView(),
+        resolve,
+        reject,
       };
 
       if (job.signal?.aborted) {
@@ -246,11 +252,13 @@ export class MeshBooleanWorkerPool {
       const request: MeshBooleanWorkerRequest = {
         kind: "mesh-boolean-request",
         jobId: job.id,
-        operation: job.operation,
-        bufferA: job.bufferA,
-        bufferB: job.bufferB,
-        cancelBuffer: job.cancelView?.buffer as SharedArrayBuffer | undefined,
-        options: job.options,
+        operation: job.operation,
+        bufferA: job.bufferA,
+        bufferB: job.bufferB,
+        trustedInputA: job.trustedInputA,
+        trustedInputB: job.trustedInputB,
+        cancelBuffer: job.cancelView?.buffer as SharedArrayBuffer | undefined,
+        options: job.options,
       };
 
       try {
@@ -467,15 +475,17 @@ export function disposeMeshBooleanWorkerPools(): void {
   customPoolStores.clear();
 }
 
-export function runMeshBooleanInWorkerPool(
-  operation: MeshBooleanOperation,
-  bufferA: Float64Array,
-  bufferB: Float64Array,
-  options?: MeshBooleanAsyncOptions,
-): Promise<Float64Array> {
-  const pool = getMeshBooleanWorkerPool({
-    workerFactory: options?.workerFactory,
-    size: options?.poolSize,
-  });
-  return pool.run(operation, bufferA, bufferB, options);
-}
+export function runMeshBooleanInWorkerPool(
+  operation: MeshBooleanOperation,
+  bufferA: Float64Array,
+  bufferB: Float64Array,
+  trustedInputA: boolean,
+  trustedInputB: boolean,
+  options?: MeshBooleanAsyncOptions,
+): Promise<Float64Array> {
+  const pool = getMeshBooleanWorkerPool({
+    workerFactory: options?.workerFactory,
+    size: options?.poolSize,
+  });
+  return pool.run(operation, bufferA, bufferB, trustedInputA, trustedInputB, options);
+}

package/src/mesh-boolean.protocol.ts

@@ -1,27 +1,26 @@
-export type MeshBooleanOperation = "union" | "subtraction" | "intersection";
-export type MeshBooleanBackend = "nextgen";
-
-export interface MeshBooleanLimits {
-  maxInputFacesPerMesh: number;
+export type MeshBooleanOperation = "union" | "subtraction" | "intersection";
+
+export interface MeshBooleanLimits {
+  maxInputFacesPerMesh: number;
   maxCombinedInputFaces: number;
   maxFaceProduct: number;
 }
 
-export interface MeshBooleanOptions {
-  /**
-   * Override one or more safety limits for this operation.
-   */
-  limits?: Partial<MeshBooleanLimits>;
-  /**
-   * Skip safety limits and force boolean execution.
-   */
-  allowUnsafe?: boolean;
-  /**
-   * Boolean backend selector.
-   * Defaults to "nextgen" (strict closed-solid topology contract).
-   */
-  backend?: MeshBooleanBackend;
-}
+export interface MeshBooleanOptions {
+  /**
+   * Override one or more safety limits for this operation.
+   */
+  limits?: Partial<MeshBooleanLimits>;
+  /**
+   * Skip safety limits and force boolean execution.
+   */
+  allowUnsafe?: boolean;
+  /**
+   * Debug-only: force explicit per-triangle face IDs through the Boolean3 path.
+   * This is only intended for parity investigation.
+   */
+  debugForceFaceID?: boolean;
+}
 
 export type MeshBooleanErrorCode =
   | "worker_unavailable"
@@ -69,17 +68,19 @@ export interface MeshBooleanAsyncOptions extends MeshBooleanOptions {
   onProgress?: (event: MeshBooleanProgressEvent) => void;
 }
 
-export interface MeshBooleanWorkerRequest {
-  kind: "mesh-boolean-request";
-  jobId: number;
-  operation: MeshBooleanOperation;
-  bufferA: ArrayBuffer;
-  bufferB: ArrayBuffer;
-  /**
-   * Optional shared cancellation flag (index 0: 0=running, 1=cancel requested).
-   * When present, kernel loops can cooperatively abort without waiting for
-   * worker message handling.
-   */
+export interface MeshBooleanWorkerRequest {
+  kind: "mesh-boolean-request";
+  jobId: number;
+  operation: MeshBooleanOperation;
+  bufferA: ArrayBuffer;
+  bufferB: ArrayBuffer;
+  trustedInputA?: boolean;
+  trustedInputB?: boolean;
+  /**
+   * Optional shared cancellation flag (index 0: 0=running, 1=cancel requested).
+   * When present, kernel loops can cooperatively abort without waiting for
+   * worker message handling.
+   */
   cancelBuffer?: SharedArrayBuffer;
   options: MeshBooleanOptions;
 }

package/src/mesh-boolean.worker.ts

@@ -114,13 +114,17 @@ workerScope.addEventListener("message", async (event: MessageEvent<MeshBooleanWo
 
     workerGlobal.__okgeometryBooleanCancelFlag = cancelView ?? null;
 
-    const meshA = Mesh.fromBuffer(new Float64Array(message.bufferA));
-    const meshB = Mesh.fromBuffer(new Float64Array(message.bufferB));
-    const options = {
-      allowUnsafe: message.options.allowUnsafe ?? true,
-      limits: message.options.limits,
-      backend: message.options.backend,
-    };
+    const meshA = Mesh.fromBuffer(new Float64Array(message.bufferA), {
+      trustedBooleanInput: message.trustedInputA,
+    });
+    const meshB = Mesh.fromBuffer(new Float64Array(message.bufferB), {
+      trustedBooleanInput: message.trustedInputB,
+    });
+    const options = {
+      allowUnsafe: message.options.allowUnsafe ?? true,
+      limits: message.options.limits,
+      debugForceFaceID: message.options.debugForceFaceID,
+    };
 
     let result: Mesh;
     if (message.operation === "union") {