okgeometry-api 1.26.1 → 1.27.0

package/dist/Mesh.js

@@ -1,4 +1,4 @@
-import { ensureInit } from "./engine.js";
+import { ensureInit, isInitialized } from "./engine.js";
 import { Point } from "./Point.js";
 import { Vec3 } from "./Vec3.js";
 import { Plane } from "./Plane.js";
@@ -11,10 +11,9 @@ import { MeshSurface } from "./MeshSurface.js";
 import { NurbsCurve } from "./NurbsCurve.js";
 import { PolyCurve } from "./PolyCurve.js";
 import { pointsToCoords, parsePolylineBuffer as parsePolylineBuf } from "./BufferCodec.js";
-import { configureDefaultMeshBooleanWorkerPool, disposeMeshBooleanWorkerPools, runMeshBooleanInWorkerPool, } from "./mesh-boolean.pool.js";
+import { configureDefaultMeshBooleanWorkerPool, disposeMeshBooleanWorkerPools, runMeshBooleanInWorkerPool, runMeshHeavyInWorkerPool, } from "./mesh-boolean.pool.js";
 import { MeshBooleanExecutionError } from "./mesh-boolean.protocol.js";
-import * as wasm from "./wasm-bindings.js";
-import { mesh_topology_metrics, mesh_topology_metrics_raw } from "./wasm-bindings.js";
+import { wasm } from "./wasm-active.js";
 export { MeshBooleanExecutionError };
 function shouldFallbackFromWorkerFailure(error) {
     if (!error || typeof error !== "object")
@@ -68,10 +67,74 @@ export class Mesh {
         this._topologyMetricsCache = null;
         this._isClosedVolumeCache = null;
         this._rawBoundsCache = undefined;
+        // ---- WASM-side residency (KERNEL-PERF-ARC lever 2) -----------------------
+        //
+        // Repeated queries on the same mesh (hover face groups, raycasts, render
+        // buffers, diagnostics) skip the per-call JS→WASM buffer copy by storing
+        // the buffer WASM-side once; raycasts additionally reuse a cached BVH.
+        // Residency is self-tuning: the FIRST hot call uses the classic buffer
+        // path (one-shot meshes never pay the store), the second call onward
+        // stores. `dispose()` releases eagerly; a FinalizationRegistry frees
+        // leaked ids on GC as a safety net. Buffers are immutable, so stored
+        // copies never need invalidation.
+        this._storeId = null;
+        this._hotCallCount = 0;
         this._buffer = buffer;
         this._vertexCount = buffer.length > 0 ? buffer[0] : 0;
         this._trustedBooleanInput = trustedBooleanInput;
     }
+    /**
+     * WASM-side stored-mesh id, or 0 when this call should use the buffer
+     * path (first hot call, store failure, or disposed-and-cold mesh).
+     */
+    storedId() {
+        if (this._storeId !== null)
+            return this._storeId;
+        if (this._hotCallCount < 1) {
+            this._hotCallCount++;
+            return 0;
+        }
+        let id = 0;
+        try {
+            id = wasm.mesh_store(this._vertexCount, this._buffer);
+        }
+        catch {
+            id = 0;
+        }
+        this._storeId = id;
+        if (id > 0)
+            Mesh.residencyFinalizer?.register(this, id, this);
+        return id;
+    }
+    /**
+     * Release this mesh's WASM-side stored copy (idempotent). The mesh stays
+     * fully usable — the next repeated hot call re-stores it. Call from
+     * long-lived hosts (okdraw engine-bridge release paths) to return WASM
+     * memory promptly instead of waiting for GC.
+     */
+    dispose() {
+        if (this._storeId !== null && this._storeId > 0) {
+            try {
+                wasm.mesh_store_free(this._storeId);
+            }
+            catch {
+                // engine torn down — nothing to free
+            }
+            Mesh.residencyFinalizer?.unregister(this);
+        }
+        this._storeId = null;
+        this._hotCallCount = 0;
+    }
+    /** Number of meshes currently resident WASM-side (diagnostics/tests). */
+    static residentMeshCount() {
+        ensureInit();
+        return wasm.mesh_store_count();
+    }
+    /** Approximate bytes of WASM-side resident mesh buffers (diagnostics). */
+    static residentMeshBytes() {
+        ensureInit();
+        return wasm.mesh_store_bytes();
+    }
     /**
      * Configure default size for the shared boolean worker pool.
      */
@@ -1559,7 +1622,10 @@ export class Mesh {
         if (this._edgeVertexPairs)
             return this._edgeVertexPairs;
         ensureInit();
-        const packed = wasm.mesh_get_edge_vertex_pairs(this._vertexCount, this._buffer);
+        const sidEdges = this.storedId();
+        const packed = sidEdges > 0
+            ? wasm.mesh_get_edge_vertex_pairs_h(sidEdges)
+            : wasm.mesh_get_edge_vertex_pairs(this._vertexCount, this._buffer);
         const edgeCount = Math.max(0, Math.floor(packed[0] ?? 0));
         const pairs = [];
         let off = 1;
@@ -2211,6 +2277,113 @@ export class Mesh {
             });
         }
     }
+    // ── Heavy async ops on the worker pool (KERNEL-PERF-ARC lever 4) ──
+    //
+    // Multi-second operations run off the main thread with the same
+    // fallback contract as the pairwise async booleans: any worker-side
+    // failure falls back to the synchronous main-thread path.
+    /** Async `Mesh.unionAll` on the worker pool. */
+    static async unionAllAsync(meshes, options) {
+        try {
+            const { buffer } = await runMeshHeavyInWorkerPool("unionAll", meshes.map((m) => m._buffer), { ...options, trusted: meshes.map((m) => m._trustedBooleanInput) });
+            return Mesh.fromTrustedBuffer(buffer);
+        }
+        catch (error) {
+            if (!shouldFallbackFromWorkerFailure(error))
+                throw error;
+            console.warn("Mesh.unionAllAsync worker failed; falling back to main thread.", error);
+            return Mesh.unionAll(meshes, {
+                allowUnsafe: options?.allowUnsafe ?? true,
+                limits: options?.limits,
+            });
+        }
+    }
+    /** Async `mesh.subtractAll` on the worker pool. */
+    async subtractAllAsync(cutters, options) {
+        try {
+            const { buffer } = await runMeshHeavyInWorkerPool("differenceAll", [this._buffer, ...cutters.map((m) => m._buffer)], {
+                ...options,
+                trusted: [this._trustedBooleanInput, ...cutters.map((m) => m._trustedBooleanInput)],
+            });
+            return Mesh.fromTrustedBuffer(buffer);
+        }
+        catch (error) {
+            if (!shouldFallbackFromWorkerFailure(error))
+                throw error;
+            console.warn("Mesh.subtractAllAsync worker failed; falling back to main thread.", error);
+            return this.subtractAll(cutters, {
+                allowUnsafe: options?.allowUnsafe ?? true,
+                limits: options?.limits,
+            });
+        }
+    }
+    /** Async `mesh.makeWatertight` on the worker pool. NOTE: the async
+     * variant reports the result mesh, method and effective resolution;
+     * before/after diagnostics can be recomputed by the caller if needed. */
+    async makeWatertightAsync(options = {}) {
+        try {
+            const { buffer, meta } = await runMeshHeavyInWorkerPool("makeWatertight", [this._buffer], {
+                ...options,
+                trusted: [this._trustedBooleanInput],
+                params: { resolution: options.resolution, iso: options.iso },
+            });
+            return {
+                mesh: Mesh.fromTrustedBuffer(buffer),
+                method: meta?.method ?? "repair",
+                effectiveResolution: Number(meta?.effectiveResolution ?? 0),
+            };
+        }
+        catch (error) {
+            if (!shouldFallbackFromWorkerFailure(error))
+                throw error;
+            console.warn("Mesh.makeWatertightAsync worker failed; falling back to main thread.", error);
+            const r = this.makeWatertight({ resolution: options.resolution, iso: options.iso });
+            return { mesh: r.mesh, method: r.method, effectiveResolution: r.effectiveResolution };
+        }
+    }
+    /** Async `mesh.voxelRemesh` on the worker pool. */
+    async voxelRemeshAsync(resolution = 0, iso = 0.5, options) {
+        try {
+            const { buffer } = await runMeshHeavyInWorkerPool("voxelRemesh", [this._buffer], {
+                ...options,
+                trusted: [this._trustedBooleanInput],
+                params: { resolution, iso },
+            });
+            return Mesh.fromTrustedBuffer(buffer);
+        }
+        catch (error) {
+            if (!shouldFallbackFromWorkerFailure(error))
+                throw error;
+            console.warn("Mesh.voxelRemeshAsync worker failed; falling back to main thread.", error);
+            return this.voxelRemesh(resolution, iso);
+        }
+    }
+    /** Async `mesh.chamferEdges` on the worker pool. */
+    async chamferEdgesAsync(edges, distance, options) {
+        const flat = new Float64Array(edges.length * 6);
+        edges.forEach((edge, i) => {
+            flat[i * 6] = edge.a.x;
+            flat[i * 6 + 1] = edge.a.y;
+            flat[i * 6 + 2] = edge.a.z;
+            flat[i * 6 + 3] = edge.b.x;
+            flat[i * 6 + 4] = edge.b.y;
+            flat[i * 6 + 5] = edge.b.z;
+        });
+        try {
+            const { buffer } = await runMeshHeavyInWorkerPool("chamferEdges", [this._buffer, flat], {
+                ...options,
+                trusted: [this._trustedBooleanInput],
+                params: { distance },
+            });
+            return Mesh.fromTrustedBuffer(buffer);
+        }
+        catch (error) {
+            if (!shouldFallbackFromWorkerFailure(error))
+                throw error;
+            console.warn("Mesh.chamferEdgesAsync worker failed; falling back to main thread.", error);
+            return this.chamferEdges(edges, distance);
+        }
+    }
     // ── Intersection queries ───────────────────────────────────────
     /**
      * Compute intersection curves with a plane.
@@ -2506,7 +2679,10 @@ export class Mesh {
         ensureInit();
         if (!Number.isFinite(faceIndex) || faceIndex < 0)
             return [];
-        const r = wasm.mesh_get_coplanar_face_indices(this._vertexCount, this._buffer, Math.floor(faceIndex));
+        const sidCfi = this.storedId();
+        const r = sidCfi > 0
+            ? wasm.mesh_get_coplanar_face_indices_h(sidCfi, Math.floor(faceIndex))
+            : wasm.mesh_get_coplanar_face_indices(this._vertexCount, this._buffer, Math.floor(faceIndex));
         const count = Math.max(0, Math.floor(r[0] ?? 0));
         const out = [];
         for (let i = 0; i < count; i++) {
@@ -2526,7 +2702,10 @@ export class Mesh {
         if (!Number.isFinite(faceIndex) || faceIndex < 0) {
             return { faceIndices: [], isPlanar: true };
         }
-        const r = wasm.mesh_get_smooth_face_group(this._vertexCount, this._buffer, Math.floor(faceIndex), maxAngleDeg);
+        const sidSfg = this.storedId();
+        const r = sidSfg > 0
+            ? wasm.mesh_get_smooth_face_group_h(sidSfg, Math.floor(faceIndex), maxAngleDeg)
+            : wasm.mesh_get_smooth_face_group(this._vertexCount, this._buffer, Math.floor(faceIndex), maxAngleDeg);
         const count = Math.max(0, Math.floor(r[0] ?? 0));
         const isPlanar = (r[1] ?? 1) !== 0;
         const faceIndices = [];
@@ -2548,7 +2727,10 @@ export class Mesh {
      */
     buildRenderBuffers(creaseAngleDeg = 30) {
         ensureInit();
-        const r = wasm.mesh_build_render_buffers(this._vertexCount, this._buffer, creaseAngleDeg);
+        const sidRb = this.storedId();
+        const r = sidRb > 0
+            ? wasm.mesh_build_render_buffers_h(sidRb, creaseAngleDeg)
+            : wasm.mesh_build_render_buffers(this._vertexCount, this._buffer, creaseAngleDeg);
         const vertexCount = Math.max(0, Math.floor(r[0] ?? 0));
         const posStart = 1;
         const norStart = posStart + vertexCount * 3;
@@ -2593,7 +2775,10 @@ export class Mesh {
         ensureInit();
         if (!Number.isFinite(faceIndex) || faceIndex < 0)
             return null;
-        const r = wasm.mesh_get_coplanar_face_group_centroid(this._vertexCount, this._buffer, Math.floor(faceIndex));
+        const sidCent = this.storedId();
+        const r = sidCent > 0
+            ? wasm.mesh_get_coplanar_face_group_centroid_h(sidCent, Math.floor(faceIndex))
+            : wasm.mesh_get_coplanar_face_group_centroid(this._vertexCount, this._buffer, Math.floor(faceIndex));
         if (!r || r.length < 3)
             return null;
         return new Point(r[0], r[1], r[2]);
@@ -2608,7 +2793,10 @@ export class Mesh {
         ensureInit();
         if (!Number.isFinite(faceIndex) || faceIndex < 0)
             return [];
-        const r = wasm.mesh_get_face_boundary_loops(this._vertexCount, this._buffer, Math.floor(faceIndex));
+        const sidLoops = this.storedId();
+        const r = sidLoops > 0
+            ? wasm.mesh_get_face_boundary_loops_h(sidLoops, Math.floor(faceIndex))
+            : wasm.mesh_get_face_boundary_loops(this._vertexCount, this._buffer, Math.floor(faceIndex));
         if (!r || r.length < 1)
             return [];
         const loopCount = Math.floor(r[0]);
@@ -2655,7 +2843,10 @@ export class Mesh {
      */
     raycast(origin, direction, maxDistance = Number.POSITIVE_INFINITY) {
         ensureInit();
-        const r = wasm.mesh_raycast(this._vertexCount, this._buffer, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, maxDistance);
+        const sidRay = this.storedId();
+        const r = sidRay > 0
+            ? wasm.mesh_raycast_h(sidRay, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, maxDistance)
+            : wasm.mesh_raycast(this._vertexCount, this._buffer, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, maxDistance);
         if (!r || r.length < 8)
             return null;
         return {
@@ -2670,7 +2861,10 @@ export class Mesh {
      */
     raycastAll(origin, direction, maxDistance = Number.POSITIVE_INFINITY) {
         ensureInit();
-        const buf = wasm.mesh_raycast_all(this._vertexCount, this._buffer, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, maxDistance);
+        const sidRayAll = this.storedId();
+        const buf = sidRayAll > 0
+            ? wasm.mesh_raycast_all_h(sidRayAll, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, maxDistance)
+            : wasm.mesh_raycast_all(this._vertexCount, this._buffer, origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, maxDistance);
         const count = Math.max(0, Math.floor(buf[0] ?? 0));
         const hits = [];
         let off = 1;
@@ -2746,8 +2940,8 @@ export class Mesh {
         }
         ensureInit();
         const metrics = this._trustedBooleanInput
-            ? mesh_topology_metrics_raw(this._vertexCount, this._buffer)
-            : mesh_topology_metrics(this._vertexCount, this._buffer);
+            ? wasm.mesh_topology_metrics_raw(this._vertexCount, this._buffer)
+            : wasm.mesh_topology_metrics(this._vertexCount, this._buffer);
         const boundaryEdges = Math.floor(metrics[0] ?? 0);
         const nonManifoldEdges = Math.floor(metrics[1] ?? 0);
         this._topologyMetricsCache = { boundaryEdges, nonManifoldEdges };
@@ -2766,7 +2960,10 @@ export class Mesh {
      */
     diagnostics() {
         ensureInit();
-        const r = wasm.mesh_repair_diagnostics(this._vertexCount, this._buffer);
+        const sidDiag = this.storedId();
+        const r = sidDiag > 0
+            ? wasm.mesh_repair_diagnostics_h(sidDiag)
+            : wasm.mesh_repair_diagnostics(this._vertexCount, this._buffer);
         return parseMeshDiagnostics(r, 0);
     }
     /**
@@ -2776,7 +2973,10 @@ export class Mesh {
      */
     boundaryEdgeSegments() {
         ensureInit();
-        return wasm.mesh_boundary_edge_segments(this._vertexCount, this._buffer);
+        const sidBes = this.storedId();
+        return sidBes > 0
+            ? wasm.mesh_boundary_edge_segments_h(sidBes)
+            : wasm.mesh_boundary_edge_segments(this._vertexCount, this._buffer);
     }
     /**
      * Chamfer feature edges of this closed solid. Each entry in `edges` is one
@@ -2820,7 +3020,10 @@ export class Mesh {
      */
     featureEdgeChains() {
         ensureInit();
-        const r = wasm.mesh_feature_edge_chains(this._vertexCount, this._buffer);
+        const sidFec = this.storedId();
+        const r = sidFec > 0
+            ? wasm.mesh_feature_edge_chains_h(sidFec)
+            : wasm.mesh_feature_edge_chains(this._vertexCount, this._buffer);
         if (!r.length) {
             throw new Error(`Mesh.featureEdgeChains() failed: ${wasm.geometry_last_error() || "unknown error"}`);
         }
@@ -3041,11 +3244,22 @@ Mesh.DEFAULT_BOOLEAN_DEBUG_PROBES = [
     "negZ",
 ];
 Mesh.DEFAULT_BOOLEAN_LIMITS = {
-    maxInputFacesPerMesh: 120000,
-    maxCombinedInputFaces: 180000,
-    maxFaceProduct: 500000000,
+    maxInputFacesPerMesh: 120_000,
+    maxCombinedInputFaces: 180_000,
+    maxFaceProduct: 500_000_000,
 };
-Mesh.TOPOLOGY_METRICS_CACHE_FACE_THRESHOLD = 20000;
+Mesh.TOPOLOGY_METRICS_CACHE_FACE_THRESHOLD = 20_000;
+Mesh.residencyFinalizer = typeof FinalizationRegistry !== "undefined"
+    ? new FinalizationRegistry((id) => {
+        try {
+            if (isInitialized())
+                wasm.mesh_store_free(id);
+        }
+        catch {
+            // engine torn down — nothing to free
+        }
+    })
+    : null;
 /** Largest supported arc sweep — just under a full circle keeps arcs open. */
 Mesh.MAX_ARC_SWEEP = Math.PI * 2 - 1e-4;
 //# sourceMappingURL=Mesh.js.map