@ifc-lite/wasm 1.19.1 → 2.0.0

package/pkg/ifc-lite.js

@@ -220,877 +220,53 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_1533(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_1533(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_1685(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_1685(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_1573(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1573(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_1832(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1832(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 ProfileCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_profilecollection_free(ptr >>> 0, 1));
-
-const ProfileEntryJsFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_profileentryjs_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 SymbolicFillAreaFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_symbolicfillarea_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 SymbolicTextFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_symbolictext_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;
-    }
-    __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);
-    }
-    /**
-     * 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);
-        }
-    }
-    /**
-     * 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;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Get rotation angle in radians
-     * @returns {number}
-     */
-    get rotation() {
-        const ret = wasm.georeferencejs_rotation(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * 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);
-        }
-    }
-    /**
-     * Eastings (X offset)
-     * @returns {number}
-     */
-    get eastings() {
-        const ret = wasm.__wbg_get_georeferencejs_eastings(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Eastings (X offset)
-     * @param {number} arg0
-     */
-    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
-     */
-    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
-     */
-    set orthogonal_height(arg0) {
-        wasm.__wbg_set_georeferencejs_orthogonal_height(this.__wbg_ptr, arg0);
-    }
-    /**
-     * 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;
-    }
-    /**
-     * X-axis abscissa (cos of rotation)
-     * @param {number} arg0
-     */
-    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
-     */
-    set x_axis_ordinate(arg0) {
-        wasm.__wbg_set_georeferencejs_x_axis_ordinate(this.__wbg_ptr, arg0);
-    }
-    /**
-     * Scale factor
-     * @returns {number}
-     */
-    get scale() {
-        const ret = wasm.__wbg_get_georeferencejs_scale(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Scale factor
-     * @param {number} arg0
-     */
-    set scale(arg0) {
-        wasm.__wbg_set_georeferencejs_scale(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;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_gpugeometry_free(ptr, 0);
-    }
-    /**
-     * Get number of meshes in this geometry batch
-     * @returns {number}
-     */
-    get meshCount() {
-        const ret = wasm.gpugeometry_meshCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get length of indices array (in u32 elements)
-     * @returns {number}
-     */
-    get indicesLen() {
-        const ret = wasm.gpugeometry_indicesLen(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get pointer to indices array for zero-copy view
-     * @returns {number}
-     */
-    get indicesPtr() {
-        const ret = wasm.gpugeometry_indicesPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get X component of RTC offset
-     * @returns {number}
-     */
-    get rtcOffsetX() {
-        const ret = wasm.gpugeometry_rtcOffsetX(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Get Y component of RTC offset
-     * @returns {number}
-     */
-    get rtcOffsetY() {
-        const ret = wasm.gpugeometry_rtcOffsetY(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * Get Z component of RTC offset
-     * @returns {number}
-     */
-    get rtcOffsetZ() {
-        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
-     * @param {number} y
-     * @param {number} z
-     */
-    set_rtc_offset(x, y, z) {
-        wasm.gpugeometry_set_rtc_offset(this.__wbg_ptr, x, y, z);
-    }
-    /**
-     * Get length of vertex data array (in f32 elements, not bytes)
-     * @returns {number}
-     */
-    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}
-     */
-    get totalVertexCount() {
-        const ret = wasm.gpugeometry_totalVertexCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get byte length of indices (for GPU buffer creation)
-     * @returns {number}
-     */
-    get indicesByteLength() {
-        const ret = wasm.gpugeometry_indicesByteLength(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get total triangle count
-     * @returns {number}
-     */
-    get totalTriangleCount() {
-        const ret = wasm.gpugeometry_totalTriangleCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get byte length of vertex data (for GPU buffer creation)
-     * @returns {number}
-     */
-    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;
-
-/**
- * GPU-ready instanced geometry for efficient rendering of repeated shapes
- *
- * Data layout:
- * - vertex_data: Interleaved [px, py, pz, nx, ny, nz, ...] (shared geometry)
- * - indices: Triangle indices (shared geometry)
- * - instance_data: [transform (16 floats) + color (4 floats)] per instance = 20 floats
- */
-export class GpuInstancedGeometry {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(GpuInstancedGeometry.prototype);
-        obj.__wbg_ptr = ptr;
-        GpuInstancedGeometryFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GpuInstancedGeometryFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_gpuinstancedgeometry_free(ptr, 0);
-    }
-    /**
-     * @returns {bigint}
-     */
-    get geometryId() {
-        const ret = wasm.gpuinstancedgeometry_geometryId(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * @returns {number}
-     */
-    get indicesLen() {
-        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get indicesPtr() {
-        const ret = wasm.gpuinstancedgeometry_indicesPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get vertexCount() {
-        const ret = wasm.gpuinstancedgeometry_vertexCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get instanceCount() {
-        const ret = wasm.gpuinstancedgeometry_instanceCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get triangleCount() {
-        const ret = wasm.gpuinstancedgeometry_triangleCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get vertexDataLen() {
-        const ret = wasm.gpuinstancedgeometry_vertexDataLen(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get vertexDataPtr() {
-        const ret = wasm.gpuinstancedgeometry_vertexDataPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get instanceDataLen() {
-        const ret = wasm.gpuinstancedgeometry_instanceDataLen(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get instanceDataPtr() {
-        const ret = wasm.gpuinstancedgeometry_instanceDataPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get indicesByteLength() {
-        const ret = wasm.gpuinstancedgeometry_indicesByteLength(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get vertexDataByteLength() {
-        const ret = wasm.gpuinstancedgeometry_vertexDataByteLength(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get instanceExpressIdsPtr() {
-        const ret = wasm.gpuinstancedgeometry_instanceExpressIdsPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    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;
-
-/**
- * Collection of GPU-ready instanced geometries
- */
-export class GpuInstancedGeometryCollection {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(GpuInstancedGeometryCollection.prototype);
-        obj.__wbg_ptr = ptr;
-        GpuInstancedGeometryCollectionFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GpuInstancedGeometryCollectionFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_gpuinstancedgeometrycollection_free(ptr, 0);
-    }
-    /**
-     * @param {number} index
-     * @returns {GpuInstancedGeometry | undefined}
-     */
-    get(index) {
-        const ret = wasm.gpuinstancedgeometrycollection_get(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : GpuInstancedGeometry.__wrap(ret);
-    }
-    constructor() {
-        const ret = wasm.gpuinstancedgeometrycollection_new();
-        this.__wbg_ptr = ret >>> 0;
-        GpuInstancedGeometryCollectionFinalization.register(this, this.__wbg_ptr, this);
-        return this;
-    }
-    /**
-     * @returns {number}
-     */
-    get length() {
-        const ret = wasm.gpuinstancedgeometrycollection_length(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * 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;
-
-/**
- * Pointer-friendly geometry view with owned backing storage.
- * Owning buffers prevents dangling pointers after collection mutation/drop.
- */
-export class GpuInstancedGeometryRef {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(GpuInstancedGeometryRef.prototype);
-        obj.__wbg_ptr = ptr;
-        GpuInstancedGeometryRefFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GpuInstancedGeometryRefFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_gpuinstancedgeometryref_free(ptr, 0);
-    }
-    /**
-     * @returns {bigint}
-     */
-    get geometryId() {
-        const ret = wasm.gpuinstancedgeometry_geometryId(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * @returns {number}
-     */
-    get indicesLen() {
-        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get indicesPtr() {
-        const ret = wasm.gpuinstancedgeometry_indicesPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get instanceCount() {
-        const ret = wasm.gpuinstancedgeometry_instanceCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get vertexDataLen() {
-        const ret = wasm.gpuinstancedgeometry_vertexDataLen(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get vertexDataPtr() {
-        const ret = wasm.gpuinstancedgeometry_vertexDataPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get instanceDataLen() {
-        const ret = wasm.gpuinstancedgeometry_instanceDataLen(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get instanceDataPtr() {
-        const ret = wasm.gpuinstancedgeometry_instanceDataPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get indicesByteLength() {
-        const ret = wasm.gpuinstancedgeometry_indicesByteLength(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get vertexDataByteLength() {
-        const ret = wasm.gpuinstancedgeometry_vertexDataByteLength(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get instanceExpressIdsPtr() {
-        const ret = wasm.gpuinstancedgeometry_instanceExpressIdsPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get instanceDataByteLength() {
-        const ret = wasm.gpuinstancedgeometry_instanceDataByteLength(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-}
-if (Symbol.dispose) GpuInstancedGeometryRef.prototype[Symbol.dispose] = GpuInstancedGeometryRef.prototype.free;
-
-/**
- * Metadata for a single mesh within the GPU geometry buffer
- */
-export class GpuMeshMetadata {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(GpuMeshMetadata.prototype);
-        obj.__wbg_ptr = ptr;
-        GpuMeshMetadataFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        GpuMeshMetadataFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_gpumeshmetadata_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    get expressId() {
-        const ret = wasm.gpumeshmetadata_expressId(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get indexCount() {
-        const ret = wasm.gpumeshmetadata_indexCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get ifcTypeIdx() {
-        const ret = wasm.gpumeshmetadata_ifcTypeIdx(this.__wbg_ptr);
-        return ret;
-    }
-    /**
-     * @returns {number}
-     */
-    get indexOffset() {
-        const ret = wasm.gpumeshmetadata_indexOffset(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get vertexCount() {
-        const ret = wasm.gpumeshmetadata_vertexCount(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get vertexOffset() {
-        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;
+const IfcAPIFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ifcapi_free(ptr >>> 0, 1));
+
+const MeshCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshcollection_free(ptr >>> 0, 1));
+
+const MeshDataJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_meshdatajs_free(ptr >>> 0, 1));
+
+const ProfileCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_profilecollection_free(ptr >>> 0, 1));
+
+const ProfileEntryJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_profileentryjs_free(ptr >>> 0, 1));
+
+const SymbolicCircleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symboliccircle_free(ptr >>> 0, 1));
+
+const SymbolicFillAreaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symbolicfillarea_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 SymbolicTextFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_symbolictext_free(ptr >>> 0, 1));
 
 /**
  * Main IFC-Lite API
@@ -1106,74 +282,6 @@ export class IfcAPI {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_ifcapi_free(ptr, 0);
     }
-    /**
-     * Parse IFC file and return individual meshes with express IDs and colors
-     * This matches the MeshData[] format expected by the viewer
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * const collection = api.parseMeshes(ifcData);
-     * for (let i = 0; i < collection.length; i++) {
-     *   const mesh = collection.get(i);
-     *   console.log('Express ID:', mesh.expressId);
-     *   console.log('Positions:', mesh.positions);
-     *   console.log('Color:', mesh.color);
-     * }
-     * ```
-     * @param {string} content
-     * @returns {MeshCollection}
-     */
-    parseMeshes(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseMeshes(this.__wbg_ptr, ptr0, len0);
-        return MeshCollection.__wrap(ret);
-    }
-    /**
-     * Parse IFC file with streaming mesh batches for progressive rendering
-     * Calls the callback with batches of meshes, yielding to browser between batches
-     *
-     * Options:
-     * - `batchSize`: Number of meshes per batch (default: 25)
-     * - `onBatch(meshes, progress)`: Called for each batch of meshes
-     * - `onRtcOffset({x, y, z, hasRtc})`: Called early with RTC offset for camera/world setup
-     * - `onColorUpdate(Map<id, color>)`: Called with style updates after initial render
-     * - `onComplete(stats)`: Called when parsing completes with stats including rtcOffset
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * await api.parseMeshesAsync(ifcData, {
-     *   batchSize: 100,
-     *   onRtcOffset: (rtc) => {
-     *     if (rtc.hasRtc) {
-     *       // Model uses large coordinates - adjust camera/world origin
-     *       viewer.setWorldOffset(rtc.x, rtc.y, rtc.z);
-     *     }
-     *   },
-     *   onBatch: (meshes, progress) => {
-     *     for (const mesh of meshes) {
-     *       scene.add(createThreeMesh(mesh));
-     *     }
-     *     console.log(`Progress: ${progress.percent}%`);
-     *   },
-     *   onComplete: (stats) => {
-     *     console.log(`Done! ${stats.totalMeshes} meshes`);
-     *     // stats.rtcOffset also available here: {x, y, z, hasRtc}
-     *   }
-     * });
-     * ```
-     * @param {string} content
-     * @param {any} options
-     * @returns {Promise<any>}
-     */
-    parseMeshesAsync(content, options) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseMeshesAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
-        return takeObject(ret);
-    }
     /**
      * Fast pre-pass: scans for geometry entities ONLY (skips style/void/material resolution).
      * Returns job list + unit scale + RTC offset in ~1-2s instead of ~6s.
@@ -1200,108 +308,6 @@ export class IfcAPI {
         const ret = wasm.ifcapi_buildPrePassOnce(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
-    /**
-     * Parse a subset of IFC geometry entities by index range.
-     *
-     * Performs the full pre-pass (entity index, combined style/void/brep scan)
-     * but only processes geometry entities whose index (in the combined
-     * simple + complex job list) falls within `[start_idx, end_idx)`.
-     *
-     * This enables Web Worker parallelization: each worker processes a
-     * disjoint slice of the entity list while sharing the same pre-pass data.
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * // Worker 1: entities 0..500
-     * const batch1 = api.parseMeshesSubset(content, 0, 500);
-     * // Worker 2: entities 500..1000
-     * const batch2 = api.parseMeshesSubset(content, 500, 1000);
-     * ```
-     * @param {string} content
-     * @param {number} start_idx
-     * @param {number} end_idx
-     * @param {boolean} skip_expensive
-     * @returns {MeshCollection}
-     */
-    parseMeshesSubset(content, start_idx, end_idx, skip_expensive) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseMeshesSubset(this.__wbg_ptr, ptr0, len0, start_idx, end_idx, skip_expensive);
-        return MeshCollection.__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
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * const gpuGeom = api.parseToGpuGeometry(ifcData);
-     *
-     * // Get WASM memory for zero-copy views
-     * const memory = api.getMemory();
-     *
-     * // Create views directly into WASM memory (NO COPY!)
-     * const vertexView = new Float32Array(
-     *   memory.buffer,
-     *   gpuGeom.vertexDataPtr,
-     *   gpuGeom.vertexDataLen
-     * );
-     * const indexView = new Uint32Array(
-     *   memory.buffer,
-     *   gpuGeom.indicesPtr,
-     *   gpuGeom.indicesLen
-     * );
-     *
-     * // Upload directly to GPU (single copy: WASM → GPU)
-     * device.queue.writeBuffer(vertexBuffer, 0, vertexView);
-     * device.queue.writeBuffer(indexBuffer, 0, indexView);
-     *
-     * // Free when done
-     * gpuGeom.free();
-     * ```
-     * @param {string} content
-     * @returns {GpuGeometry}
-     */
-    parseToGpuGeometry(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        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);
-    }
     /**
      * Process geometry for a subset of pre-scanned entities.
      * Takes raw bytes and pre-pass data from buildPrePassOnce.
@@ -1337,245 +343,53 @@ export class IfcAPI {
         const ret = wasm.ifcapi_processGeometryBatch(this.__wbg_ptr, ptr0, len0, ptr1, len1, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
         return MeshCollection.__wrap(ret);
     }
-    /**
-     * Phase 1 of Path C — sharded entity-index scan.
-     *
-     * Walks the bytes in `[range_start, range_end)` once and emits
-     * `(express_id, byte_offset, byte_length)` triples for every entity
-     * whose `#N=` opener falls in that range. Byte offsets are GLOBAL
-     * (relative to file start), so multiple shards' outputs concatenate
-     * without rewriting.
-     *
-     * Cross-boundary handling: the scanner rewinds `range_start` to the
-     * byte after the previous `\n` so we don't mis-parse a half entity.
-     * The previous shard owns any entity whose opener is BEFORE its own
-     * range_end (its terminator may extend past it; that's fine — the
-     * scanner walks STEP entities to their terminating `;`, even if that
-     * terminator is past the shard's nominal range_end).
-     *
-     * Returns nothing through the JS callback for performance signals;
-     * emits exactly one `index-shard` event with three Uint32Arrays:
-     *   `{ type: "index-shard", ids: Uint32Array, starts: Uint32Array,
-     *      lengths: Uint32Array, shardStart: u32, shardEnd: u32 }`
-     *
-     * Used by the JS-side shard coordinator to merge N shards' indices
-     * into a single entity-index without paying the 3 s single-threaded
-     * scan cost. Style and job emission are NOT done here — they remain
-     * the job of the existing `build_pre_pass_streaming` (which can be
-     * called on shard 0 in parallel with the other shards' index-only
-     * scans).
-     * @param {Uint8Array} data
-     * @param {Function} on_event
-     * @param {number} range_start
-     * @param {number} range_end
-     * @returns {any}
-     */
-    scanEntityIndexShard(data, on_event, range_start, range_end) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.ifcapi_scanEntityIndexShard(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(on_event), range_start, range_end);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            heap[stack_pointer++] = undefined;
-        }
-    }
     /**
      * Streaming pre-pass: emits geometry jobs in chunks via a JS callback
      * instead of waiting for the full file scan to complete.
      *
-     * Single linear walk over the file:
-     *   1. Builds the entity index incrementally from the same scan that
-     *      collects geometry jobs (the old `build_pre_pass_fast` did two
-     *      full-file scans — one for entities, one for the index — which
-     *      doubled wall-clock).
-     *   2. As soon as `IFCPROJECT` has been seen, the unit scale and the
-     *      first ~50 geometry jobs have been collected, resolves
-     *      `unitScale` + `rtcOffset` and emits a `meta` callback so the
-     *      JS host can spin up geometry process workers.
-     *   3. Emits `jobs` callbacks every `chunk_size` jobs (or fewer if
-     *      the meta phase already buffered some).
-     *   4. Emits `complete` with the total job count at end of scan.
-     *
-     * On a 986 MB / 14 M-entity file this drops time-to-first-geometry
-     * from ~17 s (full pre-pass + worker spawn + first batch) to ~3 s
-     * (first 100 K bytes scanned + meta + first chunk).
-     *
-     * The callback receives a single `JsValue` argument shaped as one of:
-     *   `{ type: "meta", unitScale, rtcOffset: [x,y,z], needsShift, buildingRotation? }`
-     *   `{ type: "jobs", jobs: Uint32Array }`     // [id, start, end] triples
-     *   `{ type: "complete", totalJobs }`
-     * @param {Uint8Array} data
-     * @param {Function} on_event
-     * @param {number} chunk_size
-     * @returns {any}
-     */
-    buildPrePassStreaming(data, on_event, chunk_size) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export3);
-            const len0 = WASM_VECTOR_LEN;
-            wasm.ifcapi_buildPrePassStreaming(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(on_event), chunk_size);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            heap[stack_pointer++] = undefined;
-        }
-    }
-    /**
-     * Parse IFC file with streaming GPU-ready geometry batches
-     *
-     * Yields batches of GPU-ready geometry for progressive rendering with zero-copy upload.
-     * Uses fast-first-frame streaming: simple geometry (walls, slabs) first.
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * const memory = api.getMemory();
-     *
-     * await api.parseToGpuGeometryAsync(ifcData, {
-     *   batchSize: 25,
-     *   onBatch: (gpuGeom, progress) => {
-     *     // Create zero-copy views
-     *     const vertexView = new Float32Array(
-     *       memory.buffer,
-     *       gpuGeom.vertexDataPtr,
-     *       gpuGeom.vertexDataLen
-     *     );
-     *
-     *     // Upload to GPU
-     *     device.queue.writeBuffer(vertexBuffer, 0, vertexView);
-     *
-     *     // IMPORTANT: Free immediately after upload!
-     *     gpuGeom.free();
-     *   },
-     *   onComplete: (stats) => {
-     *     console.log(`Done! ${stats.totalMeshes} meshes`);
-     *   }
-     * });
-     * ```
-     * @param {string} content
-     * @param {any} options
-     * @returns {Promise<any>}
-     */
-    parseToGpuGeometryAsync(content, options) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        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
-     *
-     * Groups identical geometries by hash for efficient GPU instancing.
-     * Returns a collection of instanced geometries with pointer access.
-     * @param {string} content
-     * @returns {GpuInstancedGeometryCollection}
-     */
-    parseToGpuInstancedGeometry(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseToGpuInstancedGeometry(this.__wbg_ptr, ptr0, len0);
-        return GpuInstancedGeometryCollection.__wrap(ret);
-    }
-    /**
-     * Process instanced geometry for a subset of pre-scanned entities.
-     * Takes raw bytes and pre-pass data from buildPrePassOnce.
-     * @param {Uint8Array} data
-     * @param {Uint32Array} jobs_flat
-     * @param {number} unit_scale
-     * @param {number} rtc_x
-     * @param {number} rtc_y
-     * @param {number} rtc_z
-     * @param {boolean} needs_shift
-     * @param {Uint32Array} style_ids
-     * @param {Uint8Array} style_colors
-     * @returns {InstancedMeshCollection}
-     */
-    processInstancedGeometryBatch(data, jobs_flat, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, style_ids, style_colors) {
-        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export3);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray32ToWasm0(jobs_flat, wasm.__wbindgen_export3);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArray32ToWasm0(style_ids, wasm.__wbindgen_export3);
-        const len2 = WASM_VECTOR_LEN;
-        const ptr3 = passArray8ToWasm0(style_colors, wasm.__wbindgen_export3);
-        const len3 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_processInstancedGeometryBatch(this.__wbg_ptr, ptr0, len0, ptr1, len1, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, ptr2, len2, ptr3, len3);
-        return InstancedMeshCollection.__wrap(ret);
-    }
-    /**
-     * Parse IFC file with zero-copy mesh data
-     * Maximum performance - returns mesh with direct memory access
-     *
-     * Example:
-     * ```javascript
-     * const api = new IfcAPI();
-     * const mesh = await api.parseZeroCopy(ifcData);
+     * Single linear walk over the file:
+     *   1. Builds the entity index incrementally from the same scan that
+     *      collects geometry jobs (the old `build_pre_pass_fast` did two
+     *      full-file scans — one for entities, one for the index — which
+     *      doubled wall-clock).
+     *   2. As soon as `IFCPROJECT` has been seen, the unit scale and the
+     *      first ~50 geometry jobs have been collected, resolves
+     *      `unitScale` + `rtcOffset` and emits a `meta` callback so the
+     *      JS host can spin up geometry process workers.
+     *   3. Emits `jobs` callbacks every `chunk_size` jobs (or fewer if
+     *      the meta phase already buffered some).
+     *   4. Emits `complete` with the total job count at end of scan.
      *
-     * // Create TypedArray views (NO COPYING!)
-     * const memory = await api.getMemory();
-     * const positions = new Float32Array(
-     *   memory.buffer,
-     *   mesh.positions_ptr,
-     *   mesh.positions_len
-     * );
+     * On a 986 MB / 14 M-entity file this drops time-to-first-geometry
+     * from ~17 s (full pre-pass + worker spawn + first batch) to ~3 s
+     * (first 100 K bytes scanned + meta + first chunk).
      *
-     * // Upload directly to GPU
-     * gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW);
-     * ```
-     * @param {string} content
-     * @returns {ZeroCopyMesh}
+     * The callback receives a single `JsValue` argument shaped as one of:
+     *   `{ type: "meta", unitScale, rtcOffset: [x,y,z], needsShift, buildingRotation? }`
+     *   `{ type: "jobs", jobs: Uint32Array }`     // [id, start, end] triples
+     *   `{ type: "complete", totalJobs }`
+     * @param {Uint8Array} data
+     * @param {Function} on_event
+     * @param {number} chunk_size
+     * @returns {any}
      */
-    parseZeroCopy(content) {
-        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_parseZeroCopy(this.__wbg_ptr, ptr0, len0);
-        return ZeroCopyMesh.__wrap(ret);
+    buildPrePassStreaming(data, on_event, chunk_size) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export3);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_buildPrePassStreaming(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(on_event), chunk_size);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
     }
     /**
      * Extract raw profile polygons from all building elements with `IfcExtrudedAreaSolid`
@@ -1608,52 +422,6 @@ export class IfcAPI {
         const ret = wasm.ifcapi_extractProfiles(this.__wbg_ptr, ptr0, len0, model_index);
         return ProfileCollection.__wrap(ret);
     }
-    /**
-     * 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);
-        }
-    }
     /**
      * Get WASM memory for zero-copy access
      * @returns {any}
@@ -1699,17 +467,15 @@ export class IfcAPI {
     /**
      * Toggle the "render multilayer walls as a single solid" mode (issue #540).
      *
-     * When `enabled` is `true`, every subsequent `parseMeshes*` call will
-     * suppress geometry emission for `IfcBuildingElementPart` entities whose
-     * `IfcRelAggregates` parent wall is sliceable (has an
+     * When `enabled` is `true`, every subsequent `processGeometryBatch` call
+     * will suppress geometry emission for `IfcBuildingElementPart` entities
+     * whose `IfcRelAggregates` parent wall is sliceable (has an
      * `IfcMaterialLayerSetUsage`) AND has its own `Representation`. The
      * parent wall keeps its per-layer sub-mesh colouring, so the visual
      * result is the same as the layered render but with one mesh per wall
      * instead of one per layer part — much cheaper for both CPU and GPU.
      *
-     * Default is `false`. Pass `true` before calling `parseMeshes`,
-     * `parseMeshesSubset`, `parseMeshesAsync`, `parseMeshesInstanced`, or
-     * `parseMeshesInstancedAsync`.
+     * Default is `false`. Pass `true` before calling `processGeometryBatch`.
      * @param {boolean} enabled
      */
     setMergeLayers(enabled) {
@@ -1765,53 +531,6 @@ export class IfcAPI {
         const ret = wasm.ifcapi_is_ready(this.__wbg_ptr);
         return ret !== 0;
     }
-    /**
-     * 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
@@ -1889,219 +608,46 @@ export class IfcAPI {
      * 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 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
- */
-export class InstanceData {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(InstanceData.prototype);
-        obj.__wbg_ptr = ptr;
-        InstanceDataFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        InstanceDataFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        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}
-     */
-    get color() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.instancedata_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 {Float32Array}
-     */
-    get transform() {
-        const ret = wasm.instancedata_transform(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-}
-if (Symbol.dispose) InstanceData.prototype[Symbol.dispose] = InstanceData.prototype.free;
-
-/**
- * Instanced geometry - one geometry definition with multiple instances
- */
-export class InstancedGeometry {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(InstancedGeometry.prototype);
-        obj.__wbg_ptr = ptr;
-        InstancedGeometryFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        InstancedGeometryFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_instancedgeometry_free(ptr, 0);
-    }
-    /**
-     * @returns {bigint}
-     */
-    get geometryId() {
-        const ret = wasm.gpuinstancedgeometry_geometryId(this.__wbg_ptr);
-        return BigInt.asUintN(64, ret);
-    }
-    /**
-     * @param {number} index
-     * @returns {InstanceData | undefined}
-     */
-    get_instance(index) {
-        const ret = wasm.instancedgeometry_get_instance(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : InstanceData.__wrap(ret);
-    }
-    /**
-     * @returns {number}
-     */
-    get instance_count() {
-        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}
-     */
-    get normals() {
-        const ret = wasm.instancedgeometry_normals(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-    /**
-     * @returns {Float32Array}
-     */
-    get positions() {
-        const ret = wasm.instancedgeometry_positions(this.__wbg_ptr);
-        return takeObject(ret);
-    }
-}
-if (Symbol.dispose) InstancedGeometry.prototype[Symbol.dispose] = InstancedGeometry.prototype.free;
-
-/**
- * Collection of instanced geometries
- */
-export class InstancedMeshCollection {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(InstancedMeshCollection.prototype);
-        obj.__wbg_ptr = ptr;
-        InstancedMeshCollectionFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        InstancedMeshCollectionFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_instancedmeshcollection_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    get totalInstances() {
-        const ret = wasm.instancedmeshcollection_totalInstances(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @returns {number}
-     */
-    get totalGeometries() {
-        const ret = wasm.gpuinstancedgeometrycollection_length(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * @param {number} index
-     * @returns {InstancedGeometry | undefined}
+     * ```javascript
+     * const api = new IfcAPI();
+     * const result = await api.parse(ifcData);
+     * console.log('Entities:', result.entityCount);
+     * ```
+     * @param {string} content
+     * @returns {Promise<any>}
      */
-    get(index) {
-        const ret = wasm.instancedmeshcollection_get(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : InstancedGeometry.__wrap(ret);
+    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);
     }
     /**
-     * @returns {number}
+     * Parse IFC file and extract symbolic representations (Plan,
+     * Annotation, FootPrint, Axis). 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}
      */
-    get length() {
-        const ret = wasm.gpuinstancedgeometrycollection_length(this.__wbg_ptr);
-        return ret >>> 0;
+    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) InstancedMeshCollection.prototype[Symbol.dispose] = InstancedMeshCollection.prototype.free;
+if (Symbol.dispose) IfcAPI.prototype[Symbol.dispose] = IfcAPI.prototype.free;
 
 /**
  * Collection of mesh data for returning multiple meshes
@@ -2130,7 +676,7 @@ export class MeshCollection {
      * @returns {number}
      */
     get rtcOffsetX() {
-        const ret = wasm.gpugeometry_rtcOffsetZ(this.__wbg_ptr);
+        const ret = wasm.meshcollection_rtcOffsetX(this.__wbg_ptr);
         return ret;
     }
     /**
@@ -2230,63 +776,6 @@ export class MeshCollection {
 }
 if (Symbol.dispose) MeshCollection.prototype[Symbol.dispose] = MeshCollection.prototype.free;
 
-/**
- * Mesh collection with RTC offset for large coordinates
- */
-export class MeshCollectionWithRtc {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(MeshCollectionWithRtc.prototype);
-        obj.__wbg_ptr = ptr;
-        MeshCollectionWithRtcFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        MeshCollectionWithRtcFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        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
-     * @returns {MeshDataJs | undefined}
-     */
-    get(index) {
-        const ret = wasm.meshcollectionwithrtc_get(this.__wbg_ptr, index);
-        return ret === 0 ? undefined : MeshDataJs.__wrap(ret);
-    }
-    /**
-     * Get number of meshes
-     * @returns {number}
-     */
-    get length() {
-        const ret = wasm.meshcollection_length(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get the mesh collection
-     * @returns {MeshCollection}
-     */
-    get meshes() {
-        const ret = wasm.meshcollectionwithrtc_meshes(this.__wbg_ptr);
-        return MeshCollection.__wrap(ret);
-    }
-}
-if (Symbol.dispose) MeshCollectionWithRtc.prototype[Symbol.dispose] = MeshCollectionWithRtc.prototype.free;
-
 /**
  * Individual mesh data with express ID and color (matches MeshData interface)
  */
@@ -2571,103 +1060,6 @@ export class ProfileEntryJs {
 }
 if (Symbol.dispose) ProfileEntryJs.prototype[Symbol.dispose] = ProfileEntryJs.prototype.free;
 
-/**
- * RTC offset information exposed to JavaScript
- */
-export class RtcOffsetJs {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(RtcOffsetJs.prototype);
-        obj.__wbg_ptr = ptr;
-        RtcOffsetJsFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        RtcOffsetJsFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_rtcoffsetjs_free(ptr, 0);
-    }
-    /**
-     * Check if offset is significant (>10km)
-     * @returns {boolean}
-     */
-    isSignificant() {
-        const ret = wasm.rtcoffsetjs_isSignificant(this.__wbg_ptr);
-        return ret !== 0;
-    }
-    /**
-     * Convert local coordinates to world coordinates
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @returns {Float64Array}
-     */
-    toWorld(x, y, z) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.rtcoffsetjs_toWorld(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);
-        }
-    }
-    /**
-     * X offset (subtracted from positions)
-     * @returns {number}
-     */
-    get x() {
-        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_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_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);
-    }
-}
-if (Symbol.dispose) RtcOffsetJs.prototype[Symbol.dispose] = RtcOffsetJs.prototype.free;
-
 /**
  * A 2D circle/arc for symbolic representations
  */
@@ -2693,7 +1085,7 @@ export class SymbolicCircle {
      * @returns {number}
      */
     get expressId() {
-        const ret = wasm.gpumeshmetadata_vertexCount(this.__wbg_ptr);
+        const ret = wasm.symboliccircle_expressId(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2832,7 +1224,7 @@ export class SymbolicFillArea {
      * @returns {number}
      */
     get holeCount() {
-        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
+        const ret = wasm.symbolicfillarea_holeCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -3392,146 +1784,6 @@ export class SymbolicText {
 }
 if (Symbol.dispose) SymbolicText.prototype[Symbol.dispose] = SymbolicText.prototype.free;
 
-/**
- * Zero-copy mesh that exposes pointers to WASM memory
- */
-export class ZeroCopyMesh {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(ZeroCopyMesh.prototype);
-        obj.__wbg_ptr = ptr;
-        ZeroCopyMeshFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ZeroCopyMeshFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_zerocopymesh_free(ptr, 0);
-    }
-    /**
-     * Get bounding box maximum point
-     * @returns {Float32Array}
-     */
-    bounds_max() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.zerocopymesh_bounds_max(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);
-        }
-    }
-    /**
-     * Get bounding box minimum point
-     * @returns {Float32Array}
-     */
-    bounds_min() {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            wasm.zerocopymesh_bounds_min(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);
-        }
-    }
-    /**
-     * Get length of indices array
-     * @returns {number}
-     */
-    get indices_len() {
-        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get pointer to indices array
-     * @returns {number}
-     */
-    get indices_ptr() {
-        const ret = wasm.gpuinstancedgeometry_indicesPtr(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get length of normals array
-     * @returns {number}
-     */
-    get normals_len() {
-        const ret = wasm.zerocopymesh_normals_len(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get pointer to normals array
-     * @returns {number}
-     */
-    get normals_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;
-    }
-    /**
-     * Get length of positions array (in f32 elements, not bytes)
-     * @returns {number}
-     */
-    get positions_len() {
-        const ret = wasm.zerocopymesh_positions_len(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    /**
-     * Get pointer to positions array
-     * JavaScript can create Float32Array view: new Float32Array(memory.buffer, ptr, length)
-     * @returns {number}
-     */
-    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.gpuinstancedgeometry_triangleCount(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;
-    }
-    /**
-     * Check if mesh is empty
-     * @returns {boolean}
-     */
-    get is_empty() {
-        const ret = wasm.zerocopymesh_is_empty(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}
@@ -3633,12 +1885,6 @@ function __wbg_get_imports() {
         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));
     };
@@ -3653,13 +1899,6 @@ function __wbg_get_imports() {
         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_debug_9d0c87ddda3dc485 = function(arg0) {
-        console.debug(getObject(arg0));
-    };
     imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
@@ -3671,29 +1910,9 @@ function __wbg_get_imports() {
             wasm.__wbindgen_export2(deferred0_0, deferred0_1, 1);
         }
     };
-    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_info_ce6bcc489c22f6f0 = function(arg0) {
         console.info(getObject(arg0));
     };
-    imports.wbg.__wbg_instancedgeometry_new = function(arg0) {
-        const ret = InstancedGeometry.__wrap(arg0);
-        return addHeapObject(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);
@@ -3713,7 +1932,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_1573(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_1832(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -3748,10 +1967,6 @@ function __wbg_get_imports() {
         const ret = new Uint8Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
-    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);
@@ -3822,9 +2037,9 @@ function __wbg_get_imports() {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_56b148ee1abaedad = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 180, function: Function { arguments: [Externref], shim_idx: 181, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1532, __wasm_bindgen_func_elem_1533);
+    imports.wbg.__wbindgen_cast_89b0435615caf0ab = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 211, function: Function { arguments: [Externref], shim_idx: 212, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1684, __wasm_bindgen_func_elem_1685);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {