okgeometry-api 1.47.0 → 1.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.47.0",
+  "version": "1.49.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;
@@ -4306,6 +4323,117 @@ export class Mesh {
     };
   }
 
+  /**
+   * Batched plane sections on the worker pool: one job cuts every mesh at
+   * its own plane and returns cut LOOPS + the fill triangulation per mesh
+   * (okdraw poché + vector cut linework). The per-mesh synchronous
+   * `planeSection` calls scale with SCENE size on an interactive path
+   * (section drags, geometry commits in a view, sheet vector computes),
+   * which is exactly the shape that must not run on the UI thread. Worker
+   * infrastructure failures fall back to the synchronous loop; a kernel
+   * failure on one mesh yields an empty section for that mesh only.
+   */
+  static async planeSectionsAsync(
+    meshes: Mesh[],
+    planes: Array<{
+      origin: { x: number; y: number; z: number };
+      normal: { x: number; y: number; z: number };
+    }>,
+    asyncOptions?: MeshBooleanAsyncOptions
+  ): Promise<
+    Array<{
+      loops: Array<{ closed: boolean; points: Float64Array }>;
+      fill: { positions: Float64Array; indices: Uint32Array } | null;
+    }>
+  > {
+    if (meshes.length === 0) return [];
+    const syncSections = (): Array<{
+      loops: Array<{ closed: boolean; points: Float64Array }>;
+      fill: { positions: Float64Array; indices: Uint32Array } | null;
+    }> =>
+      meshes.map((mesh, i) => {
+        try {
+          const p = planes[i];
+          const plane = new Plane(
+            new Point(p.origin.x, p.origin.y, p.origin.z),
+            new Vec3(p.normal.x, p.normal.y, p.normal.z)
+          );
+          const section = mesh.planeSection(plane);
+          return {
+            loops: section.loops.map((loop) => {
+              const pts = new Float64Array(loop.points.length * 3);
+              for (let k = 0; k < loop.points.length; k++) {
+                pts[k * 3] = loop.points[k].x;
+                pts[k * 3 + 1] = loop.points[k].y;
+                pts[k * 3 + 2] = loop.points[k].z;
+              }
+              return { closed: loop.isClosed(), points: pts };
+            }),
+            fill: section.fill
+              ? { positions: section.fill.positions, indices: section.fill.indices }
+              : null,
+          };
+        } catch {
+          return { loops: [], fill: null };
+        }
+      });
+    try {
+      const { buffer } = await runMeshHeavyInWorkerPool(
+        "planeSectionFills",
+        meshes.map((m) => m._buffer),
+        {
+          ...asyncOptions,
+          trusted: meshes.map((m) => m._trustedBooleanInput),
+          residents: meshes,
+          params: { sectionPlanes: planes },
+        }
+      );
+      // Packing per mesh: [loopCount, (closed, pointCount, xyz...)...,
+      //                    vertFloatLen, idxLen, positions..., indices...]
+      const data = new Float64Array(buffer);
+      const out: Array<{
+        loops: Array<{ closed: boolean; points: Float64Array }>;
+        fill: { positions: Float64Array; indices: Uint32Array } | null;
+      }> = [];
+      let offset = 0;
+      const count = data[offset++] ?? 0;
+      for (let i = 0; i < count; i++) {
+        const loopCount = data[offset++];
+        const loops: Array<{ closed: boolean; points: Float64Array }> = [];
+        for (let l = 0; l < loopCount; l++) {
+          const closed = data[offset++] === 1;
+          const pointCount = data[offset++];
+          const points = new Float64Array(
+            data.subarray(offset, offset + pointCount * 3)
+          );
+          offset += pointCount * 3;
+          loops.push({ closed, points });
+        }
+        const vertLen = data[offset++];
+        const idxLen = data[offset++];
+        let fill: { positions: Float64Array; indices: Uint32Array } | null = null;
+        if (idxLen > 0) {
+          const positions = new Float64Array(data.subarray(offset, offset + vertLen));
+          offset += vertLen;
+          const indices = new Uint32Array(idxLen);
+          for (let k = 0; k < idxLen; k++) indices[k] = data[offset++];
+          fill = { positions, indices };
+        } else {
+          offset += vertLen;
+        }
+        out.push({ loops, fill });
+      }
+      return out;
+    } catch (error) {
+      if (!shouldFallbackFromWorkerFailure(error)) throw error;
+      console.warn(
+        "Mesh.planeSectionsAsync worker failed; falling back to main thread.",
+        error
+      );
+      return syncSections();
+    }
+  }
+
   /**
    * Hidden-line removal for orthographic drawing views (okdraw
    * presentation sheets): project every input mesh's drawable edges
@@ -4322,24 +4450,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 +4480,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 +4506,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,17 @@ 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"
+  //   planeSectionFills: [mesh0, mesh1, ...] cut at params.sectionPlanes[i];
+  //                   response per mesh = [loopCount, (closed, pointCount,
+  //                   xyz...)..., vertFloatLen, idxLen, positions...,
+  //                   indices...] — cut loops + fill (idxLen 0 = no fill).
+  | "planeSectionFills";
 
 export interface MeshHeavyParams {
   resolution?: number;
@@ -249,6 +259,24 @@ export interface MeshHeavyParams {
   preserveFeatures?: boolean;
   /** isotropicRemesh: re-project onto the original surface each iteration. */
   project?: boolean;
+  /** planeSectionFills: one cutting plane per request mesh (aligned). */
+  sectionPlanes?: Array<{
+    origin: { x: number; y: number; z: number };
+    normal: { x: number; y: number; z: number };
+  }>;
+  /** 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

@@ -2,6 +2,8 @@ import { init, initThreads, isInitialized } from "./engine.js";
 import { Brep } from "./Brep.js";
 import { Mesh } from "./Mesh.js";
 import { Point } from "./Point.js";
+import { Plane } from "./Plane.js";
+import { Vec3 } from "./Vec3.js";
 import type {
   MeshBooleanErrorPayload,
   MeshBooleanWorkerErrorResponse,
@@ -268,6 +270,21 @@ function runHeavyOperation(message: {
     featureAngleDeg?: number;
     preserveFeatures?: boolean;
     project?: boolean;
+    sectionPlanes?: Array<{
+      origin: { x: number; y: number; z: number };
+      normal: { x: number; y: number; z: number };
+    }>;
+    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 +325,64 @@ function runHeavyOperation(message: {
       const result = mesh.voxelRemesh(params.resolution ?? 0, params.iso ?? 0.5);
       return packSingleResult(result, params);
     }
+    case "planeSectionFills": {
+      const planes = params.sectionPlanes;
+      if (!planes) throw new Error("planeSectionFills requires sectionPlanes params");
+      const input = meshes();
+      // Per mesh: [loopCount, (closed, pointCount, xyz...)...,
+      //            vertFloatLen, idxLen, positions..., indices...]
+      const parts: number[] = [input.length];
+      for (let i = 0; i < input.length; i++) {
+        let section: ReturnType<Mesh["planeSection"]> | null = null;
+        try {
+          const p = planes[i];
+          const plane = new Plane(
+            new Point(p.origin.x, p.origin.y, p.origin.z),
+            new Vec3(p.normal.x, p.normal.y, p.normal.z),
+          );
+          section = input[i].planeSection(plane);
+        } catch {
+          section = null; // one bad mesh never blocks the batch
+        }
+        const loops = section?.loops ?? [];
+        parts.push(loops.length);
+        for (const loop of loops) {
+          parts.push(loop.isClosed() ? 1 : 0, loop.points.length);
+          for (const pt of loop.points) parts.push(pt.x, pt.y, pt.z);
+        }
+        const fill = section?.fill ?? null;
+        if (!fill || fill.indices.length === 0) {
+          parts.push(0, 0);
+          continue;
+        }
+        parts.push(fill.positions.length, fill.indices.length);
+        for (let k = 0; k < fill.positions.length; k++) parts.push(fill.positions[k]);
+        for (let k = 0; k < fill.indices.length; k++) parts.push(fill.indices[k]);
+      }
+      return { buffer: new Float64Array(parts).buffer };
+    }
+    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({