@ifc-lite/wasm 4.0.1 → 4.1.0

package/package.json

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",

package/pkg/ifc-lite.d.ts

@@ -610,6 +610,24 @@ export class IfcAPI {
    * cap. The produced meshes are dropped; only the diagnostics are returned.
    */
   diagnoseGeometry(content: Uint8Array): any;
+  /**
+   * Simplify already-produced element meshes at per-element demesher
+   * levels (1-4 = cavity removal + clustering at 0.5/0.25/0.10/0.03
+   * triangle ratio, 5 = bounding box).
+   *
+   * One RECORD per input `MeshData` entry (an element may span several
+   * records — per-material submeshes; pass all of them, grouped or not).
+   * Per record `i`: `vertexCounts[i]` vertices from `positions` (and
+   * `normals` when non-empty), `indexCounts[i]` indices from `indices`
+   * (per-record local), `origins[i*3..]`, `localToWorld[i*16..]` valid
+   * only when `localToWorldPresent[i] != 0`, level `levels[i]` (records
+   * of one element must agree). Arrays are the boundary Y-up convention
+   * when `yUp` is true (the browser/SDK case).
+   *
+   * `rtcX/Y/Z` = `coordinateInfo.originShift` (IFC Z-up metres);
+   * `unitScale` = metres per project length unit.
+   */
+  simplifyMeshes(express_ids: Uint32Array, levels: Uint8Array, positions: Float32Array, normals: Float32Array, indices: Uint32Array, vertex_counts: Uint32Array, index_counts: Uint32Array, origins: Float64Array, local_to_world: Float64Array, local_to_world_present: Uint8Array, rtc_x: number, rtc_y: number, rtc_z: number, unit_scale: number, y_up: boolean): SimplifiedMeshes;
   /**
    * Parse IFC file and extract symbolic representations (Plan,
    * Annotation, FootPrint, Axis). These are 2D curves used for
@@ -723,10 +741,21 @@ export class MeshDataJs {
    * Get express ID
    */
   readonly expressId: number;
+  /**
+   * Stable texture dedup key (`IfcSurfaceTexture` express id, #1781).
+   * 0 when the mesh is untextured.
+   */
+  readonly textureId: number;
   /**
    * True when this mesh carries a surface texture (#961).
    */
   readonly hasTexture: boolean;
+  /**
+   * External image reference (`IfcImageTexture.URLReference`, #1781) for the
+   * host to resolve — e.g. a sibling image inside the `.ifcZIP`. `undefined`
+   * for untextured meshes and Rust-decoded blob/pixel textures.
+   */
+  readonly textureUrl: string | undefined;
   /**
    * Local (pre-placement, object-space) AABB (issue #1474), WebGL Y-up,
    * `[minX,minY,minZ,maxX,maxY,maxZ]`. `undefined` when not captured
@@ -908,6 +937,35 @@ export class ProfileEntryJs {
   readonly transform: Float32Array;
 }
 
+export class SimplifiedMeshes {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly trisAfter: Uint32Array;
+  readonly elementIds: Uint32Array;
+  readonly skippedIds: Uint32Array;
+  readonly trisBefore: Uint32Array;
+  readonly indexCounts: Uint32Array;
+  readonly localIndices: Uint32Array;
+  readonly vertexCounts: Uint32Array;
+  readonly renderIndices: Uint32Array;
+  readonly renderNormals: Float32Array;
+  /**
+   * xyz per element (frame matches the render positions' convention).
+   */
+  readonly renderOrigins: Float64Array;
+  readonly localPositions: Float64Array;
+  /**
+   * Skip reason per `skippedIds` entry (stable slugs:
+   * `no-geometry` / `missing-placement` / `singular-placement` /
+   * `empty-result` / `invalid-unit-scale`).
+   */
+  readonly skippedReasons: any[];
+  readonly cavitiesDropped: Uint32Array;
+  readonly renderPositions: Float32Array;
+  readonly levels: Uint8Array;
+}
+
 export class SpacePlateHandle {
   free(): void;
   [Symbol.dispose](): void;
@@ -1269,6 +1327,7 @@ export interface InitOutput {
   readonly __wbg_partitionedbatch_free: (a: number, b: number) => void;
   readonly __wbg_profilecollection_free: (a: number, b: number) => void;
   readonly __wbg_profileentryjs_free: (a: number, b: number) => void;
+  readonly __wbg_simplifiedmeshes_free: (a: number, b: number) => void;
   readonly __wbg_spaceplatehandle_free: (a: number, b: number) => void;
   readonly __wbg_symboliccircle_free: (a: number, b: number) => void;
   readonly __wbg_symbolicfillarea_free: (a: number, b: number) => void;
@@ -1340,6 +1399,7 @@ export interface InitOutput {
   readonly ifcapi_setSkipSmallCuts: (a: number, b: number) => void;
   readonly ifcapi_setSourceBytes: (a: number, b: number, c: number) => void;
   readonly ifcapi_setTessellationQuality: (a: number, b: number, c: number, d: number) => void;
+  readonly ifcapi_simplifyMeshes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number) => void;
   readonly ifcapi_version: (a: number, b: number) => void;
   readonly meshOutline2d: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
   readonly meshcollection_buildingRotation: (a: number, b: number) => void;
@@ -1369,9 +1429,11 @@ export interface InitOutput {
   readonly meshdatajs_positions: (a: number) => number;
   readonly meshdatajs_shadingColor: (a: number, b: number) => void;
   readonly meshdatajs_textureHeight: (a: number) => number;
+  readonly meshdatajs_textureId: (a: number) => number;
   readonly meshdatajs_textureRepeatS: (a: number) => number;
   readonly meshdatajs_textureRepeatT: (a: number) => number;
   readonly meshdatajs_textureRgba: (a: number) => number;
+  readonly meshdatajs_textureUrl: (a: number, b: number) => void;
   readonly meshdatajs_textureWidth: (a: number) => number;
   readonly meshdatajs_triangleCount: (a: number) => number;
   readonly meshdatajs_uvs: (a: number) => number;
@@ -1394,6 +1456,21 @@ export interface InitOutput {
   readonly profileentryjs_modelIndex: (a: number) => number;
   readonly profileentryjs_outerPoints: (a: number) => number;
   readonly profileentryjs_transform: (a: number) => number;
+  readonly simplifiedmeshes_cavitiesDropped: (a: number, b: number) => void;
+  readonly simplifiedmeshes_elementIds: (a: number, b: number) => void;
+  readonly simplifiedmeshes_indexCounts: (a: number, b: number) => void;
+  readonly simplifiedmeshes_levels: (a: number, b: number) => void;
+  readonly simplifiedmeshes_localIndices: (a: number, b: number) => void;
+  readonly simplifiedmeshes_localPositions: (a: number, b: number) => void;
+  readonly simplifiedmeshes_renderIndices: (a: number, b: number) => void;
+  readonly simplifiedmeshes_renderNormals: (a: number, b: number) => void;
+  readonly simplifiedmeshes_renderOrigins: (a: number, b: number) => void;
+  readonly simplifiedmeshes_renderPositions: (a: number, b: number) => void;
+  readonly simplifiedmeshes_skippedIds: (a: number, b: number) => void;
+  readonly simplifiedmeshes_skippedReasons: (a: number, b: number) => void;
+  readonly simplifiedmeshes_trisAfter: (a: number, b: number) => void;
+  readonly simplifiedmeshes_trisBefore: (a: number, b: number) => void;
+  readonly simplifiedmeshes_vertexCounts: (a: number, b: number) => void;
   readonly spaceplatehandle_addFace: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly spaceplatehandle_boundingElements: (a: number, b: number, c: number) => void;
   readonly spaceplatehandle_dissolveVertex: (a: number, b: number, c: number) => void;

package/pkg/ifc-lite.js

@@ -31,6 +31,16 @@ function getArrayF64FromWasm0(ptr, len) {
     return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+
 function getArrayU32FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
@@ -274,6 +284,10 @@ const ProfileEntryJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_profileentryjs_free(ptr >>> 0, 1));
 
+const SimplifiedMeshesFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_simplifiedmeshes_free(ptr >>> 0, 1));
+
 const SpacePlateHandleFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_spaceplatehandle_free(ptr >>> 0, 1));
@@ -2007,6 +2021,74 @@ export class IfcAPI {
         const ret = wasm.ifcapi_diagnoseGeometry(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+     * Simplify already-produced element meshes at per-element demesher
+     * levels (1-4 = cavity removal + clustering at 0.5/0.25/0.10/0.03
+     * triangle ratio, 5 = bounding box).
+     *
+     * One RECORD per input `MeshData` entry (an element may span several
+     * records — per-material submeshes; pass all of them, grouped or not).
+     * Per record `i`: `vertexCounts[i]` vertices from `positions` (and
+     * `normals` when non-empty), `indexCounts[i]` indices from `indices`
+     * (per-record local), `origins[i*3..]`, `localToWorld[i*16..]` valid
+     * only when `localToWorldPresent[i] != 0`, level `levels[i]` (records
+     * of one element must agree). Arrays are the boundary Y-up convention
+     * when `yUp` is true (the browser/SDK case).
+     *
+     * `rtcX/Y/Z` = `coordinateInfo.originShift` (IFC Z-up metres);
+     * `unitScale` = metres per project length unit.
+     * @param {Uint32Array} express_ids
+     * @param {Uint8Array} levels
+     * @param {Float32Array} positions
+     * @param {Float32Array} normals
+     * @param {Uint32Array} indices
+     * @param {Uint32Array} vertex_counts
+     * @param {Uint32Array} index_counts
+     * @param {Float64Array} origins
+     * @param {Float64Array} local_to_world
+     * @param {Uint8Array} local_to_world_present
+     * @param {number} rtc_x
+     * @param {number} rtc_y
+     * @param {number} rtc_z
+     * @param {number} unit_scale
+     * @param {boolean} y_up
+     * @returns {SimplifiedMeshes}
+     */
+    simplifyMeshes(express_ids, levels, positions, normals, indices, vertex_counts, index_counts, origins, local_to_world, local_to_world_present, rtc_x, rtc_y, rtc_z, unit_scale, y_up) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray32ToWasm0(express_ids, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray8ToWasm0(levels, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF32ToWasm0(positions, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF32ToWasm0(normals, wasm.__wbindgen_export);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArray32ToWasm0(indices, wasm.__wbindgen_export);
+            const len4 = WASM_VECTOR_LEN;
+            const ptr5 = passArray32ToWasm0(vertex_counts, wasm.__wbindgen_export);
+            const len5 = WASM_VECTOR_LEN;
+            const ptr6 = passArray32ToWasm0(index_counts, wasm.__wbindgen_export);
+            const len6 = WASM_VECTOR_LEN;
+            const ptr7 = passArrayF64ToWasm0(origins, wasm.__wbindgen_export);
+            const len7 = WASM_VECTOR_LEN;
+            const ptr8 = passArrayF64ToWasm0(local_to_world, wasm.__wbindgen_export);
+            const len8 = WASM_VECTOR_LEN;
+            const ptr9 = passArray8ToWasm0(local_to_world_present, wasm.__wbindgen_export);
+            const len9 = WASM_VECTOR_LEN;
+            wasm.ifcapi_simplifyMeshes(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, rtc_x, rtc_y, rtc_z, unit_scale, y_up);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return SimplifiedMeshes.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Parse IFC file and extract symbolic representations (Plan,
      * Annotation, FootPrint, Axis). These are 2D curves used for
@@ -2224,6 +2306,15 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_expressId(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Stable texture dedup key (`IfcSurfaceTexture` express id, #1781).
+     * 0 when the mesh is untextured.
+     * @returns {number}
+     */
+    get textureId() {
+        const ret = wasm.meshdatajs_textureId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * True when this mesh carries a surface texture (#961).
      * @returns {boolean}
@@ -2232,6 +2323,28 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_hasTexture(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * External image reference (`IfcImageTexture.URLReference`, #1781) for the
+     * host to resolve — e.g. a sibling image inside the `.ifcZIP`. `undefined`
+     * for untextured meshes and Rust-decoded blob/pixel textures.
+     * @returns {string | undefined}
+     */
+    get textureUrl() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshdatajs_textureUrl(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Local (pre-placement, object-space) AABB (issue #1474), WebGL Y-up,
      * `[minX,minY,minZ,maxX,maxY,maxZ]`. `undefined` when not captured
@@ -2725,6 +2838,280 @@ export class ProfileEntryJs {
 }
 if (Symbol.dispose) ProfileEntryJs.prototype[Symbol.dispose] = ProfileEntryJs.prototype.free;
 
+/**
+ * Flat result of `simplifyMeshes`: per surviving element `i`,
+ * `vertexCounts[i]` vertices and `indexCounts[i]` indices taken in order
+ * from the concatenated arrays (mirrors the `exportGlbFromMeshes` wire
+ * convention). `localPositions` is 1:1 with `renderPositions` (f64, file
+ * units, element object frame); `localIndices` is 1:1 with `renderIndices`
+ * but in the IFC frame's winding. Skipped elements are reported in
+ * `skippedIds` / `skippedReasons` and must keep their original geometry.
+ */
+export class SimplifiedMeshes {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SimplifiedMeshes.prototype);
+        obj.__wbg_ptr = ptr;
+        SimplifiedMeshesFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SimplifiedMeshesFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_simplifiedmeshes_free(ptr, 0);
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get trisAfter() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_trisAfter(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get elementIds() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_elementIds(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get skippedIds() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_skippedIds(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get trisBefore() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_trisBefore(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get indexCounts() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_indexCounts(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get localIndices() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_localIndices(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get vertexCounts() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_vertexCounts(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get renderIndices() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_renderIndices(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Float32Array}
+     */
+    get renderNormals() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_renderNormals(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * xyz per element (frame matches the render positions' convention).
+     * @returns {Float64Array}
+     */
+    get renderOrigins() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_renderOrigins(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get localPositions() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_localPositions(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Skip reason per `skippedIds` entry (stable slugs:
+     * `no-geometry` / `missing-placement` / `singular-placement` /
+     * `empty-result` / `invalid-unit-scale`).
+     * @returns {any[]}
+     */
+    get skippedReasons() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_skippedReasons(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    get cavitiesDropped() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_cavitiesDropped(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Float32Array}
+     */
+    get renderPositions() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_renderPositions(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF32FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    get levels() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.simplifiedmeshes_levels(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) SimplifiedMeshes.prototype[Symbol.dispose] = SimplifiedMeshes.prototype.free;
+
 /**
  * A persistent, editable floor-plate topology. See the module docs.
  */