@ifc-lite/wasm 4.2.2 → 4.3.1

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -276,6 +276,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 +381,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 +560,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;
@@ -789,6 +809,47 @@ export class MeshCollection {
      * nested shape as a single FFI crossing instead of dozens of getters.
      */
     readonly diagnostics: any;
+    /**
+     * Per-entity world-space AABBs as a `Float64Array`, SIX values per entry
+     * (`minx, miny, minz, maxx, maxy, maxz`), in the same order as
+     * [`Self::geometry_hash_ids`] — entry `i` spans `[6*i, 6*i+6)`. Empty
+     * unless geometry hashing was enabled; the same
+     * `IfcAPI.setComputeGeometryHashes` switch gates both, so nothing is
+     * computed when the diff feature is off.
+     *
+     * Unquantized world `f64` (the file's RTC folded back in), so two
+     * revisions that chose different RTC offsets report the same box. This is
+     * what lets a consumer say "MOVED" honestly instead of inferring it from a
+     * changed hash, which also fires on reshape and on retriangulation.
+     *
+     * **Frame: WebGL Y-up**, like every other box, position, origin and
+     * placement that crosses this boundary (see `MeshDataJs::local_bounds`).
+     * The hasher accumulates in the producer's IFC Z-up frame, so the swap
+     * `(x,y,z) -> (x,z,-y)` is applied here, on the way out. Unconverted, the
+     * boxes would not enclose the very meshes `processGeometryBatch` returns
+     * alongside them. Positions are RTC-relative and this box is absolute, so
+     * a consumer comparing the two folds `rtcOffset*` in — itself Y-up-swapped.
+     *
+     * Present for every hashed entity. Its companion
+     * [`Self::geometry_volume_values`] is not — see there.
+     */
+    readonly geometryAabbValues: Float64Array;
+    /**
+     * Per-entity topology verdict as a `Uint8Array`, one packed byte per entry
+     * in [`Self::geometry_hash_ids`] order:
+     *
+     * * bit 0 (`1`) — every segment closed (no boundary / non-manifold edge)
+     * * bit 1 (`2`) — every segment orientable
+     * * bit 2 (`4`) — every segment a single connected component
+     * * bit 3 (`8`) — the entity produced exactly one segment
+     *
+     * `0x0F` is exactly the set that carries a volume in
+     * [`Self::geometry_volume_values`]. The individual bits are the diagnosis:
+     * a model checker can distinguish "this wall is an open shell" (bit 0
+     * clear) from "this door is a multi-item assembly whose parts may overlap"
+     * (bit 3 clear), which are different findings with different fixes.
+     */
+    readonly geometryClosureFlags: Uint8Array;
     /**
      * Number of per-entity geometry fingerprints recorded.
      */
@@ -806,6 +867,28 @@ export class MeshCollection {
      * geometry hashing was enabled.
      */
     readonly geometryHashValues: BigUint64Array;
+    /**
+     * Per-entity enclosed volume in CUBIC METRES as a `Float64Array`, one
+     * value per entry in [`Self::geometry_hash_ids`] order. `NaN` means NO
+     * TRUSTWORTHY VOLUME — the same absent convention as
+     * [`Self::geometry_aabb_values`] — and it is `NaN` for roughly a third of
+     * entities by design, not by failure.
+     *
+     * A value is emitted only when that entity's produced geometry was
+     * PROVABLY a single closed, orientable, single-component solid, as decided
+     * by the mesher's own orientation pass. Read
+     * `ifc_lite_geometry::GeometryHasher::volume` before treating a `NaN` as a
+     * bug: an open `SurfaceModel`, a material-layered wall (whose slices are
+     * open bands by construction), and any element assembled from more than one
+     * representation item all correctly report nothing rather than a plausible
+     * wrong number. [`Self::geometry_closure_flags`] says which.
+     *
+     * This is NOT a substitute for an IFC `BaseQuantities` `GrossVolume`: it is
+     * the volume of the geometry that was actually meshed, after opening cuts,
+     * and it says nothing about whether a CSG degradation left the host uncut
+     * (see the `diagnostics` getter).
+     */
+    readonly geometryVolumeValues: Float64Array;
     /**
      * Get number of meshes
      */
@@ -1583,6 +1666,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;
@@ -1620,9 +1704,12 @@ export interface InitOutput {
     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_geometryAabbValues: (a: number) => number;
+    readonly meshcollection_geometryClosureFlags: (a: number) => number;
     readonly meshcollection_geometryHashCount: (a: number) => number;
     readonly meshcollection_geometryHashIds: (a: number) => number;
     readonly meshcollection_geometryHashValues: (a: number) => number;
+    readonly meshcollection_geometryVolumeValues: (a: number) => number;
     readonly meshcollection_get: (a: number, b: number) => number;
     readonly meshcollection_hasRtcOffset: (a: number) => number;
     readonly meshcollection_length: (a: number) => number;

package/pkg/ifc-lite.js

@@ -715,6 +715,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 +757,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 +1088,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 +1627,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
@@ -2005,6 +2046,55 @@ export class MeshCollection {
         const ret = wasm.meshcollection_diagnostics(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * Per-entity world-space AABBs as a `Float64Array`, SIX values per entry
+     * (`minx, miny, minz, maxx, maxy, maxz`), in the same order as
+     * [`Self::geometry_hash_ids`] — entry `i` spans `[6*i, 6*i+6)`. Empty
+     * unless geometry hashing was enabled; the same
+     * `IfcAPI.setComputeGeometryHashes` switch gates both, so nothing is
+     * computed when the diff feature is off.
+     *
+     * Unquantized world `f64` (the file's RTC folded back in), so two
+     * revisions that chose different RTC offsets report the same box. This is
+     * what lets a consumer say "MOVED" honestly instead of inferring it from a
+     * changed hash, which also fires on reshape and on retriangulation.
+     *
+     * **Frame: WebGL Y-up**, like every other box, position, origin and
+     * placement that crosses this boundary (see `MeshDataJs::local_bounds`).
+     * The hasher accumulates in the producer's IFC Z-up frame, so the swap
+     * `(x,y,z) -> (x,z,-y)` is applied here, on the way out. Unconverted, the
+     * boxes would not enclose the very meshes `processGeometryBatch` returns
+     * alongside them. Positions are RTC-relative and this box is absolute, so
+     * a consumer comparing the two folds `rtcOffset*` in — itself Y-up-swapped.
+     *
+     * Present for every hashed entity. Its companion
+     * [`Self::geometry_volume_values`] is not — see there.
+     * @returns {Float64Array}
+     */
+    get geometryAabbValues() {
+        const ret = wasm.meshcollection_geometryAabbValues(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Per-entity topology verdict as a `Uint8Array`, one packed byte per entry
+     * in [`Self::geometry_hash_ids`] order:
+     *
+     * * bit 0 (`1`) — every segment closed (no boundary / non-manifold edge)
+     * * bit 1 (`2`) — every segment orientable
+     * * bit 2 (`4`) — every segment a single connected component
+     * * bit 3 (`8`) — the entity produced exactly one segment
+     *
+     * `0x0F` is exactly the set that carries a volume in
+     * [`Self::geometry_volume_values`]. The individual bits are the diagnosis:
+     * a model checker can distinguish "this wall is an open shell" (bit 0
+     * clear) from "this door is a multi-item assembly whose parts may overlap"
+     * (bit 3 clear), which are different findings with different fixes.
+     * @returns {Uint8Array}
+     */
+    get geometryClosureFlags() {
+        const ret = wasm.meshcollection_geometryClosureFlags(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Number of per-entity geometry fingerprints recorded.
      * @returns {number}
@@ -2034,6 +2124,32 @@ export class MeshCollection {
         const ret = wasm.meshcollection_geometryHashValues(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * Per-entity enclosed volume in CUBIC METRES as a `Float64Array`, one
+     * value per entry in [`Self::geometry_hash_ids`] order. `NaN` means NO
+     * TRUSTWORTHY VOLUME — the same absent convention as
+     * [`Self::geometry_aabb_values`] — and it is `NaN` for roughly a third of
+     * entities by design, not by failure.
+     *
+     * A value is emitted only when that entity's produced geometry was
+     * PROVABLY a single closed, orientable, single-component solid, as decided
+     * by the mesher's own orientation pass. Read
+     * `ifc_lite_geometry::GeometryHasher::volume` before treating a `NaN` as a
+     * bug: an open `SurfaceModel`, a material-layered wall (whose slices are
+     * open bands by construction), and any element assembled from more than one
+     * representation item all correctly report nothing rather than a plausible
+     * wrong number. [`Self::geometry_closure_flags`] says which.
+     *
+     * This is NOT a substitute for an IFC `BaseQuantities` `GrossVolume`: it is
+     * the volume of the geometry that was actually meshed, after opening cuts,
+     * and it says nothing about whether a CSG degradation left the host uncut
+     * (see the `diagnostics` getter).
+     * @returns {Float64Array}
+     */
+    get geometryVolumeValues() {
+        const ret = wasm.meshcollection_geometryVolumeValues(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Get mesh at index (clones — non-destructive). Prefer `takeMesh` on the
      * hot streaming path; this stays for callers that read meshes more than once.