okgeometry-api 1.26.1 → 1.27.0

package/dist/workerHelpers-threaded.d.ts

@@ -0,0 +1,2 @@
+export function startWorkers(module: any, memory: any, builder: any): Promise<void>;
+//# sourceMappingURL=workerHelpers-threaded.d.ts.map

package/dist/workerHelpers-threaded.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerHelpers-threaded.d.ts","sourceRoot":"","sources":["../src/workerHelpers-threaded.js"],"names":[],"mappings":"AAoEA,oFAsCC"}

package/dist/workerHelpers-threaded.js

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2022 Google Inc. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Note: we use `wasm_bindgen_worker_`-prefixed message types to make sure
+// we can handle bundling into other files, which might happen to have their
+// own `postMessage`/`onmessage` communication channels.
+//
+// If we didn't take that into the account, we could send much simpler signals
+// like just `0` or whatever, but the code would be less resilient.
+function waitForMsgType(target, type) {
+    return new Promise(resolve => {
+        target.addEventListener('message', function onMsg({ data }) {
+            if (data?.type !== type)
+                return;
+            target.removeEventListener('message', onMsg);
+            resolve(data);
+        });
+    });
+}
+waitForMsgType(self, 'wasm_bindgen_worker_init').then(async ({ init, receiver }) => {
+    // # Note 1
+    // Our JS should have been generated in
+    // `[out-dir]/snippets/wasm-bindgen-rayon-[hash]/workerHelpers.js`,
+    // resolve the main module via `../../..`.
+    //
+    // This might need updating if the generated structure changes on wasm-bindgen
+    // side ever in the future, but works well with bundlers today. The whole
+    // point of this crate, after all, is to abstract away unstable features
+    // and temporary bugs so that you don't need to deal with them in your code.
+    //
+    // # Note 2
+    // This could be a regular import, but then some bundlers complain about
+    // circular deps.
+    //
+    // Dynamic import could be cheap if this file was inlined into the parent,
+    // which would require us just using `../../..` in `new Worker` below,
+    // but that doesn't work because wasm-pack unconditionally adds
+    // "sideEffects":false (see below).
+    //
+    // OTOH, even though it can't be inlined, it should be still reasonably
+    // cheap since the requested file is already in cache (it was loaded by
+    // the main thread).
+    const pkg = await import('./wasm-bindings-threaded.js');
+    await pkg.default(init);
+    postMessage({ type: 'wasm_bindgen_worker_ready' });
+    pkg.wbg_rayon_start_worker(receiver);
+});
+// Note: this is never used, but necessary to prevent a bug in Firefox
+// (https://bugzilla.mozilla.org/show_bug.cgi?id=1702191) where it collects
+// Web Workers that have a shared WebAssembly memory with the main thread,
+// but are not explicitly rooted via a `Worker` instance.
+//
+// By storing them in a variable, we can keep `Worker` objects around and
+// prevent them from getting GC-d.
+let _workers;
+export async function startWorkers(module, memory, builder) {
+    if (builder.numThreads() === 0) {
+        throw new Error(`num_threads must be > 0.`);
+    }
+    const workerInit = {
+        type: 'wasm_bindgen_worker_init',
+        init: { module_or_path: module, memory },
+        receiver: builder.receiver()
+    };
+    _workers = await Promise.all(Array.from({ length: builder.numThreads() }, async () => {
+        // Self-spawn into a new Worker.
+        //
+        // TODO: while `new URL('...', import.meta.url) becomes a semi-standard
+        // way to get asset URLs relative to the module across various bundlers
+        // and browser, ideally we should switch to `import.meta.resolve`
+        // once it becomes a standard.
+        //
+        // Note: we could use `../../..` as the URL here to inline workerHelpers.js
+        // into the parent entry instead of creating another split point -
+        // this would be preferable from optimization perspective -
+        // however, Webpack then eliminates all message handler code
+        // because wasm-pack produces "sideEffects":false in package.json
+        // unconditionally.
+        //
+        // The only way to work around that is to have side effect code
+        // in an entry point such as Worker file itself.
+        const worker = new Worker(new URL('./workerHelpers-threaded.js', import.meta.url), {
+            type: 'module'
+        });
+        worker.postMessage(workerInit);
+        await waitForMsgType(worker, 'wasm_bindgen_worker_ready');
+        return worker;
+    }));
+    builder.build();
+}
+//# sourceMappingURL=workerHelpers-threaded.js.map

package/dist/workerHelpers-threaded.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerHelpers-threaded.js","sourceRoot":"","sources":["../src/workerHelpers-threaded.js"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.26.1",
+  "version": "1.27.0",
   "description": "Geometry engine API for AEC applications - NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",
@@ -36,7 +36,11 @@
     "smoke:curve-region": "tsx scripts/smoke-curve-region.ts",
     "smoke:sculpt": "tsx scripts/smoke-sculpt.ts",
     "smoke:offset-chamfer": "tsx scripts/smoke-offset-chamfer.ts",
-    "smoke:rebuild": "tsx scripts/smoke-rebuild.ts"
+    "smoke:rebuild": "tsx scripts/smoke-rebuild.ts",
+    "smoke:mesh-residency": "tsx scripts/smoke-mesh-residency.ts",
+    "build:wasm-threaded": "node scripts/build-threaded.mjs",
+    "smoke:browser-threaded": "node scripts/browser-smoke-threaded.mjs",
+    "smoke:browser-heavy": "node scripts/browser-smoke-heavy-worker.mjs"
   },
   "keywords": [
     "geometry",
@@ -56,6 +60,7 @@
   },
   "devDependencies": {
     "tsx": "^4.7.0",
-    "typescript": "^5.4.0"
+    "typescript": "^5.4.0",
+    "playwright": "^1.49.0"
   }
 }

package/src/Arc.ts

@@ -1,117 +1,117 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import { Polyline } from "./Polyline.js";
-import type { Plane } from "./Plane.js";
-import type { RotationAxis } from "./types.js";
-import * as wasm from "./wasm-bindings.js";
-
-/**
- * Immutable circular arc defined by center, radius, and angular span.
- * Angles are in radians, measured counter-clockwise from the positive X axis
- * in the plane defined by the normal.
- */
-export class Arc {
-  /**
-   * Create a new arc.
-   * @param center - Center point
-   * @param radius - Arc radius
-   * @param startAngle - Start angle in radians
-   * @param endAngle - End angle in radians
-   * @param normal - Normal vector defining the arc's plane (default Z axis)
-   */
-  constructor(
-    public readonly center: Point,
-    public readonly radius: number,
-    public readonly startAngle: number,
-    public readonly endAngle: number,
-    public readonly normal: Vec3 = Vec3.Z
-  ) {}
-
-  /**
-   * Evaluate a point on the arc at normalized parameter t.
-   * @param t - Parameter in [0, 1] (0 = start angle, 1 = end angle)
-   * @returns Point on arc at parameter t
-   */
-  pointAt(t: number): Point {
-    ensureInit();
-    const r = wasm.arc_point_at(
-      this.center.x, this.center.y, this.center.z,
-      this.normal.x, this.normal.y, this.normal.z,
-      this.radius, this.startAngle, this.endAngle, t
-    );
-    return new Point(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Get the arc length.
-   * @returns Arc length = radius * angular span
-   */
-  length(): number {
-    ensureInit();
-    return wasm.arc_length(this.radius, this.startAngle, this.endAngle);
-  }
-
-  /**
-   * Translate this arc by an offset vector.
-   * @param offset - Translation vector
-   * @returns New translated arc
-   */
-  translate(offset: Vec3): Arc {
-    return new Arc(this.center.add(offset), this.radius, this.startAngle, this.endAngle, this.normal);
-  }
-
-  /**
-   * Rotate this arc around an axis.
-   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
-   * @param angle - Rotation angle in radians
-   * @returns New rotated arc
-   */
-  rotate(axis: RotationAxis, angle: number): Arc {
-    const n = this.normal;
-    const dirAxis = 'start' in axis ? new Vec3(axis.end.x - axis.start.x, axis.end.y - axis.start.y, axis.end.z - axis.start.z) : axis;
-    const rn = new Point(n.x, n.y, n.z).rotate(dirAxis, angle);
-    return new Arc(this.center.rotate(axis, angle), this.radius, this.startAngle, this.endAngle, new Vec3(rn.x, rn.y, rn.z));
-  }
-
-  /**
-   * Offset this arc by changing its radius.
-   * @param distance - Distance to offset (positive = larger, negative = smaller)
-   * @returns New arc with adjusted radius
-   */
-  offset(distance: number): Arc {
-    return new Arc(this.center, this.radius + distance, this.startAngle, this.endAngle, this.normal);
-  }
-
-  /**
-   * Project onto plane. Returns a Polyline because a tilted arc projects to an elliptical arc.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
-   * @param samples - Number of sample points for approximation (default 64)
-   * @returns Polyline approximating the projected arc
-   */
-  projectOntoPlane(plane: Plane, direction?: Vec3, samples = 64): Polyline {
-    const pts = this.sample(samples);
-    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
-    return new Polyline(pts.map(proj));
-  }
-
-  /**
-   * Sample the arc into evenly-spaced points.
-   * @param n - Number of points to generate
-   * @returns Array of n points along the arc
-   */
-  sample(n: number): Point[] {
-    ensureInit();
-    const buf = wasm.create_arc(
-      this.center.x, this.center.y, this.center.z,
-      this.normal.x, this.normal.y, this.normal.z,
-      this.radius, this.startAngle, this.endAngle, n
-    );
-    const pts: Point[] = [];
-    for (let i = 0; i < buf.length; i += 3) {
-      pts.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
-    }
-    return pts;
-  }
-}
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Polyline } from "./Polyline.js";
+import type { Plane } from "./Plane.js";
+import type { RotationAxis } from "./types.js";
+import { wasm } from "./wasm-active.js";
+
+/**
+ * Immutable circular arc defined by center, radius, and angular span.
+ * Angles are in radians, measured counter-clockwise from the positive X axis
+ * in the plane defined by the normal.
+ */
+export class Arc {
+  /**
+   * Create a new arc.
+   * @param center - Center point
+   * @param radius - Arc radius
+   * @param startAngle - Start angle in radians
+   * @param endAngle - End angle in radians
+   * @param normal - Normal vector defining the arc's plane (default Z axis)
+   */
+  constructor(
+    public readonly center: Point,
+    public readonly radius: number,
+    public readonly startAngle: number,
+    public readonly endAngle: number,
+    public readonly normal: Vec3 = Vec3.Z
+  ) {}
+
+  /**
+   * Evaluate a point on the arc at normalized parameter t.
+   * @param t - Parameter in [0, 1] (0 = start angle, 1 = end angle)
+   * @returns Point on arc at parameter t
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.arc_point_at(
+      this.center.x, this.center.y, this.center.z,
+      this.normal.x, this.normal.y, this.normal.z,
+      this.radius, this.startAngle, this.endAngle, t
+    );
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Get the arc length.
+   * @returns Arc length = radius * angular span
+   */
+  length(): number {
+    ensureInit();
+    return wasm.arc_length(this.radius, this.startAngle, this.endAngle);
+  }
+
+  /**
+   * Translate this arc by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated arc
+   */
+  translate(offset: Vec3): Arc {
+    return new Arc(this.center.add(offset), this.radius, this.startAngle, this.endAngle, this.normal);
+  }
+
+  /**
+   * Rotate this arc around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated arc
+   */
+  rotate(axis: RotationAxis, angle: number): Arc {
+    const n = this.normal;
+    const dirAxis = 'start' in axis ? new Vec3(axis.end.x - axis.start.x, axis.end.y - axis.start.y, axis.end.z - axis.start.z) : axis;
+    const rn = new Point(n.x, n.y, n.z).rotate(dirAxis, angle);
+    return new Arc(this.center.rotate(axis, angle), this.radius, this.startAngle, this.endAngle, new Vec3(rn.x, rn.y, rn.z));
+  }
+
+  /**
+   * Offset this arc by changing its radius.
+   * @param distance - Distance to offset (positive = larger, negative = smaller)
+   * @returns New arc with adjusted radius
+   */
+  offset(distance: number): Arc {
+    return new Arc(this.center, this.radius + distance, this.startAngle, this.endAngle, this.normal);
+  }
+
+  /**
+   * Project onto plane. Returns a Polyline because a tilted arc projects to an elliptical arc.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @param samples - Number of sample points for approximation (default 64)
+   * @returns Polyline approximating the projected arc
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3, samples = 64): Polyline {
+    const pts = this.sample(samples);
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    return new Polyline(pts.map(proj));
+  }
+
+  /**
+   * Sample the arc into evenly-spaced points.
+   * @param n - Number of points to generate
+   * @returns Array of n points along the arc
+   */
+  sample(n: number): Point[] {
+    ensureInit();
+    const buf = wasm.create_arc(
+      this.center.x, this.center.y, this.center.z,
+      this.normal.x, this.normal.y, this.normal.z,
+      this.radius, this.startAngle, this.endAngle, n
+    );
+    const pts: Point[] = [];
+    for (let i = 0; i < buf.length; i += 3) {
+      pts.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
+    }
+    return pts;
+  }
+}

package/src/Brep.ts

@@ -6,7 +6,7 @@ import { Mesh, type MeshBooleanOptions } from "./Mesh.js";
 import { Polyline } from "./Polyline.js";
 import { NurbsCurve } from "./NurbsCurve.js";
 import { NurbsSurface } from "./NurbsSurface.js";
-import * as wasm from "./wasm-bindings.js";
+import { wasm } from "./wasm-active.js";
 
 /** Options for Brep boolean operations. */
 export interface BrepBooleanOptions extends MeshBooleanOptions {