@ifc-lite/wasm 7.0.0 → 9.0.0

package/README.md

@@ -157,6 +157,22 @@ for source identity, coordinate frames, budgets and host acceptance requirements
 
 `IfcAPI.preparePdfVectorPage` validates bounded ordered PDF vector graphics states
 and preserves source operator identity, calibrated transforms and paint state.
-Unsupported content remains an explicit blocker. It emits no IFC entities and
-makes no flattened-geometry fidelity claim; see the
-[preparation contract](../../docs/api/wasm.md#pdf-vector-graphics-state-preparation).
+Content the planner cannot convert (text, images, clips, transparency,
+patterns, unqualified dashed strokes, curved/hairline strokes, unknown operators) is returned
+as a fidelity report with counts, page extents and visibility, and an
+`exact`/`rasterOnly` verdict; `IfcAPI.planPdfFillAnnotation` plans a partial
+page only when the request quotes that report's digest as the user's
+acceptance. It emits no IFC entities and makes no flattened-geometry fidelity
+claim; see the
+[preparation contract](../../docs/api/wasm.md#pdf-vector-graphics-state-preparation-and-fidelity-report).
+Qualified positive dash patterns on open and closed straight subpaths preserve
+phase, odd-array repetition, subpath reset, joins across vertices and run caps.
+The closing edge participates in the pattern. PDF 1.0–1.7 retain caps where the
+first and last on-dash pieces meet at the closure seam; PDF 2.0 joins them.
+PDF.js's effective format version is bound into the page DTO; an unknown version
+reports `dashVersion`, and a PDF 1.x dash covering the complete closed perimeter
+reports `dashTopology`. Explicit close-path and close-and-stroke operators share
+the versioned behavior.
+Combined fill and dashed-stroke paints can still refuse atomically when
+multiple run boundaries produce crossings outside the current fill-region
+qualifier.

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -399,11 +399,15 @@ export class IfcAPI {
      * 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.)
+     * `positions` / `indices`, there are fewer `index_counts` than meshes, `normals`
+     * is empty or too short to cover every vertex, a mesh's index block is not a
+     * whole number of triangles, or an index names a vertex its own mesh does not
+     * have (glTF 2.0 3.7.2.1), this throws an `Error` whose message starts with
+     * `MALFORMED_MESH_INPUT` — instead of silently emitting a GLB with those meshes
+     * dropped, a TRIANGLES primitive whose count is not a multiple of 3, or the
+     * out-of-range index copied into the BIN chunk. (The viewer always passes
+     * fully-backed, normal-covered, whole-triangle, in-range 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;
     /**
@@ -452,25 +456,18 @@ export class IfcAPI {
     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: Uint8Array, context: string, include_properties: boolean, include_quantities: boolean, pretty: boolean, included: Uint32Array): 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`/
-     * `altitude`) + `model.glb`. `x_axis_abscissa`/`x_axis_ordinate` are the
-     * `IfcMapConversion` grid-north components; pass both as `undefined` for heading 0.
+     * IFC4 OWL default.
      *
-     * `altitude_mode` selects the KML vertical placement: `"clampToGround"`
-     * (the default when omitted) rests the model on the terrain, ignoring
-     * `altitude`; `"absolute"` places the origin at `altitude` metres MSL.
-     * Google Earth's terrain already encodes the site elevation, so clamping
-     * keeps a wrong/zero/double-counted OrthogonalHeight from floating the
-     * model into the sky (#1427); absolute is offered for models whose
-     * OrthogonalHeight is a true MSL elevation the user wants honoured.
+     * `included` is an express-id isolation filter mirroring `exportObj` /
+     * `exportGlb`, and carries the same null-vs-empty distinction across the wasm
+     * boundary: omit it (`undefined`) for "no isolation filter" (every entity is
+     * emitted); pass an empty `Uint32Array` for "isolation is ACTIVE and currently
+     * matches nothing", which emits an empty `@graph`. Collapsing the two — as a
+     * bare `Uint32Array` parameter would force a caller to do — silently exported
+     * the whole model when a filter matched nothing (#4659, the JSON-LD twin of
+     * #4483/#4484). A non-empty `Uint32Array` is the ordinary allowlist.
      */
-    exportKmz(glb: Uint8Array, latitude: number, longitude: number, altitude: number, x_axis_abscissa: number | null | undefined, x_axis_ordinate: number | null | undefined, name: string, altitude_mode?: string | null): Uint8Array;
+    exportJsonld(content: Uint8Array, context: string, include_properties: boolean, include_quantities: boolean, pretty: boolean, included?: Uint32Array | null): Uint8Array;
     /**
      * Build a Google-Earth-ready **KMZ** (`Uint8Array`) straight from the viewer's
      * already-produced meshes — the working path (#1427). The model is embedded as
@@ -482,6 +479,15 @@ export class IfcAPI {
      * `altitude_mode` (`"clampToGround"` default ⇒ rest on terrain, ignoring
      * `altitude`; `"absolute"` ⇒ place at `altitude` metres MSL) selects the
      * KML vertical placement (#1427).
+     *
+     * Fails CLOSED: when no triangle survives (an empty visible set, or meshes
+     * whose only triangles are degenerate and collapse in the vertex dedup)
+     * this throws an `Error` whose message starts with `NO_RENDER_GEOMETRY`;
+     * a declared vertex/index count running past its buffer, an index block
+     * that is not whole triangles, or an index outside its mesh throws
+     * `MALFORMED_MESH_INPUT`, exactly as `exportGlbFromMeshes` does. These used
+     * to ship as a "successful" archive: an empty one around a COLLADA
+     * document the 1.4.1 schema rejects, or one with meshes or faces missing.
      */
     exportKmzFromMeshes(positions: Float32Array, normals: Float32Array, indices: Uint32Array, vertex_counts: Uint32Array, index_counts: Uint32Array, colors: Float32Array, origins: Float64Array, latitude: number, longitude: number, altitude: number, x_axis_abscissa: number | null | undefined, x_axis_ordinate: number | null | undefined, name: string, altitude_mode?: string | null): Uint8Array;
     /**
@@ -521,15 +527,23 @@ export class IfcAPI {
      * 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.
+     *
+     * `included` is an express-id allowlist carrying the same null-vs-empty
+     * distinction as `exportObj` / `exportGlb`: omit it (`undefined`) for "no
+     * isolation filter" (whole model); pass an empty `Uint32Array` for "isolation
+     * is ACTIVE and currently matches nothing", which writes a header-only file
+     * with an empty `DATA;` section. Collapsing the two — as a bare `Uint32Array`
+     * parameter would force a caller to do — silently exported the whole model
+     * when a filter matched nothing (#4659, the STEP twin of #4483/#4484). 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.
      * A non-empty but malformed `mutations_json` throws rather than silently
      * exporting the model with none of the caller's edits applied — mirrors
      * `exportGlb`'s and `exportMerged`'s fail-closed contract on this same API.
      */
-    exportStep(content: Uint8Array, schema: string, included: Uint32Array, mutations_json: string): Uint8Array;
+    exportStep(content: Uint8Array, schema: string, included: Uint32Array | null | undefined, mutations_json: string): Uint8Array;
     /**
      * Export **OpenUSD** (`.usda` ASCII): a real Z-up USD stage — spatial hierarchy of
      * `Xform` prims, `UsdGeomMesh` geometry, `UsdPreviewSurface` materials, IFC
@@ -565,7 +579,9 @@ export class IfcAPI {
      * CANONICAL styles flatten. Returns the exact `styles` event payload the
      * serial path emits. Runs on any worker with `setEntityIndex` installed.
      * Span arguments are `[id, start, len]` triples; `plane_angle_to_radians`
-     * comes from the meta event.
+     * comes from the meta event. `orphanColors` / `geomColors` carry exactly
+     * four floats per id in `orphanIds` / `geomIds`; any other length throws
+     * before either column is read.
      */
     finalizePrepassStyles(data: Uint8Array, orphan_ids: Uint32Array, orphan_colors: Float32Array, geom_ids: Uint32Array, geom_colors: Float32Array, colour_map_spans: Uint32Array, material_def_spans: Uint32Array, rel_material_spans: Uint32Array, void_spans: Uint32Array, fills_spans: Uint32Array, aggregate_spans: Uint32Array, plane_angle_to_radians: number): any;
     /**
@@ -667,13 +683,23 @@ export class IfcAPI {
      */
     planPageAppearance(content: Uint8Array, request_json: string, rgba: Uint8Array): Uint8Array;
     /**
-     * Plan a complete opaque polygonal PDF fill page as canonical IfcAnnotation
-     * geometry. Painted strokes, curves and unsupported states refuse atomically.
+     * Plan an opaque polygonal PDF fill page as canonical IfcAnnotation
+     * geometry with a provenance property set. An exact page plans directly; a
+     * page with visible omissions needs the accepted fidelity report digest.
      */
     planPdfFillAnnotation(source: Uint8Array, request_json: string): Uint8Array;
     /**
-     * Prepare bounded ordered PDF vector graphics states. No IFC entities or
-     * flattened geometry are produced; unsupported content prevents qualification.
+     * Registered RGB point-cloud observations (#4381). `request_json.source`
+     * is `{kind:'points', …}`; `positions` (3n f64, source-frame metres) and
+     * `colors` (3n RGB8) are the payload, `normals` (3n f32, oriented) and
+     * `stations` (n indices into `source.viewpoints`) are empty when absent.
+     * `rgba` carries only the target's existing rasters. Same output as
+     * `planMeshTransfer`; `transfer.source` records the orientation used.
+     */
+    planPointTransfer(content: Uint8Array, request_json: string, rgba: Uint8Array, positions: Float64Array, colors: Uint8Array, normals: Float32Array, stations: Uint32Array): Uint8Array;
+    /**
+     * Prepare bounded ordered PDF vector graphics states and the page fidelity
+     * report (convertible paths, omissions with extent, exact/raster-only).
      */
     preparePdfVectorPage(request_json: string): Uint8Array;
     /**
@@ -843,6 +869,12 @@ export class IfcAPI {
      * Idempotent in the sense that repeated calls REPLACE the cache —
      * supports the parser-worker pattern of reusing one IfcAPI across
      * multiple loads with different files.
+     *
+     * Throws when the three columns disagree in length. Every call is a
+     * content swap, a rejected one included: the previous file's index,
+     * content-scoped caches and pipeline diagnostics are dropped before the
+     * error is raised, and a rejected or empty index leaves no index, so the
+     * next batch scans the bytes it is given.
      */
     setEntityIndex(ids: Uint32Array, starts: Uint32Array, lengths: Uint32Array): void;
     /**
@@ -1009,7 +1041,9 @@ export class MeshCollection {
      */
     get(index: number): MeshDataJs | undefined;
     /**
-     * Check if RTC offset is significant (>10km)
+     * Check if an RTC offset was applied to these meshes (any non-zero
+     * component). It can be inside 10 km: the placement-bounds fallback
+     * re-bases on the bbox centre when a corner is past 10 km (#4643).
      */
     hasRtcOffset(): boolean;
     /**
@@ -1921,7 +1955,12 @@ export function intersection2d(a: Contours2D, b: Contours2D): Contours2D;
  *
  * `positions` is flat XYZ; `indices` is flat triangle indices. `axis` is
  * 0/1/2 = x/y/z (the cut axis, WebGL Y-up). Returns `undefined` when the mesh
- * has no triangles or projects to nothing.
+ * has no triangles or projects to nothing: the element has no footprint.
+ *
+ * THROWS when the outline was not computed: an `axis` outside 0..=2, or a
+ * mesh with more valid projected triangles than the overlay budget (50 000).
+ * The viewer's outline provider catches the throw and draws its TypeScript
+ * silhouette for that mesh.
  *
  * ```javascript
  * const outline = meshOutline2d(positions, indices, 1, false); // axis 1 = y
@@ -1972,10 +2011,17 @@ export function resolve2d(a: Contours2D): Contours2D;
  * meaningless volumes with a plausible `sumErrorRel`, so the closure proof
  * above is the caller's responsibility and not a formality.
  *
+ * Returns `undefined` when the mesh encloses no volume (no triangles survive
+ * the filter above, or the shell is degenerate): there is nothing to split,
+ * and a result for it would report `pieceCount` 1, `sumErrorRel` 0 and
+ * `remainderFailed` false, a perfect split of nothing. A caller that gates
+ * on those numbers must treat `undefined` as "no split", not as "no error".
+ *
  * ```javascript
  * const split = splitMeshByZones(positions, indices, new Float64Array([
  *   0, 0, 0, 10, 10, 10, 0,
  * ]));
+ * if (!split) return; // the mesh encloses no volume
  * for (let i = 0; i < split.pieceCount; i++) {
  *   const piece = split.piece(i);
  *   // piece.zoneIndex, piece.positions, piece.indices, piece.volume
@@ -1984,7 +2030,7 @@ export function resolve2d(a: Contours2D): Contours2D;
  * split.free();
  * ```
  */
-export function splitMeshByZones(positions: Float64Array, indices: Uint32Array, zones: Float64Array, footprints?: Float64Array | null, footprint_counts?: Uint32Array | null): ZoneSplitJs;
+export function splitMeshByZones(positions: Float64Array, indices: Uint32Array, zones: Float64Array, footprints?: Float64Array | null, footprint_counts?: Uint32Array | null): ZoneSplitJs | undefined;
 
 /**
  * `a ∪ b`.
@@ -2088,7 +2134,6 @@ export interface InitOutput {
     readonly ifcapi_exportIfcx: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_exportJson: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly ifcapi_exportJsonld: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
-    readonly ifcapi_exportKmz: (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) => void;
     readonly ifcapi_exportKmzFromMeshes: (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, z: number, a1: number) => void;
     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;
@@ -2111,6 +2156,7 @@ export interface InitOutput {
     readonly ifcapi_planMeshTransfer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly ifcapi_planPageAppearance: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly ifcapi_planPdfFillAnnotation: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly ifcapi_planPointTransfer: (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) => void;
     readonly ifcapi_preparePdfVectorPage: (a: number, b: number, c: number, d: number) => void;
     readonly ifcapi_processGeometryBatch: (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, z: number, a1: number, b1: number) => number;
     readonly ifcapi_processGeometryBatchFromSource: (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, z: number) => number;
@@ -2126,7 +2172,7 @@ export interface InitOutput {
     readonly ifcapi_scanEntityIndexShardFromSource: (a: number, b: number, c: number) => number;
     readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
     readonly ifcapi_setComputeGeometryHashes: (a: number, b: number, c: number) => void;
-    readonly ifcapi_setEntityIndex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly ifcapi_setEntityIndex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly ifcapi_setInstantiatedTypeIds: (a: number, b: number, c: number) => void;
     readonly ifcapi_setMappedInstancePlan: (a: number, b: number, c: number) => void;
     readonly ifcapi_setMaterialLayerIndex: (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) => void;
@@ -2139,7 +2185,7 @@ export interface InitOutput {
     readonly ifcapi_simplifyMeshes: (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, z: number, a1: number) => void;
     readonly ifcapi_version: (a: number, b: number) => void;
     readonly intersection2d: (a: number, b: number) => number;
-    readonly meshOutline2d: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
+    readonly meshOutline2d: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly meshcollection_buildingRotation: (a: number, b: number) => void;
     readonly meshcollection_diagnostics: (a: number) => number;
     readonly meshcollection_geometryAabbValues: (a: number) => number;

package/pkg/ifc-lite.js

@@ -1058,11 +1058,15 @@ export class IfcAPI {
      * 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.)
+     * `positions` / `indices`, there are fewer `index_counts` than meshes, `normals`
+     * is empty or too short to cover every vertex, a mesh's index block is not a
+     * whole number of triangles, or an index names a vertex its own mesh does not
+     * have (glTF 2.0 3.7.2.1), this throws an `Error` whose message starts with
+     * `MALFORMED_MESH_INPUT` — instead of silently emitting a GLB with those meshes
+     * dropped, a TRIANGLES primitive whose count is not a multiple of 3, or the
+     * out-of-range index copied into the BIN chunk. (The viewer always passes
+     * fully-backed, normal-covered, whole-triangle, in-range arrays, so this only
+     * fires on a caller bug.)
      * @param {Float32Array} positions
      * @param {Float32Array} normals
      * @param {Uint32Array} indices
@@ -1222,14 +1226,22 @@ export class IfcAPI {
     }
     /**
      * Export **JSON-LD** (`@graph` of `ifc:` nodes). Empty `context` ⇒ buildingSMART
-     * IFC4 OWL default. `included` is an express-id isolation filter mirroring the
-     * OBJ/glTF/STEP exporters (empty ⇒ all entities).
+     * IFC4 OWL default.
+     *
+     * `included` is an express-id isolation filter mirroring `exportObj` /
+     * `exportGlb`, and carries the same null-vs-empty distinction across the wasm
+     * boundary: omit it (`undefined`) for "no isolation filter" (every entity is
+     * emitted); pass an empty `Uint32Array` for "isolation is ACTIVE and currently
+     * matches nothing", which emits an empty `@graph`. Collapsing the two — as a
+     * bare `Uint32Array` parameter would force a caller to do — silently exported
+     * the whole model when a filter matched nothing (#4659, the JSON-LD twin of
+     * #4483/#4484). A non-empty `Uint32Array` is the ordinary allowlist.
      * @param {Uint8Array} content
      * @param {string} context
      * @param {boolean} include_properties
      * @param {boolean} include_quantities
      * @param {boolean} pretty
-     * @param {Uint32Array} included
+     * @param {Uint32Array | null} [included]
      * @returns {Uint8Array}
      */
     exportJsonld(content, context, include_properties, include_quantities, pretty, included) {
@@ -1239,51 +1251,9 @@ export class IfcAPI {
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(context, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArray32ToWasm0(included, wasm.__wbindgen_export);
-            const len2 = WASM_VECTOR_LEN;
-            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);
-            var v4 = getArrayU8FromWasm0(r0, r1).slice();
-            wasm.__wbindgen_export4(r0, r1 * 1, 1);
-            return v4;
-        } finally {
-            wasm.__wbindgen_add_to_stack_pointer(16);
-        }
-    }
-    /**
-     * Package an already-produced **GLB** + georeference into a **KMZ** (`Uint8Array`)
-     * for Google Earth: a ZIP of `doc.kml` (a `<Model>` placed at `latitude`/`longitude`/
-     * `altitude`) + `model.glb`. `x_axis_abscissa`/`x_axis_ordinate` are the
-     * `IfcMapConversion` grid-north components; pass both as `undefined` for heading 0.
-     *
-     * `altitude_mode` selects the KML vertical placement: `"clampToGround"`
-     * (the default when omitted) rests the model on the terrain, ignoring
-     * `altitude`; `"absolute"` places the origin at `altitude` metres MSL.
-     * Google Earth's terrain already encodes the site elevation, so clamping
-     * keeps a wrong/zero/double-counted OrthogonalHeight from floating the
-     * model into the sky (#1427); absolute is offered for models whose
-     * OrthogonalHeight is a true MSL elevation the user wants honoured.
-     * @param {Uint8Array} glb
-     * @param {number} latitude
-     * @param {number} longitude
-     * @param {number} altitude
-     * @param {number | null | undefined} x_axis_abscissa
-     * @param {number | null | undefined} x_axis_ordinate
-     * @param {string} name
-     * @param {string | null} [altitude_mode]
-     * @returns {Uint8Array}
-     */
-    exportKmz(glb, latitude, longitude, altitude, x_axis_abscissa, x_axis_ordinate, name, altitude_mode) {
-        try {
-            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-            const ptr0 = passArray8ToWasm0(glb, wasm.__wbindgen_export);
-            const len0 = WASM_VECTOR_LEN;
-            const ptr1 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
-            const len1 = WASM_VECTOR_LEN;
-            var ptr2 = isLikeNone(altitude_mode) ? 0 : passStringToWasm0(altitude_mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var ptr2 = isLikeNone(included) ? 0 : passArray32ToWasm0(included, wasm.__wbindgen_export);
             var len2 = WASM_VECTOR_LEN;
-            wasm.ifcapi_exportKmz(retptr, this.__wbg_ptr, ptr0, len0, latitude, longitude, altitude, !isLikeNone(x_axis_abscissa), isLikeNone(x_axis_abscissa) ? 0 : x_axis_abscissa, !isLikeNone(x_axis_ordinate), isLikeNone(x_axis_ordinate) ? 0 : x_axis_ordinate, ptr1, len1, ptr2, len2);
+            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);
             var v4 = getArrayU8FromWasm0(r0, r1).slice();
@@ -1304,6 +1274,15 @@ export class IfcAPI {
      * `altitude_mode` (`"clampToGround"` default ⇒ rest on terrain, ignoring
      * `altitude`; `"absolute"` ⇒ place at `altitude` metres MSL) selects the
      * KML vertical placement (#1427).
+     *
+     * Fails CLOSED: when no triangle survives (an empty visible set, or meshes
+     * whose only triangles are degenerate and collapse in the vertex dedup)
+     * this throws an `Error` whose message starts with `NO_RENDER_GEOMETRY`;
+     * a declared vertex/index count running past its buffer, an index block
+     * that is not whole triangles, or an index outside its mesh throws
+     * `MALFORMED_MESH_INPUT`, exactly as `exportGlbFromMeshes` does. These used
+     * to ship as a "successful" archive: an empty one around a COLLADA
+     * document the 1.4.1 schema rejects, or one with meshes or faces missing.
      * @param {Float32Array} positions
      * @param {Float32Array} normals
      * @param {Uint32Array} indices
@@ -1344,6 +1323,11 @@ export class IfcAPI {
             wasm.ifcapi_exportKmzFromMeshes(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, latitude, longitude, altitude, !isLikeNone(x_axis_abscissa), isLikeNone(x_axis_abscissa) ? 0 : x_axis_abscissa, !isLikeNone(x_axis_ordinate), isLikeNone(x_axis_ordinate) ? 0 : x_axis_ordinate, ptr7, len7, ptr8, len8);
             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 v10 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_export4(r0, r1 * 1, 1);
             return v10;
@@ -1433,8 +1417,16 @@ export class IfcAPI {
      * 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.
+     *
+     * `included` is an express-id allowlist carrying the same null-vs-empty
+     * distinction as `exportObj` / `exportGlb`: omit it (`undefined`) for "no
+     * isolation filter" (whole model); pass an empty `Uint32Array` for "isolation
+     * is ACTIVE and currently matches nothing", which writes a header-only file
+     * with an empty `DATA;` section. Collapsing the two — as a bare `Uint32Array`
+     * parameter would force a caller to do — silently exported the whole model
+     * when a filter matched nothing (#4659, the STEP twin of #4483/#4484). 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.
      * A non-empty but malformed `mutations_json` throws rather than silently
@@ -1442,7 +1434,7 @@ export class IfcAPI {
      * `exportGlb`'s and `exportMerged`'s fail-closed contract on this same API.
      * @param {Uint8Array} content
      * @param {string} schema
-     * @param {Uint32Array} included
+     * @param {Uint32Array | null | undefined} included
      * @param {string} mutations_json
      * @returns {Uint8Array}
      */
@@ -1453,8 +1445,8 @@ export class IfcAPI {
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passStringToWasm0(schema, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArray32ToWasm0(included, wasm.__wbindgen_export);
-            const len2 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(included) ? 0 : passArray32ToWasm0(included, wasm.__wbindgen_export);
+            var len2 = WASM_VECTOR_LEN;
             const ptr3 = passStringToWasm0(mutations_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len3 = WASM_VECTOR_LEN;
             wasm.ifcapi_exportStep(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
@@ -1526,7 +1518,9 @@ export class IfcAPI {
      * CANONICAL styles flatten. Returns the exact `styles` event payload the
      * serial path emits. Runs on any worker with `setEntityIndex` installed.
      * Span arguments are `[id, start, len]` triples; `plane_angle_to_radians`
-     * comes from the meta event.
+     * comes from the meta event. `orphanColors` / `geomColors` carry exactly
+     * four floats per id in `orphanIds` / `geomIds`; any other length throws
+     * before either column is read.
      * @param {Uint8Array} data
      * @param {Uint32Array} orphan_ids
      * @param {Float32Array} orphan_colors
@@ -1898,8 +1892,9 @@ export class IfcAPI {
         }
     }
     /**
-     * Plan a complete opaque polygonal PDF fill page as canonical IfcAnnotation
-     * geometry. Painted strokes, curves and unsupported states refuse atomically.
+     * Plan an opaque polygonal PDF fill page as canonical IfcAnnotation
+     * geometry with a provenance property set. An exact page plans directly; a
+     * page with visible omissions needs the accepted fidelity report digest.
      * @param {Uint8Array} source
      * @param {string} request_json
      * @returns {Uint8Array}
@@ -1927,8 +1922,56 @@ export class IfcAPI {
         }
     }
     /**
-     * Prepare bounded ordered PDF vector graphics states. No IFC entities or
-     * flattened geometry are produced; unsupported content prevents qualification.
+     * Registered RGB point-cloud observations (#4381). `request_json.source`
+     * is `{kind:'points', …}`; `positions` (3n f64, source-frame metres) and
+     * `colors` (3n RGB8) are the payload, `normals` (3n f32, oriented) and
+     * `stations` (n indices into `source.viewpoints`) are empty when absent.
+     * `rgba` carries only the target's existing rasters. Same output as
+     * `planMeshTransfer`; `transfer.source` records the orientation used.
+     * @param {Uint8Array} content
+     * @param {string} request_json
+     * @param {Uint8Array} rgba
+     * @param {Float64Array} positions
+     * @param {Uint8Array} colors
+     * @param {Float32Array} normals
+     * @param {Uint32Array} stations
+     * @returns {Uint8Array}
+     */
+    planPointTransfer(content, request_json, rgba, positions, colors, normals, stations) {
+        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(request_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray8ToWasm0(rgba, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArrayF64ToWasm0(positions, wasm.__wbindgen_export);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArray8ToWasm0(colors, wasm.__wbindgen_export);
+            const len4 = WASM_VECTOR_LEN;
+            const ptr5 = passArrayF32ToWasm0(normals, wasm.__wbindgen_export);
+            const len5 = WASM_VECTOR_LEN;
+            const ptr6 = passArray32ToWasm0(stations, wasm.__wbindgen_export);
+            const len6 = WASM_VECTOR_LEN;
+            wasm.ifcapi_planPointTransfer(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
+            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 v8 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v8;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Prepare bounded ordered PDF vector graphics states and the page fidelity
+     * report (convertible paths, omissions with extent, exact/raster-only).
      * @param {string} request_json
      * @returns {Uint8Array}
      */
@@ -2421,18 +2464,34 @@ export class IfcAPI {
      * Idempotent in the sense that repeated calls REPLACE the cache —
      * supports the parser-worker pattern of reusing one IfcAPI across
      * multiple loads with different files.
+     *
+     * Throws when the three columns disagree in length. Every call is a
+     * content swap, a rejected one included: the previous file's index,
+     * content-scoped caches and pipeline diagnostics are dropped before the
+     * error is raised, and a rejected or empty index leaves no index, so the
+     * next batch scans the bytes it is given.
      * @param {Uint32Array} ids
      * @param {Uint32Array} starts
      * @param {Uint32Array} lengths
      */
     setEntityIndex(ids, starts, lengths) {
-        const ptr0 = passArray32ToWasm0(ids, wasm.__wbindgen_export);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passArray32ToWasm0(starts, wasm.__wbindgen_export);
-        const len1 = WASM_VECTOR_LEN;
-        const ptr2 = passArray32ToWasm0(lengths, wasm.__wbindgen_export);
-        const len2 = WASM_VECTOR_LEN;
-        wasm.ifcapi_setEntityIndex(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray32ToWasm0(ids, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray32ToWasm0(starts, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(lengths, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.ifcapi_setEntityIndex(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);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * Install the pre-computed set of type ids that an `IfcRelDefinesByType`
@@ -2877,7 +2936,9 @@ export class MeshCollection {
         return ret === 0 ? undefined : MeshDataJs.__wrap(ret);
     }
     /**
-     * Check if RTC offset is significant (>10km)
+     * Check if an RTC offset was applied to these meshes (any non-zero
+     * component). It can be inside 10 km: the placement-bounds fallback
+     * re-bases on the bbox centre when a corner is past 10 km (#4643).
      * @returns {boolean}
      */
     hasRtcOffset() {
@@ -5271,7 +5332,12 @@ export function intersection2d(a, b) {
  *
  * `positions` is flat XYZ; `indices` is flat triangle indices. `axis` is
  * 0/1/2 = x/y/z (the cut axis, WebGL Y-up). Returns `undefined` when the mesh
- * has no triangles or projects to nothing.
+ * has no triangles or projects to nothing: the element has no footprint.
+ *
+ * THROWS when the outline was not computed: an `axis` outside 0..=2, or a
+ * mesh with more valid projected triangles than the overlay budget (50 000).
+ * The viewer's outline provider catches the throw and draws its TypeScript
+ * silhouette for that mesh.
  *
  * ```javascript
  * const outline = meshOutline2d(positions, indices, 1, false); // axis 1 = y
@@ -5289,12 +5355,23 @@ export function intersection2d(a, b) {
  * @returns {MeshOutlineJs | undefined}
  */
 export function meshOutline2d(positions, indices, axis, flipped) {
-    const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_export);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArray32ToWasm0(indices, wasm.__wbindgen_export);
-    const len1 = WASM_VECTOR_LEN;
-    const ret = wasm.meshOutline2d(ptr0, len0, ptr1, len1, axis, flipped);
-    return ret === 0 ? undefined : MeshOutlineJs.__wrap(ret);
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passArrayF32ToWasm0(positions, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(indices, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.meshOutline2d(retptr, ptr0, len0, ptr1, len1, axis, flipped);
+        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 r0 === 0 ? undefined : MeshOutlineJs.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
 }
 
 /**
@@ -5340,10 +5417,17 @@ export function resolve2d(a) {
  * meaningless volumes with a plausible `sumErrorRel`, so the closure proof
  * above is the caller's responsibility and not a formality.
  *
+ * Returns `undefined` when the mesh encloses no volume (no triangles survive
+ * the filter above, or the shell is degenerate): there is nothing to split,
+ * and a result for it would report `pieceCount` 1, `sumErrorRel` 0 and
+ * `remainderFailed` false, a perfect split of nothing. A caller that gates
+ * on those numbers must treat `undefined` as "no split", not as "no error".
+ *
  * ```javascript
  * const split = splitMeshByZones(positions, indices, new Float64Array([
  *   0, 0, 0, 10, 10, 10, 0,
  * ]));
+ * if (!split) return; // the mesh encloses no volume
  * for (let i = 0; i < split.pieceCount; i++) {
  *   const piece = split.piece(i);
  *   // piece.zoneIndex, piece.positions, piece.indices, piece.volume
@@ -5356,7 +5440,7 @@ export function resolve2d(a) {
  * @param {Float64Array} zones
  * @param {Float64Array | null} [footprints]
  * @param {Uint32Array | null} [footprint_counts]
- * @returns {ZoneSplitJs}
+ * @returns {ZoneSplitJs | undefined}
  */
 export function splitMeshByZones(positions, indices, zones, footprints, footprint_counts) {
     const ptr0 = passArrayF64ToWasm0(positions, wasm.__wbindgen_export);
@@ -5370,7 +5454,7 @@ export function splitMeshByZones(positions, indices, zones, footprints, footprin
     var ptr4 = isLikeNone(footprint_counts) ? 0 : passArray32ToWasm0(footprint_counts, wasm.__wbindgen_export);
     var len4 = WASM_VECTOR_LEN;
     const ret = wasm.splitMeshByZones(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
-    return ZoneSplitJs.__wrap(ret);
+    return ret === 0 ? undefined : ZoneSplitJs.__wrap(ret);
 }
 
 /**