okgeometry-api 0.5.8 → 1.0.0

package/dist/wasm-base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,spwoCAAspwoC,CAAC"}
+{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,028yDAA028yD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "0.5.8",
+  "version": "1.0.0",
   "description": "Geometry engine API for AEC applications — NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",
@@ -20,10 +20,13 @@
     "inline-wasm": "tsx scripts/inline-wasm.ts",
     "build": "npm run inline-wasm && tsc",
     "bench:boolean-manifold-baseline": "npm run build && tsx scripts/bench-boolean-manifold-baseline.ts",
-    "bench:boolean-nextgen-heavy": "npm run build && tsx scripts/bench-boolean-nextgen-heavy.ts",
-    "bench:boolean-nextgen": "npm run build && tsx scripts/gate-boolean-nextgen.ts",
-    "gate:boolean-nextgen": "npm run build && tsx scripts/gate-boolean-nextgen.ts",
-    "gate:boolean-nextgen-vs-manifold": "npm run bench:boolean-manifold-baseline && npm run gate:boolean-nextgen",
+    "bench:boolean-replacement-heavy": "npm run build && tsx scripts/bench-boolean-replacement-heavy.ts",
+    "bench:boolean-deterministic": "npm run build && tsx scripts/bench-boolean-deterministic.ts",
+    "bench:boolean-ab": "npm run build && tsx scripts/bench-boolean-ab.ts",
+    "bench:subtraction-bunny-parity": "npm run build && tsx scripts/bench-subtraction-bunny-parity.ts",
+    "bench:boolean-replacement": "npm run build && tsx scripts/gate-boolean-replacement.ts",
+    "gate:boolean-replacement": "npm run build && tsx scripts/gate-boolean-replacement.ts",
+    "gate:boolean-replacement-vs-manifold": "npm run bench:boolean-manifold-baseline && npm run gate:boolean-replacement",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -40,7 +43,7 @@
   "license": "Proprietary License",
   "repository": {
     "type": "git",
-    "url": "https://github.com/moel-ai/okgeometrycore"
+    "url": "https://www.orkestra.online"
   },
   "devDependencies": {
     "manifold-3d": "^3.3.2",

package/src/Mesh.ts

@@ -18,21 +18,20 @@ import {
   runMeshBooleanInWorkerPool,
 } from "./mesh-boolean.pool.js";
 import { MeshBooleanExecutionError } from "./mesh-boolean.protocol.js";
-import type {
-  MeshBooleanAsyncOptions,
-  MeshBooleanBackend,
-  MeshBooleanLimits,
-  MeshBooleanOptions,
-} from "./mesh-boolean.protocol.js";
-import * as wasm from "../wasm/okgeometrycore_bg.js";
+import type {
+  MeshBooleanAsyncOptions,
+  MeshBooleanLimits,
+  MeshBooleanOptions,
+} from "./mesh-boolean.protocol.js";
+import * as wasm from "../wasm/okgeometrycore_bg.js";
+import { mesh_topology_metrics } from "../wasm/okgeometrycore.js";
 
 export { MeshBooleanExecutionError };
-export type {
-  MeshBooleanAsyncOptions,
-  MeshBooleanBackend,
-  MeshBooleanLimits,
-  MeshBooleanOptions,
-  MeshBooleanErrorCode,
+export type {
+  MeshBooleanAsyncOptions,
+  MeshBooleanLimits,
+  MeshBooleanOptions,
+  MeshBooleanErrorCode,
   MeshBooleanErrorPayload,
   MeshBooleanProgressEvent,
 } from "./mesh-boolean.protocol.js";
@@ -72,27 +71,33 @@ interface RawMeshBounds {
  *
  * Buffer format: [vertexCount, x1,y1,z1, ..., i1,i2,i3, ...]
  */
-export class Mesh {
-  private _buffer: Float64Array;
-  private _vertexCount: number;
-
-  private static readonly DEFAULT_BOOLEAN_LIMITS: MeshBooleanLimits = {
-    maxInputFacesPerMesh: 120_000,
-    maxCombinedInputFaces: 180_000,
-    maxFaceProduct: 500_000_000,
-  };
-
-  // Lazy caches
-  private _positionBuffer: Float32Array | null = null;
-  private _indexBuffer: Uint32Array | null = null;
-  private _vertices: Point[] | null = null;
-  private _faces: number[][] | null = null;
-  private _edgeVertexPairs: Array<[number, number]> | null = null;
-
-  private constructor(buffer: Float64Array) {
-    this._buffer = buffer;
-    this._vertexCount = buffer.length > 0 ? buffer[0] : 0;
-  }
+export class Mesh {
+  private _buffer: Float64Array;
+  private _vertexCount: number;
+  private _trustedBooleanInput: boolean;
+
+  private static readonly DEFAULT_BOOLEAN_LIMITS: MeshBooleanLimits = {
+    maxInputFacesPerMesh: 120_000,
+    maxCombinedInputFaces: 180_000,
+    maxFaceProduct: 500_000_000,
+  };
+  private static readonly TOPOLOGY_METRICS_CACHE_FACE_THRESHOLD = 20_000;
+
+  // Lazy caches
+  private _positionBuffer: Float32Array | null = null;
+  private _indexBuffer: Uint32Array | null = null;
+  private _vertices: Point[] | null = null;
+  private _faces: number[][] | null = null;
+  private _edgeVertexPairs: Array<[number, number]> | null = null;
+  private _topologyMetricsCache: { boundaryEdges: number; nonManifoldEdges: number } | null = null;
+  private _isClosedVolumeCache: boolean | null = null;
+  private _rawBoundsCache: RawMeshBounds | null | undefined = undefined;
+
+  private constructor(buffer: Float64Array, trustedBooleanInput = false) {
+    this._buffer = buffer;
+    this._vertexCount = buffer.length > 0 ? buffer[0] : 0;
+    this._trustedBooleanInput = trustedBooleanInput;
+  }
 
   /**
    * Configure default size for the shared boolean worker pool.
@@ -119,10 +124,14 @@ export class Mesh {
     };
   }
 
-  private static computeRawBounds(mesh: Mesh): RawMeshBounds | null {
-    if (mesh._vertexCount <= 0) return null;
-
-    const data = mesh._buffer;
+  private static computeRawBounds(mesh: Mesh): RawMeshBounds | null {
+    if (mesh._rawBoundsCache !== undefined) return mesh._rawBoundsCache;
+    if (mesh._vertexCount <= 0) {
+      mesh._rawBoundsCache = null;
+      return null;
+    }
+
+    const data = mesh._buffer;
     const limit = 1 + mesh._vertexCount * 3;
 
     let minX = data[1];
@@ -144,8 +153,10 @@ export class Mesh {
       if (z > maxZ) maxZ = z;
     }
 
-    return { minX, minY, minZ, maxX, maxY, maxZ };
-  }
+    const bounds = { minX, minY, minZ, maxX, maxY, maxZ };
+    mesh._rawBoundsCache = bounds;
+    return bounds;
+  }
 
   private static boundsOverlap(a: RawMeshBounds | null, b: RawMeshBounds | null, eps = 1e-9): boolean {
     if (!a || !b) return false;
@@ -171,13 +182,15 @@ export class Mesh {
     return Math.min(1e-4, Math.max(1e-9, scale * 1e-6));
   }
 
-  private static cloneMesh(mesh: Mesh): Mesh {
-    return Mesh.fromBuffer(new Float64Array(mesh._buffer));
-  }
-
-  private static emptyMesh(): Mesh {
-    return Mesh.fromBuffer(new Float64Array(0));
-  }
+  private static cloneMesh(mesh: Mesh): Mesh {
+    return Mesh.fromBuffer(new Float64Array(mesh._buffer), {
+      trustedBooleanInput: mesh._trustedBooleanInput,
+    });
+  }
+
+  private static emptyMesh(): Mesh {
+    return Mesh.fromTrustedBuffer(new Float64Array(0));
+  }
 
   // ── GPU-ready buffers ──────────────────────────────────────────
 
@@ -217,10 +230,12 @@ export class Mesh {
     return this._vertexCount;
   }
 
-  /** Number of triangular faces in this mesh */
-  get faceCount(): number {
-    return this.indexBuffer.length / 3;
-  }
+  /** Number of triangular faces in this mesh */
+  get faceCount(): number {
+    const start = 1 + this._vertexCount * 3;
+    if (this._buffer.length <= start) return 0;
+    return Math.floor((this._buffer.length - start) / 3);
+  }
 
   // ── High-level accessors (lazy) ────────────────────────────────
 
@@ -269,9 +284,20 @@ export class Mesh {
    * @param buffer - Float64Array in mesh buffer format
    * @returns New Mesh instance
    */
-  static fromBuffer(buffer: Float64Array): Mesh {
-    return new Mesh(buffer);
-  }
+  static fromBuffer(
+    buffer: Float64Array,
+    options?: { trustedBooleanInput?: boolean },
+  ): Mesh {
+    return new Mesh(buffer, options?.trustedBooleanInput ?? false);
+  }
+
+  private static fromTrustedBuffer(buffer: Float64Array): Mesh {
+    return new Mesh(buffer, true);
+  }
+
+  get trustedBooleanInput(): boolean {
+    return this._trustedBooleanInput;
+  }
 
   /**
    * Build an axis-aligned rectangle on a plane basis from opposite corners.
@@ -554,11 +580,11 @@ export class Mesh {
    * @param pts - Ordered boundary points defining a closed polygon (minimum 3)
    * @returns New Mesh triangulating the polygon interior
    */
-  static patchFromPoints(pts: Point[]): Mesh {
-    ensureInit();
-    const coords = pointsToCoords(pts);
-    const buf = wasm.mesh_patch_from_points(coords);
-    return new Mesh(buf);
+  static patchFromPoints(pts: Point[]): Mesh {
+    ensureInit();
+    const coords = pointsToCoords(pts);
+    const buf = wasm.mesh_patch_from_points(coords);
+    return Mesh.fromTrustedBuffer(buf);
   }
 
   /**
@@ -570,7 +596,7 @@ export class Mesh {
    */
   static createBox(width: number, height: number, depth: number): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_create_box(width, height, depth));
+    return Mesh.fromTrustedBuffer(wasm.mesh_create_box(width, height, depth));
   }
 
   /**
@@ -582,7 +608,7 @@ export class Mesh {
    */
   static createSphere(radius: number, segments: number, rings: number): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_create_sphere(radius, segments, rings));
+    return Mesh.fromTrustedBuffer(wasm.mesh_create_sphere(radius, segments, rings));
   }
 
   /**
@@ -594,7 +620,7 @@ export class Mesh {
    */
   static createCylinder(radius: number, height: number, segments: number): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_create_cylinder(radius, height, segments));
+    return Mesh.fromTrustedBuffer(wasm.mesh_create_cylinder(radius, height, segments));
   }
 
   /**
@@ -606,7 +632,7 @@ export class Mesh {
    */
   static createPrism(radius: number, height: number, sides: number): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_create_prism(radius, height, sides));
+    return Mesh.fromTrustedBuffer(wasm.mesh_create_prism(radius, height, sides));
   }
 
   /**
@@ -618,7 +644,7 @@ export class Mesh {
    */
   static createCone(radius: number, height: number, segments: number): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_create_cone(radius, height, segments));
+    return Mesh.fromTrustedBuffer(wasm.mesh_create_cone(radius, height, segments));
   }
 
   /**
@@ -628,7 +654,7 @@ export class Mesh {
    */
   static fromOBJ(objString: string): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_import_obj(objString));
+    return Mesh.fromTrustedBuffer(wasm.mesh_import_obj(objString));
   }
 
   /**
@@ -656,7 +682,7 @@ export class Mesh {
       data[off + 5] = c.normal?.z ?? 0;
       data[off + 6] = c.radius;
     }
-    return new Mesh(wasm.loft_circles(data, segments, caps));
+    return Mesh.fromTrustedBuffer(wasm.loft_circles(data, segments, caps));
   }
 
   /**
@@ -676,7 +702,7 @@ export class Mesh {
         parts.push(p.x, p.y, p.z);
       }
     }
-    return new Mesh(wasm.loft_polylines(new Float64Array(parts), segments, caps));
+    return Mesh.fromTrustedBuffer(wasm.loft_polylines(new Float64Array(parts), segments, caps));
   }
 
   /**
@@ -688,7 +714,7 @@ export class Mesh {
    */
   static sweep(profilePoints: Point[], pathPoints: Point[], caps = false): Mesh {
     ensureInit();
-    return new Mesh(wasm.sweep_polylines(pointsToCoords(profilePoints), pointsToCoords(pathPoints), caps));
+    return Mesh.fromTrustedBuffer(wasm.sweep_polylines(pointsToCoords(profilePoints), pointsToCoords(pathPoints), caps));
   }
 
   /**
@@ -713,7 +739,7 @@ export class Mesh {
       height,
       closed,
     );
-    return Mesh.fromBuffer(buf);
+    return Mesh.fromTrustedBuffer(buf);
   }
 
   /**
@@ -758,7 +784,7 @@ export class Mesh {
     ensureInit();
     const profileData = Mesh.encodeCurve(profile);
     const pathData = Mesh.encodeCurve(path);
-    return new Mesh(wasm.sweep_curves(profileData, pathData, segments, segments, caps));
+    return Mesh.fromTrustedBuffer(wasm.sweep_curves(profileData, pathData, segments, segments, caps));
   }
 
   /** Encode a curve into the WASM format for sweep_curves. */
@@ -836,7 +862,7 @@ export class Mesh {
   private static mergeMeshes(meshes: Mesh[]): Mesh {
     ensureInit();
     const packed = Mesh.packMeshes(meshes);
-    return Mesh.fromBuffer(wasm.mesh_merge(packed));
+    return Mesh.fromTrustedBuffer(wasm.mesh_merge(packed));
   }
 
   /**
@@ -928,7 +954,7 @@ export class Mesh {
    */
   translate(offset: Vec3): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_translate(this._vertexCount, this._buffer, offset.x, offset.y, offset.z));
+    return Mesh.fromTrustedBuffer(wasm.mesh_translate(this._vertexCount, this._buffer, offset.x, offset.y, offset.z));
   }
 
   /**
@@ -946,7 +972,7 @@ export class Mesh {
         .rotate(dir, angleRadians)
         .translate(new Vec3(c.x, c.y, c.z));
     }
-    return new Mesh(wasm.mesh_rotate(this._vertexCount, this._buffer, axis.x, axis.y, axis.z, angleRadians));
+    return Mesh.fromTrustedBuffer(wasm.mesh_rotate(this._vertexCount, this._buffer, axis.x, axis.y, axis.z, angleRadians));
   }
 
   /**
@@ -956,7 +982,7 @@ export class Mesh {
    */
   scale(factor: number): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_scale(this._vertexCount, this._buffer, factor, factor, factor));
+    return Mesh.fromTrustedBuffer(wasm.mesh_scale(this._vertexCount, this._buffer, factor, factor, factor));
   }
 
   /**
@@ -968,7 +994,7 @@ export class Mesh {
    */
   scaleXYZ(sx: number, sy: number, sz: number): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_scale(this._vertexCount, this._buffer, sx, sy, sz));
+    return Mesh.fromTrustedBuffer(wasm.mesh_scale(this._vertexCount, this._buffer, sx, sy, sz));
   }
 
   private runBoolean(
@@ -1025,15 +1051,24 @@ export class Mesh {
     if (!Number.isFinite(vertexCount) || vertexCount < 0) {
       throw new Error(`Boolean ${operation} failed and returned a corrupt mesh buffer.`);
     }
-    return Mesh.fromBuffer(result);
-  }
-
-  private static encodeBooleanOperationWithBackend(
-    operation: "union" | "subtraction" | "intersection",
-    _backend: MeshBooleanBackend | undefined,
-  ): string {
-    return `${operation}@nextgen`;
-  }
+    return Mesh.fromTrustedBuffer(result);
+  }
+
+  static encodeBooleanOperationToken(
+    operation: "union" | "subtraction" | "intersection",
+    a: Mesh,
+    b: Mesh,
+    options?: MeshBooleanOptions,
+  ): string {
+    const tokens: string[] = [operation];
+    if (a._trustedBooleanInput && b._trustedBooleanInput) {
+      tokens.push("trustedInput");
+    }
+    if (options?.debugForceFaceID) {
+      tokens.push("forceFaceID");
+    }
+    return tokens.join("@");
+  }
 
   // ── Booleans ───────────────────────────────────────────────────
 
@@ -1043,9 +1078,9 @@ export class Mesh {
    * @param options - Optional safety overrides
    * @returns New mesh containing volume of both inputs
    */
-  union(other: Mesh, options?: MeshBooleanOptions): Mesh {
-    ensureInit();
-    const operationToken = Mesh.encodeBooleanOperationWithBackend("union", options?.backend);
+  union(other: Mesh, options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const operationToken = Mesh.encodeBooleanOperationToken("union", this, other, options);
     return this.runBoolean(
       other,
       "union",
@@ -1066,9 +1101,9 @@ export class Mesh {
    * @param options - Optional safety overrides
    * @returns New mesh with other's volume removed from this
    */
-  subtract(other: Mesh, options?: MeshBooleanOptions): Mesh {
-    ensureInit();
-    const operationToken = Mesh.encodeBooleanOperationWithBackend("subtraction", options?.backend);
+  subtract(other: Mesh, options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const operationToken = Mesh.encodeBooleanOperationToken("subtraction", this, other, options);
     return this.runBoolean(
       other,
       "subtraction",
@@ -1089,9 +1124,9 @@ export class Mesh {
    * @param options - Optional safety overrides
    * @returns New mesh containing only the overlapping volume
    */
-  intersect(other: Mesh, options?: MeshBooleanOptions): Mesh {
-    ensureInit();
-    const operationToken = Mesh.encodeBooleanOperationWithBackend("intersection", options?.backend);
+  intersect(other: Mesh, options?: MeshBooleanOptions): Mesh {
+    ensureInit();
+    const operationToken = Mesh.encodeBooleanOperationToken("intersection", this, other, options);
     return this.runBoolean(
       other,
       "intersection",
@@ -1111,8 +1146,15 @@ export class Mesh {
    * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
    */
   async unionAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
-    const result = await runMeshBooleanInWorkerPool("union", this._buffer, other._buffer, options);
-    return Mesh.fromBuffer(result);
+    const result = await runMeshBooleanInWorkerPool(
+      "union",
+      this._buffer,
+      other._buffer,
+      this._trustedBooleanInput,
+      other._trustedBooleanInput,
+      options,
+    );
+    return Mesh.fromTrustedBuffer(result);
   }
 
   /**
@@ -1120,8 +1162,15 @@ export class Mesh {
    * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
    */
   async subtractAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
-    const result = await runMeshBooleanInWorkerPool("subtraction", this._buffer, other._buffer, options);
-    return Mesh.fromBuffer(result);
+    const result = await runMeshBooleanInWorkerPool(
+      "subtraction",
+      this._buffer,
+      other._buffer,
+      this._trustedBooleanInput,
+      other._trustedBooleanInput,
+      options,
+    );
+    return Mesh.fromTrustedBuffer(result);
   }
 
   /**
@@ -1129,8 +1178,15 @@ export class Mesh {
    * Defaults to allowUnsafe=true so high-poly jobs can run off the UI thread.
    */
   async intersectAsync(other: Mesh, options?: MeshBooleanAsyncOptions): Promise<Mesh> {
-    const result = await runMeshBooleanInWorkerPool("intersection", this._buffer, other._buffer, options);
-    return Mesh.fromBuffer(result);
+    const result = await runMeshBooleanInWorkerPool(
+      "intersection",
+      this._buffer,
+      other._buffer,
+      this._trustedBooleanInput,
+      other._trustedBooleanInput,
+      options,
+    );
+    return Mesh.fromTrustedBuffer(result);
   }
 
   // ── Intersection queries ───────────────────────────────────────
@@ -1176,7 +1232,7 @@ export class Mesh {
    */
   applyMatrix(matrix: number[]): Mesh {
     ensureInit();
-    return new Mesh(wasm.mesh_apply_matrix(this._vertexCount, this._buffer, new Float64Array(matrix)));
+    return Mesh.fromTrustedBuffer(wasm.mesh_apply_matrix(this._vertexCount, this._buffer, new Float64Array(matrix)));
   }
 
   /**
@@ -1408,21 +1464,68 @@ export class Mesh {
   extrudeFace(faceIndex: number, distance: number): Mesh {
     ensureInit();
     if (!Number.isFinite(faceIndex) || faceIndex < 0) {
-      return Mesh.fromBuffer(new Float64Array(this._buffer));
-    }
-    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 welded topological boundary edges are found.
-   */
-  isClosedVolume(): boolean {
-    ensureInit();
-    return wasm.mesh_is_closed_volume(this._vertexCount, this._buffer);
-  }
+      return Mesh.fromBuffer(new Float64Array(this._buffer), {
+        trustedBooleanInput: this._trustedBooleanInput,
+      });
+    }
+    return Mesh.fromTrustedBuffer(
+      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 welded topological boundary edges are found.
+   */
+  isClosedVolume(): boolean {
+    if (this._isClosedVolumeCache !== null) {
+      return this._isClosedVolumeCache;
+    }
+    if (this._topologyMetricsCache) {
+      const closedFromMetrics = this._topologyMetricsCache.boundaryEdges === 0;
+      this._isClosedVolumeCache = closedFromMetrics;
+      return closedFromMetrics;
+    }
+
+    ensureInit();
+    if (this.faceCount >= Mesh.TOPOLOGY_METRICS_CACHE_FACE_THRESHOLD) {
+      const metrics = this.topologyMetrics();
+      const closedFromMetrics = metrics.boundaryEdges === 0;
+      this._isClosedVolumeCache = closedFromMetrics;
+      return closedFromMetrics;
+    }
+
+    const closed = wasm.mesh_is_closed_volume(this._vertexCount, this._buffer);
+    this._isClosedVolumeCache = closed;
+    return closed;
+  }
+
+  /**
+   * Return welded-edge topology metrics for this triangulated mesh.
+   * `boundaryEdges`: edges referenced by exactly one triangle.
+   * `nonManifoldEdges`: edges referenced by more than two triangles.
+   */
+  topologyMetrics(): { boundaryEdges: number; nonManifoldEdges: number } {
+    if (this._topologyMetricsCache) {
+      return {
+        boundaryEdges: this._topologyMetricsCache.boundaryEdges,
+        nonManifoldEdges: this._topologyMetricsCache.nonManifoldEdges,
+      };
+    }
+
+    ensureInit();
+    const metrics = 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 };
+    if (this._isClosedVolumeCache === null) {
+      this._isClosedVolumeCache = boundaryEdges === 0;
+    }
+    return {
+      boundaryEdges,
+      nonManifoldEdges,
+    };
+  }
 
   /**
    * Odd/even point containment test against a closed mesh.
@@ -1489,3 +1592,4 @@ export class Mesh {
 
 
 
+