@ifc-lite/wasm 1.0.0 → 1.1.0

package/{ifc_lite_wasm.js → pkg/ifc-lite.js}

@@ -89,6 +89,11 @@ function getArrayF32FromWasm0(ptr, len) {
     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);
@@ -110,6 +115,14 @@ function getFloat32ArrayMemory0() {
     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);
@@ -250,30 +263,257 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_160(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_160(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_295(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_295(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_306(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_306(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_198(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_198(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_340(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_340(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
+const GeoReferenceJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_georeferencejs_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 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_export4(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_export4(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_export4(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_export4(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;
+
 /**
  * Main IFC-Lite API
  */
@@ -370,6 +610,112 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseZeroCopy(this.__wbg_ptr, ptr0, len0);
         return ZeroCopyMesh.__wrap(ret);
     }
+    /**
+     * 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_export, wasm.__wbindgen_export2);
+        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 with streaming mesh batches for progressive rendering
+     * Calls the callback with batches of meshes, yielding to browser between batches
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * await api.parseMeshesAsync(ifcData, {
+     *   batchSize: 100,
+     *   onBatch: (meshes, progress) => {
+     *     // Add meshes to scene
+     *     for (const mesh of meshes) {
+     *       scene.add(createThreeMesh(mesh));
+     *     }
+     *     console.log(`Progress: ${progress.percent}%`);
+     *   },
+     *   onComplete: (stats) => {
+     *     console.log(`Done! ${stats.totalMeshes} meshes`);
+     *   }
+     * });
+     * ```
+     * @param {string} content
+     * @param {any} options
+     * @returns {Promise<any>}
+     */
+    parseMeshesAsync(content, options) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseMeshesAsync(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_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseMeshesWithRtc(this.__wbg_ptr, ptr0, len0);
+        return MeshCollectionWithRtc.__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_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseMeshesInstanced(this.__wbg_ptr, ptr0, len0);
+        return InstancedMeshCollection.__wrap(ret);
+    }
     /**
      * Debug: Test processing entity #953 (FacetedBrep wall)
      * @param {string} content
@@ -416,6 +762,36 @@ export class IfcAPI {
             wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * 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_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseMeshesInstancedAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
+        return takeObject(ret);
+    }
     /**
      * Create and initialize the IFC API
      */
@@ -474,6 +850,180 @@ export class IfcAPI {
 }
 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_export4(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.instancedgeometry_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.instancedmeshcollection_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 length() {
+        const ret = wasm.instancedmeshcollection_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) InstancedMeshCollection.prototype[Symbol.dispose] = InstancedMeshCollection.prototype.free;
+
 /**
  * Collection of mesh data for returning multiple meshes
  */
@@ -525,12 +1075,69 @@ export class MeshCollection {
      * @returns {number}
      */
     get length() {
-        const ret = wasm.meshcollection_length(this.__wbg_ptr);
+        const ret = wasm.instancedmeshcollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
 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.meshcollectionwithrtc_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)
  */
@@ -620,6 +1227,103 @@ export class MeshDataJs {
 }
 if (Symbol.dispose) MeshDataJs.prototype[Symbol.dispose] = MeshDataJs.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_export4(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;
+
 /**
  * Zero-copy mesh that exposes pointers to WASM memory
  */
@@ -770,14 +1474,27 @@ export function get_memory() {
 }
 
 /**
- * Initialize the WASM module
+ * 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
+ * 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() {
@@ -851,6 +1568,12 @@ 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));
     };
@@ -865,6 +1588,14 @@ 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_clearTimeout_5a54f8841c30079a = function(arg0) {
+        const ret = clearTimeout(takeObject(arg0));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
         let deferred0_0;
         let deferred0_1;
@@ -876,10 +1607,30 @@ function __wbg_get_imports() {
             wasm.__wbindgen_export4(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_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);
     };
+    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);
@@ -891,7 +1642,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_198(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_340(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -914,6 +1665,10 @@ function __wbg_get_imports() {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         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);
@@ -925,6 +1680,10 @@ function __wbg_get_imports() {
         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_781438a03c0c3c81 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
         return ret;
@@ -961,9 +1720,14 @@ function __wbg_get_imports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_a2f2ccacb7ef777f = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 31, function: Function { arguments: [Externref], shim_idx: 32, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_159, __wasm_bindgen_func_elem_160);
+    imports.wbg.__wbindgen_cast_6da2ad44da782ca3 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 43, function: Function { arguments: [], shim_idx: 44, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_294, __wasm_bindgen_func_elem_295);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbindgen_cast_cfd578dc132ebaa8 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 49, function: Function { arguments: [Externref], shim_idx: 50, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_305, __wasm_bindgen_func_elem_306);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
@@ -987,6 +1751,7 @@ function __wbg_finalize_init(instance, module) {
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
     cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
 
@@ -1028,7 +1793,7 @@ async function __wbg_init(module_or_path) {
     }
 
     if (typeof module_or_path === 'undefined') {
-        module_or_path = new URL('ifc_lite_wasm_bg.wasm', import.meta.url);
+        module_or_path = new URL('ifc-lite_bg.wasm', import.meta.url);
     }
     const imports = __wbg_get_imports();