@ifc-lite/wasm 4.2.2 → 4.3.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -789,6 +789,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 +847,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
      */
@@ -1620,9 +1683,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

@@ -2005,6 +2005,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 +2083,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.