@ifc-lite/wasm 3.0.7 → 3.0.9

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -131,6 +131,34 @@ export class IfcAPI {
    * ```
    */
   exportObj(content: Uint8Array, include_normals: boolean, hidden: Uint32Array, isolated: Uint32Array): Uint8Array;
+  /**
+   * 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.
+   *
+   * Mirrors the `setEntityIndex` lifecycle: called once per worker per load,
+   * and REPLACES the previous file wholesale (repeated calls swap the bytes),
+   * so a parser/geometry worker reusing one `IfcAPI` across loads is safe.
+   * The bytes must be the exact source the batch jobs' byte spans index into
+   * (the same buffer passed as `data` to the legacy `processGeometryBatch*`),
+   * or the decoded entities won't match — the JS worker installs its own
+   * session buffer, so this holds by construction.
+   *
+   * Taking `Vec<u8>` (by value) means wasm-bindgen hands us ownership of the
+   * single JS→wasm copy directly; we wrap it in `Arc` with no second copy.
+   */
+  setSourceBytes(data: Uint8Array): void;
+  /**
+   * Like [`IfcAPI::process_geometry_batch`] but reads the source bytes held by
+   * [`IfcAPI::set_source_bytes`] instead of taking `data`. Byte-for-byte
+   * identical output — it delegates to the legacy twin with the held slice.
+   */
+  processGeometryBatchFromSource(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, plane_angle_to_radians?: number | null, material_element_ids?: Uint32Array | null, material_color_counts?: Uint32Array | null, material_colors_rgba?: Uint8Array | null): MeshCollection;
+  /**
+   * Like [`IfcAPI::process_geometry_batch_partitioned`] but reads the source
+   * bytes held by [`IfcAPI::set_source_bytes`] instead of taking `data`.
+   * Byte-for-byte identical output — it delegates to the legacy twin.
+   */
+  processGeometryBatchPartitionedFromSource(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, plane_angle_to_radians?: number | null, material_element_ids?: Uint32Array | null, material_color_counts?: Uint32Array | null, material_colors_rgba?: Uint8Array | null): PartitionedBatch;
   /**
    * Process geometry for a subset of pre-scanned entities → flat
    * MeshCollection. Takes raw bytes + pre-pass data from buildPrePassOnce.
@@ -378,6 +406,52 @@ export class IfcAPI {
    * Recovers a poisoned cache Mutex instead of panicking; see `mod_tests.rs`.
    */
   clearPrePassCache(): void;
+  /**
+   * Install the pre-computed set of `IfcRepresentationMap` ids referenced by
+   * an `IfcMappedItem` (issue #957), so the worker's first type-product batch
+   * SKIPS the per-worker [`Self::get_or_build_referenced_repmaps`] full-file
+   * walk. The streaming pre-pass built the same set once from the
+   * `IfcMappedItem` spans it already scanned (see
+   * `styling::build_referenced_representation_maps_from_spans`) and ships the
+   * id list here — bit-identical to what each worker would compute, since a
+   * set's membership is order-invariant and consumers only call `.contains`.
+   *
+   * Installed AFTER `setEntityIndex` (which clears this cache on content
+   * swap), so the injected value survives. When this setter is never called
+   * (native path, non-streaming callers), the lazy build path is unchanged.
+   */
+  setReferencedRepmaps(ids: Uint32Array): void;
+  /**
+   * Install the pre-computed #1623 Phase 3 don't-bake plan: the flat list of
+   * `IfcRepresentationMap` ids that an `IfcMappedItem` instantiates >= 2 times.
+   * The streaming pre-pass tallies it in the SAME scan that builds the referenced-
+   * repmap set (`styling::build_mapped_instance_plan_from_spans`) and ships the id
+   * list here. The batch path arms its router with it (batch-local template mode),
+   * so a repeated single-solid mapped source materializes ONCE per batch and the
+   * rest ride as instances in the IFNS shard.
+   *
+   * Same injection contract as [`Self::set_referenced_repmaps`]: installed after
+   * `setEntityIndex` (which clears it on content swap), and a no-op absence leaves
+   * the batch path materializing every occurrence (byte-identical). Each id is
+   * stored as `(2, id)` — the batch-local router only needs the eligibility set
+   * (count >= 2); the min-id template slot is unused in batch-local mode.
+   */
+  setMappedInstancePlan(source_ids: Uint32Array): void;
+  /**
+   * Install the pre-computed [`ifc_lite_geometry::MaterialLayerIndex`] (#563)
+   * from its flat SoA encoding, so the worker's first batch skips the
+   * per-worker [`Self::get_or_build_material_layer_index`] full-file decode
+   * scan (the dominant first-batch cost on layered architectural models,
+   * which run this on the DEFAULT view). The streaming pre-pass built the
+   * index once from the `IfcRelAssociatesMaterial` spans it already scanned
+   * (`MaterialLayerIndex::from_spans`) and flat-encoded it here; the flat
+   * encoding round-trips bit-for-bit (proven in `material_layer_index` tests),
+   * so the injected index equals each worker's `from_content` result.
+   *
+   * Same injection contract as [`Self::set_referenced_repmaps`]: installed
+   * after `setEntityIndex`, and a no-op absence leaves the lazy build intact.
+   */
+  setMaterialLayerIndex(element_ids: Uint32Array, axis: Uint32Array, layer_counts: Uint32Array, direction_sense: Float64Array, offset: Float64Array, layer_material_ids: Uint32Array, layer_thicknesses: Float64Array): void;
   /**
    * Enable or disable the PARAMETRIC rectangular-opening fast path (the
    * placement-frame, ground-truth-exact analytic cut) for `processGeometryBatch`.
@@ -407,6 +481,13 @@ export class IfcAPI {
    * silently rendering at the wrong density.
    */
   setTessellationQuality(level?: string | null): void;
+  /**
+   * Install the pre-computed set of type ids that an `IfcRelDefinesByType`
+   * instantiates (#957 follow-up), so the worker's first type-product batch
+   * skips the per-worker [`Self::get_or_build_instantiated_type_ids`]
+   * full-file walk. Same injection contract as [`Self::set_referenced_repmaps`].
+   */
+  setInstantiatedTypeIds(ids: Uint32Array): void;
   /**
    * Enable or disable per-entity geometry fingerprinting in
    * `processGeometryBatch`, used by the viewer's revision-diff feature.
@@ -1156,16 +1237,23 @@ export interface InitOutput {
   readonly ifcapi_parseGridLines: (a: number, b: number, c: number) => number;
   readonly ifcapi_parseSymbolicRepresentations: (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, 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;
   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_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;
   readonly ifcapi_setComputeGeometryHashes: (a: number, b: number, c: number) => void;
   readonly ifcapi_setEntityIndex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly ifcapi_setInstantiatedTypeIds: (a: number, b: number, c: number) => void;
+  readonly ifcapi_setMappedInstancePlan: (a: number, b: number, c: number) => void;
+  readonly ifcapi_setMaterialLayerIndex: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number) => void;
   readonly ifcapi_setMergeLayers: (a: number, b: number) => void;
   readonly ifcapi_setRectParamFastPath: (a: number, b: number) => void;
+  readonly ifcapi_setReferencedRepmaps: (a: number, b: number, c: number) => void;
   readonly ifcapi_setSkipSmallCuts: (a: number, b: number) => void;
+  readonly ifcapi_setSourceBytes: (a: number, b: number, c: number) => void;
   readonly ifcapi_setTessellationQuality: (a: number, b: number, c: number, d: number) => void;
   readonly ifcapi_version: (a: number, b: number) => void;
   readonly meshOutline2d: (a: number, b: number, c: number, d: number, e: number, f: number) => number;

package/pkg/ifc-lite.js

@@ -795,6 +795,113 @@ export class IfcAPI {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * 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.
+     *
+     * Mirrors the `setEntityIndex` lifecycle: called once per worker per load,
+     * and REPLACES the previous file wholesale (repeated calls swap the bytes),
+     * so a parser/geometry worker reusing one `IfcAPI` across loads is safe.
+     * The bytes must be the exact source the batch jobs' byte spans index into
+     * (the same buffer passed as `data` to the legacy `processGeometryBatch*`),
+     * or the decoded entities won't match — the JS worker installs its own
+     * session buffer, so this holds by construction.
+     *
+     * Taking `Vec<u8>` (by value) means wasm-bindgen hands us ownership of the
+     * single JS→wasm copy directly; we wrap it in `Arc` with no second copy.
+     * @param {Uint8Array} data
+     */
+    setSourceBytes(data) {
+        const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ifcapi_setSourceBytes(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Like [`IfcAPI::process_geometry_batch`] but reads the source bytes held by
+     * [`IfcAPI::set_source_bytes`] instead of taking `data`. Byte-for-byte
+     * identical output — it delegates to the legacy twin with the held slice.
+     * @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
+     * @param {number | null} [plane_angle_to_radians]
+     * @param {Uint32Array | null} [material_element_ids]
+     * @param {Uint32Array | null} [material_color_counts]
+     * @param {Uint8Array | null} [material_colors_rgba]
+     * @returns {MeshCollection}
+     */
+    processGeometryBatchFromSource(jobs_flat, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, void_keys, void_counts, void_values, style_ids, style_colors, plane_angle_to_radians, material_element_ids, material_color_counts, material_colors_rgba) {
+        const ptr0 = passArray32ToWasm0(jobs_flat, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(void_keys, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(void_counts, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray32ToWasm0(void_values, wasm.__wbindgen_export);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray32ToWasm0(style_ids, wasm.__wbindgen_export);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArray8ToWasm0(style_colors, wasm.__wbindgen_export);
+        const len5 = WASM_VECTOR_LEN;
+        var ptr6 = isLikeNone(material_element_ids) ? 0 : passArray32ToWasm0(material_element_ids, wasm.__wbindgen_export);
+        var len6 = WASM_VECTOR_LEN;
+        var ptr7 = isLikeNone(material_color_counts) ? 0 : passArray32ToWasm0(material_color_counts, wasm.__wbindgen_export);
+        var len7 = WASM_VECTOR_LEN;
+        var ptr8 = isLikeNone(material_colors_rgba) ? 0 : passArray8ToWasm0(material_colors_rgba, wasm.__wbindgen_export);
+        var len8 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_processGeometryBatchFromSource(this.__wbg_ptr, ptr0, len0, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, !isLikeNone(plane_angle_to_radians), isLikeNone(plane_angle_to_radians) ? 0 : plane_angle_to_radians, ptr6, len6, ptr7, len7, ptr8, len8);
+        return MeshCollection.__wrap(ret);
+    }
+    /**
+     * Like [`IfcAPI::process_geometry_batch_partitioned`] but reads the source
+     * bytes held by [`IfcAPI::set_source_bytes`] instead of taking `data`.
+     * Byte-for-byte identical output — it delegates to the legacy twin.
+     * @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
+     * @param {number | null} [plane_angle_to_radians]
+     * @param {Uint32Array | null} [material_element_ids]
+     * @param {Uint32Array | null} [material_color_counts]
+     * @param {Uint8Array | null} [material_colors_rgba]
+     * @returns {PartitionedBatch}
+     */
+    processGeometryBatchPartitionedFromSource(jobs_flat, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, void_keys, void_counts, void_values, style_ids, style_colors, plane_angle_to_radians, material_element_ids, material_color_counts, material_colors_rgba) {
+        const ptr0 = passArray32ToWasm0(jobs_flat, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(void_keys, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(void_counts, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray32ToWasm0(void_values, wasm.__wbindgen_export);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray32ToWasm0(style_ids, wasm.__wbindgen_export);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArray8ToWasm0(style_colors, wasm.__wbindgen_export);
+        const len5 = WASM_VECTOR_LEN;
+        var ptr6 = isLikeNone(material_element_ids) ? 0 : passArray32ToWasm0(material_element_ids, wasm.__wbindgen_export);
+        var len6 = WASM_VECTOR_LEN;
+        var ptr7 = isLikeNone(material_color_counts) ? 0 : passArray32ToWasm0(material_color_counts, wasm.__wbindgen_export);
+        var len7 = WASM_VECTOR_LEN;
+        var ptr8 = isLikeNone(material_colors_rgba) ? 0 : passArray8ToWasm0(material_colors_rgba, wasm.__wbindgen_export);
+        var len8 = WASM_VECTOR_LEN;
+        const ret = wasm.ifcapi_processGeometryBatchPartitionedFromSource(this.__wbg_ptr, ptr0, len0, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, !isLikeNone(plane_angle_to_radians), isLikeNone(plane_angle_to_radians) ? 0 : plane_angle_to_radians, ptr6, len6, ptr7, len7, ptr8, len8);
+        return PartitionedBatch.__wrap(ret);
+    }
     /**
      * Process geometry for a subset of pre-scanned entities → flat
      * MeshCollection. Takes raw bytes + pre-pass data from buildPrePassOnce.
@@ -1410,6 +1517,85 @@ export class IfcAPI {
     clearPrePassCache() {
         wasm.ifcapi_clearPrePassCache(this.__wbg_ptr);
     }
+    /**
+     * Install the pre-computed set of `IfcRepresentationMap` ids referenced by
+     * an `IfcMappedItem` (issue #957), so the worker's first type-product batch
+     * SKIPS the per-worker [`Self::get_or_build_referenced_repmaps`] full-file
+     * walk. The streaming pre-pass built the same set once from the
+     * `IfcMappedItem` spans it already scanned (see
+     * `styling::build_referenced_representation_maps_from_spans`) and ships the
+     * id list here — bit-identical to what each worker would compute, since a
+     * set's membership is order-invariant and consumers only call `.contains`.
+     *
+     * Installed AFTER `setEntityIndex` (which clears this cache on content
+     * swap), so the injected value survives. When this setter is never called
+     * (native path, non-streaming callers), the lazy build path is unchanged.
+     * @param {Uint32Array} ids
+     */
+    setReferencedRepmaps(ids) {
+        const ptr0 = passArray32ToWasm0(ids, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ifcapi_setReferencedRepmaps(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Install the pre-computed #1623 Phase 3 don't-bake plan: the flat list of
+     * `IfcRepresentationMap` ids that an `IfcMappedItem` instantiates >= 2 times.
+     * The streaming pre-pass tallies it in the SAME scan that builds the referenced-
+     * repmap set (`styling::build_mapped_instance_plan_from_spans`) and ships the id
+     * list here. The batch path arms its router with it (batch-local template mode),
+     * so a repeated single-solid mapped source materializes ONCE per batch and the
+     * rest ride as instances in the IFNS shard.
+     *
+     * Same injection contract as [`Self::set_referenced_repmaps`]: installed after
+     * `setEntityIndex` (which clears it on content swap), and a no-op absence leaves
+     * the batch path materializing every occurrence (byte-identical). Each id is
+     * stored as `(2, id)` — the batch-local router only needs the eligibility set
+     * (count >= 2); the min-id template slot is unused in batch-local mode.
+     * @param {Uint32Array} source_ids
+     */
+    setMappedInstancePlan(source_ids) {
+        const ptr0 = passArray32ToWasm0(source_ids, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ifcapi_setMappedInstancePlan(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Install the pre-computed [`ifc_lite_geometry::MaterialLayerIndex`] (#563)
+     * from its flat SoA encoding, so the worker's first batch skips the
+     * per-worker [`Self::get_or_build_material_layer_index`] full-file decode
+     * scan (the dominant first-batch cost on layered architectural models,
+     * which run this on the DEFAULT view). The streaming pre-pass built the
+     * index once from the `IfcRelAssociatesMaterial` spans it already scanned
+     * (`MaterialLayerIndex::from_spans`) and flat-encoded it here; the flat
+     * encoding round-trips bit-for-bit (proven in `material_layer_index` tests),
+     * so the injected index equals each worker's `from_content` result.
+     *
+     * Same injection contract as [`Self::set_referenced_repmaps`]: installed
+     * after `setEntityIndex`, and a no-op absence leaves the lazy build intact.
+     * @param {Uint32Array} element_ids
+     * @param {Uint32Array} axis
+     * @param {Uint32Array} layer_counts
+     * @param {Float64Array} direction_sense
+     * @param {Float64Array} offset
+     * @param {Uint32Array} layer_material_ids
+     * @param {Float64Array} layer_thicknesses
+     */
+    setMaterialLayerIndex(element_ids, axis, layer_counts, direction_sense, offset, layer_material_ids, layer_thicknesses) {
+        const ptr0 = passArray32ToWasm0(element_ids, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(axis, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passArray32ToWasm0(layer_counts, wasm.__wbindgen_export);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayF64ToWasm0(direction_sense, wasm.__wbindgen_export);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArrayF64ToWasm0(offset, wasm.__wbindgen_export);
+        const len4 = WASM_VECTOR_LEN;
+        const ptr5 = passArray32ToWasm0(layer_material_ids, wasm.__wbindgen_export);
+        const len5 = WASM_VECTOR_LEN;
+        const ptr6 = passArrayF64ToWasm0(layer_thicknesses, wasm.__wbindgen_export);
+        const len6 = WASM_VECTOR_LEN;
+        wasm.ifcapi_setMaterialLayerIndex(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
+    }
     /**
      * Enable or disable the PARAMETRIC rectangular-opening fast path (the
      * placement-frame, ground-truth-exact analytic cut) for `processGeometryBatch`.
@@ -1457,6 +1643,18 @@ export class IfcAPI {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Install the pre-computed set of type ids that an `IfcRelDefinesByType`
+     * instantiates (#957 follow-up), so the worker's first type-product batch
+     * skips the per-worker [`Self::get_or_build_instantiated_type_ids`]
+     * full-file walk. Same injection contract as [`Self::set_referenced_repmaps`].
+     * @param {Uint32Array} ids
+     */
+    setInstantiatedTypeIds(ids) {
+        const ptr0 = passArray32ToWasm0(ids, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.ifcapi_setInstantiatedTypeIds(this.__wbg_ptr, ptr0, len0);
+    }
     /**
      * Enable or disable per-entity geometry fingerprinting in
      * `processGeometryBatch`, used by the viewer's revision-diff feature.