okgeometry-api 0.4.2 → 0.4.4

package/dist/Mesh.js

@@ -1,7 +1,6 @@
 import { ensureInit } from "./engine.js";
 import { Point } from "./Point.js";
 import { Vec3 } from "./Vec3.js";
-import { Plane } from "./Plane.js";
 import { Polyline } from "./Polyline.js";
 import { Line } from "./Line.js";
 import { Circle } from "./Circle.js";
@@ -111,6 +110,42 @@ export class Mesh {
     static fromBuffer(buffer) {
         return new Mesh(buffer);
     }
+    /**
+     * Build an axis-aligned rectangle on a plane basis from opposite corners.
+     * The resulting corners are ordered [p0, p1, p2, p3] and form a closed loop.
+     */
+    static buildPlanarRectangle(startPoint, endPoint, uAxis, vAxis) {
+        const delta = endPoint.sub(startPoint);
+        const uLen = delta.dot(uAxis);
+        const vLen = delta.dot(vAxis);
+        const p0 = startPoint;
+        const p1 = startPoint.add(uAxis.scale(uLen));
+        const p3 = startPoint.add(vAxis.scale(vLen));
+        const p2 = p1.add(vAxis.scale(vLen));
+        return {
+            corners: [p0, p1, p2, p3],
+            width: Math.abs(uLen),
+            height: Math.abs(vLen),
+        };
+    }
+    /**
+     * Build a planar circle from center and a point on/near its radius direction.
+     * Radius is measured in the plane orthogonal to `normal`.
+     */
+    static buildPlanarCircle(center, radiusPoint, normal, segments = 64) {
+        const n = normal.normalize();
+        const radial = radiusPoint.sub(center);
+        const radialInPlane = radial.sub(n.scale(radial.dot(n)));
+        const radius = radialInPlane.length();
+        if (radius < 1e-12 || segments < 3) {
+            return { points: [], radius: 0 };
+        }
+        const circle = new Circle(center, radius, n);
+        return {
+            points: circle.sample(Math.floor(segments)),
+            radius,
+        };
+    }
     /**
      * Create a planar patch mesh from boundary points using CDT (Constrained Delaunay Triangulation).
      * Correctly handles both convex and concave polygons.
@@ -245,77 +280,36 @@ export class Mesh {
      * Closed curves use Newell's method; open curves use first non-collinear triple.
      */
     static computePlanarCurveNormal(points, closed) {
-        const n = points.length;
-        if (n < 3)
-            return Vec3.Y;
-        if (closed) {
-            let nx = 0;
-            let ny = 0;
-            let nz = 0;
-            for (let i = 0; i < n; i++) {
-                const a = points[i];
-                const b = points[(i + 1) % n];
-                nx += (a.y - b.y) * (a.z + b.z);
-                ny += (a.z - b.z) * (a.x + b.x);
-                nz += (a.x - b.x) * (a.y + b.y);
-            }
-            const normal = new Vec3(nx, ny, nz);
-            if (normal.length() >= 1e-10)
-                return normal.normalize();
-        }
-        for (let i = 0; i < n - 2; i++) {
-            const p0 = points[i];
-            const p1 = points[i + 1];
-            const p2 = points[i + 2];
-            const e1 = p1.sub(p0);
-            const e2 = p2.sub(p0);
-            const cross = e1.cross(e2);
-            if (cross.length() >= 1e-10)
-                return cross.normalize();
-        }
-        return Vec3.Y;
+        ensureInit();
+        const r = wasm.mesh_compute_planar_curve_normal(pointsToCoords(points), closed);
+        return new Vec3(r[0] ?? 0, r[1] ?? 1, r[2] ?? 0);
     }
     /**
      * Extrude a planar curve along a direction.
      * Open curves return an uncapped polysurface; closed curves are capped solids.
      */
     static extrudePlanarCurve(points, normal, height, closed) {
-        if (points.length < 2)
-            return new Mesh(new Float64Array(0));
-        const topPoints = points.map((p) => new Point(p.x + normal.x * height, p.y + normal.y * height, p.z + normal.z * height));
-        if (!closed) {
-            const direction = new Vec3(normal.x * height, normal.y * height, normal.z * height);
-            return new Polyline(points).extrude(direction, 1, false);
-        }
-        const sideWalls = Mesh.loftPolylines([points, topPoints], 1, false);
-        const bottomCap = Mesh.patchFromPoints(points);
-        const topCap = Mesh.patchFromPoints(topPoints);
-        return Mesh.mergeMeshes([sideWalls, bottomCap, topCap]);
+        ensureInit();
+        const buf = wasm.mesh_extrude_planar_curve(pointsToCoords(points), normal.x, normal.y, normal.z, height, closed);
+        return Mesh.fromBuffer(buf);
     }
     /**
      * Shift a closed cutter profile slightly opposite to travel direction and
      * compensate height so the distal end remains at the user-intended depth.
      */
     static prepareBooleanCutterCurve(points, closed, normal, height) {
-        if (!closed) {
-            return { points, height, epsilon: 0 };
-        }
-        const absHeight = Math.abs(height);
-        if (absHeight < 1e-9) {
-            return { points, height, epsilon: 0 };
+        ensureInit();
+        const buf = wasm.mesh_prepare_boolean_cutter_curve(pointsToCoords(points), closed, normal.x, normal.y, normal.z, height);
+        const outHeight = buf[0] ?? height;
+        const epsilon = buf[1] ?? 0;
+        const count = Math.max(0, Math.floor(buf[2] ?? 0));
+        const shifted = [];
+        let off = 3;
+        for (let i = 0; i < count; i++) {
+            shifted.push(new Point(buf[off], buf[off + 1], buf[off + 2]));
+            off += 3;
         }
-        const scale = Mesh.estimateCurveScale(points);
-        const baseEpsilon = Math.max(1e-6, scale * 1e-5);
-        const epsilon = Math.max(1e-8, Math.min(baseEpsilon, absHeight * 0.25));
-        const delta = height >= 0 ? -epsilon : epsilon;
-        const offset = normal.scale(delta);
-        const shifted = points.map((p) => new Point(p.x + offset.x, p.y + offset.y, p.z + offset.z));
-        const offsetAlongNormal = offset.dot(normal);
-        return {
-            points: shifted,
-            height: height - offsetAlongNormal,
-            epsilon,
-        };
+        return { points: shifted, height: outHeight, epsilon };
     }
     /**
      * Sweep any curve type along any curve type.
@@ -412,79 +406,47 @@ export class Mesh {
         return data;
     }
     static mergeMeshes(meshes) {
-        let totalVertexCount = 0;
-        let totalPositionValues = 0;
-        let totalIndexValues = 0;
-        for (const mesh of meshes) {
-            const raw = mesh.rawBuffer;
-            const vertexCount = raw.length > 0 ? Math.max(0, Math.floor(raw[0])) : 0;
-            const positionValues = vertexCount * 3;
-            const indexValues = Math.max(0, raw.length - 1 - positionValues);
-            totalVertexCount += vertexCount;
-            totalPositionValues += positionValues;
-            totalIndexValues += indexValues;
-        }
-        const out = new Float64Array(1 + totalPositionValues + totalIndexValues);
-        out[0] = totalVertexCount;
-        let writePos = 1;
-        let writeIdx = 1 + totalPositionValues;
-        let vertexOffset = 0;
-        for (const mesh of meshes) {
-            const raw = mesh.rawBuffer;
-            const vertexCount = raw.length > 0 ? Math.max(0, Math.floor(raw[0])) : 0;
-            const positionValues = vertexCount * 3;
-            const indexValues = Math.max(0, raw.length - 1 - positionValues);
-            out.set(raw.subarray(1, 1 + positionValues), writePos);
-            for (let i = 0; i < indexValues; i++) {
-                out[writeIdx + i] = raw[1 + positionValues + i] + vertexOffset;
-            }
-            writePos += positionValues;
-            writeIdx += indexValues;
-            vertexOffset += vertexCount;
-        }
-        return new Mesh(out);
-    }
-    static estimateCurveScale(points) {
-        if (points.length === 0)
-            return 1;
-        let minX = Number.POSITIVE_INFINITY;
-        let minY = Number.POSITIVE_INFINITY;
-        let minZ = Number.POSITIVE_INFINITY;
-        let maxX = Number.NEGATIVE_INFINITY;
-        let maxY = Number.NEGATIVE_INFINITY;
-        let maxZ = Number.NEGATIVE_INFINITY;
-        for (const p of points) {
-            if (p.x < minX)
-                minX = p.x;
-            if (p.y < minY)
-                minY = p.y;
-            if (p.z < minZ)
-                minZ = p.z;
-            if (p.x > maxX)
-                maxX = p.x;
-            if (p.y > maxY)
-                maxY = p.y;
-            if (p.z > maxZ)
-                maxZ = p.z;
-        }
-        const dx = maxX - minX;
-        const dy = maxY - minY;
-        const dz = maxZ - minZ;
-        const diag = Math.sqrt(dx * dx + dy * dy + dz * dz);
-        return Math.max(diag, 1);
+        ensureInit();
+        const packed = Mesh.packMeshes(meshes);
+        return Mesh.fromBuffer(wasm.mesh_merge(packed));
     }
     /**
-     * Build a mesh from raw position and index buffers.
+     * Raycast against many meshes and return all hits sorted by distance.
      */
-    static fromPositionsAndIndices(positions, indices) {
-        const vertexCount = positions.length / 3;
-        const out = new Float64Array(1 + positions.length + indices.length);
-        out[0] = vertexCount;
-        out.set(positions, 1);
-        for (let i = 0; i < indices.length; i++) {
-            out[1 + positions.length + i] = indices[i];
+    static raycastMany(meshes, origin, direction, maxDistance = Number.POSITIVE_INFINITY) {
+        ensureInit();
+        if (meshes.length === 0)
+            return [];
+        const packed = Mesh.packMeshes(meshes);
+        const raycastMany = wasm.mesh_raycast_many;
+        const buf = raycastMany(packed, 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;
+        for (let i = 0; i < count; i++) {
+            hits.push({
+                meshIndex: Math.floor(buf[off]),
+                point: new Point(buf[off + 1], buf[off + 2], buf[off + 3]),
+                normal: new Vec3(buf[off + 4], buf[off + 5], buf[off + 6]),
+                faceIndex: Math.floor(buf[off + 7]),
+                distance: buf[off + 8],
+            });
+            off += 9;
         }
-        return new Mesh(out);
+        return hits;
+    }
+    static packMeshes(meshes) {
+        const totalLen = meshes.reduce((sum, m) => sum + 1 + m.rawBuffer.length, 1);
+        const packed = new Float64Array(totalLen);
+        packed[0] = meshes.length;
+        let off = 1;
+        for (const mesh of meshes) {
+            const raw = mesh.rawBuffer;
+            packed[off++] = raw.length;
+            packed.set(raw, off);
+            off += raw.length;
+        }
+        return packed;
     }
     /**
      * Unique undirected triangle edges as vertex-index pairs.
@@ -492,21 +454,19 @@ export class Mesh {
     getUniqueEdgeVertexPairs() {
         if (this._edgeVertexPairs)
             return this._edgeVertexPairs;
-        const unique = new Map();
-        const idx = this.indexBuffer;
-        for (let i = 0; i + 2 < idx.length; i += 3) {
-            const a = idx[i];
-            const b = idx[i + 1];
-            const c = idx[i + 2];
-            const edges = [[a, b], [b, c], [c, a]];
-            for (const [u, v] of edges) {
-                const key = Mesh.edgeKey(u, v);
-                if (!unique.has(key)) {
-                    unique.set(key, [u, v]);
-                }
-            }
-        }
-        this._edgeVertexPairs = Array.from(unique.values());
+        ensureInit();
+        const packed = 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;
+        for (let i = 0; i < edgeCount; i++) {
+            const a = Math.floor(packed[off++] ?? -1);
+            const b = Math.floor(packed[off++] ?? -1);
+            if (a < 0 || b < 0)
+                break;
+            pairs.push([a, b]);
+        }
+        this._edgeVertexPairs = pairs;
         return this._edgeVertexPairs;
     }
     // ── Transforms ────────────────────────────────────────────────
@@ -642,173 +602,93 @@ export class Mesh {
      * Axis-aligned bounds of this mesh.
      */
     getBounds() {
-        const pos = this.positionBuffer;
-        if (pos.length < 3) {
-            return { min: Point.ORIGIN, max: Point.ORIGIN };
-        }
-        let minX = Number.POSITIVE_INFINITY;
-        let minY = Number.POSITIVE_INFINITY;
-        let minZ = Number.POSITIVE_INFINITY;
-        let maxX = Number.NEGATIVE_INFINITY;
-        let maxY = Number.NEGATIVE_INFINITY;
-        let maxZ = Number.NEGATIVE_INFINITY;
-        for (let i = 0; i < pos.length; i += 3) {
-            const x = pos[i];
-            const y = pos[i + 1];
-            const z = pos[i + 2];
-            if (x < minX)
-                minX = x;
-            if (y < minY)
-                minY = y;
-            if (z < minZ)
-                minZ = z;
-            if (x > maxX)
-                maxX = x;
-            if (y > maxY)
-                maxY = y;
-            if (z > maxZ)
-                maxZ = z;
-        }
+        ensureInit();
+        const b = wasm.mesh_get_bounds(this._vertexCount, this._buffer);
         return {
-            min: new Point(minX, minY, minZ),
-            max: new Point(maxX, maxY, maxZ),
+            min: new Point(b[0] ?? 0, b[1] ?? 0, b[2] ?? 0),
+            max: new Point(b[3] ?? 0, b[4] ?? 0, b[5] ?? 0),
         };
     }
     /**
      * Unit normal of a triangle face.
      */
     getFaceNormal(faceIndex) {
-        if (!Number.isFinite(faceIndex) || faceIndex < 0 || faceIndex >= this.faceCount) {
+        ensureInit();
+        if (!Number.isFinite(faceIndex) || faceIndex < 0)
             return Vec3.Y;
-        }
-        const idx = this.indexBuffer;
-        const pos = this.positionBuffer;
-        const i0 = idx[faceIndex * 3];
-        const i1 = idx[faceIndex * 3 + 1];
-        const i2 = idx[faceIndex * 3 + 2];
-        const off0 = i0 * 3;
-        const off1 = i1 * 3;
-        const off2 = i2 * 3;
-        const normal = Mesh.triangleNormal(pos[off0], pos[off0 + 1], pos[off0 + 2], pos[off1], pos[off1 + 1], pos[off1 + 2], pos[off2], pos[off2 + 1], pos[off2 + 2]);
-        return normal ?? Vec3.Y;
+        const n = wasm.mesh_get_face_normal(this._vertexCount, this._buffer, Math.floor(faceIndex));
+        return new Vec3(n[0] ?? 0, n[1] ?? 1, n[2] ?? 0);
     }
     /**
      * Centroid of a triangle face.
      */
     getFaceCentroid(faceIndex) {
-        if (!Number.isFinite(faceIndex) || faceIndex < 0 || faceIndex >= this.faceCount) {
+        ensureInit();
+        if (!Number.isFinite(faceIndex) || faceIndex < 0)
             return Point.ORIGIN;
-        }
-        const idx = this.indexBuffer;
-        const pos = this.positionBuffer;
-        const i0 = idx[faceIndex * 3];
-        const i1 = idx[faceIndex * 3 + 1];
-        const i2 = idx[faceIndex * 3 + 2];
-        const off0 = i0 * 3;
-        const off1 = i1 * 3;
-        const off2 = i2 * 3;
-        return new Point((pos[off0] + pos[off1] + pos[off2]) / 3, (pos[off0 + 1] + pos[off1 + 1] + pos[off2 + 1]) / 3, (pos[off0 + 2] + pos[off1 + 2] + pos[off2 + 2]) / 3);
+        const c = wasm.mesh_get_face_centroid(this._vertexCount, this._buffer, Math.floor(faceIndex));
+        return new Point(c[0] ?? 0, c[1] ?? 0, c[2] ?? 0);
     }
     /**
      * Area of a triangle face.
      */
     getFaceArea(faceIndex) {
-        if (!Number.isFinite(faceIndex) || faceIndex < 0 || faceIndex >= this.faceCount) {
+        ensureInit();
+        if (!Number.isFinite(faceIndex) || faceIndex < 0)
             return 0;
-        }
-        const idx = this.indexBuffer;
-        const pos = this.positionBuffer;
-        const i0 = idx[faceIndex * 3];
-        const i1 = idx[faceIndex * 3 + 1];
-        const i2 = idx[faceIndex * 3 + 2];
-        const aoff = i0 * 3;
-        const boff = i1 * 3;
-        const coff = i2 * 3;
-        const e1x = pos[boff] - pos[aoff];
-        const e1y = pos[boff + 1] - pos[aoff + 1];
-        const e1z = pos[boff + 2] - pos[aoff + 2];
-        const e2x = pos[coff] - pos[aoff];
-        const e2y = pos[coff + 1] - pos[aoff + 1];
-        const e2z = pos[coff + 2] - pos[aoff + 2];
-        const cx = e1y * e2z - e1z * e2y;
-        const cy = e1z * e2x - e1x * e2z;
-        const cz = e1x * e2y - e1y * e2x;
-        return Math.sqrt(cx * cx + cy * cy + cz * cz) * 0.5;
+        return wasm.mesh_get_face_area(this._vertexCount, this._buffer, Math.floor(faceIndex));
     }
     /**
      * Find edge-connected coplanar triangles that belong to the same planar face.
      */
     getCoplanarFaceIndices(faceIndex) {
-        if (!Number.isFinite(faceIndex) || faceIndex < 0 || faceIndex >= this.faceCount) {
+        ensureInit();
+        if (!Number.isFinite(faceIndex) || faceIndex < 0)
             return [];
+        const r = 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++) {
+            out.push(Math.floor(r[1 + i] ?? 0));
         }
-        const targetNormal = this.getFaceNormal(faceIndex);
-        const targetCentroid = this.getFaceCentroid(faceIndex);
-        const EPSILON = 0.01;
-        const faceCount = this.faceCount;
-        const idx = this.indexBuffer;
-        const coplanarCandidates = [];
-        const candidateSet = new Set();
-        for (let i = 0; i < faceCount; i++) {
-            const n = this.getFaceNormal(i);
-            const dot = targetNormal.dot(n);
-            if (dot <= 1 - EPSILON)
-                continue;
-            const c = this.getFaceCentroid(i);
-            const dx = c.x - targetCentroid.x;
-            const dy = c.y - targetCentroid.y;
-            const dz = c.z - targetCentroid.z;
-            const planeDist = Math.abs(dx * targetNormal.x + dy * targetNormal.y + dz * targetNormal.z);
-            if (planeDist >= EPSILON)
-                continue;
-            coplanarCandidates.push(i);
-            candidateSet.add(i);
-        }
-        if (!candidateSet.has(faceIndex)) {
-            return [faceIndex];
-        }
-        const edgeToFaces = new Map();
-        const faceEdges = new Map();
-        for (const fi of coplanarCandidates) {
-            const a = idx[fi * 3];
-            const b = idx[fi * 3 + 1];
-            const c = idx[fi * 3 + 2];
-            const edges = [[a, b], [b, c], [c, a]];
-            const keys = [];
-            for (const [u, v] of edges) {
-                const lo = Math.min(u, v);
-                const hi = Math.max(u, v);
-                const key = `${lo}_${hi}`;
-                keys.push(key);
-                const faces = edgeToFaces.get(key);
-                if (faces) {
-                    faces.push(fi);
-                }
-                else {
-                    edgeToFaces.set(key, [fi]);
-                }
-            }
-            faceEdges.set(fi, keys);
-        }
-        const connected = [];
-        const visited = new Set();
-        const queue = [faceIndex];
-        visited.add(faceIndex);
-        while (queue.length > 0) {
-            const current = queue.shift();
-            connected.push(current);
-            const keys = faceEdges.get(current) ?? [];
-            for (const key of keys) {
-                const neighbors = edgeToFaces.get(key) ?? [];
-                for (const neighbor of neighbors) {
-                    if (!candidateSet.has(neighbor) || visited.has(neighbor))
-                        continue;
-                    visited.add(neighbor);
-                    queue.push(neighbor);
-                }
-            }
+        return out;
+    }
+    /**
+     * Coplanar connected face region and its projection bounds on a plane basis.
+     * Returns null for invalid inputs or empty regions.
+     */
+    getCoplanarFaceRegion(faceIndex, origin, uAxis, vAxis, marginScale = 0.1, minMargin = 0.2) {
+        ensureInit();
+        if (!Number.isFinite(faceIndex) || faceIndex < 0)
+            return null;
+        const r = wasm.mesh_get_coplanar_face_region(this._vertexCount, this._buffer, Math.floor(faceIndex), origin.x, origin.y, origin.z, uAxis.x, uAxis.y, uAxis.z, vAxis.x, vAxis.y, vAxis.z, marginScale, minMargin);
+        const count = Math.max(0, Math.floor(r[0] ?? 0));
+        if (count <= 0 || r.length < 1 + count + 4)
+            return null;
+        const faceIndices = [];
+        for (let i = 0; i < count; i++) {
+            faceIndices.push(Math.floor(r[1 + i] ?? 0));
         }
-        return connected;
+        const off = 1 + count;
+        return {
+            faceIndices,
+            uMin: r[off],
+            uMax: r[off + 1],
+            vMin: r[off + 2],
+            vMax: r[off + 3],
+        };
+    }
+    /**
+     * Centroid of the coplanar edge-connected face group containing faceIndex.
+     */
+    getCoplanarFaceGroupCentroid(faceIndex) {
+        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));
+        if (!r || r.length < 3)
+            return null;
+        return new Point(r[0], r[1], r[2]);
     }
     /**
      * Unique edge count for this triangulated mesh.
@@ -837,207 +717,62 @@ export class Mesh {
      * Raycast against this mesh and return nearest hit.
      */
     raycast(origin, direction, maxDistance = Number.POSITIVE_INFINITY) {
-        const hits = this.raycastAll(origin, direction, maxDistance);
-        return hits.length > 0 ? hits[0] : null;
+        ensureInit();
+        const r = 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 {
+            point: new Point(r[0], r[1], r[2]),
+            normal: new Vec3(r[3], r[4], r[5]),
+            faceIndex: Math.floor(r[6]),
+            distance: r[7],
+        };
     }
     /**
      * Raycast against this mesh and return all hits sorted by distance.
      */
     raycastAll(origin, direction, maxDistance = Number.POSITIVE_INFINITY) {
-        const dirLen = direction.length();
-        if (!Number.isFinite(dirLen) || dirLen < 1e-12)
-            return [];
-        const dir = direction.scale(1 / dirLen);
+        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 count = Math.max(0, Math.floor(buf[0] ?? 0));
         const hits = [];
-        const idx = this.indexBuffer;
-        const pos = this.positionBuffer;
-        const triCount = idx.length / 3;
-        for (let f = 0; f < triCount; f++) {
-            const i0 = idx[f * 3];
-            const i1 = idx[f * 3 + 1];
-            const i2 = idx[f * 3 + 2];
-            const off0 = i0 * 3;
-            const off1 = i1 * 3;
-            const off2 = i2 * 3;
-            const t = Mesh.rayTriangleDistance(origin.x, origin.y, origin.z, dir.x, dir.y, dir.z, pos[off0], pos[off0 + 1], pos[off0 + 2], pos[off1], pos[off1 + 1], pos[off1 + 2], pos[off2], pos[off2 + 1], pos[off2 + 2]);
-            if (t === null || !Number.isFinite(t) || t > maxDistance)
-                continue;
+        let off = 1;
+        for (let i = 0; i < count; i++) {
             hits.push({
-                point: new Point(origin.x + dir.x * t, origin.y + dir.y * t, origin.z + dir.z * t),
-                normal: this.getFaceNormal(f),
-                faceIndex: f,
-                distance: t,
+                point: new Point(buf[off], buf[off + 1], buf[off + 2]),
+                normal: new Vec3(buf[off + 3], buf[off + 4], buf[off + 5]),
+                faceIndex: Math.floor(buf[off + 6]),
+                distance: buf[off + 7],
             });
+            off += 8;
         }
-        hits.sort((a, b) => a.distance - b.distance);
         return hits;
     }
     /**
      * Push/pull a planar face set by moving its coplanar connected region.
      */
     extrudeFace(faceIndex, distance) {
-        if (!Number.isFinite(faceIndex) || faceIndex < 0 || faceIndex >= this.faceCount) {
+        ensureInit();
+        if (!Number.isFinite(faceIndex) || faceIndex < 0) {
             return Mesh.fromBuffer(new Float64Array(this._buffer));
         }
-        const pushNormal = this.getFaceNormal(faceIndex);
-        const coplanarFaces = this.getCoplanarFaceIndices(faceIndex);
-        const coplanarFaceSet = new Set(coplanarFaces);
-        const idx = this.indexBuffer;
-        const pos = this.positionBuffer;
-        const vertexCount = this.vertexCount;
-        const faceCount = this.faceCount;
-        const verts = new Float64Array(vertexCount * 3);
-        for (let i = 0; i < verts.length; i++) {
-            verts[i] = pos[i];
-        }
-        const coplanarVertexSet = new Set();
-        for (const fi of coplanarFaces) {
-            coplanarVertexSet.add(idx[fi * 3]);
-            coplanarVertexSet.add(idx[fi * 3 + 1]);
-            coplanarVertexSet.add(idx[fi * 3 + 2]);
-        }
-        const POS_EPSILON_SQ = 1e-10;
-        const NORMAL_EPSILON = 0.01;
-        const uniquePositions = [];
-        const assignedCoplanar = new Set();
-        for (const ci of coplanarVertexSet) {
-            if (assignedCoplanar.has(ci))
-                continue;
-            const cx = verts[ci * 3];
-            const cy = verts[ci * 3 + 1];
-            const cz = verts[ci * 3 + 2];
-            const allAtPos = [];
-            for (let vi = 0; vi < vertexCount; vi++) {
-                const dx = verts[vi * 3] - cx;
-                const dy = verts[vi * 3 + 1] - cy;
-                const dz = verts[vi * 3 + 2] - cz;
-                if (dx * dx + dy * dy + dz * dz < POS_EPSILON_SQ) {
-                    allAtPos.push(vi);
-                    if (coplanarVertexSet.has(vi)) {
-                        assignedCoplanar.add(vi);
-                    }
-                }
-            }
-            uniquePositions.push({ x: cx, y: cy, z: cz, allVertexIndices: allAtPos });
-        }
-        const refVi = idx[faceIndex * 3];
-        const pushOrigin = new Point(verts[refVi * 3] + pushNormal.x * distance, verts[refVi * 3 + 1] + pushNormal.y * distance, verts[refVi * 3 + 2] + pushNormal.z * distance);
-        const pushPlane = new Plane(pushOrigin, pushNormal);
-        const newVerts = new Float64Array(verts);
-        for (const upos of uniquePositions) {
-            const adjacentFaceIndices = [];
-            for (let fi = 0; fi < faceCount; fi++) {
-                if (coplanarFaceSet.has(fi))
-                    continue;
-                for (let k = 0; k < 3; k++) {
-                    const vi = idx[fi * 3 + k];
-                    const dx = verts[vi * 3] - upos.x;
-                    const dy = verts[vi * 3 + 1] - upos.y;
-                    const dz = verts[vi * 3 + 2] - upos.z;
-                    if (dx * dx + dy * dy + dz * dz < POS_EPSILON_SQ) {
-                        adjacentFaceIndices.push(fi);
-                        break;
-                    }
-                }
-            }
-            const adjacentPlanes = [];
-            for (const fi of adjacentFaceIndices) {
-                const n = this.getFaceNormal(fi);
-                let merged = false;
-                for (const existing of adjacentPlanes) {
-                    const dot = n.dot(existing.normal);
-                    if (dot > 1 - NORMAL_EPSILON) {
-                        merged = true;
-                        break;
-                    }
-                }
-                if (!merged) {
-                    const rv = idx[fi * 3];
-                    const origin = new Point(verts[rv * 3], verts[rv * 3 + 1], verts[rv * 3 + 2]);
-                    adjacentPlanes.push(new Plane(origin, n));
-                }
-            }
-            let newPos = null;
-            if (adjacentPlanes.length >= 2) {
-                const pt = Plane.intersect3(pushPlane, adjacentPlanes[0], adjacentPlanes[1]);
-                if (pt) {
-                    newPos = pt;
-                }
-            }
-            if (!newPos) {
-                newPos = new Point(upos.x + pushNormal.x * distance, upos.y + pushNormal.y * distance, upos.z + pushNormal.z * distance);
-            }
-            for (const vi of upos.allVertexIndices) {
-                newVerts[vi * 3] = newPos.x;
-                newVerts[vi * 3 + 1] = newPos.y;
-                newVerts[vi * 3 + 2] = newPos.z;
-            }
-        }
-        return Mesh.fromPositionsAndIndices(newVerts, idx);
+        return Mesh.fromBuffer(wasm.mesh_extrude_face(this._vertexCount, this._buffer, Math.floor(faceIndex), distance));
     }
     /**
      * Check if this triangulated mesh represents a closed volume.
-     * Returns true when no topological boundary edges are found.
-     *
-     * Uses kernel boundary extraction first, then falls back to a welded
-     * edge-incidence pass to tolerate duplicated seam vertices.
+     * Returns true when no welded topological boundary edges are found.
      */
     isClosedVolume() {
-        if (this.indexBuffer.length < 3)
-            return false;
-        try {
-            if (this.boundaryPolylines().length === 0)
-                return true;
-        }
-        catch {
-            // Fall through to welded index analysis.
-        }
-        const welded = this.buildWeldedVertexIndexMap();
-        const edgeCounts = new Map();
-        const idx = this.indexBuffer;
-        for (let i = 0; i + 2 < idx.length; i += 3) {
-            const ai = idx[i];
-            const bi = idx[i + 1];
-            const ci = idx[i + 2];
-            if (ai >= welded.length || bi >= welded.length || ci >= welded.length) {
-                return false;
-            }
-            const a = welded[ai];
-            const b = welded[bi];
-            const c = welded[ci];
-            if (a === b || b === c || c === a)
-                continue;
-            const edges = [[a, b], [b, c], [c, a]];
-            for (const [u, v] of edges) {
-                const lo = Math.min(u, v);
-                const hi = Math.max(u, v);
-                const key = `${lo}_${hi}`;
-                edgeCounts.set(key, (edgeCounts.get(key) ?? 0) + 1);
-            }
-        }
-        for (const count of edgeCounts.values()) {
-            if (count === 1)
-                return false;
-        }
-        return true;
+        ensureInit();
+        return wasm.mesh_is_closed_volume(this._vertexCount, this._buffer);
     }
     /**
      * Odd/even point containment test against a closed mesh.
      * Uses majority vote across multiple ray directions for robustness.
      */
     containsPoint(point) {
-        const directions = [
-            new Vec3(0.329292779969071, 0.5488212999484517, 0.7683498199278324),
-            new Vec3(0.6227991553292184, -0.2075997184430728, 0.7547910549471614),
-            new Vec3(-0.1708715315433522, 0.9405985944884371, 0.29377431425456585),
-        ];
-        let insideVotes = 0;
-        for (const dir of directions) {
-            const crossings = this.countRayCrossings(point, dir);
-            if ((crossings & 1) === 1)
-                insideVotes += 1;
-        }
-        return insideVotes >= Math.ceil(directions.length / 2);
+        ensureInit();
+        return wasm.mesh_contains_point(this._vertexCount, this._buffer, point.x, point.y, point.z);
     }
     /**
      * Find the coplanar + edge-connected face group containing a triangle.
@@ -1045,333 +780,28 @@ export class Mesh {
     findFaceByTriangleIndex(triangleIndex) {
         if (!Number.isFinite(triangleIndex) || triangleIndex < 0)
             return null;
-        const groups = this.buildCoplanarConnectedFaceGroups();
-        for (const group of groups) {
-            if (group.triangleIndices.includes(Math.floor(triangleIndex))) {
-                return { centroid: group.centroid, normal: group.normal };
-            }
-        }
-        return null;
+        ensureInit();
+        const r = wasm.mesh_find_face_group_by_triangle_index(this._vertexCount, this._buffer, Math.floor(triangleIndex));
+        if (!r || r.length < 6)
+            return null;
+        return {
+            centroid: new Point(r[0], r[1], r[2]),
+            normal: new Vec3(r[3], r[4], r[5]),
+        };
     }
     /**
      * Find the best matching coplanar + edge-connected face group by normal
      * similarity and optional point proximity.
      */
     findFaceByNormal(targetNormal, nearPoint) {
-        const groups = this.buildCoplanarConnectedFaceGroups();
-        if (groups.length === 0)
-            return null;
-        let best = null;
-        let bestScore = Number.NEGATIVE_INFINITY;
-        for (const group of groups) {
-            const normal = group.normal;
-            const centroid = group.centroid;
-            const normalScore = Math.max(0, normal.dot(targetNormal));
-            let score;
-            if (nearPoint) {
-                const dx = centroid.x - nearPoint.x;
-                const dy = centroid.y - nearPoint.y;
-                const dz = centroid.z - nearPoint.z;
-                const distSq = dx * dx + dy * dy + dz * dz;
-                const proximityScore = 1.0 / (1.0 + distSq);
-                score = proximityScore * (0.5 + 0.5 * normalScore);
-            }
-            else {
-                score = normalScore;
-            }
-            if (score > bestScore) {
-                bestScore = score;
-                best = { centroid, normal };
-            }
-        }
-        return best;
-    }
-    /**
-     * Count unique ray/triangle crossings from origin along direction.
-     * Distances are deduplicated to collapse paired hits on triangulated quads.
-     */
-    countRayCrossings(origin, direction) {
-        const MIN_DISTANCE = 1e-6;
-        const MERGE_DISTANCE = 1e-5;
-        const distances = [];
-        const idx = this.indexBuffer;
-        const verts = this.positionBuffer;
-        for (let i = 0; i + 2 < idx.length; i += 3) {
-            const i0 = idx[i];
-            const i1 = idx[i + 1];
-            const i2 = idx[i + 2];
-            const off0 = i0 * 3;
-            const off1 = i1 * 3;
-            const off2 = i2 * 3;
-            const t = Mesh.rayTriangleDistance(origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, verts[off0], verts[off0 + 1], verts[off0 + 2], verts[off1], verts[off1 + 1], verts[off1 + 2], verts[off2], verts[off2 + 1], verts[off2 + 2]);
-            if (t !== null && Number.isFinite(t) && t > MIN_DISTANCE) {
-                distances.push(t);
-            }
-        }
-        if (distances.length === 0)
-            return 0;
-        distances.sort((a, b) => a - b);
-        let crossings = 0;
-        let lastDistance = -Infinity;
-        for (const d of distances) {
-            if (Math.abs(d - lastDistance) <= MERGE_DISTANCE)
-                continue;
-            crossings += 1;
-            lastDistance = d;
-        }
-        return crossings;
-    }
-    buildCoplanarConnectedFaceGroups() {
-        const NORMAL_GROUP_EPS = 0.05;
-        const PLANE_EPS = 0.1;
-        const idx = this.indexBuffer;
-        const verts = this.positionBuffer;
-        const triCount = idx.length / 3;
-        const tris = [];
-        for (let t = 0; t < triCount; t++) {
-            const i0 = idx[t * 3];
-            const i1 = idx[t * 3 + 1];
-            const i2 = idx[t * 3 + 2];
-            const aoff = i0 * 3;
-            const boff = i1 * 3;
-            const coff = i2 * 3;
-            const ax = verts[aoff];
-            const ay = verts[aoff + 1];
-            const az = verts[aoff + 2];
-            const bx = verts[boff];
-            const by = verts[boff + 1];
-            const bz = verts[boff + 2];
-            const cx = verts[coff];
-            const cy = verts[coff + 1];
-            const cz = verts[coff + 2];
-            const normal = Mesh.triangleNormal(ax, ay, az, bx, by, bz, cx, cy, cz);
-            if (!normal)
-                continue;
-            tris.push({
-                triIndex: t,
-                i0,
-                i1,
-                i2,
-                cx: (ax + bx + cx) / 3,
-                cy: (ay + by + cy) / 3,
-                cz: (az + bz + cz) / 3,
-                nx: normal.x,
-                ny: normal.y,
-                nz: normal.z,
-            });
-        }
-        if (tris.length === 0)
-            return [];
-        const triToNeighbors = new Map();
-        const edgeToTris = new Map();
-        for (let i = 0; i < tris.length; i++) {
-            const tri = tris[i];
-            const edges = [
-                [tri.i0, tri.i1],
-                [tri.i1, tri.i2],
-                [tri.i2, tri.i0],
-            ];
-            for (const [a, b] of edges) {
-                const key = Mesh.edgeKey(a, b);
-                const bucket = edgeToTris.get(key);
-                if (bucket) {
-                    bucket.push(i);
-                }
-                else {
-                    edgeToTris.set(key, [i]);
-                }
-            }
-        }
-        for (const bucket of edgeToTris.values()) {
-            for (let i = 0; i < bucket.length; i++) {
-                const a = bucket[i];
-                let set = triToNeighbors.get(a);
-                if (!set) {
-                    set = new Set();
-                    triToNeighbors.set(a, set);
-                }
-                for (let j = 0; j < bucket.length; j++) {
-                    if (i === j)
-                        continue;
-                    set.add(bucket[j]);
-                }
-            }
-        }
-        const visited = new Uint8Array(tris.length);
-        const groups = [];
-        for (let seedIdx = 0; seedIdx < tris.length; seedIdx++) {
-            if (visited[seedIdx])
-                continue;
-            const seed = tris[seedIdx];
-            const queue = [seedIdx];
-            visited[seedIdx] = 1;
-            const groupTris = [];
-            while (queue.length > 0) {
-                const idxInTris = queue.pop();
-                const tri = tris[idxInTris];
-                groupTris.push(tri);
-                const neighbors = triToNeighbors.get(idxInTris);
-                if (!neighbors)
-                    continue;
-                for (const nIdx of neighbors) {
-                    if (visited[nIdx])
-                        continue;
-                    const candidate = tris[nIdx];
-                    const dot = seed.nx * candidate.nx + seed.ny * candidate.ny + seed.nz * candidate.nz;
-                    if (dot < 1 - NORMAL_GROUP_EPS)
-                        continue;
-                    const seedPlane = seed.cx * seed.nx + seed.cy * seed.ny + seed.cz * seed.nz;
-                    const candidatePlane = candidate.cx * seed.nx + candidate.cy * seed.ny + candidate.cz * seed.nz;
-                    if (Math.abs(candidatePlane - seedPlane) >= PLANE_EPS)
-                        continue;
-                    visited[nIdx] = 1;
-                    queue.push(nIdx);
-                }
-            }
-            if (groupTris.length === 0)
-                continue;
-            let cx = 0;
-            let cy = 0;
-            let cz = 0;
-            let nx = 0;
-            let ny = 0;
-            let nz = 0;
-            const triangleIndices = [];
-            for (const tri of groupTris) {
-                cx += tri.cx;
-                cy += tri.cy;
-                cz += tri.cz;
-                nx += tri.nx;
-                ny += tri.ny;
-                nz += tri.nz;
-                triangleIndices.push(tri.triIndex);
-            }
-            const invCount = 1 / groupTris.length;
-            cx *= invCount;
-            cy *= invCount;
-            cz *= invCount;
-            nx *= invCount;
-            ny *= invCount;
-            nz *= invCount;
-            const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
-            if (len < 1e-12)
-                continue;
-            groups.push({
-                triangleIndices,
-                centroid: new Point(cx, cy, cz),
-                normal: new Vec3(nx / len, ny / len, nz / len),
-            });
-        }
-        return groups;
-    }
-    /**
-     * Map each raw vertex index to a welded topological vertex index.
-     * Uses scale-aware quantization to merge duplicate seam vertices.
-     */
-    buildWeldedVertexIndexMap() {
-        const pos = this.positionBuffer;
-        const vertexCount = pos.length / 3;
-        const map = new Uint32Array(vertexCount);
-        if (vertexCount === 0)
-            return map;
-        let minX = Number.POSITIVE_INFINITY;
-        let minY = Number.POSITIVE_INFINITY;
-        let minZ = Number.POSITIVE_INFINITY;
-        let maxX = Number.NEGATIVE_INFINITY;
-        let maxY = Number.NEGATIVE_INFINITY;
-        let maxZ = Number.NEGATIVE_INFINITY;
-        for (let i = 0; i < vertexCount; i++) {
-            const x = pos[i * 3];
-            const y = pos[i * 3 + 1];
-            const z = pos[i * 3 + 2];
-            if (x < minX)
-                minX = x;
-            if (y < minY)
-                minY = y;
-            if (z < minZ)
-                minZ = z;
-            if (x > maxX)
-                maxX = x;
-            if (y > maxY)
-                maxY = y;
-            if (z > maxZ)
-                maxZ = z;
-        }
-        const dx = maxX - minX;
-        const dy = maxY - minY;
-        const dz = maxZ - minZ;
-        const diag = Math.sqrt(dx * dx + dy * dy + dz * dz);
-        const tol = Math.max(1e-9, diag * 1e-8);
-        const invTol = 1 / tol;
-        const weldedByKey = new Map();
-        let nextWelded = 0;
-        for (let i = 0; i < vertexCount; i++) {
-            const x = pos[i * 3];
-            const y = pos[i * 3 + 1];
-            const z = pos[i * 3 + 2];
-            const qx = Math.round(x * invTol);
-            const qy = Math.round(y * invTol);
-            const qz = Math.round(z * invTol);
-            const key = `${qx}_${qy}_${qz}`;
-            let welded = weldedByKey.get(key);
-            if (welded === undefined) {
-                welded = nextWelded++;
-                weldedByKey.set(key, welded);
-            }
-            map[i] = welded;
-        }
-        return map;
-    }
-    /**
-     * Moller-Trumbore ray/triangle intersection distance.
-     */
-    static rayTriangleDistance(ox, oy, oz, dx, dy, dz, v0x, v0y, v0z, v1x, v1y, v1z, v2x, v2y, v2z) {
-        const EPSILON = 1e-7;
-        const e1x = v1x - v0x;
-        const e1y = v1y - v0y;
-        const e1z = v1z - v0z;
-        const e2x = v2x - v0x;
-        const e2y = v2y - v0y;
-        const e2z = v2z - v0z;
-        const hx = dy * e2z - dz * e2y;
-        const hy = dz * e2x - dx * e2z;
-        const hz = dx * e2y - dy * e2x;
-        const a = e1x * hx + e1y * hy + e1z * hz;
-        if (a > -EPSILON && a < EPSILON)
-            return null;
-        const f = 1 / a;
-        const sx = ox - v0x;
-        const sy = oy - v0y;
-        const sz = oz - v0z;
-        const u = f * (sx * hx + sy * hy + sz * hz);
-        if (u < 0 || u > 1)
-            return null;
-        const qx = sy * e1z - sz * e1y;
-        const qy = sz * e1x - sx * e1z;
-        const qz = sx * e1y - sy * e1x;
-        const v = f * (dx * qx + dy * qy + dz * qz);
-        if (v < 0 || u + v > 1)
-            return null;
-        const t = f * (e2x * qx + e2y * qy + e2z * qz);
-        return t > EPSILON ? t : null;
-    }
-    static triangleNormal(ax, ay, az, bx, by, bz, cx, cy, cz) {
-        const e1x = bx - ax;
-        const e1y = by - ay;
-        const e1z = bz - az;
-        const e2x = cx - ax;
-        const e2y = cy - ay;
-        const e2z = cz - az;
-        const nx = e1y * e2z - e1z * e2y;
-        const ny = e1z * e2x - e1x * e2z;
-        const nz = e1x * e2y - e1y * e2x;
-        const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
-        if (len < 1e-12)
+        ensureInit();
+        const r = wasm.mesh_find_face_group_by_normal(this._vertexCount, this._buffer, targetNormal.x, targetNormal.y, targetNormal.z, nearPoint?.x ?? 0, nearPoint?.y ?? 0, nearPoint?.z ?? 0, nearPoint !== undefined);
+        if (!r || r.length < 6)
             return null;
-        return new Vec3(nx / len, ny / len, nz / len);
-    }
-    static edgeKey(a, b) {
-        return a < b ? `${a}:${b}` : `${b}:${a}`;
+        return {
+            centroid: new Point(r[0], r[1], r[2]),
+            normal: new Vec3(r[3], r[4], r[5]),
+        };
     }
     // ── Export ──────────────────────────────────────────────────────
     /**