@ifc-lite/wasm 2.13.3 → 2.14.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -94,7 +94,7 @@ export class IfcAPI {
    * historical look — #1321). Optional at the boundary so older 5-arg callers
    * keep lit-by-default behaviour.
    */
-  exportGlb(content: string, include_metadata: boolean, hidden: Uint32Array, isolated: Uint32Array, hidden_types_csv: string, lit?: boolean | null): Uint8Array;
+  exportGlb(content: Uint8Array, include_metadata: boolean, hidden: Uint32Array, isolated: Uint32Array, hidden_types_csv: string, lit?: boolean | null): 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`/
@@ -120,12 +120,7 @@ export class IfcAPI {
    * 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;
+  exportObj(content: Uint8Array, include_normals: boolean, hidden: Uint32Array, isolated: Uint32Array): string;
   /**
    * Process geometry for a subset of pre-scanned entities → flat
    * MeshCollection. Takes raw bytes + pre-pass data from buildPrePassOnce.
@@ -134,32 +129,6 @@ export class IfcAPI {
    * 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;
-  /**
-   * Streaming pre-pass: emits geometry jobs in chunks via a JS callback
-   * instead of waiting for the full file scan to complete.
-   *
-   * Single linear walk over the file:
-   *   1. Builds the entity index incrementally from the same scan that
-   *      collects geometry jobs (a separate index scan would double
-   *      wall-clock).
-   *   2. As soon as `IFCPROJECT` has been seen, the unit scale and the
-   *      first ~50 geometry jobs have been collected, resolves
-   *      `unitScale` + `rtcOffset` and emits a `meta` callback so the
-   *      JS host can spin up geometry process workers.
-   *   3. Emits `jobs` callbacks every `chunk_size` jobs (or fewer if
-   *      the meta phase already buffered some).
-   *   4. Emits `complete` with the total job count at end of scan.
-   *
-   * On a 986 MB / 14 M-entity file this drops time-to-first-geometry
-   * from ~17 s (full pre-pass + worker spawn + first batch) to ~3 s
-   * (first 100 K bytes scanned + meta + first chunk).
-   *
-   * The callback receives a single `JsValue` argument shaped as one of:
-   *   `{ type: "meta", unitScale, rtcOffset: [x,y,z], needsShift, buildingRotation? }`
-   *   `{ type: "jobs", jobs: Uint32Array }`     // [id, start, end] triples
-   *   `{ type: "complete", totalJobs }`
-   */
-  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
@@ -190,6 +159,37 @@ export class IfcAPI {
    * 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;
+  /**
+   * Run the pre-pass ONCE and return serialized results for worker distribution.
+   * Takes raw bytes (&[u8]) to avoid TextDecoder overhead.
+   */
+  buildPrePassOnce(data: Uint8Array): any;
+  /**
+   * Streaming pre-pass: emits geometry jobs in chunks via a JS callback
+   * instead of waiting for the full file scan to complete.
+   *
+   * Single linear walk over the file:
+   *   1. Builds the entity index incrementally from the same scan that
+   *      collects geometry jobs (a separate index scan would double
+   *      wall-clock).
+   *   2. As soon as `IFCPROJECT` has been seen, the unit scale and the
+   *      first ~50 geometry jobs have been collected, resolves
+   *      `unitScale` + `rtcOffset` and emits a `meta` callback so the
+   *      JS host can spin up geometry process workers.
+   *   3. Emits `jobs` callbacks every `chunk_size` jobs (or fewer if
+   *      the meta phase already buffered some).
+   *   4. Emits `complete` with the total job count at end of scan.
+   *
+   * On a 986 MB / 14 M-entity file this drops time-to-first-geometry
+   * from ~17 s (full pre-pass + worker spawn + first batch) to ~3 s
+   * (first 100 K bytes scanned + meta + first chunk).
+   *
+   * The callback receives a single `JsValue` argument shaped as one of:
+   *   `{ type: "meta", unitScale, rtcOffset: [x,y,z], needsShift, buildingRotation? }`
+   *   `{ type: "jobs", jobs: Uint32Array }`     // [id, start, end] triples
+   *   `{ type: "complete", totalJobs }`
+   */
+  buildPrePassStreaming(data: Uint8Array, on_event: Function, chunk_size: number, disabled_type_names: string[] | null | undefined, skip_type_geometry: boolean): any;
   /**
    * 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
@@ -211,22 +211,22 @@ export class IfcAPI {
    * `"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;
+  exportCsv(content: Uint8Array, 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;
+  exportIfcx(content: Uint8Array, 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;
+  exportJson(content: Uint8Array, 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;
+  exportJsonld(content: Uint8Array, context: string, include_properties: boolean, include_quantities: boolean, pretty: boolean, included: Uint32Array): string;
   /**
    * Re-serialize the model in `content` to a STEP/IFC string.
    *
@@ -236,7 +236,7 @@ export class IfcAPI {
    * `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;
+  exportStep(content: Uint8Array, 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
@@ -255,7 +255,7 @@ export class IfcAPI {
    * const hbjson = api.exportHbjson(ifcContent, "my_model");
    * ```
    */
-  exportHbjson(content: string, name: string): string;
+  exportHbjson(content: Uint8Array, 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
@@ -331,6 +331,17 @@ export class IfcAPI {
    * Default is `false`. Pass `true` before calling `processGeometryBatch`.
    */
   setMergeLayers(enabled: boolean): void;
+  /**
+   * Toggle the tier-independent small-cut skip (#1286). When `true`,
+   * `processGeometryBatch` drops `IfcBooleanResult` differences whose cutter is
+   * tiny relative to its host (steel copes/notches) while keeping the
+   * tessellation tier — so curves stay full-density. The viewer enables this for
+   * the on-screen load; exports/drawings leave it off so their geometry keeps
+   * every cut. Default off ⇒ byte-identical to before.
+   *
+   * Set BEFORE processing — meshes already emitted are not regenerated.
+   */
+  setSkipSmallCuts(on: boolean): void;
   /**
    * Clear the cached entity index (call between loads when reusing
    * the same `IfcAPI` instance — e.g. the parser worker keeps one
@@ -404,6 +415,14 @@ export class IfcAPI {
    * Much faster than scanning all entities (3x speedup for large files)
    */
   scanGeometryEntitiesFast(content: string): any;
+  /**
+   * Run geometry extraction on `content` and return its typed CSG / opening
+   * diagnostics (the `GeometryDiagnostics` contract) as a JS object, or
+   * `undefined` when nothing diagnostic-worthy happened (no openings, no
+   * failures). Takes the raw IFC bytes (`Uint8Array`) so there is no input-size
+   * cap. The produced meshes are dropped; only the diagnostics are returned.
+   */
+  diagnoseGeometry(content: Uint8Array): any;
   /**
    * Parse IFC file and extract symbolic representations (Plan,
    * Annotation, FootPrint, Axis). These are 2D curves used for
@@ -453,6 +472,13 @@ export class MeshCollection {
    * it twice for the same index yields the second call an empty mesh.
    */
   takeMesh(index: number): MeshDataJs | undefined;
+  /**
+   * The batch's typed CSG / opening diagnostics as a JS object (the
+   * `GeometryDiagnostics` contract), or `undefined` if none were recorded. The
+   * worker merges these across batches. One serialized value keeps the rich
+   * nested shape as a single FFI crossing instead of dozens of getters.
+   */
+  readonly diagnostics: any;
   /**
    * Get RTC offset X (for converting local coords back to world coords)
    * Add this to local X coordinates to get world X coordinates
@@ -1070,6 +1096,7 @@ 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_diagnoseGeometry: (a: number, b: number, c: number) => number;
   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, l: 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, t: number) => void;
@@ -1099,10 +1126,12 @@ export interface InitOutput {
   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_setSkipSmallCuts: (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;
   readonly meshcollection_buildingRotation: (a: number, b: number) => void;
+  readonly meshcollection_diagnostics: (a: number) => number;
   readonly meshcollection_geometryHashCount: (a: number) => number;
   readonly meshcollection_geometryHashIds: (a: number) => number;
   readonly meshcollection_geometryHashValues: (a: number) => number;

package/pkg/ifc-lite.js

@@ -639,7 +639,7 @@ export class IfcAPI {
      * `true` ⇒ lit (the default), `false` ⇒ flat `KHR_materials_unlit` (the
      * historical look — #1321). Optional at the boundary so older 5-arg callers
      * keep lit-by-default behaviour.
-     * @param {string} content
+     * @param {Uint8Array} content
      * @param {boolean} include_metadata
      * @param {Uint32Array} hidden
      * @param {Uint32Array} isolated
@@ -650,7 +650,7 @@ export class IfcAPI {
     exportGlb(content, include_metadata, hidden, isolated, hidden_types_csv, lit) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArray32ToWasm0(hidden, wasm.__wbindgen_export);
             const len1 = WASM_VECTOR_LEN;
@@ -755,7 +755,7 @@ export class IfcAPI {
      * ```javascript
      * const obj = api.exportObj(ifcContent, true, new Uint32Array(), new Uint32Array());
      * ```
-     * @param {string} content
+     * @param {Uint8Array} content
      * @param {boolean} include_normals
      * @param {Uint32Array} hidden
      * @param {Uint32Array} isolated
@@ -766,7 +766,7 @@ export class IfcAPI {
         let deferred4_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArray32ToWasm0(hidden, wasm.__wbindgen_export);
             const len1 = WASM_VECTOR_LEN;
@@ -783,18 +783,6 @@ export class IfcAPI {
             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.
-     * @param {Uint8Array} data
-     * @returns {any}
-     */
-    buildPrePassOnce(data) {
-        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
-        const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.ifcapi_buildPrePassOnce(this.__wbg_ptr, ptr0, len0);
-        return takeObject(ret);
-    }
     /**
      * Process geometry for a subset of pre-scanned entities → flat
      * MeshCollection. Takes raw bytes + pre-pass data from buildPrePassOnce.
@@ -843,57 +831,6 @@ export class IfcAPI {
         const ret = wasm.ifcapi_processGeometryBatch(this.__wbg_ptr, ptr0, len0, ptr1, len1, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, !isLikeNone(plane_angle_to_radians), isLikeNone(plane_angle_to_radians) ? 0 : plane_angle_to_radians, ptr7, len7, ptr8, len8, ptr9, len9);
         return MeshCollection.__wrap(ret);
     }
-    /**
-     * Streaming pre-pass: emits geometry jobs in chunks via a JS callback
-     * instead of waiting for the full file scan to complete.
-     *
-     * Single linear walk over the file:
-     *   1. Builds the entity index incrementally from the same scan that
-     *      collects geometry jobs (a separate index scan would double
-     *      wall-clock).
-     *   2. As soon as `IFCPROJECT` has been seen, the unit scale and the
-     *      first ~50 geometry jobs have been collected, resolves
-     *      `unitScale` + `rtcOffset` and emits a `meta` callback so the
-     *      JS host can spin up geometry process workers.
-     *   3. Emits `jobs` callbacks every `chunk_size` jobs (or fewer if
-     *      the meta phase already buffered some).
-     *   4. Emits `complete` with the total job count at end of scan.
-     *
-     * On a 986 MB / 14 M-entity file this drops time-to-first-geometry
-     * from ~17 s (full pre-pass + worker spawn + first batch) to ~3 s
-     * (first 100 K bytes scanned + meta + first chunk).
-     *
-     * The callback receives a single `JsValue` argument shaped as one of:
-     *   `{ type: "meta", unitScale, rtcOffset: [x,y,z], needsShift, buildingRotation? }`
-     *   `{ type: "jobs", jobs: Uint32Array }`     // [id, start, end] triples
-     *   `{ type: "complete", totalJobs }`
-     * @param {Uint8Array} data
-     * @param {Function} on_event
-     * @param {number} chunk_size
-     * @param {string[] | null | undefined} disabled_type_names
-     * @param {boolean} skip_type_geometry
-     * @returns {any}
-     */
-    buildPrePassStreaming(data, on_event, chunk_size, disabled_type_names, skip_type_geometry) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
-            const len0 = WASM_VECTOR_LEN;
-            var ptr1 = isLikeNone(disabled_type_names) ? 0 : passArrayJsValueToWasm0(disabled_type_names, wasm.__wbindgen_export);
-            var len1 = WASM_VECTOR_LEN;
-            wasm.ifcapi_buildPrePassStreaming(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(on_event), chunk_size, ptr1, len1, skip_type_geometry);
-            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-            if (r2) {
-                throw takeObject(r1);
-            }
-            return takeObject(r0);
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-            heap[stack_pointer++] = undefined;
-        }
-    }
     /**
      * Like [`IfcAPI::process_geometry_batch`] but collates the batch's meshes
      * into a GPU-instancing shard (IFNS wire format) instead of a flat
@@ -1013,6 +950,69 @@ export class IfcAPI {
         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);
     }
+    /**
+     * Run the pre-pass ONCE and return serialized results for worker distribution.
+     * Takes raw bytes (&[u8]) to avoid TextDecoder overhead.
+     * @param {Uint8Array} data
+     * @returns {any}
+     */
+    buildPrePassOnce(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_buildPrePassOnce(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Streaming pre-pass: emits geometry jobs in chunks via a JS callback
+     * instead of waiting for the full file scan to complete.
+     *
+     * Single linear walk over the file:
+     *   1. Builds the entity index incrementally from the same scan that
+     *      collects geometry jobs (a separate index scan would double
+     *      wall-clock).
+     *   2. As soon as `IFCPROJECT` has been seen, the unit scale and the
+     *      first ~50 geometry jobs have been collected, resolves
+     *      `unitScale` + `rtcOffset` and emits a `meta` callback so the
+     *      JS host can spin up geometry process workers.
+     *   3. Emits `jobs` callbacks every `chunk_size` jobs (or fewer if
+     *      the meta phase already buffered some).
+     *   4. Emits `complete` with the total job count at end of scan.
+     *
+     * On a 986 MB / 14 M-entity file this drops time-to-first-geometry
+     * from ~17 s (full pre-pass + worker spawn + first batch) to ~3 s
+     * (first 100 K bytes scanned + meta + first chunk).
+     *
+     * The callback receives a single `JsValue` argument shaped as one of:
+     *   `{ type: "meta", unitScale, rtcOffset: [x,y,z], needsShift, buildingRotation? }`
+     *   `{ type: "jobs", jobs: Uint32Array }`     // [id, start, end] triples
+     *   `{ type: "complete", totalJobs }`
+     * @param {Uint8Array} data
+     * @param {Function} on_event
+     * @param {number} chunk_size
+     * @param {string[] | null | undefined} disabled_type_names
+     * @param {boolean} skip_type_geometry
+     * @returns {any}
+     */
+    buildPrePassStreaming(data, on_event, chunk_size, disabled_type_names, skip_type_geometry) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(disabled_type_names) ? 0 : passArrayJsValueToWasm0(disabled_type_names, wasm.__wbindgen_export);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.ifcapi_buildPrePassStreaming(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(on_event), chunk_size, ptr1, len1, skip_type_geometry);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
     /**
      * Parse the file and return structured per-axis data (tag + endpoints) in
      * the renderer's Y-up world space (RTC-subtracted, metres). Use this when
@@ -1047,7 +1047,7 @@ export class IfcAPI {
      * 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 {Uint8Array} content
      * @param {string} mode
      * @param {string} delimiter
      * @param {boolean} include_properties
@@ -1058,7 +1058,7 @@ export class IfcAPI {
         let deferred4_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
@@ -1078,7 +1078,7 @@ export class IfcAPI {
     /**
      * Export **IFC5 / IFCX** (the USD-style node graph). `only_known_properties` keeps
      * only properties with an official IFC5 schema.
-     * @param {string} content
+     * @param {Uint8Array} content
      * @param {boolean} only_known_properties
      * @param {boolean} pretty
      * @returns {string}
@@ -1088,7 +1088,7 @@ export class IfcAPI {
         let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
             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);
@@ -1103,7 +1103,7 @@ export class IfcAPI {
     }
     /**
      * Export structured **JSON** (array of entity objects with typed property values).
-     * @param {string} content
+     * @param {Uint8Array} content
      * @param {boolean} pretty
      * @param {boolean} include_properties
      * @param {boolean} include_quantities
@@ -1114,7 +1114,7 @@ export class IfcAPI {
         let deferred2_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
             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);
@@ -1131,7 +1131,7 @@ export class IfcAPI {
      * 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 {Uint8Array} content
      * @param {string} context
      * @param {boolean} include_properties
      * @param {boolean} include_quantities
@@ -1144,7 +1144,7 @@ export class IfcAPI {
         let deferred4_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(context, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
@@ -1169,7 +1169,7 @@ export class IfcAPI {
      * `#`-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 {Uint8Array} content
      * @param {string} schema
      * @param {Uint32Array} included
      * @param {string} mutations_json
@@ -1180,7 +1180,7 @@ export class IfcAPI {
         let deferred5_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(schema, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
@@ -1241,7 +1241,7 @@ export class IfcAPI {
      * const api = new IfcAPI();
      * const hbjson = api.exportHbjson(ifcContent, "my_model");
      * ```
-     * @param {string} content
+     * @param {Uint8Array} content
      * @param {string} name
      * @returns {string}
      */
@@ -1250,7 +1250,7 @@ export class IfcAPI {
         let deferred3_1;
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
@@ -1373,6 +1373,20 @@ export class IfcAPI {
     setMergeLayers(enabled) {
         wasm.ifcapi_setMergeLayers(this.__wbg_ptr, enabled);
     }
+    /**
+     * Toggle the tier-independent small-cut skip (#1286). When `true`,
+     * `processGeometryBatch` drops `IfcBooleanResult` differences whose cutter is
+     * tiny relative to its host (steel copes/notches) while keeping the
+     * tessellation tier — so curves stay full-density. The viewer enables this for
+     * the on-screen load; exports/drawings leave it off so their geometry keeps
+     * every cut. Default off ⇒ byte-identical to before.
+     *
+     * Set BEFORE processing — meshes already emitted are not regenerated.
+     * @param {boolean} on
+     */
+    setSkipSmallCuts(on) {
+        wasm.ifcapi_setSkipSmallCuts(this.__wbg_ptr, on);
+    }
     /**
      * Clear the cached entity index (call between loads when reusing
      * the same `IfcAPI` instance — e.g. the parser worker keeps one
@@ -1523,6 +1537,21 @@ export class IfcAPI {
         const ret = wasm.ifcapi_scanGeometryEntitiesFast(this.__wbg_ptr, ptr0, len0);
         return takeObject(ret);
     }
+    /**
+     * Run geometry extraction on `content` and return its typed CSG / opening
+     * diagnostics (the `GeometryDiagnostics` contract) as a JS object, or
+     * `undefined` when nothing diagnostic-worthy happened (no openings, no
+     * failures). Takes the raw IFC bytes (`Uint8Array`) so there is no input-size
+     * cap. The produced meshes are dropped; only the diagnostics are returned.
+     * @param {Uint8Array} content
+     * @returns {any}
+     */
+    diagnoseGeometry(content) {
+        const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_diagnoseGeometry(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
     /**
      * Parse IFC file and extract symbolic representations (Plan,
      * Annotation, FootPrint, Axis). These are 2D curves used for
@@ -1571,6 +1600,17 @@ export class MeshCollection {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_meshcollection_free(ptr, 0);
     }
+    /**
+     * The batch's typed CSG / opening diagnostics as a JS object (the
+     * `GeometryDiagnostics` contract), or `undefined` if none were recorded. The
+     * worker merges these across batches. One serialized value keeps the rich
+     * nested shape as a single FFI crossing instead of dozens of getters.
+     * @returns {any}
+     */
+    get diagnostics() {
+        const ret = wasm.meshcollection_diagnostics(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Get RTC offset X (for converting local coords back to world coords)
      * Add this to local X coordinates to get world X coordinates