@ifc-lite/wasm 6.5.0 → 8.0.1

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": "6.5.0",
+  "version": "8.0.1",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",

package/pkg/ifc-lite.d.ts

@@ -365,8 +365,17 @@ export class IfcAPI {
      *
      * `hidden` / `isolated` are express-id visibility filters; `hidden_types_csv` is a
      * comma-separated list of IFC type names whose class toggle is off (e.g.
-     * `"IfcOpeningElement,IfcSpace"`). `include_metadata` attaches counts + per-node
-     * `expressId`. Per-mesh RTC origin rides the node translation (precision-safe).
+     * `"IfcOpeningElement,IfcSpace"`). `isolated` carries the isolation allowlist's
+     * null-vs-empty distinction across the wasm boundary: omit it (`undefined`) for
+     * "no isolation filter" (every mesh is a candidate); pass an empty `Uint32Array`
+     * for "isolation is ACTIVE and currently matches nothing" (every mesh is
+     * excluded). Collapsing the two — as a bare `Uint32Array` parameter would force a
+     * caller to do — silently exports the whole model when a filter matches nothing
+     * (#4328 follow-up: reachable by filtering the Class tab to a type present only
+     * in a federated model's secondary member, then exporting "Visible Only"). A
+     * non-empty `Uint32Array` is the ordinary allowlist. `include_metadata` attaches
+     * counts + per-node `expressId`. Per-mesh RTC origin rides the node translation
+     * (precision-safe).
      * `lit` emits standard PBR materials that shade from normals; omitted or
      * `true` ⇒ lit (the default), `false` ⇒ flat `KHR_materials_unlit` (the
      * historical look — #1321). Optional at the boundary so older 5-arg callers
@@ -381,7 +390,7 @@ export class IfcAPI {
      * 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: Uint8Array, include_metadata: boolean, hidden: Uint32Array, isolated: Uint32Array, hidden_types_csv: string, lit?: boolean | null, emissive?: boolean | null): Uint8Array;
+    exportGlb(content: Uint8Array, include_metadata: boolean, hidden: Uint32Array, isolated: Uint32Array | null | undefined, hidden_types_csv: string, lit?: boolean | null, emissive?: boolean | null): Uint8Array;
     /**
      * Assemble a **GLB** from already-produced meshes (the viewer's `MeshData`, flattened)
      * — no re-meshing. Per mesh `i`: `vertex_counts[i]` verts + `index_counts[i]` indices
@@ -390,11 +399,13 @@ 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, 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, or one carrying the out-of-range index straight into the
+     * BIN chunk. (The viewer always passes fully-backed, normal-covered, 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;
     /**
@@ -473,6 +484,14 @@ 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 throws
+     * `MALFORMED_MESH_INPUT`, as `exportGlbFromMeshes` does. Both used to ship
+     * as a small "successful" archive: the first around a COLLADA document
+     * the 1.4.1 schema rejects, the second with every later mesh 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;
     /**
@@ -489,14 +508,21 @@ export class IfcAPI {
      * 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.
+     * `hidden` is an express-id filter mirroring the viewer's visibility state.
+     * `isolated` carries the isolation allowlist's null-vs-empty distinction across
+     * the wasm boundary: omit it (`undefined`) for "no isolation filter" (every mesh
+     * is a candidate); pass an empty `Uint32Array` for "isolation is ACTIVE and
+     * currently matches nothing" (every mesh is excluded). Collapsing the two — as a
+     * bare `Uint32Array` parameter would force a caller to do — silently exports the
+     * whole model when a filter matches nothing (the OBJ twin of #4328/#4364, fixed
+     * for GLB in `export_glb`). A non-empty `Uint32Array` is the ordinary allowlist.
+     * Instanced type-library shapes are skipped regardless of the filter.
      *
      * ```javascript
-     * const obj = api.exportObj(ifcContent, true, new Uint32Array(), new Uint32Array());
+     * const obj = api.exportObj(ifcContent, true, new Uint32Array(), undefined);
      * ```
      */
-    exportObj(content: Uint8Array, include_normals: boolean, hidden: Uint32Array, isolated: Uint32Array): Uint8Array;
+    exportObj(content: Uint8Array, include_normals: boolean, hidden: Uint32Array, isolated?: Uint32Array | null): Uint8Array;
     /**
      * Re-serialize the model in `content` to STEP/IFC UTF-8 bytes.
      *
@@ -651,13 +677,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;
     /**
@@ -2095,6 +2131,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;

package/pkg/ifc-lite.js

@@ -991,8 +991,17 @@ export class IfcAPI {
      *
      * `hidden` / `isolated` are express-id visibility filters; `hidden_types_csv` is a
      * comma-separated list of IFC type names whose class toggle is off (e.g.
-     * `"IfcOpeningElement,IfcSpace"`). `include_metadata` attaches counts + per-node
-     * `expressId`. Per-mesh RTC origin rides the node translation (precision-safe).
+     * `"IfcOpeningElement,IfcSpace"`). `isolated` carries the isolation allowlist's
+     * null-vs-empty distinction across the wasm boundary: omit it (`undefined`) for
+     * "no isolation filter" (every mesh is a candidate); pass an empty `Uint32Array`
+     * for "isolation is ACTIVE and currently matches nothing" (every mesh is
+     * excluded). Collapsing the two — as a bare `Uint32Array` parameter would force a
+     * caller to do — silently exports the whole model when a filter matches nothing
+     * (#4328 follow-up: reachable by filtering the Class tab to a type present only
+     * in a federated model's secondary member, then exporting "Visible Only"). A
+     * non-empty `Uint32Array` is the ordinary allowlist. `include_metadata` attaches
+     * counts + per-node `expressId`. Per-mesh RTC origin rides the node translation
+     * (precision-safe).
      * `lit` emits standard PBR materials that shade from normals; omitted or
      * `true` ⇒ lit (the default), `false` ⇒ flat `KHR_materials_unlit` (the
      * historical look — #1321). Optional at the boundary so older 5-arg callers
@@ -1009,7 +1018,7 @@ export class IfcAPI {
      * @param {Uint8Array} content
      * @param {boolean} include_metadata
      * @param {Uint32Array} hidden
-     * @param {Uint32Array} isolated
+     * @param {Uint32Array | null | undefined} isolated
      * @param {string} hidden_types_csv
      * @param {boolean | null} [lit]
      * @param {boolean | null} [emissive]
@@ -1022,8 +1031,8 @@ export class IfcAPI {
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArray32ToWasm0(hidden, wasm.__wbindgen_export);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArray32ToWasm0(isolated, wasm.__wbindgen_export);
-            const len2 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(isolated) ? 0 : passArray32ToWasm0(isolated, wasm.__wbindgen_export);
+            var len2 = WASM_VECTOR_LEN;
             const ptr3 = passStringToWasm0(hidden_types_csv, wasm.__wbindgen_export, wasm.__wbindgen_export2);
             const len3 = WASM_VECTOR_LEN;
             wasm.ifcapi_exportGlb(retptr, this.__wbg_ptr, ptr0, len0, include_metadata, ptr1, len1, ptr2, len2, ptr3, len3, isLikeNone(lit) ? 0xFFFFFF : lit ? 1 : 0, isLikeNone(emissive) ? 0xFFFFFF : emissive ? 1 : 0);
@@ -1049,11 +1058,13 @@ 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, 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, or one carrying the out-of-range index straight into the
+     * BIN chunk. (The viewer always passes fully-backed, normal-covered, in-range
+     * arrays, so this only fires on a caller bug.)
      * @param {Float32Array} positions
      * @param {Float32Array} normals
      * @param {Uint32Array} indices
@@ -1295,6 +1306,14 @@ 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 throws
+     * `MALFORMED_MESH_INPUT`, as `exportGlbFromMeshes` does. Both used to ship
+     * as a small "successful" archive: the first around a COLLADA document
+     * the 1.4.1 schema rejects, the second with every later mesh missing.
      * @param {Float32Array} positions
      * @param {Float32Array} normals
      * @param {Uint32Array} indices
@@ -1335,6 +1354,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;
@@ -1378,16 +1402,23 @@ export class IfcAPI {
      * 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.
+     * `hidden` is an express-id filter mirroring the viewer's visibility state.
+     * `isolated` carries the isolation allowlist's null-vs-empty distinction across
+     * the wasm boundary: omit it (`undefined`) for "no isolation filter" (every mesh
+     * is a candidate); pass an empty `Uint32Array` for "isolation is ACTIVE and
+     * currently matches nothing" (every mesh is excluded). Collapsing the two — as a
+     * bare `Uint32Array` parameter would force a caller to do — silently exports the
+     * whole model when a filter matches nothing (the OBJ twin of #4328/#4364, fixed
+     * for GLB in `export_glb`). A non-empty `Uint32Array` is the ordinary allowlist.
+     * Instanced type-library shapes are skipped regardless of the filter.
      *
      * ```javascript
-     * const obj = api.exportObj(ifcContent, true, new Uint32Array(), new Uint32Array());
+     * const obj = api.exportObj(ifcContent, true, new Uint32Array(), undefined);
      * ```
      * @param {Uint8Array} content
      * @param {boolean} include_normals
      * @param {Uint32Array} hidden
-     * @param {Uint32Array} isolated
+     * @param {Uint32Array | null} [isolated]
      * @returns {Uint8Array}
      */
     exportObj(content, include_normals, hidden, isolated) {
@@ -1397,8 +1428,8 @@ export class IfcAPI {
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArray32ToWasm0(hidden, wasm.__wbindgen_export);
             const len1 = WASM_VECTOR_LEN;
-            const ptr2 = passArray32ToWasm0(isolated, wasm.__wbindgen_export);
-            const len2 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(isolated) ? 0 : passArray32ToWasm0(isolated, wasm.__wbindgen_export);
+            var len2 = WASM_VECTOR_LEN;
             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);
@@ -1882,8 +1913,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}
@@ -1911,8 +1943,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}
      */