@ifc-lite/wasm 10.1.2 → 10.3.0

package/README.md

@@ -33,6 +33,23 @@ console.log(`Entities: ${refs.length}`);
 api.free();                           // free the API instance
 ```
 
+`api.extrusionDefinitions(bytes, ids)` returns exact authored
+`IfcExtrudedAreaSolid` sources and placed product occurrences without decoding
+meshes. Omit `ids` for all products, pass `new Uint32Array()` for none, or
+selected product STEP IDs for a filtered view. Repeated mapping targets share a source key while each
+occurrence retains its f64 `world_from_source` matrix and deterministic ordinal.
+Complete sources with valid positive net profile area have
+`nominal_quantities` in raw squared/cubed IFC file units; unsupported or
+invalid sources have `null`.
+For a complete source-profile point, apply `profile_position`, then
+`position_matrix`, then `world_from_source`; the last matrix includes file-unit
+conversion and maps to absolute IFC Z-up metres. An absent optional `Position`
+leaves its matrix field `null`, so use identity for that step when composing
+rather than expecting an identity array. Check `status` before interpreting a
+null matrix; unsupported sources and bounded output are reported by `status`
+and `diagnostics`. CSG operands carry
+`source_modified=true` because their final body can differ.
+
 ## Meshes (pre-pass + job batches)
 
 Geometry runs as a single pre-pass (one scan that produces a flat job list
@@ -219,3 +236,34 @@ the versioned behavior.
 Combined fill and dashed-stroke paints can still refuse atomically when
 multiple run boundaries produce crossings outside the current fill-region
 qualifier.
+
+## Retained alignment station frames
+
+`AlignmentAxisJs` evaluates one `IfcAlignment` through the canonical Rust
+evaluator. Its `GlobalId` and `Name` properties use exact IFC EXPRESS names;
+`expressId`, `geometricHorizontalLengthMeters` and `approximate` are derived
+metadata. The caller owns the handle and must call `free()` in `finally`.
+
+```ts
+import init, { AlignmentAxisJs } from '@ifc-lite/wasm';
+
+await init();
+const content = await (await fetch('alignment.ifc')).text();
+const axis = new AlignmentAxisJs(content, 39);
+try {
+  const sample = axis.evaluate(10);
+  console.log(axis.GlobalId, axis.Name, sample);
+} finally {
+  axis.free();
+}
+```
+
+`evaluate(distanceMeters)` returns a `Float64Array` containing horizontal
+distance, absolute IFC Z-up point X/Y/Z in metres, and normalized world tangent
+X/Y/Z. Distance is alignment-local geometric horizontal length from the physical
+start, independent of authored chainage and different from 3D arc length. No
+renderer origin or axis conversion is applied. Nonfinite or out-of-range
+distances and unresolved units, curves or placements fail explicitly. The
+`approximate` flag identifies supported approximation paths; it must be exposed
+to precision-sensitive consumers. Whole-source parsing belongs in a disposable
+worker when used by the viewer, so releasing the tool also releases WASM pages.

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -132,6 +132,72 @@ export interface LandXmlPipeJs { source_id: string; source_path: string; name: s
 
 
 
+export type AnalyticStatusJs = { type: "complete" } | { type: "unsupported"; reason: string };
+export type AnalyticSourceContextJs =
+| { kind: "direct"; representation_id: number }
+| { kind: "mapped"; representation_map_path: number[] };
+export interface AnalyticSourceKeyJs {
+    model_sha256: string; schema: string | null; length_unit_scale_bits: string;
+    context: AnalyticSourceContextJs; solid_id: number;
+}
+export type AnalyticCurveSegmentJs =
+| { type: "line"; start: number[]; end: number[] }
+| { type: "arc"; center: number[]; normal: number[]; x_axis: number[];
+radius: number; start_angle: number; sweep_angle: number };
+export interface AnalyticProfileLoopJs {
+    kind: "outer" | "inner"; segments: AnalyticCurveSegmentJs[];
+    signed_area: number; perimeter: number;
+}
+export interface AnalyticProfileJs {
+    profile_id: number; ifc_type_name: string; ProfileType: string | null;
+    Position: number | null; profile_position: number[] | null;
+    loops: AnalyticProfileLoopJs[]; status: AnalyticStatusJs;
+}
+export interface AnalyticExtrusionJs {
+    solid_id: number; SweptArea: number | null; profile: AnalyticProfileJs | null;
+    Position: number | null; position_matrix: number[] | null;
+    ExtrudedDirection: number | null; DirectionRatios: number[] | null;
+    axis_unit_vector: number[] | null; Depth: number | null; status: AnalyticStatusJs;
+}
+export interface ExtrusionNominalQuantitiesJs {
+    profile_area: number; projected_height: number; nominal_volume: number;
+}
+export interface ExtrusionDefinitionJs {
+    key: AnalyticSourceKeyJs; source: AnalyticExtrusionJs;
+    /** Squared/cubed IFC file-length units; null for unsupported or invalid sources. */
+    nominal_quantities: ExtrusionNominalQuantitiesJs | null;
+}
+export interface ExtrusionInstanceJs {
+    ordinal: number; source: AnalyticSourceKeyJs; product_id: number;
+    solid_id: number; mapping_path: number[]; source_modified: boolean;
+    world_from_source: number[] | null; status: AnalyticStatusJs;
+}
+export interface ExtrusionDefinitionsJs {
+    up_axis: "Z"; source_units: "ifc_file_length_units"; world_units: "m";
+    coordinate_space: "absolute_ifc_world"; model_sha256: string;
+    schema: string | null; length_unit_scale: number;
+    sources: ExtrusionDefinitionJs[];
+    instances: Record<number, ExtrusionInstanceJs[]>; diagnostics: string[];
+}
+
+
+
+export class AlignmentAxisJs {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * [horizontal distance, IFC Z-up point XYZ, normalized world tangent XYZ].
+     * Coordinates remain f64 absolute metres; no renderer origin is applied.
+     */
+    evaluate(distance_m: number): Float64Array;
+    constructor(content: string, express_id: number);
+    readonly GlobalId: string | undefined;
+    readonly Name: string | undefined;
+    readonly approximate: boolean;
+    readonly expressId: number;
+    readonly geometricHorizontalLengthMeters: number;
+}
+
 /**
  * The overlap solid of one clashing pair, or the reason there is none.
  */
@@ -684,8 +750,13 @@ export class IfcAPI {
      * when a filter matched nothing (#4659, the STEP twin of #4483/#4484). When
      * set, the forward `#`-reference closure is added so the subset never dangles
      * a reference.
-     * `mutations_json` carries `MutablePropertyView` edits (attribute updates +
-     * property-set synthesis); empty ⇒ none. See `export_step_json` for the shape.
+     * `mutations_json` carries `MutablePropertyView` edits; empty ⇒ none. It is
+     * either the mutation log `MutablePropertyView.exportMutations()` returns
+     * (an object with a `mutations` array, optionally `newEntities` and
+     * `georefMutations`), written with byte parity to the TypeScript
+     * `StepExporter` (#5941), or the older pre-serialized
+     * `{ attributeUpdates, propertyMutations }` shape. A log does not combine
+     * with `included`. See `export_step_json` for both shapes.
      * A non-empty but malformed `mutations_json` throws rather than silently
      * exporting the model with none of the caller's edits applied — mirrors
      * `exportGlb`'s and `exportMerged`'s fail-closed contract on this same API.
@@ -720,6 +791,22 @@ export class IfcAPI {
      * ```
      */
     extractProfiles(content: string, model_index: number): ProfileCollection;
+    /**
+     * Return authored swept-disk occurrences, including exact line/arc
+     * directrices and derived measurements, in absolute IFC Z-up metres.
+     * `ids` contains product STEP IDs; omit it for all products or pass an
+     * empty `Uint32Array` for none. Unsupported records keep their status and
+     * a null `directrix_metrics`; malformed representation walks report a
+     * diagnostic and omit that product atomically.
+     */
+    extractSweptDiskDescriptions(content: Uint8Array, ids?: Uint32Array | null): any;
+    /**
+     * `ids` is an optional product STEP-ID filter; `None` selects all and
+     * `Some([])` selects no products, matching the Rust and Python APIs.
+     * Matrices are column-major f64; profile_position and position_matrix are
+     * applied before world_from_source. No mesh is decoded on this path.
+     */
+    extrusionDefinitions(content: Uint8Array, ids?: Uint32Array | null): ExtrusionDefinitionsJs;
     /**
      * Sharded pre-pass: merge the shard-resolved styled-item columns with the
      * SUPPORT spans (extracted host-side from the shard classes) and run the
@@ -728,7 +815,9 @@ export class IfcAPI {
      * Span arguments are `[id, start, len]` triples; `plane_angle_to_radians`
      * comes from the meta event. `orphanColors` / `geomColors` carry exactly
      * four floats per id in `orphanIds` / `geomIds`; any other length throws
-     * before either column is read.
+     * before either column is read. The payload's `styleFinishes` come from
+     * the geometry finishes a preceding `setPrepassGeometryFinishes` stashed
+     * (consumed here); without that call they are all NaN.
      */
     finalizePrepassStyles(data: Uint8Array, orphan_ids: Uint32Array, orphan_colors: Float32Array, geom_ids: Uint32Array, geom_colors: Float32Array, colour_map_spans: Uint32Array, material_def_spans: Uint32Array, rel_material_spans: Uint32Array, void_spans: Uint32Array, fills_spans: Uint32Array, aggregate_spans: Uint32Array, plane_angle_to_radians: number): any;
     /**
@@ -864,6 +953,11 @@ export class IfcAPI {
      * Does not mutate the IFC snapshot or decode the host-owned image.
      */
     planCapturedMesh(content: Uint8Array, request_json: string): Uint8Array;
+    /**
+     * Plan opt-in map similarity normalization on a completed STEP export.
+     * Returns entity patches, allocated IDs and atomic refusal warnings as JSON.
+     */
+    planMapConversionNormalization(content: Uint8Array): string;
     /**
      * Registered mesh observations over canonical target albedo. Host verifies
      * original GLB identity against decoded source mesh/image and freezes frames.
@@ -970,7 +1064,10 @@ export class IfcAPI {
      * Sharded pre-pass: resolve ONE contiguous (file-ordered) slice of the
      * styled-item span list on this worker, against the entity index installed
      * by `setEntityIndex`. Returns raw resolved maps as flat columns:
-     * `{ orphanIds, orphanColors (f32 rgba per id), geomIds, geomColors }`.
+     * `{ orphanIds, orphanColors (f32 rgba per id), geomIds, geomColors,
+     * geomFinishes }`, where `geomFinishes` is the #5582 `[metallic,
+     * roughness]` pair per `geomIds` entry (NaN when unauthored), from
+     * `resolve_geometry_finishes` over this slice.
      * The host merges shard results IN SHARD ORDER with first-wins per
      * geometry id, reproducing the serial resolver's file-order precedence,
      * then hands the merged columns to `finalizePrepassStyles`.
@@ -1138,6 +1235,15 @@ export class IfcAPI {
      * Default is `false`. Pass `true` before calling `processGeometryBatch`.
      */
     setMergeLayers(enabled: boolean): void;
+    /**
+     * Sharded pre-pass (#5582): stash the shard-merged geometry finishes —
+     * the `geomFinishes` columns `resolveStyledItemsShard` returns, merged
+     * first-wins like `geomColors` — for the next `finalizePrepassStyles` /
+     * `finalizePrepassStylesFromSource` call on this instance, which consumes
+     * them and emits the aligned `styleFinishes`. Without this call that
+     * finalize emits NaN finishes, as it always emitted colours only.
+     */
+    setPrepassGeometryFinishes(geom_ids: Uint32Array, geom_finishes: Float32Array): void;
     /**
      * Enable or disable the PARAMETRIC rectangular-opening fast path (the
      * placement-frame, ground-truth-exact analytic cut) for `processGeometryBatch`.
@@ -1193,6 +1299,22 @@ export class IfcAPI {
      * single JS→wasm copy directly; we wrap it in `Arc` with no second copy.
      */
     setSourceBytes(data: Uint8Array): void;
+    /**
+     * Install the prepass's authored metallic/roughness per style (#5582):
+     * `styleFinishes` carries two floats per `styleIds` entry,
+     * `[metallic, roughness]`, NaN for an unauthored field — the
+     * `styleFinishes` array every prepass result carries beside `styleColors`.
+     * Call it with the same `styleIds` later passed to `processGeometryBatch*`;
+     * finishes set for a different style wire are ignored. Empty arrays clear
+     * them. Malformed lengths never throw: a style without a complete pair
+     * simply gets no finish.
+     *
+     * The batch stamps each returned `MeshDataJs` (`metallic` / `roughness`)
+     * from these, taking each mesh's finish from the style its colour came
+     * from (#5984). Occurrences that ride the instanced (IFNS) shard carry
+     * theirs in the shard's per-instance finish field (v3).
+     */
+    setStyleFinishes(style_ids: Uint32Array, style_finishes: Float32Array): void;
     /**
      * Select the tessellation detail level applied by every subsequent
      * `processGeometryBatch` call (issue #976, step 4).
@@ -1492,6 +1614,10 @@ export class MeshDataJs {
      * `IfcMaterial` layer sliced, or `undefined` (#3199).
      */
     readonly materialId: number | undefined;
+    /**
+     * IFC-authored metallic/roughness (#5582). `undefined` when unauthored.
+     */
+    readonly metallic: number | undefined;
     /**
      * Get normals as Float32Array (copy to JS)
      */
@@ -1506,6 +1632,7 @@ export class MeshDataJs {
      * Get positions as Float32Array (copy to JS)
      */
     readonly positions: Float32Array;
+    readonly roughness: number | undefined;
     /**
      * Optional SurfaceColour for the "Shading" GLB-export choice — only
      * present when the file authored a distinct DiffuseColour. JS sees
@@ -2296,6 +2423,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __wbg_alignmentaxisjs_free: (a: number, b: number) => void;
     readonly __wbg_clashintersectionsolidjs_free: (a: number, b: number) => void;
     readonly __wbg_clashrunresult_free: (a: number, b: number) => void;
     readonly __wbg_clashsession_free: (a: number, b: number) => void;
@@ -2319,6 +2447,13 @@ export interface InitOutput {
     readonly __wbg_symbolictext_free: (a: number, b: number) => void;
     readonly __wbg_zonepiecejs_free: (a: number, b: number) => void;
     readonly __wbg_zonesplitjs_free: (a: number, b: number) => void;
+    readonly alignmentaxisjs_GlobalId: (a: number, b: number) => void;
+    readonly alignmentaxisjs_Name: (a: number, b: number) => void;
+    readonly alignmentaxisjs_approximate: (a: number) => number;
+    readonly alignmentaxisjs_evaluate: (a: number, b: number, c: number) => void;
+    readonly alignmentaxisjs_expressId: (a: number) => number;
+    readonly alignmentaxisjs_geometricHorizontalLengthMeters: (a: number) => number;
+    readonly alignmentaxisjs_new: (a: number, b: number, c: number, d: number) => void;
     readonly clashIntersectionSolid: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => number;
     readonly clashintersectionsolidjs_degenerateReason: (a: number, b: number) => void;
     readonly clashintersectionsolidjs_indices: (a: number, b: number) => void;
@@ -2383,6 +2518,8 @@ export interface InitOutput {
     readonly ifcapi_exportStep: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
     readonly ifcapi_exportUsd: (a: number, b: number, c: number, d: number) => void;
     readonly ifcapi_extractProfiles: (a: number, b: number, c: number, d: number) => number;
+    readonly ifcapi_extractSweptDiskDescriptions: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly ifcapi_extrusionDefinitions: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_finalizePrepassStyles: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number, k: number, l: number, m: number, n: number, o: number, p: number, q: number, r: number, s: number, t: number, u: number, v: number, w: number, x: number, y: number) => void;
     readonly ifcapi_finalizePrepassStylesFromSource: (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_getMemory: (a: number) => number;
@@ -2404,6 +2541,7 @@ export interface InitOutput {
     readonly ifcapi_planAnnotationPlane: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_planAppearance: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly ifcapi_planCapturedMesh: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly ifcapi_planMapConversionNormalization: (a: number, b: number, c: number, d: number) => void;
     readonly ifcapi_planMeshTransfer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly ifcapi_planPageAppearance: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly ifcapi_planPdfFillAnnotation: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
@@ -2430,10 +2568,12 @@ export interface InitOutput {
     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_setPrepassGeometryFinishes: (a: number, b: number, c: number, d: number, e: 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_setStyleFinishes: (a: number, b: number, c: number, d: number, e: number) => void;
     readonly ifcapi_setTessellationQuality: (a: number, b: number, c: number, d: number) => void;
     readonly ifcapi_simplifyMeshes: (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_version: (a: number, b: number) => void;
@@ -2475,9 +2615,11 @@ export interface InitOutput {
     readonly meshdatajs_localBounds: (a: number, b: number) => void;
     readonly meshdatajs_localToWorld: (a: number, b: number) => void;
     readonly meshdatajs_materialId: (a: number) => number;
+    readonly meshdatajs_metallic: (a: number) => number;
     readonly meshdatajs_normals: (a: number) => number;
     readonly meshdatajs_origin: (a: number) => number;
     readonly meshdatajs_positions: (a: number) => number;
+    readonly meshdatajs_roughness: (a: number) => number;
     readonly meshdatajs_shadingColor: (a: number, b: number) => void;
     readonly meshdatajs_textureHeight: (a: number) => number;
     readonly meshdatajs_textureId: (a: number) => number;

package/pkg/ifc-lite.js

@@ -1,5 +1,125 @@
 /* @ts-self-types="./ifc-lite.d.ts" */
 
+export class AlignmentAxisJs {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        AlignmentAxisJsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_alignmentaxisjs_free(ptr, 0);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get GlobalId() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.alignmentaxisjs_GlobalId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get Name() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.alignmentaxisjs_Name(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            let v1;
+            if (r0 !== 0) {
+                v1 = getStringFromWasm0(r0, r1).slice();
+                wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            }
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    get approximate() {
+        const ret = wasm.alignmentaxisjs_approximate(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * [horizontal distance, IFC Z-up point XYZ, normalized world tangent XYZ].
+     * Coordinates remain f64 absolute metres; no renderer origin is applied.
+     * @param {number} distance_m
+     * @returns {Float64Array}
+     */
+    evaluate(distance_m) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.alignmentaxisjs_evaluate(retptr, this.__wbg_ptr, distance_m);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get expressId() {
+        const ret = wasm.alignmentaxisjs_expressId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get geometricHorizontalLengthMeters() {
+        const ret = wasm.alignmentaxisjs_geometricHorizontalLengthMeters(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {string} content
+     * @param {number} express_id
+     */
+    constructor(content, express_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(content, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.alignmentaxisjs_new(retptr, ptr0, len0, express_id);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            AlignmentAxisJsFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) AlignmentAxisJs.prototype[Symbol.dispose] = AlignmentAxisJs.prototype.free;
+
 /**
  * The overlap solid of one clashing pair, or the reason there is none.
  */
@@ -1475,8 +1595,13 @@ export class IfcAPI {
      * when a filter matched nothing (#4659, the STEP twin of #4483/#4484). When
      * set, the forward `#`-reference closure is added so the subset never dangles
      * a reference.
-     * `mutations_json` carries `MutablePropertyView` edits (attribute updates +
-     * property-set synthesis); empty ⇒ none. See `export_step_json` for the shape.
+     * `mutations_json` carries `MutablePropertyView` edits; empty ⇒ none. It is
+     * either the mutation log `MutablePropertyView.exportMutations()` returns
+     * (an object with a `mutations` array, optionally `newEntities` and
+     * `georefMutations`), written with byte parity to the TypeScript
+     * `StepExporter` (#5941), or the older pre-serialized
+     * `{ attributeUpdates, propertyMutations }` shape. A log does not combine
+     * with `included`. See `export_step_json` for both shapes.
      * A non-empty but malformed `mutations_json` throws rather than silently
      * exporting the model with none of the caller's edits applied — mirrors
      * `exportGlb`'s and `exportMerged`'s fail-closed contract on this same API.
@@ -1500,6 +1625,11 @@ export class IfcAPI {
             wasm.ifcapi_exportStep(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            if (r3) {
+                throw takeObject(r2);
+            }
             var v5 = getArrayU8FromWasm0(r0, r1).slice();
             wasm.__wbindgen_export4(r0, r1 * 1, 1);
             return v5;
@@ -1560,6 +1690,64 @@ export class IfcAPI {
         const ret = wasm.ifcapi_extractProfiles(this.__wbg_ptr, ptr0, len0, model_index);
         return ProfileCollection.__wrap(ret);
     }
+    /**
+     * Return authored swept-disk occurrences, including exact line/arc
+     * directrices and derived measurements, in absolute IFC Z-up metres.
+     * `ids` contains product STEP IDs; omit it for all products or pass an
+     * empty `Uint32Array` for none. Unsupported records keep their status and
+     * a null `directrix_metrics`; malformed representation walks report a
+     * diagnostic and omit that product atomically.
+     * @param {Uint8Array} content
+     * @param {Uint32Array | null} [ids]
+     * @returns {any}
+     */
+    extractSweptDiskDescriptions(content, ids) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(ids) ? 0 : passArray32ToWasm0(ids, wasm.__wbindgen_export);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.ifcapi_extractSweptDiskDescriptions(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * `ids` is an optional product STEP-ID filter; `None` selects all and
+     * `Some([])` selects no products, matching the Rust and Python APIs.
+     * Matrices are column-major f64; profile_position and position_matrix are
+     * applied before world_from_source. No mesh is decoded on this path.
+     * @param {Uint8Array} content
+     * @param {Uint32Array | null} [ids]
+     * @returns {ExtrusionDefinitionsJs}
+     */
+    extrusionDefinitions(content, ids) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(ids) ? 0 : passArray32ToWasm0(ids, wasm.__wbindgen_export);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.ifcapi_extrusionDefinitions(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Sharded pre-pass: merge the shard-resolved styled-item columns with the
      * SUPPORT spans (extracted host-side from the shard classes) and run the
@@ -1568,7 +1756,9 @@ export class IfcAPI {
      * Span arguments are `[id, start, len]` triples; `plane_angle_to_radians`
      * comes from the meta event. `orphanColors` / `geomColors` carry exactly
      * four floats per id in `orphanIds` / `geomIds`; any other length throws
-     * before either column is read.
+     * before either column is read. The payload's `styleFinishes` come from
+     * the geometry finishes a preceding `setPrepassGeometryFinishes` stashed
+     * (consumed here); without that call they are all NaN.
      * @param {Uint8Array} data
      * @param {Uint32Array} orphan_ids
      * @param {Float32Array} orphan_colors
@@ -2073,6 +2263,38 @@ export class IfcAPI {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Plan opt-in map similarity normalization on a completed STEP export.
+     * Returns entity patches, allocated IDs and atomic refusal warnings as JSON.
+     * @param {Uint8Array} content
+     * @returns {string}
+     */
+    planMapConversionNormalization(content) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(content, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.ifcapi_planMapConversionNormalization(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr2 = r0;
+            var len2 = r1;
+            if (r3) {
+                ptr2 = 0; len2 = 0;
+                throw takeObject(r2);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+        }
+    }
     /**
      * Registered mesh observations over canonical target albedo. Host verifies
      * original GLB identity against decoded source mesh/image and freezes frames.
@@ -2587,7 +2809,10 @@ export class IfcAPI {
      * Sharded pre-pass: resolve ONE contiguous (file-ordered) slice of the
      * styled-item span list on this worker, against the entity index installed
      * by `setEntityIndex`. Returns raw resolved maps as flat columns:
-     * `{ orphanIds, orphanColors (f32 rgba per id), geomIds, geomColors }`.
+     * `{ orphanIds, orphanColors (f32 rgba per id), geomIds, geomColors,
+     * geomFinishes }`, where `geomFinishes` is the #5582 `[metallic,
+     * roughness]` pair per `geomIds` entry (NaN when unauthored), from
+     * `resolve_geometry_finishes` over this slice.
      * The host merges shard results IN SHARD ORDER with first-wins per
      * geometry id, reproducing the serial resolver's file-order precedence,
      * then hands the merged columns to `finalizePrepassStyles`.
@@ -2890,6 +3115,23 @@ export class IfcAPI {
     setMergeLayers(enabled) {
         wasm.ifcapi_setMergeLayers(this.__wbg_ptr, enabled);
     }
+    /**
+     * Sharded pre-pass (#5582): stash the shard-merged geometry finishes —
+     * the `geomFinishes` columns `resolveStyledItemsShard` returns, merged
+     * first-wins like `geomColors` — for the next `finalizePrepassStyles` /
+     * `finalizePrepassStylesFromSource` call on this instance, which consumes
+     * them and emits the aligned `styleFinishes`. Without this call that
+     * finalize emits NaN finishes, as it always emitted colours only.
+     * @param {Uint32Array} geom_ids
+     * @param {Float32Array} geom_finishes
+     */
+    setPrepassGeometryFinishes(geom_ids, geom_finishes) {
+        const ptr0 = passArray32ToWasm0(geom_ids, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(geom_finishes, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.ifcapi_setPrepassGeometryFinishes(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
     /**
      * Enable or disable the PARAMETRIC rectangular-opening fast path (the
      * placement-frame, ground-truth-exact analytic cut) for `processGeometryBatch`.
@@ -2961,6 +3203,30 @@ export class IfcAPI {
         const len0 = WASM_VECTOR_LEN;
         wasm.ifcapi_setSourceBytes(this.__wbg_ptr, ptr0, len0);
     }
+    /**
+     * Install the prepass's authored metallic/roughness per style (#5582):
+     * `styleFinishes` carries two floats per `styleIds` entry,
+     * `[metallic, roughness]`, NaN for an unauthored field — the
+     * `styleFinishes` array every prepass result carries beside `styleColors`.
+     * Call it with the same `styleIds` later passed to `processGeometryBatch*`;
+     * finishes set for a different style wire are ignored. Empty arrays clear
+     * them. Malformed lengths never throw: a style without a complete pair
+     * simply gets no finish.
+     *
+     * The batch stamps each returned `MeshDataJs` (`metallic` / `roughness`)
+     * from these, taking each mesh's finish from the style its colour came
+     * from (#5984). Occurrences that ride the instanced (IFNS) shard carry
+     * theirs in the shard's per-instance finish field (v3).
+     * @param {Uint32Array} style_ids
+     * @param {Float32Array} style_finishes
+     */
+    setStyleFinishes(style_ids, style_finishes) {
+        const ptr0 = passArray32ToWasm0(style_ids, wasm.__wbindgen_export);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArrayF32ToWasm0(style_finishes, wasm.__wbindgen_export);
+        const len1 = WASM_VECTOR_LEN;
+        wasm.ifcapi_setStyleFinishes(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    }
     /**
      * Select the tessellation detail level applied by every subsequent
      * `processGeometryBatch` call (issue #976, step 4).
@@ -3634,6 +3900,14 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_materialId(this.__wbg_ptr);
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
+    /**
+     * IFC-authored metallic/roughness (#5582). `undefined` when unauthored.
+     * @returns {number | undefined}
+     */
+    get metallic() {
+        const ret = wasm.meshdatajs_metallic(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Get normals as Float32Array (copy to JS)
      * @returns {Float32Array}
@@ -3660,6 +3934,13 @@ export class MeshDataJs {
         const ret = wasm.meshdatajs_positions(this.__wbg_ptr);
         return takeObject(ret);
     }
+    /**
+     * @returns {number | undefined}
+     */
+    get roughness() {
+        const ret = wasm.meshdatajs_roughness(this.__wbg_ptr);
+        return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
+    }
     /**
      * Optional SurfaceColour for the "Shading" GLB-export choice — only
      * present when the file authored a distinct DiffuseColour. JS sees
@@ -6239,6 +6520,9 @@ function __wbg_get_imports() {
     };
 }
 
+const AlignmentAxisJsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_alignmentaxisjs_free(ptr, 1));
 const ClashIntersectionSolidJsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_clashintersectionsolidjs_free(ptr, 1));