@ifc-lite/wasm 2.9.1 → 2.11.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -82,6 +82,41 @@ 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.
@@ -134,6 +169,56 @@ 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.
+   *
+   * Rooms are built analytically from extruded-area profiles (watertight by construction);
+   * faces are typed Floor / RoofCeiling / Wall with outward normals. The result loads via
+   * `honeybee.model.Model.from_hbjson` and is ready for Ladybug Tools / Pollination.
+   *
+   * ```javascript
+   * const api = new IfcAPI();
+   * const hbjson = api.exportHbjson(ifcContent, "my_model");
+   * ```
+   */
+  exportHbjson(content: string, name: string): string;
   /**
    * Parse the file and return every `IfcAlignment` directrix as a flat
    * `Float32Array` of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` in
@@ -220,6 +305,18 @@ export class IfcAPI {
    * fail fast.
    */
   clearPrePassCache(): void;
+  /**
+   * Enable or disable the PARAMETRIC rectangular-opening fast path (the
+   * placement-frame, ground-truth-exact analytic cut) for `processGeometryBatch`.
+   *
+   * DEFAULT OFF. This is the wasm-side toggle that lets native and wasm flip the
+   * flag in LOCKSTEP — the byte-identical native==wasm contract requires both
+   * targets take the same path, and wasm has no env to read `IFC_LITE_RECT_PARAM`.
+   * The path subtracts rectangular openings as exact parametric boxes in the host's
+   * own placement frame (rotated walls included), deferring any non-clean case to
+   * the exact kernel. Pass `true` before `processGeometryBatch`.
+   */
+  setRectParamFastPath(enabled: boolean): void;
   /**
    * Select the tessellation detail level applied by every subsequent
    * `processGeometryBatch` call (issue #976, step 4).
@@ -914,6 +1011,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;
@@ -929,6 +1037,7 @@ export interface InitOutput {
   readonly ifcapi_setComputeGeometryHashes: (a: number, b: number, c: number) => void;
   readonly ifcapi_setEntityIndex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
   readonly ifcapi_setMergeLayers: (a: number, b: number) => void;
+  readonly ifcapi_setRectParamFastPath: (a: number, b: number) => void;
   readonly ifcapi_setTessellationQuality: (a: number, b: number, c: number, d: number) => void;
   readonly ifcapi_version: (a: number, b: number) => void;
   readonly meshOutline2d: (a: number, b: number, c: number, d: number, e: number, f: number) => number;

package/pkg/ifc-lite.js

@@ -624,6 +624,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.
@@ -762,6 +911,228 @@ 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.
+     *
+     * Rooms are built analytically from extruded-area profiles (watertight by construction);
+     * faces are typed Floor / RoofCeiling / Wall with outward normals. The result loads via
+     * `honeybee.model.Model.from_hbjson` and is ready for Ladybug Tools / Pollination.
+     *
+     * ```javascript
+     * const api = new IfcAPI();
+     * const hbjson = api.exportHbjson(ifcContent, "my_model");
+     * ```
+     * @param {string} content
+     * @param {string} name
+     * @returns {string}
+     */
+    exportHbjson(content, name) {
+        let deferred3_0;
+        let deferred3_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(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportHbjson(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred3_0 = r0;
+            deferred3_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+        }
+    }
     /**
      * Parse the file and return every `IfcAlignment` directrix as a flat
      * `Float32Array` of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` in
@@ -883,6 +1254,21 @@ export class IfcAPI {
     clearPrePassCache() {
         wasm.ifcapi_clearPrePassCache(this.__wbg_ptr);
     }
+    /**
+     * Enable or disable the PARAMETRIC rectangular-opening fast path (the
+     * placement-frame, ground-truth-exact analytic cut) for `processGeometryBatch`.
+     *
+     * DEFAULT OFF. This is the wasm-side toggle that lets native and wasm flip the
+     * flag in LOCKSTEP — the byte-identical native==wasm contract requires both
+     * targets take the same path, and wasm has no env to read `IFC_LITE_RECT_PARAM`.
+     * The path subtracts rectangular openings as exact parametric boxes in the host's
+     * own placement frame (rotated walls included), deferring any non-clean case to
+     * the exact kernel. Pass `true` before `processGeometryBatch`.
+     * @param {boolean} enabled
+     */
+    setRectParamFastPath(enabled) {
+        wasm.ifcapi_setRectParamFastPath(this.__wbg_ptr, enabled);
+    }
     /**
      * Select the tessellation detail level applied by every subsequent
      * `processGeometryBatch` call (issue #976, step 4).