@ifc-lite/wasm 3.0.15 → 4.0.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -155,6 +155,61 @@ export class IfcAPI {
    * ```
    */
   exportObj(content: Uint8Array, include_normals: boolean, hidden: Uint32Array, isolated: Uint32Array): Uint8Array;
+  /**
+   * Sharded pre-pass: merge the shard-resolved styled-item columns with the
+   * SUPPORT spans (extracted host-side from the shard classes) and run the
+   * 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.
+   */
+  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;
+  /**
+   * SPIKE (sharded pre-pass): scan the entity index over a single byte range.
+   *
+   * Each idle browser geometry worker calls this on its `[range_start,
+   * 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.
+   *
+   * 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
+   * `range_end` (the next shard's first real entity), or `-1` at EOF.
+   */
+  scanEntityIndexShard(data: Uint8Array, range_start: number, range_end: number): any;
+  /**
+   * Sharded pre-pass: resolve ONE contiguous (file-ordered) slice of the
+   * styled-item span list on this worker, against the entity index installed
+   * by `setEntityIndex`. Returns raw resolved maps as flat columns:
+   * `{ orphanIds, orphanColors (f32 rgba per id), geomIds, geomColors }`.
+   * The host merges shard results IN SHARD ORDER with first-wins per
+   * geometry id, reproducing the serial resolver's file-order precedence,
+   * then hands the merged columns to `finalizePrepassStyles`.
+   * `spans` is `[id, start, len]` triples.
+   */
+  resolveStyledItemsShard(data: Uint8Array, spans: Uint32Array): any;
+  /**
+   * Sharded pre-pass variant: same scan/discovery/jobs/columns pipeline as
+   * `buildPrePassStreaming`, but
+   *  1. the entity index is PREBUILT from the host's stitched shard columns
+   *     (file order; see `scanEntityIndexShard`) — the scan skips its inline
+   *     index build, the meta RTC ladder resolves against the FULL index
+   *     (no partial-ladder full-rescan detour), and the post-scan
+   *     `entity-index` event is skipped (the host already delivered it), and
+   *  2. styles resolution is EXTERNAL: the styled-item spans are resolved as
+   *     shard slices on the geometry workers (`resolveStyledItemsShard`);
+   *     this call stashes the SUPPORT spans + plane-angle scale, and the
+   *     follow-up `finalizePrepassStyles` merges + flattens into the exact
+   *     styles payload the serial path emits. NO `styles` event is emitted
+   *     here.
+   */
+  buildPrePassStreamingSharded(data: Uint8Array, on_event: Function, chunk_size: number, disabled_type_names: string[] | null | undefined, skip_type_geometry: boolean, index_ids: Uint32Array, index_starts: Uint32Array, index_lengths: Uint32Array, index_classes: Uint8Array): any;
   /**
    * Store the whole IFC source file ONCE per load so the `*FromSource` batch
    * variants can read it from the wasm heap instead of re-copying it per call.
@@ -1239,6 +1294,7 @@ export interface InitOutput {
   readonly gridaxisjs_tag: (a: number, b: number) => void;
   readonly ifcapi_buildPrePassOnce: (a: number, b: number, c: number) => number;
   readonly ifcapi_buildPrePassStreaming: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly ifcapi_buildPrePassStreamingSharded: (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) => void;
   readonly ifcapi_clearPrePassCache: (a: number) => void;
   readonly ifcapi_diagnoseGeometry: (a: number, b: number, c: number) => number;
   readonly ifcapi_exportCsv: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
@@ -1254,6 +1310,7 @@ export interface InitOutput {
   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_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;
   readonly ifcapi_getPipelineDiagnostics: (a: number) => number;
   readonly ifcapi_is_ready: (a: number) => number;
@@ -1267,8 +1324,10 @@ export interface InitOutput {
   readonly ifcapi_processGeometryBatchInstanced: (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, c1: number) => void;
   readonly ifcapi_processGeometryBatchPartitioned: (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_processGeometryBatchPartitionedFromSource: (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;
+  readonly ifcapi_resolveStyledItemsShard: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
   readonly ifcapi_scanEntitiesFast: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanEntitiesFastBytes: (a: number, b: number, c: number) => number;
+  readonly ifcapi_scanEntityIndexShard: (a: number, b: number, c: number, d: number, e: 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;

package/pkg/ifc-lite.js

@@ -869,6 +869,177 @@ export class IfcAPI {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sharded pre-pass: merge the shard-resolved styled-item columns with the
+     * SUPPORT spans (extracted host-side from the shard classes) and run the
+     * 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.
+     * @param {Uint8Array} data
+     * @param {Uint32Array} orphan_ids
+     * @param {Float32Array} orphan_colors
+     * @param {Uint32Array} geom_ids
+     * @param {Float32Array} geom_colors
+     * @param {Uint32Array} colour_map_spans
+     * @param {Uint32Array} material_def_spans
+     * @param {Uint32Array} rel_material_spans
+     * @param {Uint32Array} void_spans
+     * @param {Uint32Array} fills_spans
+     * @param {Uint32Array} aggregate_spans
+     * @param {number} plane_angle_to_radians
+     * @returns {any}
+     */
+    finalizePrepassStyles(data, orphan_ids, orphan_colors, geom_ids, geom_colors, colour_map_spans, material_def_spans, rel_material_spans, void_spans, fills_spans, aggregate_spans, plane_angle_to_radians) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray32ToWasm0(orphan_ids, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArrayF32ToWasm0(orphan_colors, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArray32ToWasm0(geom_ids, wasm.__wbindgen_export);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArrayF32ToWasm0(geom_colors, wasm.__wbindgen_export);
+            const len4 = WASM_VECTOR_LEN;
+            const ptr5 = passArray32ToWasm0(colour_map_spans, wasm.__wbindgen_export);
+            const len5 = WASM_VECTOR_LEN;
+            const ptr6 = passArray32ToWasm0(material_def_spans, wasm.__wbindgen_export);
+            const len6 = WASM_VECTOR_LEN;
+            const ptr7 = passArray32ToWasm0(rel_material_spans, wasm.__wbindgen_export);
+            const len7 = WASM_VECTOR_LEN;
+            const ptr8 = passArray32ToWasm0(void_spans, wasm.__wbindgen_export);
+            const len8 = WASM_VECTOR_LEN;
+            const ptr9 = passArray32ToWasm0(fills_spans, wasm.__wbindgen_export);
+            const len9 = WASM_VECTOR_LEN;
+            const ptr10 = passArray32ToWasm0(aggregate_spans, wasm.__wbindgen_export);
+            const len10 = WASM_VECTOR_LEN;
+            wasm.ifcapi_finalizePrepassStyles(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6, ptr7, len7, ptr8, len8, ptr9, len9, ptr10, len10, plane_angle_to_radians);
+            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 takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * SPIKE (sharded pre-pass): scan the entity index over a single byte range.
+     *
+     * Each idle browser geometry worker calls this on its `[range_start,
+     * 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.
+     *
+     * 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
+     * `range_end` (the next shard's first real entity), or `-1` at EOF.
+     * @param {Uint8Array} data
+     * @param {number} range_start
+     * @param {number} range_end
+     * @returns {any}
+     */
+    scanEntityIndexShard(data, range_start, range_end) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_scanEntityIndexShard(this.__wbg_ptr, ptr0, len0, range_start, range_end);
+        return takeObject(ret);
+    }
+    /**
+     * Sharded pre-pass: resolve ONE contiguous (file-ordered) slice of the
+     * styled-item span list on this worker, against the entity index installed
+     * by `setEntityIndex`. Returns raw resolved maps as flat columns:
+     * `{ orphanIds, orphanColors (f32 rgba per id), geomIds, geomColors }`.
+     * The host merges shard results IN SHARD ORDER with first-wins per
+     * geometry id, reproducing the serial resolver's file-order precedence,
+     * then hands the merged columns to `finalizePrepassStyles`.
+     * `spans` is `[id, start, len]` triples.
+     * @param {Uint8Array} data
+     * @param {Uint32Array} spans
+     * @returns {any}
+     */
+    resolveStyledItemsShard(data, spans) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passArray32ToWasm0(spans, wasm.__wbindgen_export);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.ifcapi_resolveStyledItemsShard(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            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 takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Sharded pre-pass variant: same scan/discovery/jobs/columns pipeline as
+     * `buildPrePassStreaming`, but
+     *  1. the entity index is PREBUILT from the host's stitched shard columns
+     *     (file order; see `scanEntityIndexShard`) — the scan skips its inline
+     *     index build, the meta RTC ladder resolves against the FULL index
+     *     (no partial-ladder full-rescan detour), and the post-scan
+     *     `entity-index` event is skipped (the host already delivered it), and
+     *  2. styles resolution is EXTERNAL: the styled-item spans are resolved as
+     *     shard slices on the geometry workers (`resolveStyledItemsShard`);
+     *     this call stashes the SUPPORT spans + plane-angle scale, and the
+     *     follow-up `finalizePrepassStyles` merges + flattens into the exact
+     *     styles payload the serial path emits. NO `styles` event is emitted
+     *     here.
+     * @param {Uint8Array} data
+     * @param {Function} on_event
+     * @param {number} chunk_size
+     * @param {string[] | null | undefined} disabled_type_names
+     * @param {boolean} skip_type_geometry
+     * @param {Uint32Array} index_ids
+     * @param {Uint32Array} index_starts
+     * @param {Uint32Array} index_lengths
+     * @param {Uint8Array} index_classes
+     * @returns {any}
+     */
+    buildPrePassStreamingSharded(data, on_event, chunk_size, disabled_type_names, skip_type_geometry, index_ids, index_starts, index_lengths, index_classes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(disabled_type_names) ? 0 : passArrayJsValueToWasm0(disabled_type_names, wasm.__wbindgen_export);
+            var len1 = WASM_VECTOR_LEN;
+            const ptr2 = passArray32ToWasm0(index_ids, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            const ptr3 = passArray32ToWasm0(index_starts, wasm.__wbindgen_export);
+            const len3 = WASM_VECTOR_LEN;
+            const ptr4 = passArray32ToWasm0(index_lengths, wasm.__wbindgen_export);
+            const len4 = WASM_VECTOR_LEN;
+            const ptr5 = passArray8ToWasm0(index_classes, wasm.__wbindgen_export);
+            const len5 = WASM_VECTOR_LEN;
+            wasm.ifcapi_buildPrePassStreamingSharded(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(on_event), chunk_size, ptr1, len1, skip_type_geometry, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
+            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 takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
     /**
      * Store the whole IFC source file ONCE per load so the `*FromSource` batch
      * variants can read it from the wasm heap instead of re-copying it per call.
@@ -3934,6 +4105,10 @@ function __wbg_get_imports() {
         const ret = new Float64Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_with_length_95ba657dfb7d3dfb = function(arg0) {
+        const ret = new Float32Array(arg0 >>> 0);
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_now_69d776cd24f5215b = function() {
         const ret = Date.now();
         return ret;
@@ -3951,6 +4126,9 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_set_index_021489b2916af13e = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = arg2;
     };
+    imports.wbg.__wbg_set_index_165b46b0114d368c = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = arg2;
+    };
     imports.wbg.__wbg_set_index_42abe35f117e614e = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = arg2 >>> 0;
     };