@ifc-lite/wasm 4.3.0 → 4.4.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -248,6 +248,19 @@ export class IfcAPI {
      * flattened `Pset_Prop` columns to the entities view.
      */
     exportCsv(content: Uint8Array, mode: string, delimiter: string, include_properties: boolean): Uint8Array;
+    /**
+     * Export the `IfcSpace` volumes in `content` as a Dragonfly **DFJSON** string.
+     *
+     * Each space becomes an extruded `Room2D` (floor polygon + floor-to-ceiling height)
+     * grouped into stories — the simpler Ladybug Tools target for mostly-vertical-wall
+     * models. Loads via `dragonfly.model.Model.from_dfjson`.
+     *
+     * ```javascript
+     * const api = new IfcAPI();
+     * const dfjson = api.exportDfjson(ifcContent, "my_model");
+     * ```
+     */
+    exportDfjson(content: Uint8Array, name: string): string;
     /**
      * Export the render geometry in `content` as a binary **GLB** (`Uint8Array`).
      *
@@ -276,6 +289,13 @@ export class IfcAPI {
      * 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.
+     *
+     * Fails CLOSED: if the declared vertex/index counts run past the flattened
+     * `positions` / `indices`, there are fewer `index_counts` than meshes, or `normals`
+     * is empty or too short to cover every vertex, this throws an `Error` whose message
+     * starts with `MALFORMED_MESH_INPUT` — instead of silently emitting a GLB with those
+     * meshes dropped. (The viewer always passes fully-backed, normal-covered arrays, so
+     * this only fires on a caller bug.)
      */
     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, emissive?: boolean | null): Uint8Array;
     /**
@@ -374,6 +394,12 @@ export class IfcAPI {
      * property-set synthesis); empty ⇒ none. See `export_step_json` for the shape.
      */
     exportStep(content: Uint8Array, schema: string, included: Uint32Array, mutations_json: string): Uint8Array;
+    /**
+     * Export **OpenUSD** (`.usda` ASCII): a real Z-up USD stage — spatial hierarchy of
+     * `Xform` prims, `UsdGeomMesh` geometry, `UsdPreviewSurface` materials, IFC
+     * metadata as custom attributes. Whole-model (geometry-backed).
+     */
+    exportUsd(content: Uint8Array): Uint8Array;
     /**
      * Extract raw profile polygons from all building elements with `IfcExtrudedAreaSolid`
      * representations.
@@ -547,15 +573,22 @@ export class IfcAPI {
      * range_end)` shard; the main thread stitches the returned columns into the
      * full entity index (byte-identical to the single-threaded
      * `build_entity_index`) by binary-searching each shard for the previous
-     * shard's `handoff`. Delegates to `ifc_lite_processing::scan_shard`, the
-     * exact per-chunk primitive the native `build_entity_index_parallel` fans
-     * across cores — so the sharded merge cannot drift from the serial builder.
+     * shard's `handoff`. Delegates to `ifc_lite_processing::scan_shard_classified`
+     * — a separately-maintained loop over the same `EntityScanner` primitive as
+     * `scan_shard` (the one the native `build_entity_index_parallel` fans across
+     * cores), plus a per-record class column this sharded path also needs. The
+     * two loops' records/handoff are kept in parity by a dedicated test
+     * (`rust/processing/tests/issue_2053_shard_scan_parity.rs`), not by
+     * delegation — edit one without the other and that test catches the drift.
      *
      * Byte offsets returned are GLOBAL (relative to file start), so shards
      * concatenate without rewriting. Returns a plain object:
      *   `{ ids: Uint32Array, starts: Uint32Array, lengths: Uint32Array,
-     *      handoff: number }`
-     * where `handoff` is the global start of the first entity at/after
+     *      classes: Uint8Array, handoff: number }`
+     * where `classes` is the parallel per-record prepass class byte
+     * (`PREPASS_CLASS_*`: named code in the low bits plus the geometry-job /
+     * type-candidate flags) the host filters on to rebuild pre-pass span
+     * lists, and `handoff` is the global start of the first entity at/after
      * `range_end` (the next shard's first real entity), or `-1` at EOF.
      */
     scanEntityIndexShard(data: Uint8Array, range_start: number, range_end: number): any;
@@ -1635,6 +1668,7 @@ export interface InitOutput {
     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_exportDfjson: (a: number, b: number, c: number, d: number, e: number, f: 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, m: 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, u: number) => void;
     readonly ifcapi_exportHbjson: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
@@ -1646,6 +1680,7 @@ export interface InitOutput {
     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_exportUsd: (a: number, b: number, c: number, d: number) => void;
     readonly ifcapi_extractProfiles: (a: number, b: number, c: number, d: number) => number;
     readonly ifcapi_finalizePrepassStyles: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number) => void;
     readonly ifcapi_getMemory: (a: number) => number;

package/pkg/ifc-lite.js

@@ -654,6 +654,41 @@ export class IfcAPI {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Export the `IfcSpace` volumes in `content` as a Dragonfly **DFJSON** string.
+     *
+     * Each space becomes an extruded `Room2D` (floor polygon + floor-to-ceiling height)
+     * grouped into stories — the simpler Ladybug Tools target for mostly-vertical-wall
+     * models. Loads via `dragonfly.model.Model.from_dfjson`.
+     *
+     * ```javascript
+     * const api = new IfcAPI();
+     * const dfjson = api.exportDfjson(ifcContent, "my_model");
+     * ```
+     * @param {Uint8Array} content
+     * @param {string} name
+     * @returns {string}
+     */
+    exportDfjson(content, name) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            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_exportDfjson(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);
+        }
+    }
     /**
      * Export the render geometry in `content` as a binary **GLB** (`Uint8Array`).
      *
@@ -715,6 +750,13 @@ export class IfcAPI {
      * 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.
+     *
+     * Fails CLOSED: if the declared vertex/index counts run past the flattened
+     * `positions` / `indices`, there are fewer `index_counts` than meshes, or `normals`
+     * is empty or too short to cover every vertex, this throws an `Error` whose message
+     * starts with `MALFORMED_MESH_INPUT` — instead of silently emitting a GLB with those
+     * meshes dropped. (The viewer always passes fully-backed, normal-covered arrays, so
+     * this only fires on a caller bug.)
      * @param {Float32Array} positions
      * @param {Float32Array} normals
      * @param {Uint32Array} indices
@@ -750,6 +792,11 @@ export class IfcAPI {
             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, isLikeNone(lit) ? 0xFFFFFF : lit ? 1 : 0, isLikeNone(emissive) ? 0xFFFFFF : emissive ? 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 v9 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_export4(r0, r1 * 1, 1);
             return v9;
@@ -1076,6 +1123,28 @@ export class IfcAPI {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Export **OpenUSD** (`.usda` ASCII): a real Z-up USD stage — spatial hierarchy of
+     * `Xform` prims, `UsdGeomMesh` geometry, `UsdPreviewSurface` materials, IFC
+     * metadata as custom attributes. Whole-model (geometry-backed).
+     * @param {Uint8Array} content
+     * @returns {Uint8Array}
+     */
+    exportUsd(content) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_exportUsd(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v2 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v2;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Extract raw profile polygons from all building elements with `IfcExtrudedAreaSolid`
      * representations.
@@ -1593,15 +1662,22 @@ export class IfcAPI {
      * range_end)` shard; the main thread stitches the returned columns into the
      * full entity index (byte-identical to the single-threaded
      * `build_entity_index`) by binary-searching each shard for the previous
-     * shard's `handoff`. Delegates to `ifc_lite_processing::scan_shard`, the
-     * exact per-chunk primitive the native `build_entity_index_parallel` fans
-     * across cores — so the sharded merge cannot drift from the serial builder.
+     * shard's `handoff`. Delegates to `ifc_lite_processing::scan_shard_classified`
+     * — a separately-maintained loop over the same `EntityScanner` primitive as
+     * `scan_shard` (the one the native `build_entity_index_parallel` fans across
+     * cores), plus a per-record class column this sharded path also needs. The
+     * two loops' records/handoff are kept in parity by a dedicated test
+     * (`rust/processing/tests/issue_2053_shard_scan_parity.rs`), not by
+     * delegation — edit one without the other and that test catches the drift.
      *
      * Byte offsets returned are GLOBAL (relative to file start), so shards
      * concatenate without rewriting. Returns a plain object:
      *   `{ ids: Uint32Array, starts: Uint32Array, lengths: Uint32Array,
-     *      handoff: number }`
-     * where `handoff` is the global start of the first entity at/after
+     *      classes: Uint8Array, handoff: number }`
+     * where `classes` is the parallel per-record prepass class byte
+     * (`PREPASS_CLASS_*`: named code in the low bits plus the geometry-job /
+     * type-candidate flags) the host filters on to rebuild pre-pass span
+     * lists, and `handoff` is the global start of the first entity at/after
      * `range_end` (the next shard's first real entity), or `-1` at EOF.
      * @param {Uint8Array} data
      * @param {number} range_start