@ifc-lite/wasm 2.10.0 → 2.11.1

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -82,14 +82,52 @@ export class GridAxisJs {
 export class IfcAPI {
   free(): void;
   [Symbol.dispose](): void;
+  /**
+   * Export the render geometry in `content` as a binary **GLB** (`Uint8Array`).
+   *
+   * `hidden` / `isolated` are express-id visibility filters; `hidden_types_csv` is a
+   * comma-separated list of IFC type names whose class toggle is off (e.g.
+   * `"IfcOpeningElement,IfcSpace"`). `include_metadata` attaches counts + per-node
+   * `expressId`. Per-mesh RTC origin rides the node translation (precision-safe).
+   */
+  exportGlb(content: string, include_metadata: boolean, hidden: Uint32Array, isolated: Uint32Array, hidden_types_csv: string): Uint8Array;
+  /**
+   * Package an already-produced **GLB** + georeference into a **KMZ** (`Uint8Array`)
+   * for Google Earth: a ZIP of `doc.kml` (a `<Model>` placed at `latitude`/`longitude`/
+   * `altitude`) + `model.glb`. `x_axis_abscissa`/`x_axis_ordinate` are the
+   * `IfcMapConversion` grid-north components; pass both as `undefined` for heading 0.
+   */
+  exportKmz(glb: Uint8Array, latitude: number, longitude: number, altitude: number, x_axis_abscissa: number | null | undefined, x_axis_ordinate: number | null | undefined, name: string): Uint8Array;
+  /**
+   * Assemble a **GLB** from already-produced meshes (the viewer's `MeshData`, flattened)
+   * — no re-meshing. Per mesh `i`: `vertex_counts[i]` verts + `index_counts[i]` indices
+   * taken in order from the concatenated `positions`/`normals`/`indices`; `colors` is
+   * RGBA per mesh, `origins` xyz per mesh, `express_ids` labels each mesh (indices are
+   * per-mesh local). The caller passes exactly the meshes it wants emitted.
+   */
+  exportGlbFromMeshes(positions: Float32Array, normals: Float32Array, indices: Uint32Array, vertex_counts: Uint32Array, index_counts: Uint32Array, colors: Float32Array, origins: Float64Array, express_ids: Uint32Array, include_metadata: boolean): Uint8Array;
+  /**
+   * Export the render geometry in `content` as a Wavefront **OBJ** string.
+   *
+   * `hidden` / `isolated` are express-id filters mirroring the viewer's visibility
+   * state (empty `isolated` ⇒ all visible). Instanced type-library shapes are skipped.
+   *
+   * ```javascript
+   * const obj = api.exportObj(ifcContent, true, new Uint32Array(), new Uint32Array());
+   * ```
+   */
+  exportObj(content: string, include_normals: boolean, hidden: Uint32Array, isolated: Uint32Array): string;
   /**
    * Run the pre-pass ONCE and return serialized results for worker distribution.
    * Takes raw bytes (&[u8]) to avoid TextDecoder overhead.
    */
   buildPrePassOnce(data: Uint8Array): any;
   /**
-   * Process geometry for a subset of pre-scanned entities.
-   * Takes raw bytes and pre-pass data from buildPrePassOnce.
+   * Process geometry for a subset of pre-scanned entities → flat
+   * MeshCollection. Takes raw bytes + pre-pass data from buildPrePassOnce.
+   * Thin wrapper over [`IfcAPI::produce_batch`]; converts each produced mesh
+   * to MeshDataJs (the IFC Z-up→WebGL Y-up swap + winding reversal happen
+   * there). Output is byte-for-byte what the pre-refactor method produced.
    */
   processGeometryBatch(data: Uint8Array, jobs_flat: Uint32Array, unit_scale: number, rtc_x: number, rtc_y: number, rtc_z: number, needs_shift: boolean, void_keys: Uint32Array, void_counts: Uint32Array, void_values: Uint32Array, style_ids: Uint32Array, style_colors: Uint8Array, plane_angle_to_radians?: number | null, material_element_ids?: Uint32Array | null, material_color_counts?: Uint32Array | null, material_colors_rgba?: Uint8Array | null): MeshCollection;
   /**
@@ -118,6 +156,36 @@ export class IfcAPI {
    *   `{ type: "complete", totalJobs }`
    */
   buildPrePassStreaming(data: Uint8Array, on_event: Function, chunk_size: number, disabled_type_names: string[] | null | undefined, skip_type_geometry: boolean): any;
+  /**
+   * Like [`IfcAPI::process_geometry_batch`] but collates the batch's meshes
+   * into a GPU-instancing shard (IFNS wire format) instead of a flat
+   * MeshCollection. Repeated geometry collapses to one template + per-
+   * occurrence transforms; non-instanceable meshes ride as flat singleton
+   * templates so nothing is dropped. The shard stays in the producer-native
+   * (IFC Z-up) frame — the renderer composes the constant Z-up→Y-up swap at
+   * upload. Each batch shard renders independently: affinity routing already
+   * co-locates identical geometry on one worker, so per-batch collation
+   * captures ~all the dedup and no cross-batch merge is needed. Returns empty
+   * bytes only when the batch produced zero non-empty meshes.
+   */
+  processGeometryBatchInstanced(data: Uint8Array, jobs_flat: Uint32Array, unit_scale: number, rtc_x: number, rtc_y: number, rtc_z: number, needs_shift: boolean, void_keys: Uint32Array, void_counts: Uint32Array, void_values: Uint32Array, style_ids: Uint32Array, style_colors: Uint8Array, plane_angle_to_radians?: number | null, material_element_ids?: Uint32Array | null, material_color_counts?: Uint32Array | null, material_colors_rgba?: Uint8Array | null): Uint8Array;
+  /**
+   * Produce a batch ONCE and PARTITION it (the instanced-ONLY path): opaque
+   * ordinary occurrences (colour alpha >= 0.99 AND geometry_class == 0) are
+   * collated into the instanced shard; everything else (transparent glass,
+   * type-product geometry) goes to the flat MeshCollection. Each mesh takes
+   * exactly ONE route, so produce_batch runs once (no emit-both 2× meshing)
+   * and the renderer draws opaque occurrences via instancing instead of flat.
+   * Partition mirrors the renderer gates: INSTANCED_ALPHA_CUTOFF (0.99 =
+   * OPAQUE_ALPHA_CUTOFF) for transparency, geometry_class for the Model/Types
+   * split.
+   *
+   * NOTE: the renderer must be instanced-feature-complete (picking / selection
+   * / lens overlays on instanced geometry) before the worker calls this in
+   * place of processGeometryBatch — otherwise those features break for the
+   * opaque bulk. See the instanced-only follow-ups.
+   */
+  processGeometryBatchPartitioned(data: Uint8Array, jobs_flat: Uint32Array, unit_scale: number, rtc_x: number, rtc_y: number, rtc_z: number, needs_shift: boolean, void_keys: Uint32Array, void_counts: Uint32Array, void_values: Uint32Array, style_ids: Uint32Array, style_colors: Uint8Array, plane_angle_to_radians?: number | null, material_element_ids?: Uint32Array | null, material_color_counts?: Uint32Array | null, material_colors_rgba?: Uint8Array | null): PartitionedBatch;
   /**
    * Parse the file and return structured per-axis data (tag + endpoints) in
    * the renderer's Y-up world space (RTC-subtracted, metres). Use this when
@@ -134,6 +202,43 @@ export class IfcAPI {
    * clear the overlay cheaply.
    */
   parseGridLines(content: string): Float32Array;
+  /**
+   * Export tabular **CSV**. `mode` ∈ {`"entities"`, `"properties"`, `"quantities"`,
+   * `"spatial"`}. `delimiter` defaults to `,` when empty; `include_properties` adds
+   * flattened `Pset_Prop` columns to the entities view.
+   */
+  exportCsv(content: string, mode: string, delimiter: string, include_properties: boolean): string;
+  /**
+   * Export **IFC5 / IFCX** (the USD-style node graph). `only_known_properties` keeps
+   * only properties with an official IFC5 schema.
+   */
+  exportIfcx(content: string, only_known_properties: boolean, pretty: boolean): string;
+  /**
+   * Export structured **JSON** (array of entity objects with typed property values).
+   */
+  exportJson(content: string, pretty: boolean, include_properties: boolean, include_quantities: boolean): string;
+  /**
+   * Export **JSON-LD** (`@graph` of `ifc:` nodes). Empty `context` ⇒ buildingSMART
+   * IFC4 OWL default. `included` is an express-id isolation filter mirroring the
+   * OBJ/glTF/STEP exporters (empty ⇒ all entities).
+   */
+  exportJsonld(content: string, context: string, include_properties: boolean, include_quantities: boolean, pretty: boolean, included: Uint32Array): string;
+  /**
+   * Re-serialize the model in `content` to a STEP/IFC string.
+   *
+   * `schema` is the FILE_SCHEMA label to write (empty ⇒ preserve the source schema).
+   * `included` is an express-id allowlist (empty ⇒ whole model); when set, the forward
+   * `#`-reference closure is added so the subset never dangles a reference.
+   * `mutations_json` carries `MutablePropertyView` edits (attribute updates +
+   * property-set synthesis); empty ⇒ none. See `export_step_json` for the shape.
+   */
+  exportStep(content: string, schema: string, included: Uint32Array, mutations_json: string): string;
+  /**
+   * Merge several IFC models into one STEP/IFC string. `concatenated` is every model's
+   * bytes laid end-to-end; `lengths[i]` is the byte length of model `i`. The first model
+   * keeps its ids; later models are id-offset and their project unified to the first.
+   */
+  exportMerged(concatenated: Uint8Array, lengths: Uint32Array, schema: string): string;
   /**
    * Export the `IfcSpace` volumes in `content` as a Honeybee **HBJSON** string.
    *
@@ -496,6 +601,27 @@ export class MeshOutlineJs {
   readonly axisMin: number;
 }
 
+export class PartitionedBatch {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * The instanced IFNS shard bytes (opaque ordinary occurrences). Moves out.
+   */
+  takeShard(): Uint8Array;
+  /**
+   * The flat MeshCollection (transparent glass + type-product geometry).
+   * Moves out — call once.
+   */
+  takeMeshes(): MeshCollection | undefined;
+  /**
+   * Number of occurrences routed into the instanced shard this batch. The viewer
+   * folds this into its total mesh count so the count reflects ALL rendered
+   * geometry (flat + instanced), not just the flat MeshCollection.
+   */
+  readonly instancedOccurrences: number;
+}
+
 export class ProfileCollection {
   private constructor();
   free(): void;
@@ -911,6 +1037,7 @@ export interface InitOutput {
   readonly __wbg_meshcollection_free: (a: number, b: number) => void;
   readonly __wbg_meshdatajs_free: (a: number, b: number) => void;
   readonly __wbg_meshoutlinejs_free: (a: number, b: number) => void;
+  readonly __wbg_partitionedbatch_free: (a: number, b: number) => void;
   readonly __wbg_profilecollection_free: (a: number, b: number) => void;
   readonly __wbg_profileentryjs_free: (a: number, b: number) => void;
   readonly __wbg_spaceplatehandle_free: (a: number, b: number) => void;
@@ -939,7 +1066,17 @@ export interface InitOutput {
   readonly ifcapi_buildPrePassOnce: (a: number, b: number, c: number) => number;
   readonly ifcapi_buildPrePassStreaming: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
   readonly ifcapi_clearPrePassCache: (a: number) => void;
+  readonly ifcapi_exportCsv: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly ifcapi_exportGlb: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+  readonly ifcapi_exportGlbFromMeshes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number) => void;
   readonly ifcapi_exportHbjson: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly ifcapi_exportIfcx: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly ifcapi_exportJson: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly ifcapi_exportJsonld: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
+  readonly ifcapi_exportKmz: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number) => void;
+  readonly ifcapi_exportMerged: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+  readonly ifcapi_exportObj: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly ifcapi_exportStep: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
   readonly ifcapi_extractProfiles: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_getMemory: (a: number) => number;
   readonly ifcapi_is_ready: (a: number) => number;
@@ -949,6 +1086,8 @@ export interface InitOutput {
   readonly ifcapi_parseGridLines: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseSymbolicRepresentations: (a: number, b: number, c: number) => number;
   readonly ifcapi_processGeometryBatch: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number) => number;
+  readonly ifcapi_processGeometryBatchInstanced: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number, c1: number) => void;
+  readonly ifcapi_processGeometryBatchPartitioned: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number, b1: number) => number;
   readonly ifcapi_scanEntitiesFast: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanEntitiesFastBytes: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
@@ -994,6 +1133,9 @@ export interface InitOutput {
   readonly meshoutlinejs_axisMin: (a: number) => number;
   readonly meshoutlinejs_contour: (a: number, b: number) => number;
   readonly meshoutlinejs_contourCount: (a: number) => number;
+  readonly partitionedbatch_instancedOccurrences: (a: number) => number;
+  readonly partitionedbatch_takeMeshes: (a: number) => number;
+  readonly partitionedbatch_takeShard: (a: number, b: number) => void;
   readonly profilecollection_get: (a: number, b: number) => number;
   readonly profilecollection_length: (a: number) => number;
   readonly profileentryjs_extrusionDepth: (a: number) => number;

package/pkg/ifc-lite.js

@@ -262,6 +262,10 @@ const MeshOutlineJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_meshoutlinejs_free(ptr >>> 0, 1));
 
+const PartitionedBatchFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_partitionedbatch_free(ptr >>> 0, 1));
+
 const ProfileCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_profilecollection_free(ptr >>> 0, 1));
@@ -624,6 +628,155 @@ export class IfcAPI {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_ifcapi_free(ptr, 0);
     }
+    /**
+     * Export the render geometry in `content` as a binary **GLB** (`Uint8Array`).
+     *
+     * `hidden` / `isolated` are express-id visibility filters; `hidden_types_csv` is a
+     * comma-separated list of IFC type names whose class toggle is off (e.g.
+     * `"IfcOpeningElement,IfcSpace"`). `include_metadata` attaches counts + per-node
+     * `expressId`. Per-mesh RTC origin rides the node translation (precision-safe).
+     * @param {string} content
+     * @param {boolean} include_metadata
+     * @param {Uint32Array} hidden
+     * @param {Uint32Array} isolated
+     * @param {string} hidden_types_csv
+     * @returns {Uint8Array}
+     */
+    exportGlb(content, include_metadata, hidden, isolated, hidden_types_csv) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray32ToWasm0(hidden, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(isolated, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passStringToWasm0(hidden_types_csv, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportGlb(retptr, this.__wbg_ptr, ptr0, len0, include_metadata, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v5 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v5;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Package an already-produced **GLB** + georeference into a **KMZ** (`Uint8Array`)
+     * for Google Earth: a ZIP of `doc.kml` (a `<Model>` placed at `latitude`/`longitude`/
+     * `altitude`) + `model.glb`. `x_axis_abscissa`/`x_axis_ordinate` are the
+     * `IfcMapConversion` grid-north components; pass both as `undefined` for heading 0.
+     * @param {Uint8Array} glb
+     * @param {number} latitude
+     * @param {number} longitude
+     * @param {number} altitude
+     * @param {number | null | undefined} x_axis_abscissa
+     * @param {number | null | undefined} x_axis_ordinate
+     * @param {string} name
+     * @returns {Uint8Array}
+     */
+    exportKmz(glb, latitude, longitude, altitude, x_axis_abscissa, x_axis_ordinate, name) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(glb, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportKmz(retptr, this.__wbg_ptr, ptr0, len0, latitude, longitude, altitude, !isLikeNone(x_axis_abscissa), isLikeNone(x_axis_abscissa) ? 0 : x_axis_abscissa, !isLikeNone(x_axis_ordinate), isLikeNone(x_axis_ordinate) ? 0 : x_axis_ordinate, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v3 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v3;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Assemble a **GLB** from already-produced meshes (the viewer's `MeshData`, flattened)
+     * — no re-meshing. Per mesh `i`: `vertex_counts[i]` verts + `index_counts[i]` indices
+     * taken in order from the concatenated `positions`/`normals`/`indices`; `colors` is
+     * RGBA per mesh, `origins` xyz per mesh, `express_ids` labels each mesh (indices are
+     * per-mesh local). The caller passes exactly the meshes it wants emitted.
+     * @param {Float32Array} positions
+     * @param {Float32Array} normals
+     * @param {Uint32Array} indices
+     * @param {Uint32Array} vertex_counts
+     * @param {Uint32Array} index_counts
+     * @param {Float32Array} colors
+     * @param {Float64Array} origins
+     * @param {Uint32Array} express_ids
+     * @param {boolean} include_metadata
+     * @returns {Uint8Array}
+     */
+    exportGlbFromMeshes(positions, normals, indices, vertex_counts, index_counts, colors, origins, express_ids, include_metadata) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArrayF32ToWasm0(normals, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(indices, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArray32ToWasm0(vertex_counts, wasm.__wbindgen_export);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArray32ToWasm0(index_counts, wasm.__wbindgen_export);
+            const len4 = WASM_VECTOR_LEN;
+            const ptr5 = passArrayF32ToWasm0(colors, wasm.__wbindgen_export);
+            const len5 = WASM_VECTOR_LEN;
+            const ptr6 = passArrayF64ToWasm0(origins, wasm.__wbindgen_export);
+            const len6 = WASM_VECTOR_LEN;
+            const ptr7 = passArray32ToWasm0(express_ids, wasm.__wbindgen_export);
+            const len7 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportGlbFromMeshes(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, include_metadata);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v9 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v9;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Export the render geometry in `content` as a Wavefront **OBJ** string.
+     *
+     * `hidden` / `isolated` are express-id filters mirroring the viewer's visibility
+     * state (empty `isolated` ⇒ all visible). Instanced type-library shapes are skipped.
+     *
+     * ```javascript
+     * const obj = api.exportObj(ifcContent, true, new Uint32Array(), new Uint32Array());
+     * ```
+     * @param {string} content
+     * @param {boolean} include_normals
+     * @param {Uint32Array} hidden
+     * @param {Uint32Array} isolated
+     * @returns {string}
+     */
+    exportObj(content, include_normals, hidden, isolated) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray32ToWasm0(hidden, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(isolated, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportObj(retptr, this.__wbg_ptr, ptr0, len0, include_normals, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred4_0 = r0;
+            deferred4_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+        }
+    }
     /**
      * Run the pre-pass ONCE and return serialized results for worker distribution.
      * Takes raw bytes (&[u8]) to avoid TextDecoder overhead.
@@ -637,8 +790,11 @@ export class IfcAPI {
         return takeObject(ret);
     }
     /**
-     * Process geometry for a subset of pre-scanned entities.
-     * Takes raw bytes and pre-pass data from buildPrePassOnce.
+     * Process geometry for a subset of pre-scanned entities → flat
+     * MeshCollection. Takes raw bytes + pre-pass data from buildPrePassOnce.
+     * Thin wrapper over [`IfcAPI::produce_batch`]; converts each produced mesh
+     * to MeshDataJs (the IFC Z-up→WebGL Y-up swap + winding reversal happen
+     * there). Output is byte-for-byte what the pre-refactor method produced.
      * @param {Uint8Array} data
      * @param {Uint32Array} jobs_flat
      * @param {number} unit_scale
@@ -732,6 +888,125 @@ export class IfcAPI {
             heap[stack_pointer++] = undefined;
         }
     }
+    /**
+     * Like [`IfcAPI::process_geometry_batch`] but collates the batch's meshes
+     * into a GPU-instancing shard (IFNS wire format) instead of a flat
+     * MeshCollection. Repeated geometry collapses to one template + per-
+     * occurrence transforms; non-instanceable meshes ride as flat singleton
+     * templates so nothing is dropped. The shard stays in the producer-native
+     * (IFC Z-up) frame — the renderer composes the constant Z-up→Y-up swap at
+     * upload. Each batch shard renders independently: affinity routing already
+     * co-locates identical geometry on one worker, so per-batch collation
+     * captures ~all the dedup and no cross-batch merge is needed. Returns empty
+     * bytes only when the batch produced zero non-empty meshes.
+     * @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} void_keys
+     * @param {Uint32Array} void_counts
+     * @param {Uint32Array} void_values
+     * @param {Uint32Array} style_ids
+     * @param {Uint8Array} style_colors
+     * @param {number | null} [plane_angle_to_radians]
+     * @param {Uint32Array | null} [material_element_ids]
+     * @param {Uint32Array | null} [material_color_counts]
+     * @param {Uint8Array | null} [material_colors_rgba]
+     * @returns {Uint8Array}
+     */
+    processGeometryBatchInstanced(data, jobs_flat, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, void_keys, void_counts, void_values, style_ids, style_colors, plane_angle_to_radians, material_element_ids, material_color_counts, material_colors_rgba) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray32ToWasm0(jobs_flat, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(void_keys, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArray32ToWasm0(void_counts, wasm.__wbindgen_export);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArray32ToWasm0(void_values, wasm.__wbindgen_export);
+            const len4 = WASM_VECTOR_LEN;
+            const ptr5 = passArray32ToWasm0(style_ids, wasm.__wbindgen_export);
+            const len5 = WASM_VECTOR_LEN;
+            const ptr6 = passArray8ToWasm0(style_colors, wasm.__wbindgen_export);
+            const len6 = WASM_VECTOR_LEN;
+            var ptr7 = isLikeNone(material_element_ids) ? 0 : passArray32ToWasm0(material_element_ids, wasm.__wbindgen_export);
+            var len7 = WASM_VECTOR_LEN;
+            var ptr8 = isLikeNone(material_color_counts) ? 0 : passArray32ToWasm0(material_color_counts, wasm.__wbindgen_export);
+            var len8 = WASM_VECTOR_LEN;
+            var ptr9 = isLikeNone(material_colors_rgba) ? 0 : passArray8ToWasm0(material_colors_rgba, wasm.__wbindgen_export);
+            var len9 = WASM_VECTOR_LEN;
+            wasm.ifcapi_processGeometryBatchInstanced(retptr, 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, !isLikeNone(plane_angle_to_radians), isLikeNone(plane_angle_to_radians) ? 0 : plane_angle_to_radians, ptr7, len7, ptr8, len8, ptr9, len9);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v11 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v11;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Produce a batch ONCE and PARTITION it (the instanced-ONLY path): opaque
+     * ordinary occurrences (colour alpha >= 0.99 AND geometry_class == 0) are
+     * collated into the instanced shard; everything else (transparent glass,
+     * type-product geometry) goes to the flat MeshCollection. Each mesh takes
+     * exactly ONE route, so produce_batch runs once (no emit-both 2× meshing)
+     * and the renderer draws opaque occurrences via instancing instead of flat.
+     * Partition mirrors the renderer gates: INSTANCED_ALPHA_CUTOFF (0.99 =
+     * OPAQUE_ALPHA_CUTOFF) for transparency, geometry_class for the Model/Types
+     * split.
+     *
+     * NOTE: the renderer must be instanced-feature-complete (picking / selection
+     * / lens overlays on instanced geometry) before the worker calls this in
+     * place of processGeometryBatch — otherwise those features break for the
+     * opaque bulk. See the instanced-only follow-ups.
+     * @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} void_keys
+     * @param {Uint32Array} void_counts
+     * @param {Uint32Array} void_values
+     * @param {Uint32Array} style_ids
+     * @param {Uint8Array} style_colors
+     * @param {number | null} [plane_angle_to_radians]
+     * @param {Uint32Array | null} [material_element_ids]
+     * @param {Uint32Array | null} [material_color_counts]
+     * @param {Uint8Array | null} [material_colors_rgba]
+     * @returns {PartitionedBatch}
+     */
+    processGeometryBatchPartitioned(data, jobs_flat, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, void_keys, void_counts, void_values, style_ids, style_colors, plane_angle_to_radians, material_element_ids, material_color_counts, material_colors_rgba) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(jobs_flat, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(void_keys, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray32ToWasm0(void_counts, wasm.__wbindgen_export);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray32ToWasm0(void_values, wasm.__wbindgen_export);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArray32ToWasm0(style_ids, wasm.__wbindgen_export);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passArray8ToWasm0(style_colors, wasm.__wbindgen_export);
+        const len6 = WASM_VECTOR_LEN;
+        var ptr7 = isLikeNone(material_element_ids) ? 0 : passArray32ToWasm0(material_element_ids, wasm.__wbindgen_export);
+        var len7 = WASM_VECTOR_LEN;
+        var ptr8 = isLikeNone(material_color_counts) ? 0 : passArray32ToWasm0(material_color_counts, wasm.__wbindgen_export);
+        var len8 = WASM_VECTOR_LEN;
+        var ptr9 = isLikeNone(material_colors_rgba) ? 0 : passArray8ToWasm0(material_colors_rgba, wasm.__wbindgen_export);
+        var len9 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_processGeometryBatchPartitioned(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, !isLikeNone(plane_angle_to_radians), isLikeNone(plane_angle_to_radians) ? 0 : plane_angle_to_radians, ptr7, len7, ptr8, len8, ptr9, len9);
+        return PartitionedBatch.__wrap(ret);
+    }
     /**
      * Parse the file and return structured per-axis data (tag + endpoints) in
      * the renderer's Y-up world space (RTC-subtracted, metres). Use this when
@@ -762,6 +1037,193 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseGridLines(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+     * Export tabular **CSV**. `mode` ∈ {`"entities"`, `"properties"`, `"quantities"`,
+     * `"spatial"`}. `delimiter` defaults to `,` when empty; `include_properties` adds
+     * flattened `Pset_Prop` columns to the entities view.
+     * @param {string} content
+     * @param {string} mode
+     * @param {string} delimiter
+     * @param {boolean} include_properties
+     * @returns {string}
+     */
+    exportCsv(content, mode, delimiter, include_properties) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(delimiter, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportCsv(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, include_properties);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred4_0 = r0;
+            deferred4_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Export **IFC5 / IFCX** (the USD-style node graph). `only_known_properties` keeps
+     * only properties with an official IFC5 schema.
+     * @param {string} content
+     * @param {boolean} only_known_properties
+     * @param {boolean} pretty
+     * @returns {string}
+     */
+    exportIfcx(content, only_known_properties, pretty) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportIfcx(retptr, this.__wbg_ptr, ptr0, len0, only_known_properties, pretty);
+            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_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Export structured **JSON** (array of entity objects with typed property values).
+     * @param {string} content
+     * @param {boolean} pretty
+     * @param {boolean} include_properties
+     * @param {boolean} include_quantities
+     * @returns {string}
+     */
+    exportJson(content, pretty, include_properties, include_quantities) {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportJson(retptr, this.__wbg_ptr, ptr0, len0, pretty, include_properties, include_quantities);
+            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_export4(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Export **JSON-LD** (`@graph` of `ifc:` nodes). Empty `context` ⇒ buildingSMART
+     * IFC4 OWL default. `included` is an express-id isolation filter mirroring the
+     * OBJ/glTF/STEP exporters (empty ⇒ all entities).
+     * @param {string} content
+     * @param {string} context
+     * @param {boolean} include_properties
+     * @param {boolean} include_quantities
+     * @param {boolean} pretty
+     * @param {Uint32Array} included
+     * @returns {string}
+     */
+    exportJsonld(content, context, include_properties, include_quantities, pretty, included) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(context, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(included, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportJsonld(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, include_properties, include_quantities, pretty, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred4_0 = r0;
+            deferred4_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Re-serialize the model in `content` to a STEP/IFC string.
+     *
+     * `schema` is the FILE_SCHEMA label to write (empty ⇒ preserve the source schema).
+     * `included` is an express-id allowlist (empty ⇒ whole model); when set, the forward
+     * `#`-reference closure is added so the subset never dangles a reference.
+     * `mutations_json` carries `MutablePropertyView` edits (attribute updates +
+     * property-set synthesis); empty ⇒ none. See `export_step_json` for the shape.
+     * @param {string} content
+     * @param {string} schema
+     * @param {Uint32Array} included
+     * @param {string} mutations_json
+     * @returns {string}
+     */
+    exportStep(content, schema, included, mutations_json) {
+        let deferred5_0;
+        let deferred5_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(schema, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(included, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passStringToWasm0(mutations_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len3 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportStep(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred5_0 = r0;
+            deferred5_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred5_0, deferred5_1, 1);
+        }
+    }
+    /**
+     * Merge several IFC models into one STEP/IFC string. `concatenated` is every model's
+     * bytes laid end-to-end; `lengths[i]` is the byte length of model `i`. The first model
+     * keeps its ids; later models are id-offset and their project unified to the first.
+     * @param {Uint8Array} concatenated
+     * @param {Uint32Array} lengths
+     * @param {string} schema
+     * @returns {string}
+     */
+    exportMerged(concatenated, lengths, schema) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(concatenated, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray32ToWasm0(lengths, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(schema, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportMerged(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred4_0 = r0;
+            deferred4_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred4_0, deferred4_1, 1);
+        }
+    }
     /**
      * Export the `IfcSpace` volumes in `content` as a Honeybee **HBJSON** string.
      *
@@ -1502,6 +1964,69 @@ export class MeshOutlineJs {
 }
 if (Symbol.dispose) MeshOutlineJs.prototype[Symbol.dispose] = MeshOutlineJs.prototype.free;
 
+/**
+ * Result of [`IfcAPI::process_geometry_batch_partitioned`]: the flat
+ * MeshCollection (transparent + type geometry) and the instanced IFNS shard
+ * (opaque ordinary occurrences) from ONE produce_batch. Take-once accessors so
+ * the JS side moves each out without a clone.
+ */
+export class PartitionedBatch {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PartitionedBatch.prototype);
+        obj.__wbg_ptr = ptr;
+        PartitionedBatchFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PartitionedBatchFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_partitionedbatch_free(ptr, 0);
+    }
+    /**
+     * The instanced IFNS shard bytes (opaque ordinary occurrences). Moves out.
+     * @returns {Uint8Array}
+     */
+    takeShard() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.partitionedbatch_takeShard(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * The flat MeshCollection (transparent glass + type-product geometry).
+     * Moves out — call once.
+     * @returns {MeshCollection | undefined}
+     */
+    takeMeshes() {
+        const ret = wasm.partitionedbatch_takeMeshes(this.__wbg_ptr);
+        return ret === 0 ? undefined : MeshCollection.__wrap(ret);
+    }
+    /**
+     * Number of occurrences routed into the instanced shard this batch. The viewer
+     * folds this into its total mesh count so the count reflects ALL rendered
+     * geometry (flat + instanced), not just the flat MeshCollection.
+     * @returns {number}
+     */
+    get instancedOccurrences() {
+        const ret = wasm.partitionedbatch_instancedOccurrences(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) PartitionedBatch.prototype[Symbol.dispose] = PartitionedBatch.prototype.free;
+
 /**
  * A collection of extracted profiles.
  */