@ifc-lite/wasm 1.14.5 → 1.16.0

package/package.json

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "1.14.5",
+  "version": "1.16.0",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",
@@ -32,5 +32,8 @@
     "wasm",
     "webassembly",
     "aec"
-  ]
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  }
 }

package/pkg/ifc-lite.d.ts

@@ -254,6 +254,38 @@ export class IfcAPI {
    * ```
    */
   parseMeshesAsync(content: string, options: any): Promise<any>;
+  /**
+   * Fast pre-pass: scans for geometry entities ONLY (skips style/void/material resolution).
+   * Returns job list + unit scale + RTC offset in ~1-2s instead of ~6s.
+   * Geometry workers can start immediately with default colors + no void subtraction.
+   * A parallel style worker can run buildPrePassOnce for correct colors later.
+   */
+  buildPrePassFast(data: Uint8Array): any;
+  /**
+   * Run the pre-pass ONCE and return serialized results for worker distribution.
+   * Takes raw bytes (&[u8]) to avoid TextDecoder overhead.
+   */
+  buildPrePassOnce(data: Uint8Array): any;
+  /**
+   * Parse a subset of IFC geometry entities by index range.
+   *
+   * Performs the full pre-pass (entity index, combined style/void/brep scan)
+   * but only processes geometry entities whose index (in the combined
+   * simple + complex job list) falls within `[start_idx, end_idx)`.
+   *
+   * This enables Web Worker parallelization: each worker processes a
+   * disjoint slice of the entity list while sharing the same pre-pass data.
+   *
+   * Example:
+   * ```javascript
+   * const api = new IfcAPI();
+   * // Worker 1: entities 0..500
+   * const batch1 = api.parseMeshesSubset(content, 0, 500);
+   * // Worker 2: entities 500..1000
+   * const batch2 = api.parseMeshesSubset(content, 500, 1000);
+   * ```
+   */
+  parseMeshesSubset(content: string, start_idx: number, end_idx: number, skip_expensive: boolean): MeshCollection;
   /**
    * Parse IFC file and return GPU-ready geometry for zero-copy upload
    *
@@ -312,6 +344,11 @@ export class IfcAPI {
    * ```
    */
   parseMeshesInstanced(content: string): InstancedMeshCollection;
+  /**
+   * Process geometry for a subset of pre-scanned entities.
+   * Takes raw bytes and pre-pass data from buildPrePassOnce.
+   */
+  processGeometryBatch(data: Uint8Array, jobs_flat: Uint32Array, unit_scale: number, rtc_x: number, rtc_y: number, rtc_z: number, needs_shift: boolean, void_keys: Uint32Array, void_counts: Uint32Array, void_values: Uint32Array, style_ids: Uint32Array, style_colors: Uint8Array): MeshCollection;
   /**
    * Parse IFC file with streaming GPU-ready geometry batches
    *
@@ -397,6 +434,29 @@ export class IfcAPI {
    * ```
    */
   parseZeroCopy(content: string): ZeroCopyMesh;
+  /**
+   * Extract raw profile polygons from all building elements with `IfcExtrudedAreaSolid`
+   * representations.
+   *
+   * Returns a [`ProfileCollection`] whose entries each carry:
+   * - A 2D polygon (outer + holes) in local profile space (metres)
+   * - A 4 × 4 column-major transform in WebGL Y-up world space
+   * - Extrusion direction (world space) and depth (metres)
+   *
+   * Use [`ProfileProjector`] (TypeScript) to convert these into `DrawingLine[]`
+   * for clean projection without tessellation artifacts.
+   *
+   * ```javascript
+   * const api = new IfcAPI();
+   * const profiles = api.extractProfiles(ifcContent, 0);
+   * console.log('Profiles:', profiles.length);
+   * for (let i = 0; i < profiles.length; i++) {
+   *   const p = profiles.get(i);
+   *   console.log(p.ifcType, 'depth:', p.extrusionDepth);
+   * }
+   * ```
+   */
+  extractProfiles(content: string, model_index: number): ProfileCollection;
   /**
    * Debug: Test processing entity #953 (FacetedBrep wall)
    */
@@ -655,6 +715,63 @@ export class MeshDataJs {
   readonly positions: Float32Array;
 }
 
+export class ProfileCollection {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Get profile at `index`.  Returns `undefined` for out-of-bounds index.
+   */
+  get(index: number): ProfileEntryJs | undefined;
+  /**
+   * Number of profiles.
+   */
+  readonly length: number;
+}
+
+export class ProfileEntryJs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Express ID of the building element.
+   */
+  readonly expressId: number;
+  /**
+   * Number of points per hole.
+   */
+  readonly holeCounts: Uint32Array;
+  /**
+   * All hole points concatenated: `[x0, y0, x1, y1, …]` (metres).
+   */
+  readonly holePoints: Float32Array;
+  /**
+   * Model index for multi-model federation.
+   */
+  readonly modelIndex: number;
+  /**
+   * Outer boundary: flat `[x0, y0, x1, y1, …]` in local profile space (metres).
+   */
+  readonly outerPoints: Float32Array;
+  /**
+   * Extrusion direction `[dx, dy, dz]` in WebGL Y-up world space (unit vector).
+   */
+  readonly extrusionDir: Float32Array;
+  /**
+   * Extrusion depth (metres).
+   */
+  readonly extrusionDepth: number;
+  /**
+   * IFC type name (e.g., `"IfcWall"`).
+   */
+  readonly ifcType: string;
+  /**
+   * 4 × 4 column-major transform in WebGL Y-up world space.
+   * `M * [x, y, 0, 1]ᵀ` gives the world position.
+   */
+  readonly transform: Float32Array;
+}
+
 export class RtcOffsetJs {
   private constructor();
   free(): void;
@@ -830,8 +947,6 @@ export function get_memory(): any;
  */
 export function init(): void;
 
-export function initThreadPool(num_threads: number): Promise<any>;
-
 /**
  * Get the version of IFC-Lite.
  *
@@ -847,20 +962,10 @@ export function initThreadPool(num_threads: number): Promise<any>;
  */
 export function version(): string;
 
-export class wbg_rayon_PoolBuilder {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  numThreads(): number;
-  build(): void;
-  receiver(): number;
-}
-
-export function wbg_rayon_start_worker(receiver: number): void;
-
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
+  readonly memory: WebAssembly.Memory;
   readonly __wbg_georeferencejs_free: (a: number, b: number) => void;
   readonly __wbg_get_georeferencejs_eastings: (a: number) => number;
   readonly __wbg_get_georeferencejs_northings: (a: number) => number;
@@ -879,6 +984,8 @@ export interface InitOutput {
   readonly __wbg_meshcollection_free: (a: number, b: number) => void;
   readonly __wbg_meshcollectionwithrtc_free: (a: number, b: number) => void;
   readonly __wbg_meshdatajs_free: (a: number, b: number) => void;
+  readonly __wbg_profilecollection_free: (a: number, b: number) => void;
+  readonly __wbg_profileentryjs_free: (a: number, b: number) => void;
   readonly __wbg_rtcoffsetjs_free: (a: number, b: number) => void;
   readonly __wbg_set_georeferencejs_eastings: (a: number, b: number) => void;
   readonly __wbg_set_georeferencejs_northings: (a: number, b: number) => void;
@@ -938,8 +1045,11 @@ export interface InitOutput {
   readonly gpumeshmetadata_indexOffset: (a: number) => number;
   readonly gpumeshmetadata_vertexCount: (a: number) => number;
   readonly gpumeshmetadata_vertexOffset: (a: number) => number;
+  readonly ifcapi_buildPrePassFast: (a: number, b: number, c: number) => number;
+  readonly ifcapi_buildPrePassOnce: (a: number, b: number, c: number) => number;
   readonly ifcapi_debugProcessEntity953: (a: number, b: number, c: number, d: number) => void;
   readonly ifcapi_debugProcessFirstWall: (a: number, b: number, c: number, d: number) => void;
+  readonly ifcapi_extractProfiles: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_getGeoReference: (a: number, b: number, c: number) => number;
   readonly ifcapi_getMemory: (a: number) => number;
   readonly ifcapi_is_ready: (a: number) => number;
@@ -949,6 +1059,7 @@ export interface InitOutput {
   readonly ifcapi_parseMeshesAsync: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_parseMeshesInstanced: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseMeshesInstancedAsync: (a: number, b: number, c: number, d: number) => number;
+  readonly ifcapi_parseMeshesSubset: (a: number, b: number, c: number, d: number, e: number, f: number) => number;
   readonly ifcapi_parseMeshesWithRtc: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseStreaming: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_parseSymbolicRepresentations: (a: number, b: number, c: number) => number;
@@ -956,6 +1067,7 @@ export interface InitOutput {
   readonly ifcapi_parseToGpuGeometryAsync: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_parseToGpuInstancedGeometry: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseZeroCopy: (a: number, b: number, c: number) => number;
+  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) => number;
   readonly ifcapi_scanEntitiesFast: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanEntitiesFastBytes: (a: number, b: number, c: number) => number;
   readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
@@ -990,6 +1102,16 @@ export interface InitOutput {
   readonly meshdatajs_positions: (a: number) => number;
   readonly meshdatajs_triangleCount: (a: number) => number;
   readonly meshdatajs_vertexCount: (a: number) => number;
+  readonly profilecollection_get: (a: number, b: number) => number;
+  readonly profilecollection_length: (a: number) => number;
+  readonly profileentryjs_extrusionDepth: (a: number) => number;
+  readonly profileentryjs_extrusionDir: (a: number) => number;
+  readonly profileentryjs_holeCounts: (a: number) => number;
+  readonly profileentryjs_holePoints: (a: number) => number;
+  readonly profileentryjs_ifcType: (a: number, b: number) => void;
+  readonly profileentryjs_modelIndex: (a: number) => number;
+  readonly profileentryjs_outerPoints: (a: number) => number;
+  readonly profileentryjs_transform: (a: number) => number;
   readonly rtcoffsetjs_isSignificant: (a: number) => number;
   readonly rtcoffsetjs_toWorld: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly symboliccircle_centerX: (a: number) => number;
@@ -1022,6 +1144,7 @@ export interface InitOutput {
   readonly zerocopymesh_positions_len: (a: number) => number;
   readonly zerocopymesh_positions_ptr: (a: number) => number;
   readonly zerocopymesh_vertex_count: (a: number) => number;
+  readonly init: () => void;
   readonly gpuinstancedgeometryref_indicesLen: (a: number) => number;
   readonly gpuinstancedgeometryref_instanceCount: (a: number) => number;
   readonly gpuinstancedgeometryref_instanceDataLen: (a: number) => number;
@@ -1030,7 +1153,6 @@ export interface InitOutput {
   readonly instancedmeshcollection_totalGeometries: (a: number) => number;
   readonly meshcollectionwithrtc_length: (a: number) => number;
   readonly zerocopymesh_indices_len: (a: number) => number;
-  readonly init: () => void;
   readonly __wbg_set_rtcoffsetjs_x: (a: number, b: number) => void;
   readonly __wbg_set_rtcoffsetjs_y: (a: number, b: number) => void;
   readonly __wbg_set_rtcoffsetjs_z: (a: number, b: number) => void;
@@ -1052,27 +1174,18 @@ export interface InitOutput {
   readonly gpuinstancedgeometryref_geometryId: (a: number) => bigint;
   readonly instancedgeometry_geometryId: (a: number) => bigint;
   readonly meshcollection_rtcOffsetX: (a: number) => number;
+  readonly profileentryjs_expressId: (a: number) => number;
   readonly symboliccircle_expressId: (a: number) => number;
   readonly __wbg_gpuinstancedgeometryref_free: (a: number, b: number) => void;
-  readonly __wbg_wbg_rayon_poolbuilder_free: (a: number, b: number) => void;
-  readonly initThreadPool: (a: number) => number;
-  readonly wbg_rayon_poolbuilder_build: (a: number) => void;
-  readonly wbg_rayon_poolbuilder_numThreads: (a: number) => number;
-  readonly wbg_rayon_poolbuilder_receiver: (a: number) => number;
-  readonly wbg_rayon_start_worker: (a: number) => void;
-  readonly __wasm_bindgen_func_elem_959: (a: number, b: number, c: number) => void;
-  readonly __wasm_bindgen_func_elem_958: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_498: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_497: (a: number, b: number) => void;
-  readonly __wasm_bindgen_func_elem_1230: (a: number, b: number, c: number, d: number) => void;
-  readonly memory: WebAssembly.Memory;
+  readonly __wasm_bindgen_func_elem_1127: (a: number, b: number, c: number) => void;
+  readonly __wasm_bindgen_func_elem_1126: (a: number, b: number) => void;
+  readonly __wasm_bindgen_func_elem_1167: (a: number, b: number, c: number, d: number) => void;
   readonly __wbindgen_export: (a: number) => void;
   readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
   readonly __wbindgen_export3: (a: number, b: number) => number;
   readonly __wbindgen_export4: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
-  readonly __wbindgen_thread_destroy: (a?: number, b?: number, c?: number) => void;
-  readonly __wbindgen_start: (a: number) => void;
+  readonly __wbindgen_start: () => void;
 }
 
 export type SyncInitInput = BufferSource | WebAssembly.Module;
@@ -1081,20 +1194,18 @@ export type SyncInitInput = BufferSource | WebAssembly.Module;
 * Instantiates the given `module`, which can either be bytes or
 * a precompiled `WebAssembly.Module`.
 *
-* @param {{ module: SyncInitInput, memory?: WebAssembly.Memory, thread_stack_size?: number }} module - Passing `SyncInitInput` directly is deprecated.
-* @param {WebAssembly.Memory} memory - Deprecated.
+* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
 *
 * @returns {InitOutput}
 */
-export function initSync(module: { module: SyncInitInput, memory?: WebAssembly.Memory, thread_stack_size?: number } | SyncInitInput, memory?: WebAssembly.Memory): InitOutput;
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
 
 /**
 * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
 * for everything else, calls `WebAssembly.instantiate` directly.
 *
-* @param {{ module_or_path: InitInput | Promise<InitInput>, memory?: WebAssembly.Memory, thread_stack_size?: number }} module_or_path - Passing `InitInput` directly is deprecated.
-* @param {WebAssembly.Memory} memory - Deprecated.
+* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
 *
 * @returns {Promise<InitOutput>}
 */
-export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput>, memory?: WebAssembly.Memory, thread_stack_size?: number } | InitInput | Promise<InitInput>, memory?: WebAssembly.Memory): Promise<InitOutput>;
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/pkg/ifc-lite.js

@@ -1,5 +1,3 @@
-import { startWorkers } from './snippets/wasm-bindgen-rayon-38edf6e439f6d70d/src/workerHelpers.js';
-
 let wasm;
 
 function addHeapObject(obj) {
@@ -38,7 +36,7 @@ function getArrayU32FromWasm0(ptr, len) {
 
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
         cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
     }
     return cachedDataViewMemory0;
@@ -46,7 +44,7 @@ function getDataViewMemory0() {
 
 let cachedFloat32ArrayMemory0 = null;
 function getFloat32ArrayMemory0() {
-    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.buffer !== wasm.memory.buffer) {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
         cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
     }
     return cachedFloat32ArrayMemory0;
@@ -54,7 +52,7 @@ function getFloat32ArrayMemory0() {
 
 let cachedFloat64ArrayMemory0 = null;
 function getFloat64ArrayMemory0() {
-    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.buffer !== wasm.memory.buffer) {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
         cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
     }
     return cachedFloat64ArrayMemory0;
@@ -67,7 +65,7 @@ function getStringFromWasm0(ptr, len) {
 
 let cachedUint32ArrayMemory0 = null;
 function getUint32ArrayMemory0() {
-    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.buffer !== wasm.memory.buffer) {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
         cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
     }
     return cachedUint32ArrayMemory0;
@@ -75,7 +73,7 @@ function getUint32ArrayMemory0() {
 
 let cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
-    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.buffer !== wasm.memory.buffer) {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
         cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
     }
     return cachedUint8ArrayMemory0;
@@ -128,6 +126,13 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -178,9 +183,8 @@ function takeObject(idx) {
     return ret;
 }
 
-let cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : undefined);
-if (cachedTextDecoder) cachedTextDecoder.decode();
-
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
 const MAX_SAFARI_DECODE_BYTES = 2146435072;
 let numBytesDecoded = 0;
 function decodeText(ptr, len) {
@@ -190,12 +194,12 @@ function decodeText(ptr, len) {
         cachedTextDecoder.decode();
         numBytesDecoded = len;
     }
-    return cachedTextDecoder.decode(getUint8ArrayMemory0().slice(ptr, ptr + len));
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
-const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder() : undefined);
+const cachedTextEncoder = new TextEncoder();
 
-if (cachedTextEncoder) {
+if (!('encodeInto' in cachedTextEncoder)) {
     cachedTextEncoder.encodeInto = function (arg, view) {
         const buf = cachedTextEncoder.encode(arg);
         view.set(buf);
@@ -208,16 +212,12 @@ if (cachedTextEncoder) {
 
 let WASM_VECTOR_LEN = 0;
 
-function __wasm_bindgen_func_elem_959(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_959(arg0, arg1, addHeapObject(arg2));
-}
-
-function __wasm_bindgen_func_elem_498(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_498(arg0, arg1);
+function __wasm_bindgen_func_elem_1127(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_1127(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_1230(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_1230(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_1167(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_1167(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 
 const GeoReferenceJsFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -272,6 +272,14 @@ const MeshDataJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_meshdatajs_free(ptr >>> 0, 1));
 
+const ProfileCollectionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_profilecollection_free(ptr >>> 0, 1));
+
+const ProfileEntryJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_profileentryjs_free(ptr >>> 0, 1));
+
 const RtcOffsetJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_rtcoffsetjs_free(ptr >>> 0, 1));
@@ -292,10 +300,6 @@ const ZeroCopyMeshFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_zerocopymesh_free(ptr >>> 0, 1));
 
-const wbg_rayon_PoolBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_wbg_rayon_poolbuilder_free(ptr >>> 0, 1));
-
 /**
  * Georeferencing information exposed to JavaScript
  */
@@ -1154,6 +1158,62 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseMeshesAsync(this.__wbg_ptr, ptr0, len0, addHeapObject(options));
         return takeObject(ret);
     }
+    /**
+     * Fast pre-pass: scans for geometry entities ONLY (skips style/void/material resolution).
+     * Returns job list + unit scale + RTC offset in ~1-2s instead of ~6s.
+     * Geometry workers can start immediately with default colors + no void subtraction.
+     * A parallel style worker can run buildPrePassOnce for correct colors later.
+     * @param {Uint8Array} data
+     * @returns {any}
+     */
+    buildPrePassFast(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_buildPrePassFast(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Run the pre-pass ONCE and return serialized results for worker distribution.
+     * Takes raw bytes (&[u8]) to avoid TextDecoder overhead.
+     * @param {Uint8Array} data
+     * @returns {any}
+     */
+    buildPrePassOnce(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_buildPrePassOnce(this.__wbg_ptr, ptr0, len0);
+        return takeObject(ret);
+    }
+    /**
+     * Parse a subset of IFC geometry entities by index range.
+     *
+     * Performs the full pre-pass (entity index, combined style/void/brep scan)
+     * but only processes geometry entities whose index (in the combined
+     * simple + complex job list) falls within `[start_idx, end_idx)`.
+     *
+     * This enables Web Worker parallelization: each worker processes a
+     * disjoint slice of the entity list while sharing the same pre-pass data.
+     *
+     * Example:
+     * ```javascript
+     * const api = new IfcAPI();
+     * // Worker 1: entities 0..500
+     * const batch1 = api.parseMeshesSubset(content, 0, 500);
+     * // Worker 2: entities 500..1000
+     * const batch2 = api.parseMeshesSubset(content, 500, 1000);
+     * ```
+     * @param {string} content
+     * @param {number} start_idx
+     * @param {number} end_idx
+     * @param {boolean} skip_expensive
+     * @returns {MeshCollection}
+     */
+    parseMeshesSubset(content, start_idx, end_idx, skip_expensive) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_parseMeshesSubset(this.__wbg_ptr, ptr0, len0, start_idx, end_idx, skip_expensive);
+        return MeshCollection.__wrap(ret);
+    }
     /**
      * Parse IFC file and return GPU-ready geometry for zero-copy upload
      *
@@ -1226,6 +1286,41 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseMeshesInstanced(this.__wbg_ptr, ptr0, len0);
         return InstancedMeshCollection.__wrap(ret);
     }
+    /**
+     * Process geometry for a subset of pre-scanned entities.
+     * Takes raw bytes and pre-pass data from buildPrePassOnce.
+     * @param {Uint8Array} data
+     * @param {Uint32Array} jobs_flat
+     * @param {number} unit_scale
+     * @param {number} rtc_x
+     * @param {number} rtc_y
+     * @param {number} rtc_z
+     * @param {boolean} needs_shift
+     * @param {Uint32Array} void_keys
+     * @param {Uint32Array} void_counts
+     * @param {Uint32Array} void_values
+     * @param {Uint32Array} style_ids
+     * @param {Uint8Array} style_colors
+     * @returns {MeshCollection}
+     */
+    processGeometryBatch(data, jobs_flat, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, void_keys, void_counts, void_values, style_ids, style_colors) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(jobs_flat, wasm.__wbindgen_export3);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(void_keys, wasm.__wbindgen_export3);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray32ToWasm0(void_counts, wasm.__wbindgen_export3);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray32ToWasm0(void_values, wasm.__wbindgen_export3);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArray32ToWasm0(style_ids, wasm.__wbindgen_export3);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passArray8ToWasm0(style_colors, wasm.__wbindgen_export3);
+        const len6 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_processGeometryBatch(this.__wbg_ptr, ptr0, len0, ptr1, len1, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
+        return MeshCollection.__wrap(ret);
+    }
     /**
      * Parse IFC file with streaming GPU-ready geometry batches
      *
@@ -1341,6 +1436,37 @@ export class IfcAPI {
         const ret = wasm.ifcapi_parseZeroCopy(this.__wbg_ptr, ptr0, len0);
         return ZeroCopyMesh.__wrap(ret);
     }
+    /**
+     * Extract raw profile polygons from all building elements with `IfcExtrudedAreaSolid`
+     * representations.
+     *
+     * Returns a [`ProfileCollection`] whose entries each carry:
+     * - A 2D polygon (outer + holes) in local profile space (metres)
+     * - A 4 × 4 column-major transform in WebGL Y-up world space
+     * - Extrusion direction (world space) and depth (metres)
+     *
+     * Use [`ProfileProjector`] (TypeScript) to convert these into `DrawingLine[]`
+     * for clean projection without tessellation artifacts.
+     *
+     * ```javascript
+     * const api = new IfcAPI();
+     * const profiles = api.extractProfiles(ifcContent, 0);
+     * console.log('Profiles:', profiles.length);
+     * for (let i = 0; i < profiles.length; i++) {
+     *   const p = profiles.get(i);
+     *   console.log(p.ifcType, 'depth:', p.extrusionDepth);
+     * }
+     * ```
+     * @param {string} content
+     * @param {number} model_index
+     * @returns {ProfileCollection}
+     */
+    extractProfiles(content, model_index) {
+        const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_extractProfiles(this.__wbg_ptr, ptr0, len0, model_index);
+        return ProfileCollection.__wrap(ret);
+    }
     /**
      * Debug: Test processing entity #953 (FacetedBrep wall)
      * @param {string} content
@@ -2051,6 +2177,159 @@ export class MeshDataJs {
 }
 if (Symbol.dispose) MeshDataJs.prototype[Symbol.dispose] = MeshDataJs.prototype.free;
 
+/**
+ * A collection of extracted profiles.
+ */
+export class ProfileCollection {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ProfileCollection.prototype);
+        obj.__wbg_ptr = ptr;
+        ProfileCollectionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProfileCollectionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_profilecollection_free(ptr, 0);
+    }
+    /**
+     * Get profile at `index`.  Returns `undefined` for out-of-bounds index.
+     * @param {number} index
+     * @returns {ProfileEntryJs | undefined}
+     */
+    get(index) {
+        const ret = wasm.profilecollection_get(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : ProfileEntryJs.__wrap(ret);
+    }
+    /**
+     * Number of profiles.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.profilecollection_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) ProfileCollection.prototype[Symbol.dispose] = ProfileCollection.prototype.free;
+
+/**
+ * A single profile entry – raw 2D polygon + world transform.
+ *
+ * Profile points are in **local 2D profile space** (metres).
+ * Apply `transform` to `[x, y, 0, 1]` to get WebGL Y-up world coordinates.
+ */
+export class ProfileEntryJs {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ProfileEntryJs.prototype);
+        obj.__wbg_ptr = ptr;
+        ProfileEntryJsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ProfileEntryJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_profileentryjs_free(ptr, 0);
+    }
+    /**
+     * Express ID of the building element.
+     * @returns {number}
+     */
+    get expressId() {
+        const ret = wasm.meshdatajs_expressId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Number of points per hole.
+     * @returns {Uint32Array}
+     */
+    get holeCounts() {
+        const ret = wasm.profileentryjs_holeCounts(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * All hole points concatenated: `[x0, y0, x1, y1, …]` (metres).
+     * @returns {Float32Array}
+     */
+    get holePoints() {
+        const ret = wasm.profileentryjs_holePoints(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Model index for multi-model federation.
+     * @returns {number}
+     */
+    get modelIndex() {
+        const ret = wasm.profileentryjs_modelIndex(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Outer boundary: flat `[x0, y0, x1, y1, …]` in local profile space (metres).
+     * @returns {Float32Array}
+     */
+    get outerPoints() {
+        const ret = wasm.profileentryjs_outerPoints(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Extrusion direction `[dx, dy, dz]` in WebGL Y-up world space (unit vector).
+     * @returns {Float32Array}
+     */
+    get extrusionDir() {
+        const ret = wasm.profileentryjs_extrusionDir(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Extrusion depth (metres).
+     * @returns {number}
+     */
+    get extrusionDepth() {
+        const ret = wasm.profileentryjs_extrusionDepth(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * IFC type name (e.g., `"IfcWall"`).
+     * @returns {string}
+     */
+    get ifcType() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.profileentryjs_ifcType(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export2(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * 4 × 4 column-major transform in WebGL Y-up world space.
+     * `M * [x, y, 0, 1]ᵀ` gives the world position.
+     * @returns {Float32Array}
+     */
+    get transform() {
+        const ret = wasm.profileentryjs_transform(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) ProfileEntryJs.prototype[Symbol.dispose] = ProfileEntryJs.prototype.free;
+
 /**
  * RTC offset information exposed to JavaScript
  */
@@ -2607,15 +2886,6 @@ export function init() {
     wasm.init();
 }
 
-/**
- * @param {number} num_threads
- * @returns {Promise<any>}
- */
-export function initThreadPool(num_threads) {
-    const ret = wasm.initThreadPool(num_threads);
-    return takeObject(ret);
-}
-
 /**
  * Get the version of IFC-Lite.
  *
@@ -2647,51 +2917,6 @@ export function version() {
     }
 }
 
-export class wbg_rayon_PoolBuilder {
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(wbg_rayon_PoolBuilder.prototype);
-        obj.__wbg_ptr = ptr;
-        wbg_rayon_PoolBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        wbg_rayon_PoolBuilderFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_wbg_rayon_poolbuilder_free(ptr, 0);
-    }
-    /**
-     * @returns {number}
-     */
-    numThreads() {
-        const ret = wasm.wbg_rayon_poolbuilder_numThreads(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-    build() {
-        wasm.wbg_rayon_poolbuilder_build(this.__wbg_ptr);
-    }
-    /**
-     * @returns {number}
-     */
-    receiver() {
-        const ret = wasm.wbg_rayon_poolbuilder_receiver(this.__wbg_ptr);
-        return ret >>> 0;
-    }
-}
-if (Symbol.dispose) wbg_rayon_PoolBuilder.prototype[Symbol.dispose] = wbg_rayon_PoolBuilder.prototype.free;
-
-/**
- * @param {number} receiver
- */
-export function wbg_rayon_start_worker(receiver) {
-    wasm.wbg_rayon_start_worker(receiver);
-}
-
 const EXPECTED_RESPONSE_TYPES = new Set(['basic', 'cors', 'default']);
 
 async function __wbg_load(module, imports) {
@@ -2724,7 +2949,7 @@ async function __wbg_load(module, imports) {
     }
 }
 
-function __wbg_get_imports(memory) {
+function __wbg_get_imports() {
     const imports = {};
     imports.wbg = {};
     imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
@@ -2743,33 +2968,18 @@ function __wbg_get_imports(memory) {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg___wbindgen_module_967adef62ea6cbf8 = function() {
-        const ret = __wbg_init.__wbindgen_wasm_module;
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
         const obj = getObject(arg1);
         const ret = typeof(obj) === 'number' ? obj : undefined;
         getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
     };
-    imports.wbg.__wbg___wbindgen_rethrow_78714972834ecdf1 = function(arg0) {
-        throw takeObject(arg0);
-    };
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
     imports.wbg.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
         getObject(arg0)._wbg_cb_unref();
     };
-    imports.wbg.__wbg_async_bba5a2ac54b734df = function(arg0) {
-        const ret = getObject(arg0).async;
-        return ret;
-    };
-    imports.wbg.__wbg_buffer_063cd102cc769a1c = function(arg0) {
-        const ret = getObject(arg0).buffer;
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
         return addHeapObject(ret);
@@ -2782,14 +2992,6 @@ function __wbg_get_imports(memory) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
         return addHeapObject(ret);
     }, arguments) };
-    imports.wbg.__wbg_clearTimeout_5a54f8841c30079a = function(arg0) {
-        const ret = clearTimeout(takeObject(arg0));
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_data_8bf4ae669a78a688 = function(arg0) {
-        const ret = getObject(arg0).data;
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_debug_9d0c87ddda3dc485 = function(arg0) {
         console.debug(getObject(arg0));
     };
@@ -2816,16 +3018,6 @@ function __wbg_get_imports(memory) {
         const ret = InstancedGeometry.__wrap(arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_instanceof_Window_b5cf7783caa68180 = function(arg0) {
-        let result;
-        try {
-            result = getObject(arg0) instanceof Window;
-        } catch (_) {
-            result = false;
-        }
-        const ret = result;
-        return ret;
-    };
     imports.wbg.__wbg_length_86ce4877baf913bb = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;
@@ -2846,18 +3038,10 @@ function __wbg_get_imports(memory) {
         const ret = new Array();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_53cb1e86c1ef5d2a = function() { return handleError(function (arg0, arg1) {
-        const ret = new Worker(getStringFromWasm0(arg0, arg1));
-        return addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
         const ret = new Error();
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_new_de1e660b88fc921f = function(arg0) {
-        const ret = new Int32Array(getObject(arg0));
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
         try {
             var state0 = {a: arg0, b: arg1};
@@ -2865,7 +3049,7 @@ function __wbg_get_imports(memory) {
                 const a = state0.a;
                 state0.a = 0;
                 try {
-                    return __wasm_bindgen_func_elem_1230(a, state0.b, arg0, arg1);
+                    return __wasm_bindgen_func_elem_1167(a, state0.b, arg0, arg1);
                 } finally {
                     state0.a = a;
                 }
@@ -2888,13 +3072,18 @@ function __wbg_get_imports(memory) {
         const ret = new Function(getStringFromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_of_7779827fa663eec8 = function(arg0, arg1, arg2) {
-        const ret = Array.of(getObject(arg0), getObject(arg1), getObject(arg2));
+    imports.wbg.__wbg_new_with_length_202b3db94ba5fc86 = function(arg0) {
+        const ret = new Uint32Array(arg0 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_with_length_806b9e5b8290af7c = function(arg0) {
+        const ret = new Float64Array(arg0 >>> 0);
+        return addHeapObject(ret);
+    };
+    imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
+        const ret = new Uint8Array(arg0 >>> 0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_postMessage_07504dbe15265d5c = function() { return handleError(function (arg0, arg1) {
-        getObject(arg0).postMessage(getObject(arg1));
-    }, arguments) };
     imports.wbg.__wbg_prototypesetcall_96cc7097487b926d = function(arg0, arg1, arg2) {
         Float32Array.prototype.set.call(getArrayF32FromWasm0(arg0, arg1), getObject(arg2));
     };
@@ -2913,10 +3102,6 @@ function __wbg_get_imports(memory) {
         const ret = Promise.resolve(getObject(arg0));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_setTimeout_db2dbaeefb6f39c7 = function() { return handleError(function (arg0, arg1) {
-        const ret = setTimeout(getObject(arg0), arg1);
-        return addHeapObject(ret);
-    }, arguments) };
     imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
         getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
     };
@@ -2927,8 +3112,14 @@ function __wbg_get_imports(memory) {
     imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
         getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
     };
-    imports.wbg.__wbg_set_onmessage_deb94985de696ac7 = function(arg0, arg1) {
-        getObject(arg0).onmessage = getObject(arg1);
+    imports.wbg.__wbg_set_index_021489b2916af13e = function(arg0, arg1, arg2) {
+        getObject(arg0)[arg1 >>> 0] = arg2;
+    };
+    imports.wbg.__wbg_set_index_04c4b93e64d08a52 = 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;
     };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = getObject(arg1).stack;
@@ -2937,10 +3128,6 @@ function __wbg_get_imports(memory) {
         getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
         getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
     };
-    imports.wbg.__wbg_startWorkers_2ca11761e08ff5d5 = function(arg0, arg1, arg2) {
-        const ret = startWorkers(takeObject(arg0), takeObject(arg1), wbg_rayon_PoolBuilder.__wrap(arg2));
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
         const ret = typeof global === 'undefined' ? null : global;
         return isLikeNone(ret) ? 0 : addHeapObject(ret);
@@ -2961,26 +3148,9 @@ function __wbg_get_imports(memory) {
         const ret = getObject(arg0).then(getObject(arg1));
         return addHeapObject(ret);
     };
-    imports.wbg.__wbg_value_4cd497eeadba94bd = function(arg0) {
-        const ret = getObject(arg0).value;
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_waitAsync_8afec80ffd213eca = function(arg0, arg1, arg2) {
-        const ret = Atomics.waitAsync(getObject(arg0), arg1 >>> 0, arg2);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbg_waitAsync_c186cb97ffacd552 = function() {
-        const ret = Atomics.waitAsync;
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
         console.warn(getObject(arg0));
     };
-    imports.wbg.__wbindgen_cast_188ff5bafa3120b4 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 56, function: Function { arguments: [], shim_idx: 57, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_497, __wasm_bindgen_func_elem_498);
-        return addHeapObject(ret);
-    };
     imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
         // Cast intrinsic for `Ref(String) -> Externref`.
         const ret = getStringFromWasm0(arg0, arg1);
@@ -2991,14 +3161,9 @@ function __wbg_get_imports(memory) {
         const ret = BigInt.asUintN(64, arg0);
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_cast_72f2309ca88b7133 = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 161, function: Function { arguments: [Externref], shim_idx: 162, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_958, __wasm_bindgen_func_elem_959);
-        return addHeapObject(ret);
-    };
-    imports.wbg.__wbindgen_cast_96f117460864886d = function(arg0, arg1) {
-        // Cast intrinsic for `Closure(Closure { dtor_idx: 161, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 162, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_958, __wasm_bindgen_func_elem_959);
+    imports.wbg.__wbindgen_cast_8410bcb836a2825d = function(arg0, arg1) {
+        // Cast intrinsic for `Closure(Closure { dtor_idx: 145, function: Function { arguments: [Externref], shim_idx: 146, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+        const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_1126, __wasm_bindgen_func_elem_1127);
         return addHeapObject(ret);
     };
     imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
@@ -3006,20 +3171,6 @@ function __wbg_get_imports(memory) {
         const ret = arg0;
         return addHeapObject(ret);
     };
-    imports.wbg.__wbindgen_link_203404ece0e9bab9 = function(arg0) {
-        const val = `onmessage = function (ev) {
-            let [ia, index, value] = ev.data;
-            ia = new Int32Array(ia.buffer);
-            let result = Atomics.wait(ia, index, value);
-            postMessage(result);
-        };
-        `;
-        const ret = typeof URL.createObjectURL === 'undefined' ? "data:application/javascript," + encodeURIComponent(val) : URL.createObjectURL(new Blob([val], { type: "text/javascript" }));
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export3, wasm.__wbindgen_export4);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
     imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
         const ret = getObject(arg0);
         return addHeapObject(ret);
@@ -3027,12 +3178,11 @@ function __wbg_get_imports(memory) {
     imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
         takeObject(arg0);
     };
-    imports.wbg.memory = memory || new WebAssembly.Memory({initial:20,maximum:65536,shared:true});
 
     return imports;
 }
 
-function __wbg_finalize_init(instance, module, thread_stack_size) {
+function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
@@ -3041,38 +3191,38 @@ function __wbg_finalize_init(instance, module, thread_stack_size) {
     cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;
 
-    if (typeof thread_stack_size !== 'undefined' && (typeof thread_stack_size !== 'number' || thread_stack_size === 0 || thread_stack_size % 65536 !== 0)) { throw 'invalid stack size' }
-    wasm.__wbindgen_start(thread_stack_size);
+
+    wasm.__wbindgen_start();
     return wasm;
 }
 
-function initSync(module, memory) {
+function initSync(module) {
     if (wasm !== undefined) return wasm;
 
-    let thread_stack_size
+
     if (typeof module !== 'undefined') {
         if (Object.getPrototypeOf(module) === Object.prototype) {
-            ({module, memory, thread_stack_size} = module)
+            ({module} = module)
         } else {
             console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
         }
     }
 
-    const imports = __wbg_get_imports(memory);
+    const imports = __wbg_get_imports();
     if (!(module instanceof WebAssembly.Module)) {
         module = new WebAssembly.Module(module);
     }
     const instance = new WebAssembly.Instance(module, imports);
-    return __wbg_finalize_init(instance, module, thread_stack_size);
+    return __wbg_finalize_init(instance, module);
 }
 
-async function __wbg_init(module_or_path, memory) {
+async function __wbg_init(module_or_path) {
     if (wasm !== undefined) return wasm;
 
-    let thread_stack_size
+
     if (typeof module_or_path !== 'undefined') {
         if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
-            ({module_or_path, memory, thread_stack_size} = module_or_path)
+            ({module_or_path} = module_or_path)
         } else {
             console.warn('using deprecated parameters for the initialization function; pass a single object instead')
         }
@@ -3081,7 +3231,7 @@ async function __wbg_init(module_or_path, memory) {
     if (typeof module_or_path === 'undefined') {
         module_or_path = new URL('ifc-lite_bg.wasm', import.meta.url);
     }
-    const imports = __wbg_get_imports(memory);
+    const imports = __wbg_get_imports();
 
     if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
         module_or_path = fetch(module_or_path);
@@ -3089,7 +3239,7 @@ async function __wbg_init(module_or_path, memory) {
 
     const { instance, module } = await __wbg_load(await module_or_path, imports);
 
-    return __wbg_finalize_init(instance, module, thread_stack_size);
+    return __wbg_finalize_init(instance, module);
 }
 
 export { initSync };