@ifc-lite/wasm 10.3.0 → 10.5.0

package/README.md

@@ -10,6 +10,16 @@ Pre-built WebAssembly bindings for the IFClite Rust core, covering STEP parsing
 npm install @ifc-lite/wasm
 ```
 
+The package includes generated private JavaScript helpers under `pkg/snippets/`
+when the WASM bindings import them. Keep these files beside the generated glue;
+copying only `ifc-lite.js` and the `.wasm` file can leave an incomplete runtime.
+The canonical build and prebuilt fetch generate npm ignore metadata so
+wasm-pack's broad Git ignore does not exclude these helpers from publication.
+`pnpm build:wasm:fetch` validates the static helper dependency closure and runtime
+exports before installation, preserving committed types and an existing runtime
+if validation fails. Validation parses code without evaluating the generated JavaScript.
+Dynamic imports remain lazy and are outside this static dependency check.
+
 ## Direct WASM use
 
 The text-based entity scanner (`scanEntitiesFast`) takes the raw IFC text
@@ -208,6 +218,21 @@ residuals. Frames and asset identities are bound into the report; the call does
 not align a loaded model or approve scan accuracy. See the
 [registration contract](../../docs/api/wasm.md#scan-correspondence-registration).
 
+`IfcAPI.segmentScanPoints` detects planes in an xyz `Float32Array` point cloud
+(voxel means, PCA normals, region growing, a robust refit and coplanar
+merging). It also detects cylinders, such as columns and pipes, among the
+remaining voxels (seeded RANSAC, then a least-squares refit), and wide round
+and polygonal columns among rings of vertical planes; a column's surface is
+not also reported as planes. The JSON report is independent of point order. See the
+[segmentation contract](../../docs/api/wasm.md#scan-plane-segmentation); the
+typed wrapper is `@ifc-lite/geometry/scan-segmentation`.
+
+`IfcAPI.proposeScanElements` turns that report into proposed walls, slabs,
+columns and pipes in the IFC model frame, each with a confidence and its source
+detections; it creates nothing. See the
+[proposal contract](../../docs/api/wasm.md#scan-element-proposals); the typed
+wrapper is `@ifc-lite/geometry/scan-proposals`.
+
 `IfcAPI.planMeshTransfer` composes registered opaque textured-mesh observations
 onto supported direct IFC tessellations using the shared atlas planner. Unknown
 samples retain existing target albedo; the IFPA response includes explicit

package/package.json

@@ -5,7 +5,7 @@
     "IFC-Lite Contributors"
   ],
   "description": "WebAssembly bindings for IFC-Lite",
-  "version": "10.3.0",
+  "version": "10.5.0",
   "license": "MPL-2.0",
   "repository": {
     "type": "git",
@@ -14,7 +14,11 @@
   "files": [
     "pkg/ifc-lite_bg.wasm",
     "pkg/ifc-lite.js",
-    "pkg/ifc-lite.d.ts"
+    "pkg/ifc-lite.d.ts",
+    "pkg/snippets/**",
+    "retained.js",
+    "retained.d.ts",
+    "pkg-retained/ifc-lite.d.ts"
   ],
   "main": "./pkg/ifc-lite.js",
   "module": "./pkg/ifc-lite.js",
@@ -25,7 +29,12 @@
       "import": "./pkg/ifc-lite.js",
       "default": "./pkg/ifc-lite.js"
     },
-    "./ifc-lite_bg.wasm": "./pkg/ifc-lite_bg.wasm"
+    "./ifc-lite_bg.wasm": "./pkg/ifc-lite_bg.wasm",
+    "./retained": {
+      "types": "./retained.d.ts",
+      "import": "./retained.js",
+      "default": "./retained.js"
+    }
   },
   "sideEffects": false,
   "keywords": [

package/pkg/ifc-lite.d.ts

@@ -1,6 +1,55 @@
 /* tslint:disable */
 /* eslint-disable */
 
+/** Every field is optional; absent or `undefined` means the default. Unknown fields and non-finite numbers are refused. Lengths in metres; pass plane coordinates local to the slab (f32 input). */
+export interface ScanOutlineOptionsJs {
+    /** Fixed cell edge; omit to pick it from the point density between minCellSize and maxCellSize. */
+    cellSize?: number;
+    /** Default 0.02, at least 0.001. */ minCellSize?: number;
+    /** Default 0.05. */ maxCellSize?: number;
+    /** Adaptive cells grow until the median occupied cell holds this many points. Default 6. */
+    targetPointsPerCell?: number;
+    /** Cell budget for the padded grid, from (2·pad + 1)² (81 with the defaults) up to 67108864. Default 16777216; hitting it sets diagnostics.cellCapHit. */
+    maxCells?: number;
+    /** Default 1. */ minPointsPerCell?: number;
+    /** A cell is occupied from this fraction of the median occupied-cell count. Default 0.25. */
+    noiseFraction?: number;
+    /** Widest gap the closing bridges, about a wall thickness; clamped to 0.5. Default 0.3. */
+    maxGap?: number;
+    /** Speckle opening radius in cells (0 disables). Default 1. */ openRadiusCells?: number;
+    /** Solid components below this area (m²) are dropped. Default 0.02. */ minComponentArea?: number;
+    /** Enclosed holes below this area (m²) are filled. Default 0.5. */ minHoleArea?: number;
+    /** Douglas-Peucker tolerance in cells. Default 1.5. */ simplifyToleranceCells?: number;
+    /** Refit edges to the points. Default true. */ snap?: boolean;
+    /** Evidence band beside an edge, in cells (at most 16). Default 3. */ snapDistanceCells?: number;
+    /** Fewest points to refit an edge. Default 8. */ minSnapPoints?: number;
+    /** Largest squaring move, in cells (at most 32). Default 4. */ maxVertexMoveCells?: number;
+    /** Square edges to the dominant direction. Default true. */ square?: boolean;
+    /** Default 3. */ squareAngleToleranceDeg?: number;
+    /** Squares edges whose ends move at most this far. Default 0.03. */ squareOffsetTolerance?: number;
+}
+/** world = origin + u * uAxis + v * vAxis */
+export interface ScanOutlinePlaneFrameJs {
+    origin: [number, number, number];
+    uAxis: [number, number, number];
+    vAxis: [number, number, number];
+}
+export interface ScanOutlineDiagnosticsJs {
+    inputPoints: number; usedPoints: number; nonFinitePoints: number; outlierPoints: number;
+    cellSize: number; gridWidth: number; gridHeight: number;
+    cellCapHit: boolean; maxGapClamped: boolean; countThreshold: number;
+    /** f32 step at the largest input coordinate; `coordinatePrecisionDegraded` when above a tenth of a cell. Pass coordinates local to the slab. */
+    coordinateSpacingMetres: number; coordinatePrecisionDegraded: boolean;
+    occupiedCells: number; solidCells: number; componentsDropped: number; holesFilled: number;
+    ringCount: number; outerRingCount: number; holeRingCount: number; vertexCount: number;
+    simplifyReinsertions: number; snappedEdges: number;
+    /** Degrees in [0, 90); absent when no edge was long enough to tell. */
+    dominantAngleDeg?: number;
+    squaredEdges: number; revertedMoves: number;
+}
+
+
+
 /** Exact browser mesh RTC frame, in IFC Z-up metres. */
 export interface RtcFrame {
     x: number;
@@ -11,6 +60,21 @@ export interface RtcFrame {
 
 
 
+export interface LandXmlTerrainOptionsJs {
+    /** `YYYY-MM-DD`, the required `LandXML@date`; the caller owns the clock. */
+    date: string;
+    /** `HH:MM:SS`, the required `LandXML@time`. */
+    time: string;
+    /** Default `'metre'`. US survey feet write elevations in international feet (LandXML 1.2 has no US-survey-foot elevation unit); both are declared. */
+    linearUnit?: 'metre' | 'internationalFoot' | 'usSurveyFoot';
+    /** Decimal places in the written unit, 0 to 9. Default 6. */
+    decimals?: number;
+    /** `Surface@name` per product; a blank name keeps the IFC name. */
+    surfaceNames?: { productId: number; name: string }[];
+}
+
+
+
 export interface LandXmlTinDocumentJs {
     format: "landxml";
     schema: "LandXML-1.0" | "LandXML-1.1" | "LandXML-1.2";
@@ -110,7 +174,8 @@ export interface LandXmlCrossSectionSurfaceJs { source_id: string; parent_cross_
 export interface LandXmlRoadwayJs { source_id: string; ordinal: number; name: string; alignment_refs: string[]; alignment_source_ids: string[]; surface_refs: string[]; surface_source_ids: string[]; grade_model_refs: string[]; }
 export interface LandXmlCapabilityDiagnosticJs { code: string; source_id?: string; source_path: string; message: string; }
 export interface LandXmlPreservedOnlyExtensionJs { source_id: string; parent_source_id?: string; local_name: string; source_path: string; kind: "corridor" | "string_line"; }
-export interface LandXmlPipeUnitsJs { linear_unit: string; elevation_unit: string; diameter_unit: string; width_unit: string; height_unit: string; flow_unit?: string; linear_scale_to_meters: number; elevation_scale_to_meters: number; diameter_scale_to_meters: number; width_scale_to_meters: number; height_scale_to_meters: number; }
+/** `assumed` is true only when these units came from `LandXmlParseOptionsJs.assumedLinearUnit` because the source declares no root LandXML/Units element, never from a declared one (#5175, #7693). */
+export interface LandXmlPipeUnitsJs { linear_unit: string; elevation_unit: string; diameter_unit: string; width_unit: string; height_unit: string; flow_unit?: string; linear_scale_to_meters: number; elevation_scale_to_meters: number; diameter_scale_to_meters: number; width_scale_to_meters: number; height_scale_to_meters: number; assumed: boolean; }
 export interface LandXmlPipeNetworkDocumentJs {
     schema: "LandXML-1.0" | "LandXML-1.1" | "LandXML-1.2"; version: string;
     capability_diagnostics: LandXmlCapabilityDiagnosticJs[];
@@ -621,8 +686,16 @@ export class IfcAPI {
      * out-of-range index copied into the BIN chunk. (The viewer always passes
      * fully-backed, normal-covered, whole-triangle, in-range arrays, so this only
      * fires on a caller bug.)
+     *
+     * `world_matrix` is the frame the meshes were baked in (#7734): 16 finite
+     * numbers, a column-major 4x4 in IFC Z-up metres with `world = M * baked`
+     * (the viewer builds it from `CoordinateInfo`). The GLB root carries it, so
+     * a georeferenced model exports where the from-bytes `exportGlb` puts it
+     * instead of in the render frame. Omit it (`undefined`) for an unshifted
+     * model; a matrix that is not 16 finite numbers throws
+     * `MALFORMED_MESH_INPUT`.
      */
-    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;
+    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, world_matrix?: Float64Array | null): Uint8Array;
     /**
      * Export the `IfcSpace` volumes in `content` as Honeybee **HBJSON** UTF-8 bytes.
      *
@@ -703,6 +776,17 @@ export class IfcAPI {
      * document the 1.4.1 schema rejects, or one with meshes or faces missing.
      */
     exportKmzFromMeshes(positions: Float32Array, normals: Float32Array, indices: Uint32Array, vertex_counts: Uint32Array, index_counts: Uint32Array, colors: Float32Array, origins: Float64Array, latitude: number, longitude: number, altitude: number, x_axis_abscissa: number | null | undefined, x_axis_ordinate: number | null | undefined, name: string, altitude_mode?: string | null): Uint8Array;
+    /**
+     * Export the terrain products `product_ids` (express ids) of `content` as
+     * one LandXML 1.2 document, one `<Surface>` each.
+     *
+     * Returns JSON `{ xml, crsName, surfaces: [{ productId, globalId, name,
+     * points, faces }] }`. A selection that is not an authored triangulated
+     * terrain, or whose georeferencing is missing or ambiguous, throws an
+     * `Error` whose message starts with `TERRAIN_REFUSED:` and names the
+     * reason.
+     */
+    exportLandXmlTerrain(content: Uint8Array, product_ids: Uint32Array, options: LandXmlTerrainOptionsJs): string;
     /**
      * Merge several IFC models into one STEP/IFC UTF-8 byte buffer (`Uint8Array`).
      * `concatenated` is every model's
@@ -727,6 +811,10 @@ export class IfcAPI {
      * for GLB in `export_glb`). A non-empty `Uint32Array` is the ordinary allowlist.
      * Instanced type-library shapes are skipped regardless of the filter.
      *
+     * Fails CLOSED like `exportGlb`: when no mesh is written this throws an
+     * `Error` whose message starts with `NO_RENDER_GEOMETRY`, instead of
+     * returning a header-only OBJ (#7695).
+     *
      * ```javascript
      * const obj = api.exportObj(ifcContent, true, new Uint32Array(), undefined);
      * ```
@@ -766,6 +854,10 @@ export class IfcAPI {
      * Export **OpenUSD** (`.usda` ASCII): a real Z-up USD stage — spatial hierarchy of
      * `Xform` prims, `UsdGeomMesh` geometry, `UsdPreviewSurface` materials, IFC
      * metadata as custom attributes. Whole-model (geometry-backed).
+     *
+     * Fails CLOSED like `exportGlb`: a model with no render geometry throws an
+     * `Error` whose message starts with `NO_RENDER_GEOMETRY`, instead of
+     * returning a stage with nothing to look at (#7695).
      */
     exportUsd(content: Uint8Array): Uint8Array;
     /**
@@ -1055,6 +1147,15 @@ export class IfcAPI {
      * 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;
+    /**
+     * Propose IFC walls, slabs, columns and pipes from a scan segmentation
+     * report (#6894). `report_json` is the JSON `segmentScanPoints`
+     * returned; `options_json` is a camelCase `ScanProposalOptions` object
+     * (`{}` for the defaults; `scanToModel` maps the report's frame into the
+     * IFC model frame). Returns the UTF-8 JSON `ScanProposalReport` in the
+     * model frame (Z up, metres). Pure: loads and changes nothing.
+     */
+    proposeScanElements(report_json: string, options_json: string): Uint8Array;
     /**
      * Fit bounded manual correspondences in source metres -> IFC world Z-up
      * metres, reporting held-out errors separately. Does not load or move models.
@@ -1082,12 +1183,20 @@ export class IfcAPI {
      * Fast entity scanning using SIMD-accelerated Rust scanner
      * Returns array of entity references for data model parsing
      * Much faster than TypeScript byte-by-byte scanning (5-10x speedup)
+     *
+     * The returned array also carries two own properties describing what the
+     * scan refused (#7393): `oversizedIdCount` (records skipped because their
+     * express id does not fit u32, #3395) and `malformedRecordCount` (0 or 1:
+     * whether a record was dropped for having no terminating `;`, #3695).
      */
     scanEntitiesFast(content: string): any;
     /**
      * Fast entity scanning from raw bytes (avoids TextDecoder.decode on JS side).
      * Accepts Uint8Array directly — saves ~2-5s for 487MB files by skipping
      * JS string creation and UTF-16→UTF-8 conversion.
+     *
+     * Carries the same `oversizedIdCount` / `malformedRecordCount` array
+     * properties as `scanEntitiesFast` (#7393).
      */
     scanEntitiesFastBytes(data: Uint8Array): any;
     /**
@@ -1140,6 +1249,13 @@ export class IfcAPI {
      * Much faster than scanning all entities (3x speedup for large files)
      */
     scanGeometryEntitiesFast(content: string): any;
+    /**
+     * Detect planes and cylinders (columns, pipes) in a point cloud (#6870). `positions` are xyz f32 metres
+     * (at most 100,000,000 points); `options_json` is a camelCase
+     * `ScanSegmentationOptions` object (`{}` for the defaults). Returns the
+     * UTF-8 JSON `ScanSegmentationReport`. Pure: loads and changes nothing.
+     */
+    segmentScanPoints(positions: Float32Array, options_json: string): Uint8Array;
     /**
      * Enable or disable per-entity geometry fingerprinting in
      * `processGeometryBatch`, used by the viewer's revision-diff feature.
@@ -1810,6 +1926,50 @@ export class ProfileEntryJs {
     readonly transform: Float32Array;
 }
 
+/**
+ * The traced outline. Owns wasm memory: call `free()`.
+ */
+export class ScanOutlineJs {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Every ring's plane coordinates concatenated, `[u0, v0, u1, v1, …]`.
+     */
+    coords(): Float64Array;
+    /**
+     * What the run did: cell size, cap hits, ring counts, repairs.
+     */
+    diagnostics(): ScanOutlineDiagnosticsJs;
+    /**
+     * Vertex count of each ring, in `coords()` order.
+     */
+    ringLengths(): Uint32Array;
+    /**
+     * The ring directly containing each ring (a hole's outer boundary, an
+     * island's hole), or `-1` at top level.
+     */
+    ringParents(): Int32Array;
+    /**
+     * Ring index at which each shape starts; entry `s` is shape `s`'s outer
+     * ring and the rings up to the next entry are its holes.
+     */
+    shapeOffsets(): Uint32Array;
+    /**
+     * Every ring mapped through the plane frame, `[x0, y0, z0, …]` in
+     * `coords()` order, or `undefined` when no frame was given.
+     */
+    worldCoords(): Float64Array | undefined;
+    /**
+     * Total number of rings (outer boundaries and holes).
+     */
+    readonly ringCount: number;
+    /**
+     * Number of outer boundaries.
+     */
+    readonly shapeCount: number;
+}
+
 /**
  * Flat result of `simplifyMeshes`: per surviving element `i`,
  * `vertexCounts[i]` vertices and `indexCounts[i]` indices taken in order
@@ -2348,6 +2508,14 @@ export function meshOutline2d(positions: Float32Array, indices: Uint32Array, axi
  */
 export function resolve2d(a: Contours2D): Contours2D;
 
+/**
+ * Install (or, with `undefined`, remove) the callback invoked at most once a
+ * second while geometry work is in progress inside a WASM call. It runs
+ * synchronously inside that call, so it must only do something cheap such as
+ * `postMessage`, and must not call back into this module.
+ */
+export function setGeometryProgressCallback(callback?: Function | null): void;
+
 /**
  * Split a mesh into one closed solid per zone, plus the remainder.
  *
@@ -2378,6 +2546,14 @@ export function resolve2d(a: Contours2D): Contours2D;
  * meaningless volumes with a plausible `sumErrorRel`, so the closure proof
  * above is the caller's responsibility and not a formality.
  *
+ * Returns `undefined` when a zone parameter is non-finite, or a mesh vertex
+ * or zone corner lies past ±2^128, the exact kernel's coordinate bound
+ * (#7677): such a split is refused rather than answered wrongly.
+ *
+ * Returns `undefined` if an intersection, zone union or remainder exhausts
+ * the exact kernel's work budget. Completed pieces are not returned as a
+ * successful partial split, and a failed empty piece is not treated as disjoint.
+ *
  * Returns `undefined` when the mesh encloses no volume (no triangles survive
  * the filter above, or the shell is degenerate): there is nothing to split,
  * and a result for it would report `pieceCount` 1, `sumErrorRel` 0 and
@@ -2388,7 +2564,7 @@ export function resolve2d(a: Contours2D): Contours2D;
  * const split = splitMeshByZones(positions, indices, new Float64Array([
  *   0, 0, 0, 10, 10, 10, 0,
  * ]));
- * if (!split) return; // the mesh encloses no volume
+ * if (!split) return; // no usable complete split
  * for (let i = 0; i < split.pieceCount; i++) {
  *   const piece = split.piece(i);
  *   // piece.zoneIndex, piece.positions, piece.indices, piece.volume
@@ -2399,6 +2575,14 @@ export function resolve2d(a: Contours2D): Contours2D;
  */
 export function splitMeshByZones(positions: Float64Array, indices: Uint32Array, zones: Float64Array, footprints?: Float64Array | null, footprint_counts?: Uint32Array | null): ZoneSplitJs | undefined;
 
+/**
+ * Trace closed outlines from slab points given in plane coordinates.
+ *
+ * THROWS on invalid options or plane frame (unknown field, non-finite or
+ * out-of-range value). Points that are not finite are skipped and counted.
+ */
+export function traceScanOutline(plane_xy: Float32Array, options?: ScanOutlineOptionsJs | null, plane_frame?: ScanOutlinePlaneFrameJs | null): ScanOutlineJs;
+
 /**
  * `a ∪ b`.
  */
@@ -2438,6 +2622,7 @@ export interface InitOutput {
     readonly __wbg_partitionedbatch_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_scanoutlinejs_free: (a: number, b: number) => void;
     readonly __wbg_simplifiedmeshes_free: (a: number, b: number) => void;
     readonly __wbg_spaceplatehandle_free: (a: number, b: number) => void;
     readonly __wbg_symboliccircle_free: (a: number, b: number) => void;
@@ -2506,13 +2691,14 @@ export interface InitOutput {
     readonly ifcapi_exportCsv: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly ifcapi_exportDfjson: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_exportGlb: (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) => void;
-    readonly ifcapi_exportGlbFromMeshes: (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) => void;
+    readonly ifcapi_exportGlbFromMeshes: (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) => void;
     readonly ifcapi_exportHbjson: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_exportHbjsonWithStats: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly ifcapi_exportIfcx: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_exportJson: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly ifcapi_exportJsonld: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number) => void;
     readonly ifcapi_exportKmzFromMeshes: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number, z: number, a1: number) => void;
+    readonly ifcapi_exportLandXmlTerrain: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly ifcapi_exportMerged: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly ifcapi_exportObj: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly ifcapi_exportStep: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
@@ -2554,6 +2740,7 @@ 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_proposeScanElements: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_registerScanCorrespondences: (a: number, b: number, c: number, d: number) => void;
     readonly ifcapi_resolveStyledItemsShard: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_resolveStyledItemsShardFromSource: (a: number, b: number, c: number, d: number) => void;
@@ -2562,6 +2749,7 @@ export interface InitOutput {
     readonly ifcapi_scanEntityIndexShard: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly ifcapi_scanEntityIndexShardFromSource: (a: number, b: number, c: number) => number;
     readonly ifcapi_scanGeometryEntitiesFast: (a: number, b: number, c: number) => number;
+    readonly ifcapi_segmentScanPoints: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     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, h: number) => void;
     readonly ifcapi_setInstantiatedTypeIds: (a: number, b: number, c: number) => void;
@@ -2650,6 +2838,15 @@ export interface InitOutput {
     readonly profileentryjs_outerPoints: (a: number) => number;
     readonly profileentryjs_transform: (a: number) => number;
     readonly resolve2d: (a: number) => number;
+    readonly scanoutlinejs_coords: (a: number) => number;
+    readonly scanoutlinejs_diagnostics: (a: number, b: number) => void;
+    readonly scanoutlinejs_ringCount: (a: number) => number;
+    readonly scanoutlinejs_ringLengths: (a: number) => number;
+    readonly scanoutlinejs_ringParents: (a: number) => number;
+    readonly scanoutlinejs_shapeCount: (a: number) => number;
+    readonly scanoutlinejs_shapeOffsets: (a: number) => number;
+    readonly scanoutlinejs_worldCoords: (a: number) => number;
+    readonly setGeometryProgressCallback: (a: number) => void;
     readonly simplifiedmeshes_cavitiesDropped: (a: number, b: number) => void;
     readonly simplifiedmeshes_elementIds: (a: number, b: number) => void;
     readonly simplifiedmeshes_indexCounts: (a: number, b: number) => void;
@@ -2742,6 +2939,7 @@ export interface InitOutput {
     readonly symbolictext_repIdentifier: (a: number, b: number) => void;
     readonly symbolictext_x: (a: number) => number;
     readonly symbolictext_y: (a: number) => number;
+    readonly traceScanOutline: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly union2d: (a: number, b: number) => number;
     readonly version: (a: number) => void;
     readonly zonepiecejs_indices: (a: number) => number;