@ifc-lite/wasm 2.13.4 → 3.0.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -93,8 +93,14 @@ 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.
+   *
+   * Fails CLOSED: when the visible mesh set is empty this throws an `Error`
+   * whose message starts with `NO_RENDER_GEOMETRY`, instead of returning a
+   * structurally valid but empty GLB. #1438 put that guard only in the TS
+   * CLI/MCP wrappers; making the boundary itself refuse means SDK/viewer/
+   * direct callers inherit it too (the TS guards stay as defense-in-depth).
    */
-  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`/
@@ -111,7 +117,11 @@ export class IfcAPI {
    */
   exportGlbFromMeshes(positions: Float32Array, normals: Float32Array, indices: Uint32Array, vertex_counts: Uint32Array, index_counts: Uint32Array, colors: Float32Array, origins: Float64Array, express_ids: Uint32Array, include_metadata: boolean, lit?: boolean | null): Uint8Array;
   /**
-   * Export the render geometry in `content` as a Wavefront **OBJ** string.
+   * Export the render geometry in `content` as Wavefront **OBJ** UTF-8 bytes.
+   *
+   * Returned as UTF-8 bytes (`Uint8Array`) so output is not capped by the
+   * V8 max-string ceiling (~512 MB); decode with `TextDecoder` when a string
+   * is genuinely needed.
    *
    * `hidden` / `isolated` are express-id filters mirroring the viewer's visibility
    * state (empty `isolated` ⇒ all visible). Instanced type-library shapes are skipped.
@@ -120,12 +130,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): Uint8Array;
   /**
    * Process geometry for a subset of pre-scanned entities → flat
    * MeshCollection. Takes raw bytes + pre-pass data from buildPrePassOnce.
@@ -134,32 +139,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 +169,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,24 +221,28 @@ 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): Uint8Array;
   /**
    * 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): Uint8Array;
   /**
    * 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): Uint8Array;
   /**
    * 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): Uint8Array;
   /**
-   * Re-serialize the model in `content` to a STEP/IFC string.
+   * Re-serialize the model in `content` to STEP/IFC UTF-8 bytes.
+   *
+   * Returned as UTF-8 bytes (`Uint8Array`) so output is not capped by the
+   * V8 max-string ceiling (~512 MB); decode with `TextDecoder` when a string
+   * is genuinely needed.
    *
    * `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
@@ -236,15 +250,20 @@ 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): Uint8Array;
   /**
-   * Merge several IFC models into one STEP/IFC string. `concatenated` is every model's
+   * Merge several IFC models into one STEP/IFC UTF-8 byte buffer (`Uint8Array`).
+   * `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;
+  exportMerged(concatenated: Uint8Array, lengths: Uint32Array, schema: string): Uint8Array;
   /**
-   * Export the `IfcSpace` volumes in `content` as a Honeybee **HBJSON** string.
+   * Export the `IfcSpace` volumes in `content` as Honeybee **HBJSON** UTF-8 bytes.
+   *
+   * Returned as UTF-8 bytes (`Uint8Array`) so output is not capped by the
+   * V8 max-string ceiling (~512 MB); decode with `TextDecoder` when a string
+   * is genuinely needed.
    *
    * Rooms are built analytically from extruded-area profiles (watertight by construction);
    * faces are typed Floor / RoofCeiling / Wall with outward normals. The result loads via
@@ -255,7 +274,7 @@ export class IfcAPI {
    * const hbjson = api.exportHbjson(ifcContent, "my_model");
    * ```
    */
-  exportHbjson(content: string, name: string): string;
+  exportHbjson(content: Uint8Array, name: string): Uint8Array;
   /**
    * Parse the file and return every `IfcAlignment` directrix as a flat
    * `Float32Array` of 3D line-list vertices `[x0,y0,z0, x1,y1,z1, …]` in
@@ -290,6 +309,15 @@ export class IfcAPI {
    * ```
    */
   extractProfiles(content: string, model_index: number): ProfileCollection;
+  /**
+   * Structured pipeline diagnostics accumulated across every
+   * `processGeometryBatch*` call since the last load reset
+   * (`clearPrePassCache` / `setEntityIndex`), as a JS object with a
+   * `schemaVersion` field — or `undefined` when no batch has run yet.
+   * Includes per-batch summed geometry wall time, mesh/triangle counts,
+   * the degenerate-backstop drop count, and the CSG failure aggregates.
+   */
+  getPipelineDiagnostics(): any;
   /**
    * Get WASM memory for zero-copy access
    */
@@ -331,6 +359,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
@@ -346,12 +385,13 @@ export class IfcAPI {
    * 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`.
+   * DEFAULT ON (corpus-validated; native defaults ON too, and wasm has no env to
+   * read `IFC_LITE_RECT_PARAM`, so both targets default in LOCKSTEP -- the
+   * byte-identical native==wasm contract requires both take the same path). This
+   * toggle is the wasm-side escape hatch mirroring `IFC_LITE_RECT_PARAM=0`.
    * 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`.
+   * the exact kernel. Pass `false` before `processGeometryBatch` to opt out.
    */
   setRectParamFastPath(enabled: boolean): void;
   /**
@@ -404,6 +444,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 +501,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
@@ -514,6 +569,12 @@ export class MeshDataJs {
    * True when this mesh carries a surface texture (#961).
    */
   readonly hasTexture: boolean;
+  /**
+   * Local (pre-placement, object-space) AABB (issue #1474), WebGL Y-up,
+   * `[minX,minY,minZ,maxX,maxY,maxZ]`. `undefined` when not captured
+   * (wasm-bindgen maps `Option::None` to `undefined`, not `null`).
+   */
+  readonly localBounds: Float32Array | undefined;
   /**
    * Decoded RGBA8 texture bytes (`width*height*4`). Empty when untextured.
    */
@@ -535,6 +596,12 @@ export class MeshDataJs {
    * type geometry (hidden in Model mode, shown in Types mode).
    */
   readonly geometryClass: number;
+  /**
+   * The resolved `IfcLocalPlacement` chain for this mesh (issue #1474),
+   * row-major 4×4, WebGL Y-up. `undefined` when not captured (see
+   * `local_bounds` above).
+   */
+  readonly localToWorld: Float64Array | undefined;
   readonly textureHeight: number;
   /**
    * Get triangle count
@@ -1070,6 +1137,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;
@@ -1083,6 +1151,7 @@ export interface InitOutput {
   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_getPipelineDiagnostics: (a: number) => number;
   readonly ifcapi_is_ready: (a: number) => number;
   readonly ifcapi_new: () => number;
   readonly ifcapi_parseAlignmentLines: (a: number, b: number, c: number) => number;
@@ -1099,10 +1168,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;
@@ -1121,6 +1192,8 @@ export interface InitOutput {
   readonly meshdatajs_hasTexture: (a: number) => number;
   readonly meshdatajs_ifcType: (a: number, b: number) => void;
   readonly meshdatajs_indices: (a: number) => number;
+  readonly meshdatajs_localBounds: (a: number, b: number) => void;
+  readonly meshdatajs_localToWorld: (a: number, b: number) => void;
   readonly meshdatajs_normals: (a: number) => number;
   readonly meshdatajs_origin: (a: number) => number;
   readonly meshdatajs_positions: (a: number) => number;
@@ -1142,6 +1215,7 @@ export interface InitOutput {
   readonly partitionedbatch_takeShard: (a: number, b: number) => void;
   readonly profilecollection_get: (a: number, b: number) => number;
   readonly profilecollection_length: (a: number) => number;
+  readonly profileentryjs_expressId: (a: number) => number;
   readonly profileentryjs_extrusionDepth: (a: number) => number;
   readonly profileentryjs_extrusionDir: (a: number) => number;
   readonly profileentryjs_holeCounts: (a: number) => number;
@@ -1224,7 +1298,6 @@ export interface InitOutput {
   readonly init: () => void;
   readonly symbolicpolyline_pointCount: (a: number) => number;
   readonly get_memory: () => number;
-  readonly profileentryjs_expressId: (a: number) => number;
   readonly symbolicfillarea_expressId: (a: number) => number;
   readonly symbolicpolyline_worldY: (a: number) => number;
   readonly symbolictext_colorB: (a: number) => number;

package/pkg/ifc-lite.js

@@ -639,7 +639,13 @@ 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
+     *
+     * Fails CLOSED: when the visible mesh set is empty this throws an `Error`
+     * whose message starts with `NO_RENDER_GEOMETRY`, instead of returning a
+     * structurally valid but empty GLB. #1438 put that guard only in the TS
+     * CLI/MCP wrappers; making the boundary itself refuse means SDK/viewer/
+     * direct callers inherit it too (the TS guards stay as defense-in-depth).
+     * @param {Uint8Array} content
      * @param {boolean} include_metadata
      * @param {Uint32Array} hidden
      * @param {Uint32Array} isolated
@@ -650,7 +656,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;
@@ -661,6 +667,11 @@ export class IfcAPI {
             wasm.ifcapi_exportGlb(retptr, this.__wbg_ptr, ptr0, len0, include_metadata, ptr1, len1, ptr2, len2, ptr3, len3, isLikeNone(lit) ? 0xFFFFFF : lit ? 1 : 0);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
             var v5 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_export4(r0, r1 * 1, 1);
             return v5;
@@ -747,7 +758,11 @@ export class IfcAPI {
         }
     }
     /**
-     * Export the render geometry in `content` as a Wavefront **OBJ** string.
+     * Export the render geometry in `content` as Wavefront **OBJ** UTF-8 bytes.
+     *
+     * Returned as UTF-8 bytes (`Uint8Array`) so output is not capped by the
+     * V8 max-string ceiling (~512 MB); decode with `TextDecoder` when a string
+     * is genuinely needed.
      *
      * `hidden` / `isolated` are express-id filters mirroring the viewer's visibility
      * state (empty `isolated` ⇒ all visible). Instanced type-library shapes are skipped.
@@ -755,18 +770,16 @@ 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
-     * @returns {string}
+     * @returns {Uint8Array}
      */
     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 ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArray32ToWasm0(hidden, wasm.__wbindgen_export);
             const len1 = WASM_VECTOR_LEN;
@@ -775,26 +788,13 @@ export class IfcAPI {
             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);
+            var v4 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v4;
         } 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.
-     * @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 +843,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 +962,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,18 +1059,16 @@ 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
-     * @returns {string}
+     * @returns {Uint8Array}
      */
     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 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;
@@ -1067,84 +1077,75 @@ export class IfcAPI {
             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);
+            var v4 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v4;
         } 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 {Uint8Array} content
      * @param {boolean} only_known_properties
      * @param {boolean} pretty
-     * @returns {string}
+     * @returns {Uint8Array}
      */
     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 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);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
         } 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 {Uint8Array} content
      * @param {boolean} pretty
      * @param {boolean} include_properties
      * @param {boolean} include_quantities
-     * @returns {string}
+     * @returns {Uint8Array}
      */
     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 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);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-            deferred2_0 = r0;
-            deferred2_1 = r1;
-            return getStringFromWasm0(r0, r1);
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
         } 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 {Uint8Array} content
      * @param {string} context
      * @param {boolean} include_properties
      * @param {boolean} include_quantities
      * @param {boolean} pretty
      * @param {Uint32Array} included
-     * @returns {string}
+     * @returns {Uint8Array}
      */
     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 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;
@@ -1153,34 +1154,35 @@ export class IfcAPI {
             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);
+            var v4 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v4;
         } 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.
+     * Re-serialize the model in `content` to STEP/IFC UTF-8 bytes.
+     *
+     * Returned as UTF-8 bytes (`Uint8Array`) so output is not capped by the
+     * V8 max-string ceiling (~512 MB); decode with `TextDecoder` when a string
+     * is genuinely needed.
      *
      * `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 {Uint8Array} content
      * @param {string} schema
      * @param {Uint32Array} included
      * @param {string} mutations_json
-     * @returns {string}
+     * @returns {Uint8Array}
      */
     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 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;
@@ -1191,26 +1193,24 @@ export class IfcAPI {
             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);
+            var v5 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v5;
         } 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
+     * Merge several IFC models into one STEP/IFC UTF-8 byte buffer (`Uint8Array`).
+     * `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}
+     * @returns {Uint8Array}
      */
     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);
@@ -1222,16 +1222,19 @@ export class IfcAPI {
             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);
+            var v4 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v4;
         } 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.
+     * Export the `IfcSpace` volumes in `content` as Honeybee **HBJSON** UTF-8 bytes.
+     *
+     * Returned as UTF-8 bytes (`Uint8Array`) so output is not capped by the
+     * V8 max-string ceiling (~512 MB); decode with `TextDecoder` when a string
+     * is genuinely needed.
      *
      * Rooms are built analytically from extruded-area profiles (watertight by construction);
      * faces are typed Floor / RoofCeiling / Wall with outward normals. The result loads via
@@ -1241,28 +1244,25 @@ 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}
+     * @returns {Uint8Array}
      */
     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 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;
             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);
+            var v3 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v3;
         } finally {
             wasm.__wbindgen_add_to_stack_pointer(16);
-            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
         }
     }
     /**
@@ -1314,6 +1314,19 @@ export class IfcAPI {
         const ret = wasm.ifcapi_extractProfiles(this.__wbg_ptr, ptr0, len0, model_index);
         return ProfileCollection.__wrap(ret);
     }
+    /**
+     * Structured pipeline diagnostics accumulated across every
+     * `processGeometryBatch*` call since the last load reset
+     * (`clearPrePassCache` / `setEntityIndex`), as a JS object with a
+     * `schemaVersion` field — or `undefined` when no batch has run yet.
+     * Includes per-batch summed geometry wall time, mesh/triangle counts,
+     * the degenerate-backstop drop count, and the CSG failure aggregates.
+     * @returns {any}
+     */
+    getPipelineDiagnostics() {
+        const ret = wasm.ifcapi_getPipelineDiagnostics(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Get WASM memory for zero-copy access
      * @returns {any}
@@ -1373,6 +1386,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
@@ -1390,12 +1417,13 @@ export class IfcAPI {
      * 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`.
+     * DEFAULT ON (corpus-validated; native defaults ON too, and wasm has no env to
+     * read `IFC_LITE_RECT_PARAM`, so both targets default in LOCKSTEP -- the
+     * byte-identical native==wasm contract requires both take the same path). This
+     * toggle is the wasm-side escape hatch mirroring `IFC_LITE_RECT_PARAM=0`.
      * 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`.
+     * the exact kernel. Pass `false` before `processGeometryBatch` to opt out.
      * @param {boolean} enabled
      */
     setRectParamFastPath(enabled) {
@@ -1523,6 +1551,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 +1614,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
@@ -1737,6 +1791,28 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_hasTexture(this.__wbg_ptr);
         return ret !== 0;
     }
+    /**
+     * Local (pre-placement, object-space) AABB (issue #1474), WebGL Y-up,
+     * `[minX,minY,minZ,maxX,maxY,maxZ]`. `undefined` when not captured
+     * (wasm-bindgen maps `Option::None` to `undefined`, not `null`).
+     * @returns {Float32Array | undefined}
+     */
+    get localBounds() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshdatajs_localBounds(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getArrayF32FromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 4, 4);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Decoded RGBA8 texture bytes (`width*height*4`). Empty when untextured.
      * @returns {Uint8Array}
@@ -1792,6 +1868,28 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_geometryClass(this.__wbg_ptr);
         return ret;
     }
+    /**
+     * The resolved `IfcLocalPlacement` chain for this mesh (issue #1474),
+     * row-major 4×4, WebGL Y-up. `undefined` when not captured (see
+     * `local_bounds` above).
+     * @returns {Float64Array | undefined}
+     */
+    get localToWorld() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.meshdatajs_localToWorld(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getArrayF64FromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @returns {number}
      */
@@ -2103,7 +2201,7 @@ export class ProfileEntryJs {
      * @returns {number}
      */
     get expressId() {
-        const ret = wasm.meshdatajs_textureWidth(this.__wbg_ptr);
+        const ret = wasm.profileentryjs_expressId(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2795,7 +2893,7 @@ export class SymbolicFillArea {
      * @returns {number}
      */
     get expressId() {
-        const ret = wasm.meshdatajs_textureWidth(this.__wbg_ptr);
+        const ret = wasm.profileentryjs_expressId(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -3203,7 +3301,7 @@ export class SymbolicText {
      * @returns {number}
      */
     get expressId() {
-        const ret = wasm.meshdatajs_textureWidth(this.__wbg_ptr);
+        const ret = wasm.profileentryjs_expressId(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -3566,6 +3664,10 @@ function __wbg_get_imports() {
         const ret = new Float64Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_now_69d776cd24f5215b = function() {
+        const ret = Date.now();
+        return ret;
+    };
     imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
         getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
     };