okgeometry-api 1.47.0 → 1.48.0

package/package.json

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

@@ -50,6 +50,23 @@ export interface HlrLine {
   b3: Point;
 }
 
+/** View parameters for `Mesh.hlrProject` / `hlrProjectAsync`. */
+export interface HlrProjectOptions {
+  viewDir: { x: number; y: number; z: number };
+  up: { x: number; y: number; z: number };
+  section?: {
+    origin: { x: number; y: number; z: number };
+    normal: { x: number; y: number; z: number };
+  };
+  featureAngleDeg?: number;
+  /**
+   * View depth in world units beyond the section plane — geometry farther
+   * than this is discarded (drafting far clip). Requires `section`; <= 0
+   * or absent = unlimited.
+   */
+  depth?: number;
+}
+
 export interface PlanarRectangle {
   corners: [Point, Point, Point, Point];
   width: number;
@@ -4322,24 +4339,21 @@ export class Mesh {
    */
   static hlrProject(
     meshes: Mesh[],
-    options: {
-      viewDir: { x: number; y: number; z: number };
-      up: { x: number; y: number; z: number };
-      section?: {
-        origin: { x: number; y: number; z: number };
-        normal: { x: number; y: number; z: number };
-      };
-      featureAngleDeg?: number;
-      /**
-       * View depth in world units beyond the section plane — geometry
-       * farther than this is discarded (drafting far clip). Requires
-       * `section`; <= 0 or absent = unlimited.
-       */
-      depth?: number;
-    }
+    options: HlrProjectOptions
   ): HlrLine[] {
+    return Mesh.parseHlrResult(Mesh.hlrProjectRaw(meshes, options));
+  }
+
+  /**
+   * The raw f64 result of `hlrProject` (wasm layout: [count, (class,
+   * meshIndex, ax, ay, bx, by, a3xyz, b3xyz) x count]). The worker path
+   * transfers this buffer back to the main thread, which parses it with
+   * `parseHlrResult` — HlrLine carries Point instances, which do not
+   * survive structured clone.
+   */
+  static hlrProjectRaw(meshes: Mesh[], options: HlrProjectOptions): Float64Array {
     ensureInit();
-    if (meshes.length === 0) return [];
+    if (meshes.length === 0) return new Float64Array([0]);
     const packed = Mesh.packMeshes(meshes);
     const s = options.section;
     const result = wasm.hlr_project_meshes(
@@ -4355,9 +4369,14 @@ export class Mesh {
     if (result.length === 0) {
       const error = wasm.geometry_last_error?.();
       if (error) throw new Error(`hlrProject failed: ${error}`);
-      return [];
+      return new Float64Array([0]);
     }
+    return result;
+  }
 
+  /** Parse a `hlrProjectRaw` result buffer into classified lines. */
+  static parseHlrResult(result: Float64Array): HlrLine[] {
+    if (result.length === 0) return [];
     const lines: HlrLine[] = [];
     const count = result[0];
     let offset = 1;
@@ -4376,6 +4395,44 @@ export class Mesh {
     return lines;
   }
 
+  /**
+   * Async `Mesh.hlrProject` on the worker pool — the whole-scene projection
+   * scales with MODEL size, not edit size, and must not block the UI
+   * thread. `options.transforms` (row-major, aligned with `meshes`) bakes
+   * WORKER-side so the main thread never pays the per-mesh transform pass;
+   * pass LOCAL meshes with their placement transforms. Worker
+   * INFRASTRUCTURE failures fall back to the synchronous main-thread path
+   * (baking transforms first); kernel failures propagate.
+   */
+  static async hlrProjectAsync(
+    meshes: Mesh[],
+    options: HlrProjectOptions & { transforms?: (number[] | undefined)[] },
+    asyncOptions?: MeshBooleanAsyncOptions
+  ): Promise<HlrLine[]> {
+    if (meshes.length === 0) return [];
+    const { transforms, ...view } = options;
+    try {
+      const { buffer } = await runMeshHeavyInWorkerPool(
+        "hlrProject",
+        meshes.map((m) => m._buffer),
+        {
+          ...asyncOptions,
+          trusted: meshes.map((m) => m._trustedBooleanInput),
+          residents: meshes,
+          params: { hlr: { ...view, transforms } },
+        }
+      );
+      return Mesh.parseHlrResult(new Float64Array(buffer));
+    } catch (error) {
+      if (!shouldFallbackFromWorkerFailure(error)) throw error;
+      console.warn("Mesh.hlrProjectAsync worker failed; falling back to main thread.", error);
+      const baked = meshes.map((m, i) =>
+        transforms?.[i] ? m.applyMatrix(transforms[i]) : m
+      );
+      return Mesh.hlrProject(baked, view);
+    }
+  }
+
   /**
    * Compute intersection curves with another mesh.
    * @param other - Mesh to intersect with

package/src/mesh-boolean.protocol.ts

@@ -205,7 +205,12 @@ export type MeshHeavyOperation =
   | "solidSplitBySurface"
   | "diagnostics"
   | "repair"
-  | "importStl";
+  | "importStl"
+  //   hlrProject:     [mesh0, mesh1, ...] (LOCAL-space; per-mesh transforms
+  //                   ride `params.hlr.transforms` and bake worker-side).
+  //                   Response buffer = the raw f64 hlr result (parse with
+  //                   Mesh.parseHlrResult).
+  | "hlrProject";
 
 export interface MeshHeavyParams {
   resolution?: number;
@@ -249,6 +254,19 @@ export interface MeshHeavyParams {
   preserveFeatures?: boolean;
   /** isotropicRemesh: re-project onto the original surface each iteration. */
   project?: boolean;
+  /** hlrProject: view/section parameters + optional per-mesh row-major
+   *  transforms (aligned with the request buffers, baked worker-side). */
+  hlr?: {
+    viewDir: { x: number; y: number; z: number };
+    up: { x: number; y: number; z: number };
+    section?: {
+      origin: { x: number; y: number; z: number };
+      normal: { x: number; y: number; z: number };
+    };
+    featureAngleDeg?: number;
+    depth?: number;
+    transforms?: (number[] | undefined)[];
+  };
 }
 
 export interface MeshHeavyWorkerRequest {

package/src/mesh-boolean.worker.ts

@@ -268,6 +268,17 @@ function runHeavyOperation(message: {
     featureAngleDeg?: number;
     preserveFeatures?: boolean;
     project?: boolean;
+    hlr?: {
+      viewDir: { x: number; y: number; z: number };
+      up: { x: number; y: number; z: number };
+      section?: {
+        origin: { x: number; y: number; z: number };
+        normal: { x: number; y: number; z: number };
+      };
+      featureAngleDeg?: number;
+      depth?: number;
+      transforms?: (number[] | undefined)[];
+    };
   };
   options: { allowUnsafe?: boolean; limits?: unknown; debugForceFaceID?: boolean };
 }): { buffer: ArrayBuffer; meta?: Record<string, string | number | boolean> } {
@@ -308,6 +319,28 @@ function runHeavyOperation(message: {
       const result = mesh.voxelRemesh(params.resolution ?? 0, params.iso ?? 0.5);
       return packSingleResult(result, params);
     }
+    case "hlrProject": {
+      const view = params.hlr;
+      if (!view) throw new Error("hlrProject requires hlr params");
+      const input = meshes();
+      // Bake per-mesh transforms HERE — the whole point of the worker job
+      // is that the main thread pays neither the projection nor the
+      // per-mesh transform pass. applyMatrix returns a NEW mesh, so
+      // worker-resident operands are never mutated.
+      const baked = input.map((m, i) => {
+        const t = view.transforms?.[i];
+        return t ? m.applyMatrix(t) : m;
+      });
+      const raw = Mesh.hlrProjectRaw(baked, {
+        viewDir: view.viewDir,
+        up: view.up,
+        section: view.section,
+        featureAngleDeg: view.featureAngleDeg,
+        depth: view.depth,
+      });
+      // Copy before transfer: the wasm result may view the wasm heap.
+      return { buffer: new Float64Array(raw).buffer };
+    }
     case "isotropicRemesh": {
       const [mesh] = meshes();
       const r = mesh.remesh({