@ifc-lite/wasm 1.1.7 → 1.2.1

package/pkg/ifc-lite.js

@@ -263,22 +263,42 @@ if (!('encodeInto' in cachedTextEncoder)) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_295(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_295(arg0, arg1);
+function __wasm_bindgen_func_elem_393(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_393(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_725(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_725(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_340(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_340(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_756(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_756(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));
@@ -336,6 +356,96 @@ export class GeoReferenceJs {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_georeferencejs_free(ptr, 0);
     }
+    /**
+     * 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);
+    }
     /**
      * Transform local coordinates to map coordinates
      * @param {number} x
@@ -421,98 +531,544 @@ export class GeoReferenceJs {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+}
+if (Symbol.dispose) GeoReferenceJs.prototype[Symbol.dispose] = GeoReferenceJs.prototype.free;
+
+/**
+ * GPU-ready geometry stored in WASM linear memory
+ *
+ * Data layout:
+ * - vertex_data: Interleaved [px, py, pz, nx, ny, nz, ...] (6 floats per vertex)
+ * - indices: Triangle indices [i0, i1, i2, ...]
+ * - mesh_metadata: Per-mesh metadata for draw calls
+ *
+ * All coordinates are pre-converted from IFC Z-up to WebGL Y-up
+ */
+export class GpuGeometry {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(GpuGeometry.prototype);
+        obj.__wbg_ptr = ptr;
+        GpuGeometryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        GpuGeometryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_gpugeometry_free(ptr, 0);
+    }
+    /**
+     * Get 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 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_export4(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.gpugeometry_indicesPtr(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 zero-copy access
+     * Returns a reference that provides pointer access
+     * @param {number} index
+     * @returns {GpuInstancedGeometryRef | undefined}
+     */
+    getRef(index) {
+        const ret = wasm.gpuinstancedgeometrycollection_getRef(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : GpuInstancedGeometryRef.__wrap(ret);
+    }
+}
+if (Symbol.dispose) GpuInstancedGeometryCollection.prototype[Symbol.dispose] = GpuInstancedGeometryCollection.prototype.free;
+
+/**
+ * Reference to geometry in collection for zero-copy access
+ * This avoids cloning when accessing geometry data
+ */
+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.gpuinstancedgeometryref_geometryId(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {number}
+     */
+    get indicesLen() {
+        const ret = wasm.gpuinstancedgeometryref_indicesLen(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get indicesPtr() {
+        const ret = wasm.gpuinstancedgeometryref_indicesPtr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get instanceCount() {
+        const ret = wasm.gpuinstancedgeometryref_instanceCount(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get vertexDataLen() {
+        const ret = wasm.gpuinstancedgeometryref_vertexDataLen(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get vertexDataPtr() {
+        const ret = wasm.gpuinstancedgeometryref_vertexDataPtr(this.__wbg_ptr);
+        return ret >>> 0;
+    }
     /**
-     * Eastings (X offset)
      * @returns {number}
      */
-    get eastings() {
-        const ret = wasm.__wbg_get_georeferencejs_eastings(this.__wbg_ptr);
-        return ret;
+    get instanceDataLen() {
+        const ret = wasm.gpuinstancedgeometryref_instanceDataLen(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Eastings (X offset)
-     * @param {number} arg0
+     * @returns {number}
      */
-    set eastings(arg0) {
-        wasm.__wbg_set_georeferencejs_eastings(this.__wbg_ptr, arg0);
+    get instanceDataPtr() {
+        const ret = wasm.gpuinstancedgeometryref_instanceDataPtr(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Northings (Y offset)
      * @returns {number}
      */
-    get northings() {
-        const ret = wasm.__wbg_get_georeferencejs_northings(this.__wbg_ptr);
-        return ret;
+    get indicesByteLength() {
+        const ret = wasm.gpuinstancedgeometryref_indicesByteLength(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Northings (Y offset)
-     * @param {number} arg0
+     * @returns {number}
      */
-    set northings(arg0) {
-        wasm.__wbg_set_georeferencejs_northings(this.__wbg_ptr, arg0);
+    get vertexDataByteLength() {
+        const ret = wasm.gpuinstancedgeometryref_vertexDataByteLength(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Orthogonal height (Z offset)
      * @returns {number}
      */
-    get orthogonal_height() {
-        const ret = wasm.__wbg_get_georeferencejs_orthogonal_height(this.__wbg_ptr);
-        return ret;
+    get instanceExpressIdsPtr() {
+        const ret = wasm.gpuinstancedgeometryref_instanceExpressIdsPtr(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Orthogonal height (Z offset)
-     * @param {number} arg0
+     * @returns {number}
      */
-    set orthogonal_height(arg0) {
-        wasm.__wbg_set_georeferencejs_orthogonal_height(this.__wbg_ptr, arg0);
+    get instanceDataByteLength() {
+        const ret = wasm.gpuinstancedgeometryref_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);
     }
     /**
-     * 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;
+    get expressId() {
+        const ret = wasm.gpumeshmetadata_expressId(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * X-axis abscissa (cos of rotation)
-     * @param {number} arg0
+     * @returns {number}
      */
-    set x_axis_abscissa(arg0) {
-        wasm.__wbg_set_georeferencejs_x_axis_abscissa(this.__wbg_ptr, arg0);
+    get indexCount() {
+        const ret = wasm.gpumeshmetadata_indexCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * X-axis ordinate (sin of rotation)
      * @returns {number}
      */
-    get x_axis_ordinate() {
-        const ret = wasm.__wbg_get_georeferencejs_x_axis_ordinate(this.__wbg_ptr);
+    get ifcTypeIdx() {
+        const ret = wasm.gpumeshmetadata_ifcTypeIdx(this.__wbg_ptr);
         return ret;
     }
     /**
-     * X-axis ordinate (sin of rotation)
-     * @param {number} arg0
+     * @returns {number}
      */
-    set x_axis_ordinate(arg0) {
-        wasm.__wbg_set_georeferencejs_x_axis_ordinate(this.__wbg_ptr, arg0);
+    get indexOffset() {
+        const ret = wasm.gpumeshmetadata_indexOffset(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Scale factor
      * @returns {number}
      */
-    get scale() {
-        const ret = wasm.__wbg_get_georeferencejs_scale(this.__wbg_ptr);
-        return ret;
+    get vertexCount() {
+        const ret = wasm.gpumeshmetadata_vertexCount(this.__wbg_ptr);
+        return ret >>> 0;
     }
     /**
-     * Scale factor
-     * @param {number} arg0
+     * @returns {number}
      */
-    set scale(arg0) {
-        wasm.__wbg_set_georeferencejs_scale(this.__wbg_ptr, arg0);
+    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_export4(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
 }
-if (Symbol.dispose) GeoReferenceJs.prototype[Symbol.dispose] = GeoReferenceJs.prototype.free;
+if (Symbol.dispose) GpuMeshMetadata.prototype[Symbol.dispose] = GpuMeshMetadata.prototype.free;
 
 /**
  * Main IFC-Lite API
@@ -663,6 +1219,19 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseMeshesAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * Fast entity scanning using SIMD-accelerated Rust scanner
+     * Returns array of entity references for data model parsing
+     * Much faster than TypeScript byte-by-byte scanning (5-10x speedup)
+     * @param {string} content
+     * @returns {any}
+     */
+    scanEntitiesFast(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_scanEntitiesFast(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * Parse IFC file and return mesh with RTC offset for large coordinates
      * This handles georeferenced models by shifting to centroid
@@ -688,6 +1257,50 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseMeshesWithRtc(this.__wbg_ptr, ptr0, len0);
         return MeshCollectionWithRtc.__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_export, wasm.__wbindgen_export2);
+        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
@@ -762,6 +1375,62 @@ export class IfcAPI {
             wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
         }
     }
+    /**
+     * 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_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseToGpuGeometryAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
+        return takeObject(ret);
+    }
+    /**
+     * Fast geometry-only entity scanning
+     * Scans only entities that have geometry, skipping 99% of non-geometry entities
+     * Returns array of geometry entity references for parallel processing
+     * Much faster than scanning all entities (3x speedup for large files)
+     * @param {string} content
+     * @returns {any}
+     */
+    scanGeometryEntitiesFast(content) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_scanGeometryEntitiesFast(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * Parse IFC file with streaming instanced geometry batches for progressive rendering
      * Groups identical geometries and yields batches of InstancedGeometry
@@ -792,6 +1461,20 @@ export class IfcAPI {
         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_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseToGpuInstancedGeometry(this.__wbg_ptr, ptr0, len0);
+        return GpuInstancedGeometryCollection.__wrap(ret);
+    }
     /**
      * Create and initialize the IFC API
      */
@@ -929,7 +1612,7 @@ export class InstancedGeometry {
      * @returns {bigint}
      */
     get geometryId() {
-        const ret = wasm.instancedgeometry_geometryId(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_geometryId(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
     /**
@@ -1003,7 +1686,7 @@ export class InstancedMeshCollection {
      * @returns {number}
      */
     get totalGeometries() {
-        const ret = wasm.instancedmeshcollection_length(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometrycollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1018,7 +1701,7 @@ export class InstancedMeshCollection {
      * @returns {number}
      */
     get length() {
-        const ret = wasm.instancedmeshcollection_length(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometrycollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
@@ -1075,7 +1758,7 @@ export class MeshCollection {
      * @returns {number}
      */
     get length() {
-        const ret = wasm.instancedmeshcollection_length(this.__wbg_ptr);
+        const ret = wasm.meshcollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
 }
@@ -1172,7 +1855,7 @@ export class MeshDataJs {
      * @returns {number}
      */
     get vertexCount() {
-        const ret = wasm.meshdatajs_vertexCount(this.__wbg_ptr);
+        const ret = wasm.gpugeometry_totalTriangleCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1216,6 +1899,26 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_normals(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * Get IFC type name (e.g., "IfcWall", "IfcSpace")
+     * @returns {string}
+     */
+    get ifcType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshdatajs_ifcType(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Get positions as Float32Array (copy to JS)
      * @returns {Float32Array}
@@ -1248,34 +1951,6 @@ export class RtcOffsetJs {
         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}
@@ -1321,6 +1996,34 @@ export class RtcOffsetJs {
     set z(arg0) {
         wasm.__wbg_set_georeferencejs_orthogonal_height(this.__wbg_ptr, arg0);
     }
+    /**
+     * 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);
+        }
+    }
 }
 if (Symbol.dispose) RtcOffsetJs.prototype[Symbol.dispose] = RtcOffsetJs.prototype.free;
 
@@ -1384,7 +2087,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get indices_len() {
-        const ret = wasm.zerocopymesh_indices_len(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_indicesLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1392,7 +2095,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get indices_ptr() {
-        const ret = wasm.zerocopymesh_indices_ptr(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_indicesPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1400,7 +2103,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get normals_len() {
-        const ret = wasm.zerocopymesh_normals_len(this.__wbg_ptr);
+        const ret = wasm.gpugeometry_indicesLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1408,7 +2111,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get normals_ptr() {
-        const ret = wasm.zerocopymesh_normals_ptr(this.__wbg_ptr);
+        const ret = wasm.gpugeometry_indicesPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1416,7 +2119,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get vertex_count() {
-        const ret = wasm.meshdatajs_vertexCount(this.__wbg_ptr);
+        const ret = wasm.zerocopymesh_vertex_count(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1424,7 +2127,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get positions_len() {
-        const ret = wasm.zerocopymesh_positions_len(this.__wbg_ptr);
+        const ret = wasm.gpugeometry_vertexDataLen(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1433,7 +2136,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get positions_ptr() {
-        const ret = wasm.zerocopymesh_positions_ptr(this.__wbg_ptr);
+        const ret = wasm.gpugeometry_vertexDataPtr(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1441,7 +2144,7 @@ export class ZeroCopyMesh {
      * @returns {number}
      */
     get triangle_count() {
-        const ret = wasm.meshdatajs_triangleCount(this.__wbg_ptr);
+        const ret = wasm.gpuinstancedgeometry_triangleCount(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1458,7 +2161,7 @@ export class ZeroCopyMesh {
      * @returns {boolean}
      */
     get is_empty() {
-        const ret = wasm.zerocopymesh_is_empty(this.__wbg_ptr);
+        const ret = wasm.gpugeometry_isEmpty(this.__wbg_ptr);
         return ret !== 0;
     }
 }
@@ -1549,6 +2252,10 @@ async function __wbg_load(module, imports) {
 function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
+    imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
+        const ret = Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
         const ret = debugString(getObject(arg1));
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -1611,6 +2318,10 @@ function __wbg_get_imports() {
         const ret = Reflect.get(getObject(arg0), getObject(arg1));
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_gpugeometry_new = function(arg0) {
+        const ret = GpuGeometry.__wrap(arg0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_instancedgeometry_new = function(arg0) {
         const ret = InstancedGeometry.__wrap(arg0);
         return addHeapObject(ret);
@@ -1635,6 +2346,10 @@ function __wbg_get_imports() {
         const ret = new Error();
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_b546ae120718850e = function() {
+        const ret = new Map();
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
         try {
             var state0 = {a: arg0, b: arg1};
@@ -1642,7 +2357,7 @@ function __wbg_get_imports() {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_340(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_756(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -1684,10 +2399,24 @@ function __wbg_get_imports() {
         const ret = setTimeout(getObject(arg0), arg1);
         return addHeapObject(ret);
     }, arguments) };
+    imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+        getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+    };
     imports.wbg.__wbg_set_781438a03c0c3c81 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
         return ret;
     }, arguments) };
+    imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+    };
+    imports.wbg.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
+        const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_size_aeb57b993c620133 = function(arg0) {
+        const ret = getObject(arg0).size;
+        return ret;
+    };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = getObject(arg1).stack;
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
@@ -1720,14 +2449,14 @@ function __wbg_get_imports() {
         const ret = getStringFromWasm0(arg0, arg1);
         return addHeapObject(ret);
     };
-    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);
+    imports.wbg.__wbindgen_cast_2ead27b74a7138e7 = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 48, function: Function { arguments: [], shim_idx: 49, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_389, __wasm_bindgen_func_elem_393);
         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);
+    imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+        // Cast intrinsic for `U64 -> Externref`.
+        const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
@@ -1735,6 +2464,11 @@ function __wbg_get_imports() {
         const ret = arg0;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbindgen_cast_f2cc0f2a96e2ef5b = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 115, function: Function { arguments: [Externref], shim_idx: 116, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_720, __wasm_bindgen_func_elem_725);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
         const ret = getObject(arg0);
         return addHeapObject(ret);