@ifc-lite/wasm 1.14.2 → 1.14.3

package/pkg/ifc-lite.js

@@ -1,157 +1,321 @@
-/* @ts-self-types="./ifc-lite.d.ts" */
+let wasm;
 
-/**
- * Georeferencing information exposed to JavaScript
- */
-export class GeoReferenceJs {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(GeoReferenceJs.prototype);
-        obj.__wbg_ptr = ptr;
-        GeoReferenceJsFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
     }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GeoReferenceJsFinalization.unregister(this);
-        return ptr;
+    return cachedDataViewMemory0;
+}
+
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_georeferencejs_free(ptr, 0);
+    return cachedFloat32ArrayMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
     }
-    /**
-     * Get CRS name
-     * @returns {string | undefined}
-     */
-    get crsName() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.georeferencejs_crsName(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_export2(r0, r1 * 1, 1);
-            }
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
     }
-    /**
-     * Transform local coordinates to map coordinates
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @returns {Float64Array}
-     */
-    localToMap(x, y, z) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.georeferencejs_localToMap(retptr, this.__wbg_ptr, x, y, z);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayF64FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export2(r0, r1 * 8, 8);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
     }
-    /**
-     * Transform map coordinates to local coordinates
-     * @param {number} e
-     * @param {number} n
-     * @param {number} h
-     * @returns {Float64Array}
-     */
-    mapToLocal(e, n, h) {
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export(addHeapObject(e));
+    }
+}
+
+let heap = new Array(128).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
         try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.georeferencejs_mapToLocal(retptr, this.__wbg_ptr, e, n, h);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var v1 = getArrayF64FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export2(r0, r1 * 8, 8);
-            return v1;
+            return f(a, state.b, ...args);
         } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+            state.a = a;
+            real._wbg_cb_unref();
         }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
     }
-    /**
-     * Get rotation angle in radians
-     * @returns {number}
-     */
-    get rotation() {
-        const ret = wasm.georeferencejs_rotation(this.__wbg_ptr);
-        return ret;
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
     }
-    /**
-     * Get 4x4 transformation matrix (column-major for WebGL)
-     * @returns {Float64Array}
-     */
-    toMatrix() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.georeferencejs_toMatrix(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_export2(r0, r1 * 8, 8);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
         }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
     }
-    /**
-     * Eastings (X offset)
-     * @returns {number}
-     */
-    get eastings() {
-        const ret = wasm.__wbg_get_georeferencejs_eastings(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Northings (Y offset)
-     * @returns {number}
-     */
-    get northings() {
-        const ret = wasm.__wbg_get_georeferencejs_northings(this.__wbg_ptr);
-        return ret;
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
     }
-    /**
-     * Orthogonal height (Z offset)
-     * @returns {number}
-     */
-    get orthogonal_height() {
-        const ret = wasm.__wbg_get_georeferencejs_orthogonal_height(this.__wbg_ptr);
-        return ret;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
     }
-    /**
-     * Scale factor
-     * @returns {number}
-     */
-    get scale() {
-        const ret = wasm.__wbg_get_georeferencejs_scale(this.__wbg_ptr);
-        return ret;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+function __wasm_bindgen_func_elem_1021(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_1021(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_469(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_469(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_1052(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1052(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+const GeoReferenceJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_georeferencejs_free(ptr >>> 0, 1));
+
+const GpuGeometryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gpugeometry_free(ptr >>> 0, 1));
+
+const GpuInstancedGeometryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gpuinstancedgeometry_free(ptr >>> 0, 1));
+
+const GpuInstancedGeometryCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gpuinstancedgeometrycollection_free(ptr >>> 0, 1));
+
+const GpuInstancedGeometryRefFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gpuinstancedgeometryref_free(ptr >>> 0, 1));
+
+const GpuMeshMetadataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_gpumeshmetadata_free(ptr >>> 0, 1));
+
+const IfcAPIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ifcapi_free(ptr >>> 0, 1));
+
+const InstanceDataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_instancedata_free(ptr >>> 0, 1));
+
+const InstancedGeometryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_instancedgeometry_free(ptr >>> 0, 1));
+
+const InstancedMeshCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_instancedmeshcollection_free(ptr >>> 0, 1));
+
+const MeshCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshcollection_free(ptr >>> 0, 1));
+
+const MeshCollectionWithRtcFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshcollectionwithrtc_free(ptr >>> 0, 1));
+
+const MeshDataJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshdatajs_free(ptr >>> 0, 1));
+
+const RtcOffsetJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rtcoffsetjs_free(ptr >>> 0, 1));
+
+const SymbolicCircleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symboliccircle_free(ptr >>> 0, 1));
+
+const SymbolicPolylineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symbolicpolyline_free(ptr >>> 0, 1));
+
+const SymbolicRepresentationCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symbolicrepresentationcollection_free(ptr >>> 0, 1));
+
+const ZeroCopyMeshFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_zerocopymesh_free(ptr >>> 0, 1));
+
+/**
+ * Georeferencing information exposed to JavaScript
+ */
+export class GeoReferenceJs {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GeoReferenceJs.prototype);
+        obj.__wbg_ptr = ptr;
+        GeoReferenceJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
     }
-    /**
-     * X-axis abscissa (cos of rotation)
-     * @returns {number}
-     */
-    get x_axis_abscissa() {
-        const ret = wasm.__wbg_get_georeferencejs_x_axis_abscissa(this.__wbg_ptr);
-        return ret;
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GeoReferenceJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_georeferencejs_free(ptr, 0);
     }
     /**
-     * X-axis ordinate (sin of rotation)
+     * Eastings (X offset)
      * @returns {number}
      */
-    get x_axis_ordinate() {
-        const ret = wasm.__wbg_get_georeferencejs_x_axis_ordinate(this.__wbg_ptr);
+    get eastings() {
+        const ret = wasm.__wbg_get_georeferencejs_eastings(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -161,6 +325,14 @@ export class GeoReferenceJs {
     set eastings(arg0) {
         wasm.__wbg_set_georeferencejs_eastings(this.__wbg_ptr, arg0);
     }
+    /**
+     * Northings (Y offset)
+     * @returns {number}
+     */
+    get northings() {
+        const ret = wasm.__wbg_get_georeferencejs_northings(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Northings (Y offset)
      * @param {number} arg0
@@ -168,6 +340,14 @@ export class GeoReferenceJs {
     set northings(arg0) {
         wasm.__wbg_set_georeferencejs_northings(this.__wbg_ptr, arg0);
     }
+    /**
+     * Orthogonal height (Z offset)
+     * @returns {number}
+     */
+    get orthogonal_height() {
+        const ret = wasm.__wbg_get_georeferencejs_orthogonal_height(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * Orthogonal height (Z offset)
      * @param {number} arg0
@@ -176,11 +356,12 @@ export class GeoReferenceJs {
         wasm.__wbg_set_georeferencejs_orthogonal_height(this.__wbg_ptr, arg0);
     }
     /**
-     * Scale factor
-     * @param {number} arg0
+     * X-axis abscissa (cos of rotation)
+     * @returns {number}
      */
-    set scale(arg0) {
-        wasm.__wbg_set_georeferencejs_scale(this.__wbg_ptr, arg0);
+    get x_axis_abscissa() {
+        const ret = wasm.__wbg_get_georeferencejs_x_axis_abscissa(this.__wbg_ptr);
+        return ret;
     }
     /**
      * X-axis abscissa (cos of rotation)
@@ -189,6 +370,14 @@ export class GeoReferenceJs {
     set x_axis_abscissa(arg0) {
         wasm.__wbg_set_georeferencejs_x_axis_abscissa(this.__wbg_ptr, arg0);
     }
+    /**
+     * X-axis ordinate (sin of rotation)
+     * @returns {number}
+     */
+    get x_axis_ordinate() {
+        const ret = wasm.__wbg_get_georeferencejs_x_axis_ordinate(this.__wbg_ptr);
+        return ret;
+    }
     /**
      * X-axis ordinate (sin of rotation)
      * @param {number} arg0
@@ -196,51 +385,74 @@ export class GeoReferenceJs {
     set x_axis_ordinate(arg0) {
         wasm.__wbg_set_georeferencejs_x_axis_ordinate(this.__wbg_ptr, arg0);
     }
-}
-if (Symbol.dispose) GeoReferenceJs.prototype[Symbol.dispose] = GeoReferenceJs.prototype.free;
-
-/**
- * GPU-ready geometry stored in WASM linear memory
- *
- * Data layout:
- * - vertex_data: Interleaved [px, py, pz, nx, ny, nz, ...] (6 floats per vertex)
- * - indices: Triangle indices [i0, i1, i2, ...]
- * - mesh_metadata: Per-mesh metadata for draw calls
- *
- * All coordinates are pre-converted from IFC Z-up to WebGL Y-up
- */
-export class GpuGeometry {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(GpuGeometry.prototype);
-        obj.__wbg_ptr = ptr;
-        GpuGeometryFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GpuGeometryFinalization.unregister(this);
-        return ptr;
+    /**
+     * Scale factor
+     * @returns {number}
+     */
+    get scale() {
+        const ret = wasm.__wbg_get_georeferencejs_scale(this.__wbg_ptr);
+        return ret;
     }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_gpugeometry_free(ptr, 0);
+    /**
+     * Scale factor
+     * @param {number} arg0
+     */
+    set scale(arg0) {
+        wasm.__wbg_set_georeferencejs_scale(this.__wbg_ptr, arg0);
     }
     /**
-     * Get IFC type name by index
-     * @param {number} index
-     * @returns {string | undefined}
+     * Transform local coordinates to map coordinates
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {Float64Array}
      */
-    getIfcTypeName(index) {
+    localToMap(x, y, z) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.gpugeometry_getIfcTypeName(retptr, this.__wbg_ptr, index);
+            wasm.georeferencejs_localToMap(retptr, this.__wbg_ptr, x, y, z);
             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();
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export2(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Transform map coordinates to local coordinates
+     * @param {number} e
+     * @param {number} n
+     * @param {number} h
+     * @returns {Float64Array}
+     */
+    mapToLocal(e, n, h) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.georeferencejs_mapToLocal(retptr, this.__wbg_ptr, e, n, h);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export2(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get CRS name
+     * @returns {string | undefined}
+     */
+    get crsName() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.georeferencejs_crsName(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_export2(r0, r1 * 1, 1);
             }
             return v1;
@@ -249,28 +461,67 @@ export class GpuGeometry {
         }
     }
     /**
-     * Get metadata for a specific mesh
-     * @param {number} index
-     * @returns {GpuMeshMetadata | undefined}
+     * Get rotation angle in radians
+     * @returns {number}
      */
-    getMeshMetadata(index) {
-        const ret = wasm.gpugeometry_getMeshMetadata(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : GpuMeshMetadata.__wrap(ret);
+    get rotation() {
+        const ret = wasm.georeferencejs_rotation(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Check if RTC offset is active (non-zero)
-     * @returns {boolean}
+     * Get 4x4 transformation matrix (column-major for WebGL)
+     * @returns {Float64Array}
      */
-    get hasRtcOffset() {
-        const ret = wasm.gpugeometry_hasRtcOffset(this.__wbg_ptr);
-        return ret !== 0;
+    toMatrix() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.georeferencejs_toMatrix(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_export2(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) GeoReferenceJs.prototype[Symbol.dispose] = GeoReferenceJs.prototype.free;
+
+/**
+ * GPU-ready geometry stored in WASM linear memory
+ *
+ * Data layout:
+ * - vertex_data: Interleaved [px, py, pz, nx, ny, nz, ...] (6 floats per vertex)
+ * - indices: Triangle indices [i0, i1, i2, ...]
+ * - mesh_metadata: Per-mesh metadata for draw calls
+ *
+ * All coordinates are pre-converted from IFC Z-up to WebGL Y-up
+ */
+export class GpuGeometry {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GpuGeometry.prototype);
+        obj.__wbg_ptr = ptr;
+        GpuGeometryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GpuGeometryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gpugeometry_free(ptr, 0);
     }
     /**
-     * Get byte length of indices (for GPU buffer creation)
+     * Get number of meshes in this geometry batch
      * @returns {number}
      */
-    get indicesByteLength() {
-        const ret = wasm.gpugeometry_indicesByteLength(this.__wbg_ptr);
+    get meshCount() {
+        const ret = wasm.gpugeometry_meshCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -289,31 +540,6 @@ export class GpuGeometry {
         const ret = wasm.gpugeometry_indicesPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
-    /**
-     * Check if geometry is empty
-     * @returns {boolean}
-     */
-    get isEmpty() {
-        const ret = wasm.gpugeometry_isEmpty(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Get number of meshes in this geometry batch
-     * @returns {number}
-     */
-    get meshCount() {
-        const ret = wasm.gpugeometry_meshCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Create a new empty GPU geometry container
-     */
-    constructor() {
-        const ret = wasm.gpugeometry_new();
-        this.__wbg_ptr = ret >>> 0;
-        GpuGeometryFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * Get X component of RTC offset
      * @returns {number}
@@ -338,6 +564,14 @@ export class GpuGeometry {
         const ret = wasm.gpugeometry_rtcOffsetZ(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Check if RTC offset is active (non-zero)
+     * @returns {boolean}
+     */
+    get hasRtcOffset() {
+        const ret = wasm.gpugeometry_hasRtcOffset(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * Set the RTC (Relative To Center) offset applied to coordinates
      * @param {number} x
@@ -348,13 +582,54 @@ export class GpuGeometry {
         wasm.gpugeometry_set_rtc_offset(this.__wbg_ptr, x, y, z);
     }
     /**
-     * Get total triangle count
+     * Get length of vertex data array (in f32 elements, not bytes)
      * @returns {number}
      */
-    get totalTriangleCount() {
-        const ret = wasm.gpugeometry_totalTriangleCount(this.__wbg_ptr);
+    get vertexDataLen() {
+        const ret = wasm.gpugeometry_vertexDataLen(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get pointer to vertex data for zero-copy view
+     *
+     * SAFETY: View is only valid until next WASM allocation!
+     * Create view, upload to GPU, then discard view immediately.
+     * @returns {number}
+     */
+    get vertexDataPtr() {
+        const ret = wasm.gpugeometry_vertexDataPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Get IFC type name by index
+     * @param {number} index
+     * @returns {string | undefined}
+     */
+    getIfcTypeName(index) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.gpugeometry_getIfcTypeName(retptr, this.__wbg_ptr, index);
+            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_export2(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get metadata for a specific mesh
+     * @param {number} index
+     * @returns {GpuMeshMetadata | undefined}
+     */
+    getMeshMetadata(index) {
+        const ret = wasm.gpugeometry_getMeshMetadata(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : GpuMeshMetadata.__wrap(ret);
+    }
     /**
      * Get total vertex count
      * @returns {number}
@@ -364,32 +639,46 @@ export class GpuGeometry {
         return ret >>> 0;
     }
     /**
-     * Get byte length of vertex data (for GPU buffer creation)
+     * Get byte length of indices (for GPU buffer creation)
      * @returns {number}
      */
-    get vertexDataByteLength() {
-        const ret = wasm.gpugeometry_vertexDataByteLength(this.__wbg_ptr);
+    get indicesByteLength() {
+        const ret = wasm.gpugeometry_indicesByteLength(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Get length of vertex data array (in f32 elements, not bytes)
+     * Get total triangle count
      * @returns {number}
      */
-    get vertexDataLen() {
-        const ret = wasm.gpugeometry_vertexDataLen(this.__wbg_ptr);
+    get totalTriangleCount() {
+        const ret = wasm.gpugeometry_totalTriangleCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Get pointer to vertex data for zero-copy view
-     *
-     * SAFETY: View is only valid until next WASM allocation!
-     * Create view, upload to GPU, then discard view immediately.
+     * Get byte length of vertex data (for GPU buffer creation)
      * @returns {number}
      */
-    get vertexDataPtr() {
-        const ret = wasm.gpugeometry_vertexDataPtr(this.__wbg_ptr);
+    get vertexDataByteLength() {
+        const ret = wasm.gpugeometry_vertexDataByteLength(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Create a new empty GPU geometry container
+     */
+    constructor() {
+        const ret = wasm.gpugeometry_new();
+        this.__wbg_ptr = ret >>> 0;
+        GpuGeometryFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Check if geometry is empty
+     * @returns {boolean}
+     */
+    get isEmpty() {
+        const ret = wasm.gpugeometry_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 if (Symbol.dispose) GpuGeometry.prototype[Symbol.dispose] = GpuGeometry.prototype.free;
 
@@ -429,22 +718,22 @@ export class GpuInstancedGeometry {
     /**
      * @returns {number}
      */
-    get indicesByteLength() {
-        const ret = wasm.gpuinstancedgeometry_indicesByteLength(this.__wbg_ptr);
+    get indicesLen() {
+        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get indicesLen() {
-        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
+    get indicesPtr() {
+        const ret = wasm.gpuinstancedgeometry_indicesPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get indicesPtr() {
-        const ret = wasm.gpuinstancedgeometry_indicesPtr(this.__wbg_ptr);
+    get vertexCount() {
+        const ret = wasm.gpuinstancedgeometry_vertexCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -457,53 +746,43 @@ export class GpuInstancedGeometry {
     /**
      * @returns {number}
      */
-    get instanceDataByteLength() {
-        const ret = wasm.gpuinstancedgeometry_instanceDataByteLength(this.__wbg_ptr);
+    get triangleCount() {
+        const ret = wasm.gpuinstancedgeometry_triangleCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get instanceDataLen() {
-        const ret = wasm.gpuinstancedgeometry_instanceDataLen(this.__wbg_ptr);
+    get vertexDataLen() {
+        const ret = wasm.gpuinstancedgeometry_vertexDataLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get instanceDataPtr() {
-        const ret = wasm.gpuinstancedgeometry_instanceDataPtr(this.__wbg_ptr);
+    get vertexDataPtr() {
+        const ret = wasm.gpuinstancedgeometry_vertexDataPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get instanceExpressIdsPtr() {
-        const ret = wasm.gpuinstancedgeometry_instanceExpressIdsPtr(this.__wbg_ptr);
+    get instanceDataLen() {
+        const ret = wasm.gpuinstancedgeometry_instanceDataLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
-     * Create new instanced geometry
-     * @param {bigint} geometry_id
+     * @returns {number}
      */
-    constructor(geometry_id) {
-        const ret = wasm.gpuinstancedgeometry_new(geometry_id);
-        this.__wbg_ptr = ret >>> 0;
-        GpuInstancedGeometryFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {number}
-     */
-    get triangleCount() {
-        const ret = wasm.gpuinstancedgeometry_triangleCount(this.__wbg_ptr);
+    get instanceDataPtr() {
+        const ret = wasm.gpuinstancedgeometry_instanceDataPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get vertexCount() {
-        const ret = wasm.gpuinstancedgeometry_vertexCount(this.__wbg_ptr);
+    get indicesByteLength() {
+        const ret = wasm.gpuinstancedgeometry_indicesByteLength(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -516,17 +795,27 @@ export class GpuInstancedGeometry {
     /**
      * @returns {number}
      */
-    get vertexDataLen() {
-        const ret = wasm.gpuinstancedgeometry_vertexDataLen(this.__wbg_ptr);
+    get instanceExpressIdsPtr() {
+        const ret = wasm.gpuinstancedgeometry_instanceExpressIdsPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get vertexDataPtr() {
-        const ret = wasm.gpuinstancedgeometry_vertexDataPtr(this.__wbg_ptr);
+    get instanceDataByteLength() {
+        const ret = wasm.gpuinstancedgeometry_instanceDataByteLength(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Create new instanced geometry
+     * @param {bigint} geometry_id
+     */
+    constructor(geometry_id) {
+        const ret = wasm.gpuinstancedgeometry_new(geometry_id);
+        this.__wbg_ptr = ret >>> 0;
+        GpuInstancedGeometryFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
 }
 if (Symbol.dispose) GpuInstancedGeometry.prototype[Symbol.dispose] = GpuInstancedGeometry.prototype.free;
 
@@ -559,15 +848,11 @@ export class GpuInstancedGeometryCollection {
         const ret = wasm.gpuinstancedgeometrycollection_get(this.__wbg_ptr, index);
         return ret === 0 ? undefined : GpuInstancedGeometry.__wrap(ret);
     }
-    /**
-     * Get geometry by index with zero-copy access
-     * Returns a reference that provides pointer access
-     * @param {number} index
-     * @returns {GpuInstancedGeometryRef | undefined}
-     */
-    getRef(index) {
-        const ret = wasm.gpuinstancedgeometrycollection_getRef(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : GpuInstancedGeometryRef.__wrap(ret);
+    constructor() {
+        const ret = wasm.gpuinstancedgeometrycollection_new();
+        this.__wbg_ptr = ret >>> 0;
+        GpuInstancedGeometryCollectionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
      * @returns {number}
@@ -576,18 +861,22 @@ export class GpuInstancedGeometryCollection {
         const ret = wasm.gpuinstancedgeometrycollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
-    constructor() {
-        const ret = wasm.gpuinstancedgeometrycollection_new();
-        this.__wbg_ptr = ret >>> 0;
-        GpuInstancedGeometryCollectionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * Get geometry by index with pointer access over owned buffers.
+     * This avoids exposing references tied to collection lifetime.
+     * @param {number} index
+     * @returns {GpuInstancedGeometryRef | undefined}
+     */
+    getRef(index) {
+        const ret = wasm.gpuinstancedgeometrycollection_get(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : GpuInstancedGeometryRef.__wrap(ret);
     }
 }
 if (Symbol.dispose) GpuInstancedGeometryCollection.prototype[Symbol.dispose] = GpuInstancedGeometryCollection.prototype.free;
 
 /**
- * Reference to geometry in collection for zero-copy access
- * This avoids cloning when accessing geometry data
+ * Pointer-friendly geometry view with owned backing storage.
+ * Owning buffers prevents dangling pointers after collection mutation/drop.
  */
 export class GpuInstancedGeometryRef {
     static __wrap(ptr) {
@@ -611,84 +900,84 @@ export class GpuInstancedGeometryRef {
      * @returns {bigint}
      */
     get geometryId() {
-        const ret = wasm.gpuinstancedgeometryref_geometryId(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_geometryId(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
      * @returns {number}
      */
-    get indicesByteLength() {
-        const ret = wasm.gpuinstancedgeometryref_indicesByteLength(this.__wbg_ptr);
+    get indicesLen() {
+        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get indicesLen() {
-        const ret = wasm.gpuinstancedgeometryref_indicesLen(this.__wbg_ptr);
+    get indicesPtr() {
+        const ret = wasm.gpuinstancedgeometry_indicesPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get indicesPtr() {
-        const ret = wasm.gpuinstancedgeometryref_indicesPtr(this.__wbg_ptr);
+    get instanceCount() {
+        const ret = wasm.gpuinstancedgeometry_instanceCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get instanceCount() {
-        const ret = wasm.gpuinstancedgeometryref_instanceCount(this.__wbg_ptr);
+    get vertexDataLen() {
+        const ret = wasm.gpuinstancedgeometry_vertexDataLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get instanceDataByteLength() {
-        const ret = wasm.gpuinstancedgeometryref_instanceDataByteLength(this.__wbg_ptr);
+    get vertexDataPtr() {
+        const ret = wasm.gpuinstancedgeometry_vertexDataPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
     get instanceDataLen() {
-        const ret = wasm.gpuinstancedgeometryref_instanceDataLen(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_instanceDataLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
     get instanceDataPtr() {
-        const ret = wasm.gpuinstancedgeometryref_instanceDataPtr(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_instanceDataPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get instanceExpressIdsPtr() {
-        const ret = wasm.gpuinstancedgeometryref_instanceExpressIdsPtr(this.__wbg_ptr);
+    get indicesByteLength() {
+        const ret = wasm.gpuinstancedgeometry_indicesByteLength(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
     get vertexDataByteLength() {
-        const ret = wasm.gpuinstancedgeometryref_vertexDataByteLength(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_vertexDataByteLength(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get vertexDataLen() {
-        const ret = wasm.gpuinstancedgeometryref_vertexDataLen(this.__wbg_ptr);
+    get instanceExpressIdsPtr() {
+        const ret = wasm.gpuinstancedgeometry_instanceExpressIdsPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get vertexDataPtr() {
-        const ret = wasm.gpuinstancedgeometryref_vertexDataPtr(this.__wbg_ptr);
+    get instanceDataByteLength() {
+        const ret = wasm.gpuinstancedgeometry_instanceDataByteLength(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
@@ -715,22 +1004,6 @@ export class GpuMeshMetadata {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_gpumeshmetadata_free(ptr, 0);
     }
-    /**
-     * @returns {Float32Array}
-     */
-    get color() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.gpumeshmetadata_color(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_export2(r0, r1 * 4, 4);
-            return v1;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
     /**
      * @returns {number}
      */
@@ -741,16 +1014,16 @@ export class GpuMeshMetadata {
     /**
      * @returns {number}
      */
-    get ifcTypeIdx() {
-        const ret = wasm.gpumeshmetadata_ifcTypeIdx(this.__wbg_ptr);
-        return ret;
+    get indexCount() {
+        const ret = wasm.gpumeshmetadata_indexCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get indexCount() {
-        const ret = wasm.gpumeshmetadata_indexCount(this.__wbg_ptr);
-        return ret >>> 0;
+    get ifcTypeIdx() {
+        const ret = wasm.gpumeshmetadata_ifcTypeIdx(this.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {number}
@@ -773,6 +1046,22 @@ export class GpuMeshMetadata {
         const ret = wasm.gpumeshmetadata_vertexOffset(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @returns {Float32Array}
+     */
+    get color() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.gpumeshmetadata_color(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_export2(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
 }
 if (Symbol.dispose) GpuMeshMetadata.prototype[Symbol.dispose] = GpuMeshMetadata.prototype.free;
 
@@ -790,117 +1079,6 @@ export class IfcAPI {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_ifcapi_free(ptr, 0);
     }
-    /**
-     * Debug: Test processing entity #953 (FacetedBrep wall)
-     * @param {string} content
-     * @returns {string}
-     */
-    debugProcessEntity953(content) {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.ifcapi_debugProcessEntity953(retptr, this.__wbg_ptr, ptr0, len0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
-        }
-    }
-    /**
-     * Debug: Test processing a single wall
-     * @param {string} content
-     * @returns {string}
-     */
-    debugProcessFirstWall(content) {
-        let deferred2_0;
-        let deferred2_1;
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.ifcapi_debugProcessFirstWall(retptr, this.__wbg_ptr, ptr0, len0);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
-        }
-    }
-    /**
-     * Extract georeferencing information from IFC content
-     * Returns null if no georeferencing is present
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * const georef = api.getGeoReference(ifcData);
-     * if (georef) {
-     *   console.log('CRS:', georef.crsName);
-     *   const [e, n, h] = georef.localToMap(10, 20, 5);
-     * }
-     * ```
-     * @param {string} content
-     * @returns {GeoReferenceJs | undefined}
-     */
-    getGeoReference(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_getGeoReference(this.__wbg_ptr, ptr0, len0);
-        return ret === 0 ? undefined : GeoReferenceJs.__wrap(ret);
-    }
-    /**
-     * Get WASM memory for zero-copy access
-     * @returns {any}
-     */
-    getMemory() {
-        const ret = wasm.ifcapi_getMemory(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-     * Check if API is initialized
-     * @returns {boolean}
-     */
-    get is_ready() {
-        const ret = wasm.ifcapi_is_ready(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Create and initialize the IFC API
-     */
-    constructor() {
-        const ret = wasm.ifcapi_new();
-        this.__wbg_ptr = ret >>> 0;
-        IfcAPIFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * Parse IFC file (traditional - waits for completion)
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * const result = await api.parse(ifcData);
-     * console.log('Entities:', result.entityCount);
-     * ```
-     * @param {string} content
-     * @returns {Promise<any>}
-     */
-    parse(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parse(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
     /**
      * Parse IFC file and return individual meshes with express IDs and colors
      * This matches the MeshData[] format expected by the viewer
@@ -970,139 +1148,12 @@ export class IfcAPI {
         return takeObject(ret);
     }
     /**
-     * Parse IFC file and return instanced geometry grouped by geometry hash
-     * This reduces draw calls by grouping identical geometries with different transforms
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * const collection = api.parseMeshesInstanced(ifcData);
-     * for (let i = 0; i < collection.length; i++) {
-     *   const geometry = collection.get(i);
-     *   console.log('Geometry ID:', geometry.geometryId);
-     *   console.log('Instances:', geometry.instanceCount);
-     *   for (let j = 0; j < geometry.instanceCount; j++) {
-     *     const inst = geometry.getInstance(j);
-     *     console.log('  Express ID:', inst.expressId);
-     *     console.log('  Transform:', inst.transform);
-     *   }
-     * }
-     * ```
-     * @param {string} content
-     * @returns {InstancedMeshCollection}
-     */
-    parseMeshesInstanced(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseMeshesInstanced(this.__wbg_ptr, ptr0, len0);
-        return InstancedMeshCollection.__wrap(ret);
-    }
-    /**
-     * Parse IFC file with streaming instanced geometry batches for progressive rendering
-     * Groups identical geometries and yields batches of InstancedGeometry
-     * Uses fast-first-frame streaming: simple geometry (walls, slabs) first
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * await api.parseMeshesInstancedAsync(ifcData, {
-     *   batchSize: 25,  // Number of unique geometries per batch
-     *   onBatch: (geometries, progress) => {
-     *     for (const geom of geometries) {
-     *       renderer.addInstancedGeometry(geom);
-     *     }
-     *   },
-     *   onComplete: (stats) => {
-     *     console.log(`Done! ${stats.totalGeometries} unique geometries, ${stats.totalInstances} instances`);
-     *   }
-     * });
-     * ```
-     * @param {string} content
-     * @param {any} options
-     * @returns {Promise<any>}
-     */
-    parseMeshesInstancedAsync(content, options) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseMeshesInstancedAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
-        return takeObject(ret);
-    }
-    /**
-     * Parse IFC file and return mesh with RTC offset for large coordinates
-     * This handles georeferenced models by shifting to centroid
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * const result = api.parseMeshesWithRtc(ifcData);
-     * const rtcOffset = result.rtcOffset;
-     * const meshes = result.meshes;
-     *
-     * // Convert local coords back to world:
-     * if (rtcOffset.isSignificant()) {
-     *   const [wx, wy, wz] = rtcOffset.toWorld(localX, localY, localZ);
-     * }
-     * ```
-     * @param {string} content
-     * @returns {MeshCollectionWithRtc}
-     */
-    parseMeshesWithRtc(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseMeshesWithRtc(this.__wbg_ptr, ptr0, len0);
-        return MeshCollectionWithRtc.__wrap(ret);
-    }
-    /**
-     * Parse IFC file with streaming events
-     * Calls the callback function for each parse event
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * await api.parseStreaming(ifcData, (event) => {
-     *   console.log('Event:', event);
-     * });
-     * ```
-     * @param {string} content
-     * @param {Function} callback
-     * @returns {Promise<any>}
-     */
-    parseStreaming(content, callback) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseStreaming(this.__wbg_ptr, ptr0, len0, addHeapObject(callback));
-        return takeObject(ret);
-    }
-    /**
-     * Parse IFC file and extract symbolic representations (Plan, Annotation, FootPrint)
-     * These are 2D curves used for architectural drawings instead of sectioning 3D geometry
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * const symbols = api.parseSymbolicRepresentations(ifcData);
-     * console.log('Found', symbols.totalCount, 'symbolic items');
-     * for (let i = 0; i < symbols.polylineCount; i++) {
-     *   const polyline = symbols.getPolyline(i);
-     *   console.log('Polyline for', polyline.ifcType, ':', polyline.points);
-     * }
-     * ```
-     * @param {string} content
-     * @returns {SymbolicRepresentationCollection}
-     */
-    parseSymbolicRepresentations(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseSymbolicRepresentations(this.__wbg_ptr, ptr0, len0);
-        return SymbolicRepresentationCollection.__wrap(ret);
-    }
-    /**
-     * Parse IFC file and return GPU-ready geometry for zero-copy upload
-     *
-     * This method generates geometry that is:
-     * - Pre-interleaved (position + normal per vertex)
-     * - Coordinate-converted (Z-up to Y-up)
-     * - Ready for direct GPU upload via pointer access
+     * Parse IFC file and return GPU-ready geometry for zero-copy upload
+     *
+     * This method generates geometry that is:
+     * - Pre-interleaved (position + normal per vertex)
+     * - Coordinate-converted (Z-up to Y-up)
+     * - Ready for direct GPU upload via pointer access
      *
      * Example:
      * ```javascript
@@ -1140,6 +1191,34 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseToGpuGeometry(this.__wbg_ptr, ptr0, len0);
         return GpuGeometry.__wrap(ret);
     }
+    /**
+     * Parse IFC file and return instanced geometry grouped by geometry hash
+     * This reduces draw calls by grouping identical geometries with different transforms
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * const collection = api.parseMeshesInstanced(ifcData);
+     * for (let i = 0; i < collection.length; i++) {
+     *   const geometry = collection.get(i);
+     *   console.log('Geometry ID:', geometry.geometryId);
+     *   console.log('Instances:', geometry.instanceCount);
+     *   for (let j = 0; j < geometry.instanceCount; j++) {
+     *     const inst = geometry.getInstance(j);
+     *     console.log('  Express ID:', inst.expressId);
+     *     console.log('  Transform:', inst.transform);
+     *   }
+     * }
+     * ```
+     * @param {string} content
+     * @returns {InstancedMeshCollection}
+     */
+    parseMeshesInstanced(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseMeshesInstanced(this.__wbg_ptr, ptr0, len0);
+        return InstancedMeshCollection.__wrap(ret);
+    }
     /**
      * Parse IFC file with streaming GPU-ready geometry batches
      *
@@ -1182,6 +1261,36 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseToGpuGeometryAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * Parse IFC file with streaming instanced geometry batches for progressive rendering
+     * Groups identical geometries and yields batches of InstancedGeometry
+     * Uses fast-first-frame streaming: simple geometry (walls, slabs) first
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * await api.parseMeshesInstancedAsync(ifcData, {
+     *   batchSize: 25,  // Number of unique geometries per batch
+     *   onBatch: (geometries, progress) => {
+     *     for (const geom of geometries) {
+     *       renderer.addInstancedGeometry(geom);
+     *     }
+     *   },
+     *   onComplete: (stats) => {
+     *     console.log(`Done! ${stats.totalGeometries} unique geometries, ${stats.totalInstances} instances`);
+     *   }
+     * });
+     * ```
+     * @param {string} content
+     * @param {any} options
+     * @returns {Promise<any>}
+     */
+    parseMeshesInstancedAsync(content, options) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseMeshesInstancedAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
+        return takeObject(ret);
+    }
     /**
      * Parse IFC file to GPU-ready instanced geometry for zero-copy upload
      *
@@ -1226,67 +1335,247 @@ export class IfcAPI {
         return ZeroCopyMesh.__wrap(ret);
     }
     /**
-     * Fast entity scanning using SIMD-accelerated Rust scanner
-     * Returns array of entity references for data model parsing
-     * Much faster than TypeScript byte-by-byte scanning (5-10x speedup)
+     * Debug: Test processing entity #953 (FacetedBrep wall)
      * @param {string} content
-     * @returns {any}
-     */
-    scanEntitiesFast(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_scanEntitiesFast(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * Fast entity scanning from raw bytes (avoids TextDecoder.decode on JS side).
-     * Accepts Uint8Array directly — saves ~2-5s for 487MB files by skipping
-     * JS string creation and UTF-16→UTF-8 conversion.
-     * @param {Uint8Array} data
-     * @returns {any}
+     * @returns {string}
      */
-    scanEntitiesFastBytes(data) {
-        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export3);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_scanEntitiesFastBytes(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
+    debugProcessEntity953(content) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_debugProcessEntity953(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred2_0 = r0;
+            deferred2_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
+        }
     }
     /**
-     * Fast geometry-only entity scanning
-     * Scans only entities that have geometry, skipping 99% of non-geometry entities
-     * Returns array of geometry entity references for parallel processing
-     * Much faster than scanning all entities (3x speedup for large files)
+     * Debug: Test processing a single wall
      * @param {string} content
-     * @returns {any}
-     */
-    scanGeometryEntitiesFast(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_scanGeometryEntitiesFast(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
-    /**
-     * Get version string
      * @returns {string}
      */
-    get version() {
-        let deferred1_0;
-        let deferred1_1;
+    debugProcessFirstWall(content) {
+        let deferred2_0;
+        let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.ifcapi_version(retptr, this.__wbg_ptr);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_debugProcessFirstWall(retptr, this.__wbg_ptr, ptr0, len0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred1_0 = r0;
-            deferred1_1 = r1;
+            deferred2_0 = r0;
+            deferred2_1 = r1;
             return getStringFromWasm0(r0, r1);
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
+            wasm.__wbindgen_export2(deferred2_0, deferred2_1, 1);
         }
     }
-}
-if (Symbol.dispose) IfcAPI.prototype[Symbol.dispose] = IfcAPI.prototype.free;
+    /**
+     * Extract georeferencing information from IFC content
+     * Returns null if no georeferencing is present
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * const georef = api.getGeoReference(ifcData);
+     * if (georef) {
+     *   console.log('CRS:', georef.crsName);
+     *   const [e, n, h] = georef.localToMap(10, 20, 5);
+     * }
+     * ```
+     * @param {string} content
+     * @returns {GeoReferenceJs | undefined}
+     */
+    getGeoReference(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_getGeoReference(this.__wbg_ptr, ptr0, len0);
+        return ret === 0 ? undefined : GeoReferenceJs.__wrap(ret);
+    }
+    /**
+     * Parse IFC file and return mesh with RTC offset for large coordinates
+     * This handles georeferenced models by shifting to centroid
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * const result = api.parseMeshesWithRtc(ifcData);
+     * const rtcOffset = result.rtcOffset;
+     * const meshes = result.meshes;
+     *
+     * // Convert local coords back to world:
+     * if (rtcOffset.isSignificant()) {
+     *   const [wx, wy, wz] = rtcOffset.toWorld(localX, localY, localZ);
+     * }
+     * ```
+     * @param {string} content
+     * @returns {MeshCollectionWithRtc}
+     */
+    parseMeshesWithRtc(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseMeshesWithRtc(this.__wbg_ptr, ptr0, len0);
+        return MeshCollectionWithRtc.__wrap(ret);
+    }
+    /**
+     * Parse IFC file with streaming events
+     * Calls the callback function for each parse event
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * await api.parseStreaming(ifcData, (event) => {
+     *   console.log('Event:', event);
+     * });
+     * ```
+     * @param {string} content
+     * @param {Function} callback
+     * @returns {Promise<any>}
+     */
+    parseStreaming(content, callback) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseStreaming(this.__wbg_ptr, ptr0, len0, addHeapObject(callback));
+        return takeObject(ret);
+    }
+    /**
+     * Fast entity scanning using SIMD-accelerated Rust scanner
+     * Returns array of entity references for data model parsing
+     * Much faster than TypeScript byte-by-byte scanning (5-10x speedup)
+     * @param {string} content
+     * @returns {any}
+     */
+    scanEntitiesFast(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_scanEntitiesFast(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Fast entity scanning from raw bytes (avoids TextDecoder.decode on JS side).
+     * Accepts Uint8Array directly — saves ~2-5s for 487MB files by skipping
+     * JS string creation and UTF-16→UTF-8 conversion.
+     * @param {Uint8Array} data
+     * @returns {any}
+     */
+    scanEntitiesFastBytes(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_scanEntitiesFastBytes(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Fast geometry-only entity scanning
+     * Scans only entities that have geometry, skipping 99% of non-geometry entities
+     * Returns array of geometry entity references for parallel processing
+     * Much faster than scanning all entities (3x speedup for large files)
+     * @param {string} content
+     * @returns {any}
+     */
+    scanGeometryEntitiesFast(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_scanGeometryEntitiesFast(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Parse IFC file (traditional - waits for completion)
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * const result = await api.parse(ifcData);
+     * console.log('Entities:', result.entityCount);
+     * ```
+     * @param {string} content
+     * @returns {Promise<any>}
+     */
+    parse(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parse(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Get WASM memory for zero-copy access
+     * @returns {any}
+     */
+    getMemory() {
+        const ret = wasm.ifcapi_getMemory(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Create and initialize the IFC API
+     */
+    constructor() {
+        const ret = wasm.ifcapi_new();
+        this.__wbg_ptr = ret >>> 0;
+        IfcAPIFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Get version string
+     * @returns {string}
+     */
+    get version() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.ifcapi_version(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Check if API is initialized
+     * @returns {boolean}
+     */
+    get is_ready() {
+        const ret = wasm.ifcapi_is_ready(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Parse IFC file and extract symbolic representations (Plan, Annotation, FootPrint)
+     * These are 2D curves used for architectural drawings instead of sectioning 3D geometry
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * const symbols = api.parseSymbolicRepresentations(ifcData);
+     * console.log('Found', symbols.totalCount, 'symbolic items');
+     * for (let i = 0; i < symbols.polylineCount; i++) {
+     *   const polyline = symbols.getPolyline(i);
+     *   console.log('Polyline for', polyline.ifcType, ':', polyline.points);
+     * }
+     * ```
+     * @param {string} content
+     * @returns {SymbolicRepresentationCollection}
+     */
+    parseSymbolicRepresentations(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseSymbolicRepresentations(this.__wbg_ptr, ptr0, len0);
+        return SymbolicRepresentationCollection.__wrap(ret);
+    }
+}
+if (Symbol.dispose) IfcAPI.prototype[Symbol.dispose] = IfcAPI.prototype.free;
 
 /**
  * Instance data for instanced rendering
@@ -1309,6 +1598,13 @@ export class InstanceData {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_instancedata_free(ptr, 0);
     }
+    /**
+     * @returns {number}
+     */
+    get expressId() {
+        const ret = wasm.instancedata_expressId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * @returns {Float32Array}
      */
@@ -1325,13 +1621,6 @@ export class InstanceData {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * @returns {number}
-     */
-    get expressId() {
-        const ret = wasm.instancedata_expressId(this.__wbg_ptr);
-        return ret >>> 0;
-    }
     /**
      * @returns {Float32Array}
      */
@@ -1367,7 +1656,7 @@ export class InstancedGeometry {
      * @returns {bigint}
      */
     get geometryId() {
-        const ret = wasm.instancedgeometry_geometryId(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_geometryId(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -1378,13 +1667,6 @@ export class InstancedGeometry {
         const ret = wasm.instancedgeometry_get_instance(this.__wbg_ptr, index);
         return ret === 0 ? undefined : InstanceData.__wrap(ret);
     }
-    /**
-     * @returns {Uint32Array}
-     */
-    get indices() {
-        const ret = wasm.instancedgeometry_indices(this.__wbg_ptr);
-        return takeObject(ret);
-    }
     /**
      * @returns {number}
      */
@@ -1392,6 +1674,13 @@ export class InstancedGeometry {
         const ret = wasm.instancedgeometry_instance_count(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @returns {Uint32Array}
+     */
+    get indices() {
+        const ret = wasm.instancedgeometry_indices(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * @returns {Float32Array}
      */
@@ -1430,33 +1719,33 @@ export class InstancedMeshCollection {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_instancedmeshcollection_free(ptr, 0);
     }
-    /**
-     * @param {number} index
-     * @returns {InstancedGeometry | undefined}
-     */
-    get(index) {
-        const ret = wasm.instancedmeshcollection_get(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : InstancedGeometry.__wrap(ret);
-    }
     /**
      * @returns {number}
      */
-    get length() {
-        const ret = wasm.instancedmeshcollection_length(this.__wbg_ptr);
+    get totalInstances() {
+        const ret = wasm.instancedmeshcollection_totalInstances(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
      * @returns {number}
      */
     get totalGeometries() {
-        const ret = wasm.instancedmeshcollection_totalGeometries(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometrycollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * @param {number} index
+     * @returns {InstancedGeometry | undefined}
+     */
+    get(index) {
+        const ret = wasm.instancedmeshcollection_get(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : InstancedGeometry.__wrap(ret);
+    }
     /**
      * @returns {number}
      */
-    get totalInstances() {
-        const ret = wasm.instancedmeshcollection_totalInstances(this.__wbg_ptr);
+    get length() {
+        const ret = wasm.gpuinstancedgeometrycollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
@@ -1484,29 +1773,29 @@ export class MeshCollection {
         wasm.__wbg_meshcollection_free(ptr, 0);
     }
     /**
-     * Get building rotation angle in radians (from IfcSite placement)
-     * Returns None if no rotation was detected
-     * @returns {number | undefined}
+     * Get RTC offset X (for converting local coords back to world coords)
+     * Add this to local X coordinates to get world X coordinates
+     * @returns {number}
      */
-    get buildingRotation() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.meshcollection_buildingRotation(retptr, this.__wbg_ptr);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
-            return r0 === 0 ? undefined : r2;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
+    get rtcOffsetX() {
+        const ret = wasm.gpugeometry_rtcOffsetZ(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Get mesh at index
-     * @param {number} index
-     * @returns {MeshDataJs | undefined}
+     * Get RTC offset Y
+     * @returns {number}
      */
-    get(index) {
-        const ret = wasm.meshcollection_get(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : MeshDataJs.__wrap(ret);
+    get rtcOffsetY() {
+        const ret = wasm.meshcollection_rtcOffsetY(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Get RTC offset Z
+     * @returns {number}
+     */
+    get rtcOffsetZ() {
+        const ret = wasm.meshcollection_rtcOffsetZ(this.__wbg_ptr);
+        return ret;
     }
     /**
      * Check if RTC offset is significant (>10km)
@@ -1516,14 +1805,6 @@ export class MeshCollection {
         const ret = wasm.meshcollection_hasRtcOffset(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Get number of meshes
-     * @returns {number}
-     */
-    get length() {
-        const ret = wasm.meshcollection_length(this.__wbg_ptr);
-        return ret >>> 0;
-    }
     /**
      * Convert local coordinates to world coordinates
      * Use this to convert mesh positions back to original IFC coordinates
@@ -1546,44 +1827,52 @@ export class MeshCollection {
         }
     }
     /**
-     * Get RTC offset X (for converting local coords back to world coords)
-     * Add this to local X coordinates to get world X coordinates
+     * Get total vertex count across all meshes
      * @returns {number}
      */
-    get rtcOffsetX() {
-        const ret = wasm.meshcollection_rtcOffsetX(this.__wbg_ptr);
-        return ret;
+    get totalVertices() {
+        const ret = wasm.meshcollection_totalVertices(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Get RTC offset Y
+     * Get total triangle count across all meshes
      * @returns {number}
      */
-    get rtcOffsetY() {
-        const ret = wasm.meshcollection_rtcOffsetY(this.__wbg_ptr);
-        return ret;
+    get totalTriangles() {
+        const ret = wasm.meshcollection_totalTriangles(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Get RTC offset Z
-     * @returns {number}
+     * Get building rotation angle in radians (from IfcSite placement)
+     * Returns None if no rotation was detected
+     * @returns {number | undefined}
      */
-    get rtcOffsetZ() {
-        const ret = wasm.meshcollection_rtcOffsetZ(this.__wbg_ptr);
-        return ret;
+    get buildingRotation() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshcollection_buildingRotation(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r2 = getDataViewMemory0().getFloat64(retptr + 8 * 1, true);
+            return r0 === 0 ? undefined : r2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
-     * Get total triangle count across all meshes
-     * @returns {number}
+     * Get mesh at index
+     * @param {number} index
+     * @returns {MeshDataJs | undefined}
      */
-    get totalTriangles() {
-        const ret = wasm.meshcollection_totalTriangles(this.__wbg_ptr);
-        return ret >>> 0;
+    get(index) {
+        const ret = wasm.meshcollection_get(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : MeshDataJs.__wrap(ret);
     }
     /**
-     * Get total vertex count across all meshes
+     * Get number of meshes
      * @returns {number}
      */
-    get totalVertices() {
-        const ret = wasm.meshcollection_totalVertices(this.__wbg_ptr);
+    get length() {
+        const ret = wasm.meshcollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
@@ -1610,6 +1899,14 @@ export class MeshCollectionWithRtc {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_meshcollectionwithrtc_free(ptr, 0);
     }
+    /**
+     * Get the RTC offset
+     * @returns {RtcOffsetJs}
+     */
+    get rtcOffset() {
+        const ret = wasm.meshcollectionwithrtc_rtcOffset(this.__wbg_ptr);
+        return RtcOffsetJs.__wrap(ret);
+    }
     /**
      * Get mesh at index
      * @param {number} index
@@ -1624,7 +1921,7 @@ export class MeshCollectionWithRtc {
      * @returns {number}
      */
     get length() {
-        const ret = wasm.meshcollectionwithrtc_length(this.__wbg_ptr);
+        const ret = wasm.meshcollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1635,14 +1932,6 @@ export class MeshCollectionWithRtc {
         const ret = wasm.meshcollectionwithrtc_meshes(this.__wbg_ptr);
         return MeshCollection.__wrap(ret);
     }
-    /**
-     * Get the RTC offset
-     * @returns {RtcOffsetJs}
-     */
-    get rtcOffset() {
-        const ret = wasm.meshcollectionwithrtc_rtcOffset(this.__wbg_ptr);
-        return RtcOffsetJs.__wrap(ret);
-    }
 }
 if (Symbol.dispose) MeshCollectionWithRtc.prototype[Symbol.dispose] = MeshCollectionWithRtc.prototype.free;
 
@@ -1667,6 +1956,30 @@ export class MeshDataJs {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_meshdatajs_free(ptr, 0);
     }
+    /**
+     * Get express ID
+     * @returns {number}
+     */
+    get expressId() {
+        const ret = wasm.meshdatajs_expressId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get vertex count
+     * @returns {number}
+     */
+    get vertexCount() {
+        const ret = wasm.meshdatajs_vertexCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get triangle count
+     * @returns {number}
+     */
+    get triangleCount() {
+        const ret = wasm.meshdatajs_triangleCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Get color as [r, g, b, a] array
      * @returns {Float32Array}
@@ -1685,12 +1998,20 @@ export class MeshDataJs {
         }
     }
     /**
-     * Get express ID
-     * @returns {number}
+     * Get indices as Uint32Array (copy to JS)
+     * @returns {Uint32Array}
      */
-    get expressId() {
-        const ret = wasm.meshdatajs_expressId(this.__wbg_ptr);
-        return ret >>> 0;
+    get indices() {
+        const ret = wasm.meshdatajs_indices(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Get normals as Float32Array (copy to JS)
+     * @returns {Float32Array}
+     */
+    get normals() {
+        const ret = wasm.meshdatajs_normals(this.__wbg_ptr);
+        return takeObject(ret);
     }
     /**
      * Get IFC type name (e.g., "IfcWall", "IfcSpace")
@@ -1712,22 +2033,6 @@ export class MeshDataJs {
             wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * Get indices as Uint32Array (copy to JS)
-     * @returns {Uint32Array}
-     */
-    get indices() {
-        const ret = wasm.meshdatajs_indices(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-     * Get normals as Float32Array (copy to JS)
-     * @returns {Float32Array}
-     */
-    get normals() {
-        const ret = wasm.meshdatajs_normals(this.__wbg_ptr);
-        return takeObject(ret);
-    }
     /**
      * Get positions as Float32Array (copy to JS)
      * @returns {Float32Array}
@@ -1736,22 +2041,6 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_positions(this.__wbg_ptr);
         return takeObject(ret);
     }
-    /**
-     * Get triangle count
-     * @returns {number}
-     */
-    get triangleCount() {
-        const ret = wasm.meshdatajs_triangleCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get vertex count
-     * @returns {number}
-     */
-    get vertexCount() {
-        const ret = wasm.meshdatajs_vertexCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
 }
 if (Symbol.dispose) MeshDataJs.prototype[Symbol.dispose] = MeshDataJs.prototype.free;
 
@@ -1781,25 +2070,46 @@ export class RtcOffsetJs {
      * @returns {number}
      */
     get x() {
-        const ret = wasm.__wbg_get_rtcoffsetjs_x(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_georeferencejs_eastings(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * X offset (subtracted from positions)
+     * @param {number} arg0
+     */
+    set x(arg0) {
+        wasm.__wbg_set_georeferencejs_eastings(this.__wbg_ptr, arg0);
+    }
     /**
      * Y offset
      * @returns {number}
      */
     get y() {
-        const ret = wasm.__wbg_get_rtcoffsetjs_y(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_georeferencejs_northings(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Y offset
+     * @param {number} arg0
+     */
+    set y(arg0) {
+        wasm.__wbg_set_georeferencejs_northings(this.__wbg_ptr, arg0);
+    }
     /**
      * Z offset
      * @returns {number}
      */
     get z() {
-        const ret = wasm.__wbg_get_rtcoffsetjs_z(this.__wbg_ptr);
+        const ret = wasm.__wbg_get_georeferencejs_orthogonal_height(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * Z offset
+     * @param {number} arg0
+     */
+    set z(arg0) {
+        wasm.__wbg_set_georeferencejs_orthogonal_height(this.__wbg_ptr, arg0);
+    }
     /**
      * Check if offset is significant (>10km)
      * @returns {boolean}
@@ -1828,27 +2138,6 @@ export class RtcOffsetJs {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * X offset (subtracted from positions)
-     * @param {number} arg0
-     */
-    set x(arg0) {
-        wasm.__wbg_set_rtcoffsetjs_x(this.__wbg_ptr, arg0);
-    }
-    /**
-     * Y offset
-     * @param {number} arg0
-     */
-    set y(arg0) {
-        wasm.__wbg_set_rtcoffsetjs_y(this.__wbg_ptr, arg0);
-    }
-    /**
-     * Z offset
-     * @param {number} arg0
-     */
-    set z(arg0) {
-        wasm.__wbg_set_rtcoffsetjs_z(this.__wbg_ptr, arg0);
-    }
 }
 if (Symbol.dispose) RtcOffsetJs.prototype[Symbol.dispose] = RtcOffsetJs.prototype.free;
 
@@ -1876,40 +2165,34 @@ export class SymbolicCircle {
     /**
      * @returns {number}
      */
-    get centerX() {
-        const ret = wasm.symboliccircle_centerX(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {number}
-     */
-    get centerY() {
-        const ret = wasm.symboliccircle_centerY(this.__wbg_ptr);
-        return ret;
+    get expressId() {
+        const ret = wasm.gpumeshmetadata_vertexCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
      * @returns {number}
      */
-    get endAngle() {
-        const ret = wasm.symboliccircle_endAngle(this.__wbg_ptr);
+    get startAngle() {
+        const ret = wasm.symboliccircle_startAngle(this.__wbg_ptr);
         return ret;
     }
     /**
-     * @returns {number}
+     * Check if this is a full circle
+     * @returns {boolean}
      */
-    get expressId() {
-        const ret = wasm.symboliccircle_expressId(this.__wbg_ptr);
-        return ret >>> 0;
+    get isFullCircle() {
+        const ret = wasm.symboliccircle_isFullCircle(this.__wbg_ptr);
+        return ret !== 0;
     }
     /**
      * @returns {string}
      */
-    get ifcType() {
+    get repIdentifier() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.symboliccircle_ifcType(retptr, this.__wbg_ptr);
+            wasm.symboliccircle_repIdentifier(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1921,29 +2204,35 @@ export class SymbolicCircle {
         }
     }
     /**
-     * Check if this is a full circle
-     * @returns {boolean}
+     * @returns {number}
      */
-    get isFullCircle() {
-        const ret = wasm.symboliccircle_isFullCircle(this.__wbg_ptr);
-        return ret !== 0;
+    get radius() {
+        const ret = wasm.symboliccircle_radius(this.__wbg_ptr);
+        return ret;
     }
     /**
      * @returns {number}
      */
-    get radius() {
-        const ret = wasm.symboliccircle_radius(this.__wbg_ptr);
+    get centerX() {
+        const ret = wasm.symboliccircle_centerX(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get centerY() {
+        const ret = wasm.symboliccircle_centerY(this.__wbg_ptr);
         return ret;
     }
     /**
      * @returns {string}
      */
-    get repIdentifier() {
+    get ifcType() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.symboliccircle_repIdentifier(retptr, this.__wbg_ptr);
+            wasm.symboliccircle_ifcType(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -1957,8 +2246,8 @@ export class SymbolicCircle {
     /**
      * @returns {number}
      */
-    get startAngle() {
-        const ret = wasm.symboliccircle_startAngle(this.__wbg_ptr);
+    get endAngle() {
+        const ret = wasm.symboliccircle_endAngle(this.__wbg_ptr);
         return ret;
     }
 }
@@ -1995,15 +2284,23 @@ export class SymbolicPolyline {
         return ret >>> 0;
     }
     /**
-     * Get IFC type name (e.g., "IfcDoor", "IfcWindow")
+     * Get number of points
+     * @returns {number}
+     */
+    get pointCount() {
+        const ret = wasm.symbolicpolyline_pointCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get representation identifier ("Plan", "Annotation", "FootPrint", "Axis")
      * @returns {string}
      */
-    get ifcType() {
+    get repIdentifier() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.symbolicpolyline_ifcType(retptr, this.__wbg_ptr);
+            wasm.symbolicpolyline_repIdentifier(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -2014,22 +2311,6 @@ export class SymbolicPolyline {
             wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
         }
     }
-    /**
-     * Check if this is a closed loop
-     * @returns {boolean}
-     */
-    get isClosed() {
-        const ret = wasm.symbolicpolyline_isClosed(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Get number of points
-     * @returns {number}
-     */
-    get pointCount() {
-        const ret = wasm.symbolicpolyline_pointCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
     /**
      * Get 2D points as Float32Array [x1, y1, x2, y2, ...]
      * @returns {Float32Array}
@@ -2039,15 +2320,15 @@ export class SymbolicPolyline {
         return takeObject(ret);
     }
     /**
-     * Get representation identifier ("Plan", "Annotation", "FootPrint", "Axis")
+     * Get IFC type name (e.g., "IfcDoor", "IfcWindow")
      * @returns {string}
      */
-    get repIdentifier() {
+    get ifcType() {
         let deferred1_0;
         let deferred1_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.symbolicpolyline_repIdentifier(retptr, this.__wbg_ptr);
+            wasm.symbolicpolyline_ifcType(retptr, this.__wbg_ptr);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             deferred1_0 = r0;
@@ -2058,6 +2339,14 @@ export class SymbolicPolyline {
             wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Check if this is a closed loop
+     * @returns {boolean}
+     */
+    get isClosed() {
+        const ret = wasm.symbolicpolyline_isClosed(this.__wbg_ptr);
+        return ret !== 0;
+    }
 }
 if (Symbol.dispose) SymbolicPolyline.prototype[Symbol.dispose] = SymbolicPolyline.prototype.free;
 
@@ -2082,6 +2371,23 @@ export class SymbolicRepresentationCollection {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_symbolicrepresentationcollection_free(ptr, 0);
     }
+    /**
+     * Get circle at index
+     * @param {number} index
+     * @returns {SymbolicCircle | undefined}
+     */
+    getCircle(index) {
+        const ret = wasm.symbolicrepresentationcollection_getCircle(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : SymbolicCircle.__wrap(ret);
+    }
+    /**
+     * Get total count of all symbolic items
+     * @returns {number}
+     */
+    get totalCount() {
+        const ret = wasm.symbolicrepresentationcollection_totalCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
      * Get number of circles/arcs
      * @returns {number}
@@ -2091,13 +2397,21 @@ export class SymbolicRepresentationCollection {
         return ret >>> 0;
     }
     /**
-     * Get circle at index
+     * Get polyline at index
      * @param {number} index
-     * @returns {SymbolicCircle | undefined}
+     * @returns {SymbolicPolyline | undefined}
      */
-    getCircle(index) {
-        const ret = wasm.symbolicrepresentationcollection_getCircle(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : SymbolicCircle.__wrap(ret);
+    getPolyline(index) {
+        const ret = wasm.symbolicrepresentationcollection_getPolyline(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : SymbolicPolyline.__wrap(ret);
+    }
+    /**
+     * Get number of polylines
+     * @returns {number}
+     */
+    get polylineCount() {
+        const ret = wasm.symbolicrepresentationcollection_polylineCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
      * Get all express IDs that have symbolic representations
@@ -2116,15 +2430,6 @@ export class SymbolicRepresentationCollection {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
-    /**
-     * Get polyline at index
-     * @param {number} index
-     * @returns {SymbolicPolyline | undefined}
-     */
-    getPolyline(index) {
-        const ret = wasm.symbolicrepresentationcollection_getPolyline(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : SymbolicPolyline.__wrap(ret);
-    }
     /**
      * Check if collection is empty
      * @returns {boolean}
@@ -2133,22 +2438,6 @@ export class SymbolicRepresentationCollection {
         const ret = wasm.symbolicrepresentationcollection_isEmpty(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * Get number of polylines
-     * @returns {number}
-     */
-    get polylineCount() {
-        const ret = wasm.symbolicrepresentationcollection_polylineCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get total count of all symbolic items
-     * @returns {number}
-     */
-    get totalCount() {
-        const ret = wasm.symbolicrepresentationcollection_totalCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
 }
 if (Symbol.dispose) SymbolicRepresentationCollection.prototype[Symbol.dispose] = SymbolicRepresentationCollection.prototype.free;
 
@@ -2212,7 +2501,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get indices_len() {
-        const ret = wasm.zerocopymesh_indices_len(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2220,26 +2509,9 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get indices_ptr() {
-        const ret = wasm.zerocopymesh_indices_ptr(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_indicesPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
-    /**
-     * Check if mesh is empty
-     * @returns {boolean}
-     */
-    get is_empty() {
-        const ret = wasm.zerocopymesh_is_empty(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Create a new zero-copy mesh from a Mesh
-     */
-    constructor() {
-        const ret = wasm.zerocopymesh_new();
-        this.__wbg_ptr = ret >>> 0;
-        ZeroCopyMeshFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
     /**
      * Get length of normals array
      * @returns {number}
@@ -2253,7 +2525,15 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get normals_ptr() {
-        const ret = wasm.zerocopymesh_normals_ptr(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_vertexDataPtr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Get vertex count
+     * @returns {number}
+     */
+    get vertex_count() {
+        const ret = wasm.zerocopymesh_vertex_count(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2271,595 +2551,87 @@ export class ZeroCopyMesh {
      */
     get positions_ptr() {
         const ret = wasm.zerocopymesh_positions_ptr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get triangle count
-     * @returns {number}
-     */
-    get triangle_count() {
-        const ret = wasm.zerocopymesh_triangle_count(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get vertex count
-     * @returns {number}
-     */
-    get vertex_count() {
-        const ret = wasm.zerocopymesh_vertex_count(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-}
-if (Symbol.dispose) ZeroCopyMesh.prototype[Symbol.dispose] = ZeroCopyMesh.prototype.free;
-
-/**
- * Get WASM memory to allow JavaScript to create TypedArray views
- * @returns {any}
- */
-export function get_memory() {
-    const ret = wasm.get_memory();
-    return takeObject(ret);
-}
-
-/**
- * Initialize the WASM module.
- *
- * This function is called automatically when the WASM module is loaded.
- * It sets up panic hooks for better error messages in the browser console.
- */
-export function init() {
-    wasm.init();
-}
-
-/**
- * Get the version of IFC-Lite.
- *
- * # Returns
- *
- * Version string (e.g., "0.1.0")
- *
- * # Example
- *
- * ```javascript
- * console.log(`IFC-Lite version: ${version()}`);
- * ```
- * @returns {string}
- */
-export function version() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.version(retptr);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        deferred1_0 = r0;
-        deferred1_1 = r1;
-        return getStringFromWasm0(r0, r1);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-        wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
-    }
-}
-
-function __wbg_get_imports() {
-    const import0 = {
-        __proto__: null,
-        __wbg_Error_83742b46f01ce22d: function(arg0, arg1) {
-            const ret = Error(getStringFromWasm0(arg0, arg1));
-            return addHeapObject(ret);
-        },
-        __wbg___wbindgen_is_function_3c846841762788c1: function(arg0) {
-            const ret = typeof(getObject(arg0)) === 'function';
-            return ret;
-        },
-        __wbg___wbindgen_is_undefined_52709e72fb9f179c: function(arg0) {
-            const ret = getObject(arg0) === undefined;
-            return ret;
-        },
-        __wbg___wbindgen_memory_edb3f01e3930bbf6: function() {
-            const ret = wasm.memory;
-            return addHeapObject(ret);
-        },
-        __wbg___wbindgen_number_get_34bb9d9dcfa21373: function(arg0, arg1) {
-            const obj = getObject(arg1);
-            const ret = typeof(obj) === 'number' ? obj : undefined;
-            getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
-        },
-        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
-            throw new Error(getStringFromWasm0(arg0, arg1));
-        },
-        __wbg__wbg_cb_unref_6b5b6b8576d35cb1: function(arg0) {
-            getObject(arg0)._wbg_cb_unref();
-        },
-        __wbg_call_2d781c1f4d5c0ef8: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
-            return addHeapObject(ret);
-        }, arguments); },
-        __wbg_call_dcc2662fa17a72cf: function() { return handleError(function (arg0, arg1, arg2, arg3) {
-            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
-            return addHeapObject(ret);
-        }, arguments); },
-        __wbg_call_e133b57c9155d22c: function() { return handleError(function (arg0, arg1) {
-            const ret = getObject(arg0).call(getObject(arg1));
-            return addHeapObject(ret);
-        }, arguments); },
-        __wbg_clearTimeout_113b1cde814ec762: function(arg0) {
-            const ret = clearTimeout(takeObject(arg0));
-            return addHeapObject(ret);
-        },
-        __wbg_debug_4b9b1a2d5972be57: function(arg0) {
-            console.debug(getObject(arg0));
-        },
-        __wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
-            let deferred0_0;
-            let deferred0_1;
-            try {
-                deferred0_0 = arg0;
-                deferred0_1 = arg1;
-                console.error(getStringFromWasm0(arg0, arg1));
-            } finally {
-                wasm.__wbindgen_export2(deferred0_0, deferred0_1, 1);
-            }
-        },
-        __wbg_get_3ef1eba1850ade27: function() { return handleError(function (arg0, arg1) {
-            const ret = Reflect.get(getObject(arg0), getObject(arg1));
-            return addHeapObject(ret);
-        }, arguments); },
-        __wbg_gpugeometry_new: function(arg0) {
-            const ret = GpuGeometry.__wrap(arg0);
-            return addHeapObject(ret);
-        },
-        __wbg_instancedgeometry_new: function(arg0) {
-            const ret = InstancedGeometry.__wrap(arg0);
-            return addHeapObject(ret);
-        },
-        __wbg_length_259ee9d041e381ad: function(arg0) {
-            const ret = getObject(arg0).length;
-            return ret;
-        },
-        __wbg_length_b3416cf66a5452c8: function(arg0) {
-            const ret = getObject(arg0).length;
-            return ret;
-        },
-        __wbg_meshdatajs_new: function(arg0) {
-            const ret = MeshDataJs.__wrap(arg0);
-            return addHeapObject(ret);
-        },
-        __wbg_new_227d7c05414eb861: function() {
-            const ret = new Error();
-            return addHeapObject(ret);
-        },
-        __wbg_new_a70fbab9066b301f: function() {
-            const ret = new Array();
-            return addHeapObject(ret);
-        },
-        __wbg_new_ab79df5bd7c26067: function() {
-            const ret = new Object();
-            return addHeapObject(ret);
-        },
-        __wbg_new_d098e265629cd10f: function(arg0, arg1) {
-            try {
-                var state0 = {a: arg0, b: arg1};
-                var cb0 = (arg0, arg1) => {
-                    const a = state0.a;
-                    state0.a = 0;
-                    try {
-                        return __wasm_bindgen_func_elem_1070(a, state0.b, arg0, arg1);
-                    } finally {
-                        state0.a = a;
-                    }
-                };
-                const ret = new Promise(cb0);
-                return addHeapObject(ret);
-            } finally {
-                state0.a = state0.b = 0;
-            }
-        },
-        __wbg_new_from_slice_898ac63cbd46f332: function(arg0, arg1) {
-            const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
-            return addHeapObject(ret);
-        },
-        __wbg_new_from_slice_ff2c15e8e05ffdfc: function(arg0, arg1) {
-            const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
-            return addHeapObject(ret);
-        },
-        __wbg_prototypesetcall_247ac4333d4d3cb4: function(arg0, arg1, arg2) {
-            Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), getObject(arg2));
-        },
-        __wbg_push_e87b0e732085a946: function(arg0, arg1) {
-            const ret = getObject(arg0).push(getObject(arg1));
-            return ret;
-        },
-        __wbg_queueMicrotask_0c399741342fb10f: function(arg0) {
-            const ret = getObject(arg0).queueMicrotask;
-            return addHeapObject(ret);
-        },
-        __wbg_queueMicrotask_a082d78ce798393e: function(arg0) {
-            queueMicrotask(getObject(arg0));
-        },
-        __wbg_resolve_ae8d83246e5bcc12: function(arg0) {
-            const ret = Promise.resolve(getObject(arg0));
-            return addHeapObject(ret);
-        },
-        __wbg_setTimeout_ef24d2fc3ad97385: function() { return handleError(function (arg0, arg1) {
-            const ret = setTimeout(getObject(arg0), arg1);
-            return addHeapObject(ret);
-        }, arguments); },
-        __wbg_set_282384002438957f: function(arg0, arg1, arg2) {
-            getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
-        },
-        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
-            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
-        },
-        __wbg_set_7eaa4f96924fd6b3: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
-            return ret;
-        }, arguments); },
-        __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
-            const ret = getObject(arg1).stack;
-            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-            const len1 = WASM_VECTOR_LEN;
-            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-        },
-        __wbg_static_accessor_GLOBAL_8adb955bd33fac2f: function() {
-            const ret = typeof global === 'undefined' ? null : global;
-            return isLikeNone(ret) ? 0 : addHeapObject(ret);
-        },
-        __wbg_static_accessor_GLOBAL_THIS_ad356e0db91c7913: function() {
-            const ret = typeof globalThis === 'undefined' ? null : globalThis;
-            return isLikeNone(ret) ? 0 : addHeapObject(ret);
-        },
-        __wbg_static_accessor_SELF_f207c857566db248: function() {
-            const ret = typeof self === 'undefined' ? null : self;
-            return isLikeNone(ret) ? 0 : addHeapObject(ret);
-        },
-        __wbg_static_accessor_WINDOW_bb9f1ba69d61b386: function() {
-            const ret = typeof window === 'undefined' ? null : window;
-            return isLikeNone(ret) ? 0 : addHeapObject(ret);
-        },
-        __wbg_then_098abe61755d12f6: function(arg0, arg1) {
-            const ret = getObject(arg0).then(getObject(arg1));
-            return addHeapObject(ret);
-        },
-        __wbg_warn_69424c2d92a2fa73: function(arg0) {
-            console.warn(getObject(arg0));
-        },
-        __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 135, function: Function { arguments: [Externref], shim_idx: 136, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1032, __wasm_bindgen_func_elem_1037);
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 46, function: Function { arguments: [], shim_idx: 47, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_480, __wasm_bindgen_func_elem_484);
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000003: function(arg0) {
-            // Cast intrinsic for `F64 -> Externref`.
-            const ret = arg0;
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Ref(String) -> Externref`.
-            const ret = getStringFromWasm0(arg0, arg1);
-            return addHeapObject(ret);
-        },
-        __wbindgen_cast_0000000000000005: function(arg0) {
-            // Cast intrinsic for `U64 -> Externref`.
-            const ret = BigInt.asUintN(64, arg0);
-            return addHeapObject(ret);
-        },
-        __wbindgen_object_clone_ref: function(arg0) {
-            const ret = getObject(arg0);
-            return addHeapObject(ret);
-        },
-        __wbindgen_object_drop_ref: function(arg0) {
-            takeObject(arg0);
-        },
-    };
-    return {
-        __proto__: null,
-        "./ifc_lite_wasm_bg.js": import0,
-    };
-}
-
-function __wasm_bindgen_func_elem_484(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_484(arg0, arg1);
-}
-
-function __wasm_bindgen_func_elem_1037(arg0, arg1, arg2) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_1037(retptr, arg0, arg1, addHeapObject(arg2));
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        if (r1) {
-            throw takeObject(r0);
-        }
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-}
-
-function __wasm_bindgen_func_elem_1070(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1070(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
-}
-
-const GeoReferenceJsFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_georeferencejs_free(ptr >>> 0, 1));
-const GpuGeometryFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_gpugeometry_free(ptr >>> 0, 1));
-const GpuInstancedGeometryFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_gpuinstancedgeometry_free(ptr >>> 0, 1));
-const GpuInstancedGeometryCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_gpuinstancedgeometrycollection_free(ptr >>> 0, 1));
-const GpuInstancedGeometryRefFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_gpuinstancedgeometryref_free(ptr >>> 0, 1));
-const GpuMeshMetadataFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_gpumeshmetadata_free(ptr >>> 0, 1));
-const IfcAPIFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ifcapi_free(ptr >>> 0, 1));
-const InstanceDataFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_instancedata_free(ptr >>> 0, 1));
-const InstancedGeometryFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_instancedgeometry_free(ptr >>> 0, 1));
-const InstancedMeshCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_instancedmeshcollection_free(ptr >>> 0, 1));
-const MeshCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_meshcollection_free(ptr >>> 0, 1));
-const MeshCollectionWithRtcFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_meshcollectionwithrtc_free(ptr >>> 0, 1));
-const MeshDataJsFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_meshdatajs_free(ptr >>> 0, 1));
-const RtcOffsetJsFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_rtcoffsetjs_free(ptr >>> 0, 1));
-const SymbolicCircleFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_symboliccircle_free(ptr >>> 0, 1));
-const SymbolicPolylineFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_symbolicpolyline_free(ptr >>> 0, 1));
-const SymbolicRepresentationCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_symbolicrepresentationcollection_free(ptr >>> 0, 1));
-const ZeroCopyMeshFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_zerocopymesh_free(ptr >>> 0, 1));
-
-function addHeapObject(obj) {
-    if (heap_next === heap.length) heap.push(heap.length + 1);
-    const idx = heap_next;
-    heap_next = heap[idx];
-
-    heap[idx] = obj;
-    return idx;
-}
-
-const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
-
-function dropObject(idx) {
-    if (idx < 1028) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function getArrayF32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
-
-function getArrayF64FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
-}
-
-function getArrayU32FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
-}
-
-let cachedDataViewMemory0 = null;
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-let cachedFloat32ArrayMemory0 = null;
-function getFloat32ArrayMemory0() {
-    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
-        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
-    }
-    return cachedFloat32ArrayMemory0;
-}
-
-let cachedFloat64ArrayMemory0 = null;
-function getFloat64ArrayMemory0() {
-    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
-        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
-    }
-    return cachedFloat64ArrayMemory0;
-}
-
-function getStringFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return decodeText(ptr, len);
-}
-
-let cachedUint32ArrayMemory0 = null;
-function getUint32ArrayMemory0() {
-    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
-        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
-    }
-    return cachedUint32ArrayMemory0;
-}
-
-let cachedUint8ArrayMemory0 = null;
-function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
-        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
-    }
-    return cachedUint8ArrayMemory0;
-}
-
-function getObject(idx) { return heap[idx]; }
-
-function handleError(f, args) {
-    try {
-        return f.apply(this, args);
-    } catch (e) {
-        wasm.__wbindgen_export(addHeapObject(e));
+        return ret >>> 0;
     }
-}
-
-let heap = new Array(1024).fill(undefined);
-heap.push(undefined, null, true, false);
-
-let heap_next = heap.length;
-
-function isLikeNone(x) {
-    return x === undefined || x === null;
-}
-
-function makeMutClosure(arg0, arg1, dtor, f) {
-    const state = { a: arg0, b: arg1, cnt: 1, dtor };
-    const real = (...args) => {
-
-        // First up with a closure we increment the internal reference
-        // count. This ensures that the Rust closure environment won't
-        // be deallocated while we're invoking it.
-        state.cnt++;
-        const a = state.a;
-        state.a = 0;
-        try {
-            return f(a, state.b, ...args);
-        } finally {
-            state.a = a;
-            real._wbg_cb_unref();
-        }
-    };
-    real._wbg_cb_unref = () => {
-        if (--state.cnt === 0) {
-            state.dtor(state.a, state.b);
-            state.a = 0;
-            CLOSURE_DTORS.unregister(state);
-        }
-    };
-    CLOSURE_DTORS.register(real, state, state);
-    return real;
-}
-
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
-
-function passStringToWasm0(arg, malloc, realloc) {
-    if (realloc === undefined) {
-        const buf = cachedTextEncoder.encode(arg);
-        const ptr = malloc(buf.length, 1) >>> 0;
-        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
-        WASM_VECTOR_LEN = buf.length;
-        return ptr;
+    /**
+     * Get triangle count
+     * @returns {number}
+     */
+    get triangle_count() {
+        const ret = wasm.gpuinstancedgeometry_triangleCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
-
-    let len = arg.length;
-    let ptr = malloc(len, 1) >>> 0;
-
-    const mem = getUint8ArrayMemory0();
-
-    let offset = 0;
-
-    for (; offset < len; offset++) {
-        const code = arg.charCodeAt(offset);
-        if (code > 0x7F) break;
-        mem[ptr + offset] = code;
+    /**
+     * Create a new zero-copy mesh from a Mesh
+     */
+    constructor() {
+        const ret = wasm.zerocopymesh_new();
+        this.__wbg_ptr = ret >>> 0;
+        ZeroCopyMeshFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
-    if (offset !== len) {
-        if (offset !== 0) {
-            arg = arg.slice(offset);
-        }
-        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
-        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
-        const ret = cachedTextEncoder.encodeInto(arg, view);
-
-        offset += ret.written;
-        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    /**
+     * Check if mesh is empty
+     * @returns {boolean}
+     */
+    get is_empty() {
+        const ret = wasm.zerocopymesh_is_empty(this.__wbg_ptr);
+        return ret !== 0;
     }
-
-    WASM_VECTOR_LEN = offset;
-    return ptr;
 }
+if (Symbol.dispose) ZeroCopyMesh.prototype[Symbol.dispose] = ZeroCopyMesh.prototype.free;
 
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
+/**
+ * Get WASM memory to allow JavaScript to create TypedArray views
+ * @returns {any}
+ */
+export function get_memory() {
+    const ret = wasm.get_memory();
+    return takeObject(ret);
 }
 
-let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-cachedTextDecoder.decode();
-const MAX_SAFARI_DECODE_BYTES = 2146435072;
-let numBytesDecoded = 0;
-function decodeText(ptr, len) {
-    numBytesDecoded += len;
-    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
-        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
-        cachedTextDecoder.decode();
-        numBytesDecoded = len;
-    }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+/**
+ * Initialize the WASM module.
+ *
+ * This function is called automatically when the WASM module is loaded.
+ * It sets up panic hooks for better error messages in the browser console.
+ */
+export function init() {
+    wasm.init();
 }
 
-const cachedTextEncoder = new TextEncoder();
-
-if (!('encodeInto' in cachedTextEncoder)) {
-    cachedTextEncoder.encodeInto = function (arg, view) {
-        const buf = cachedTextEncoder.encode(arg);
-        view.set(buf);
-        return {
-            read: arg.length,
-            written: buf.length
-        };
-    };
+/**
+ * Get the version of IFC-Lite.
+ *
+ * # Returns
+ *
+ * Version string (e.g., "0.1.0")
+ *
+ * # Example
+ *
+ * ```javascript
+ * console.log(`IFC-Lite version: ${version()}`);
+ * ```
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.version(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
+    }
 }
 
-let WASM_VECTOR_LEN = 0;
-
-let wasmModule, wasm;
-function __wbg_finalize_init(instance, module) {
-    wasm = instance.exports;
-    wasmModule = module;
-    cachedDataViewMemory0 = null;
-    cachedFloat32ArrayMemory0 = null;
-    cachedFloat64ArrayMemory0 = null;
-    cachedUint32ArrayMemory0 = null;
-    cachedUint8ArrayMemory0 = null;
-    wasm.__wbindgen_start();
-    return wasm;
-}
+const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
     if (typeof Response === 'function' && module instanceof Response) {
@@ -2867,12 +2639,14 @@ async function __wbg_load(module, imports) {
             try {
                 return await WebAssembly.instantiateStreaming(module, imports);
             } catch (e) {
-                const validResponse = module.ok && expectedResponseType(module.type);
+                const validResponse = module.ok && EXPECTED_RESPONSE_TYPES.has(module.type);
 
                 if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
                     console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
 
-                } else { throw e; }
+                } else {
+                    throw e;
+                }
             }
         }
 
@@ -2887,20 +2661,252 @@ async function __wbg_load(module, imports) {
             return instance;
         }
     }
+}
 
-    function expectedResponseType(type) {
-        switch (type) {
-            case 'basic': case 'cors': case 'default': return true;
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
+        const ret = Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+        const ret = typeof(getObject(arg0)) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+        const ret = getObject(arg0) === undefined;
+        return ret;
+    };
+    imports.wbg.__wbg___wbindgen_memory_a342e963fbcabd68 = function() {
+        const ret = wasm.memory;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'number' ? obj : undefined;
+        getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+    };
+    imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
+        getObject(arg0)._wbg_cb_unref();
+    };
+    imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
+        const ret = getObject(arg0).call(getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_call_c8baa5c5e72d274e = function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_clearTimeout_5a54f8841c30079a = function(arg0) {
+        const ret = clearTimeout(takeObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_debug_9d0c87ddda3dc485 = function(arg0) {
+        console.debug(getObject(arg0));
+    };
+    imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+        let deferred0_0;
+        let deferred0_1;
+        try {
+            deferred0_0 = arg0;
+            deferred0_1 = arg1;
+            console.error(getStringFromWasm0(arg0, arg1));
+        } finally {
+            wasm.__wbindgen_export2(deferred0_0, deferred0_1, 1);
         }
-        return false;
-    }
+    };
+    imports.wbg.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+        const ret = Reflect.get(getObject(arg0), getObject(arg1));
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_gpugeometry_new = function(arg0) {
+        const ret = GpuGeometry.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_instancedgeometry_new = function(arg0) {
+        const ret = InstancedGeometry.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_length_86ce4877baf913bb = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+        const ret = getObject(arg0).length;
+        return ret;
+    };
+    imports.wbg.__wbg_meshdatajs_new = function(arg0) {
+        const ret = MeshDataJs.__wrap(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
+        const ret = new Object();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_25f239778d6112b9 = function() {
+        const ret = new Array();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+        const ret = new Error();
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
+        try {
+            var state0 = {a: arg0, b: arg1};
+            var cb0 = (arg0, arg1) => {
+                const a = state0.a;
+                state0.a = 0;
+                try {
+                    return __wasm_bindgen_func_elem_1052(a, state0.b, arg0, arg1);
+                } finally {
+                    state0.a = a;
+                }
+            };
+            const ret = new Promise(cb0);
+            return addHeapObject(ret);
+        } finally {
+            state0.a = state0.b = 0;
+        }
+    };
+    imports.wbg.__wbg_new_from_slice_41e2764a343e3cb1 = function(arg0, arg1) {
+        const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_from_slice_db0691b69e9d3891 = function(arg0, arg1) {
+        const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_prototypesetcall_96cc7097487b926d = function(arg0, arg1, arg2) {
+        Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), getObject(arg2));
+    };
+    imports.wbg.__wbg_push_7d9be8f38fc13975 = function(arg0, arg1) {
+        const ret = getObject(arg0).push(getObject(arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_queueMicrotask_9b549dfce8865860 = function(arg0) {
+        const ret = getObject(arg0).queueMicrotask;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_queueMicrotask_fca69f5bfad613a5 = function(arg0) {
+        queueMicrotask(getObject(arg0));
+    };
+    imports.wbg.__wbg_resolve_fd5bfbaa4ce36e1e = function(arg0) {
+        const ret = Promise.resolve(getObject(arg0));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_setTimeout_db2dbaeefb6f39c7 = function() { return handleError(function (arg0, arg1) {
+        const ret = setTimeout(getObject(arg0), arg1);
+        return addHeapObject(ret);
+    }, arguments) };
+    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+        getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_set_781438a03c0c3c81 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+        const ret = getObject(arg1).stack;
+        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addHeapObject(ret);
+    };
+    imports.wbg.__wbg_then_4f95312d68691235 = function(arg0, arg1) {
+        const ret = getObject(arg0).then(getObject(arg1));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
+        console.warn(getObject(arg0));
+    };
+    imports.wbg.__wbindgen_cast_0663cdfcad33dbe7 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 135, function: Function { arguments: [Externref], shim_idx: 136, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1019, __wasm_bindgen_func_elem_1021);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+        // Cast intrinsic for `Ref(String) -> Externref`.
+        const ret = getStringFromWasm0(arg0, arg1);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+        // Cast intrinsic for `U64 -> Externref`.
+        const ret = BigInt.asUintN(64, arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+        // Cast intrinsic for `F64 -> Externref`.
+        const ret = arg0;
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_dcf665cfcd643c22 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 46, function: Function { arguments: [], shim_idx: 47, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_467, __wasm_bindgen_func_elem_469);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+        const ret = getObject(arg0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+        takeObject(arg0);
+    };
+
+    return imports;
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
 }
 
 function initSync(module) {
     if (wasm !== undefined) return wasm;
 
 
-    if (module !== undefined) {
+    if (typeof module !== 'undefined') {
         if (Object.getPrototypeOf(module) === Object.prototype) {
             ({module} = module)
         } else {
@@ -2920,7 +2926,7 @@ async function __wbg_init(module_or_path) {
     if (wasm !== undefined) return wasm;
 
 
-    if (module_or_path !== undefined) {
+    if (typeof module_or_path !== 'undefined') {
         if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
             ({module_or_path} = module_or_path)
         } else {
@@ -2928,7 +2934,7 @@ async function __wbg_init(module_or_path) {
         }
     }
 
-    if (module_or_path === undefined) {
+    if (typeof module_or_path === 'undefined') {
         module_or_path = new URL('ifc-lite_bg.wasm', import.meta.url);
     }
     const imports = __wbg_get_imports();
@@ -2942,4 +2948,5 @@ async function __wbg_init(module_or_path) {
     return __wbg_finalize_init(instance, module);
 }
 
-export { initSync, __wbg_init as default };
+export { initSync };
+export default __wbg_init;