@ifc-lite/wasm 2.8.0 → 2.9.0

package/package.json

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

package/pkg/ifc-lite.d.ts

@@ -91,7 +91,7 @@ export class IfcAPI {
    * 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;
+  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, plane_angle_to_radians?: number | null, material_element_ids?: Uint32Array | null, material_color_counts?: Uint32Array | null, material_colors_rgba?: Uint8Array | null): MeshCollection;
   /**
    * Streaming pre-pass: emits geometry jobs in chunks via a JS callback
    * instead of waiting for the full file scan to complete.
@@ -117,7 +117,7 @@ export class IfcAPI {
    *   `{ type: "jobs", jobs: Uint32Array }`     // [id, start, end] triples
    *   `{ type: "complete", totalJobs }`
    */
-  buildPrePassStreaming(data: Uint8Array, on_event: Function, chunk_size: number): any;
+  buildPrePassStreaming(data: Uint8Array, on_event: Function, chunk_size: number, disabled_type_names: string[] | null | undefined, skip_type_geometry: boolean): any;
   /**
    * Parse the file and return structured per-axis data (tag + endpoints) in
    * the renderer's Y-up world space (RTC-subtracted, metres). Use this when
@@ -306,9 +306,19 @@ export class MeshCollection {
    */
   hasRtcOffset(): boolean;
   /**
-   * Get mesh at index
+   * Get mesh at index (clones — non-destructive). Prefer `takeMesh` on the
+   * hot streaming path; this stays for callers that read meshes more than once.
    */
   get(index: number): MeshDataJs | undefined;
+  /**
+   * #1097 perf: MOVE the mesh at `index` out of the collection (the Vec
+   * buffers are `std::mem::take`-n, leaving an empty stub). The streaming
+   * worker reads each mesh exactly once, so moving avoids the full vertex-
+   * data clone `get` pays — one fewer copy of positions/normals/indices/uvs/
+   * texture per mesh (the JS getters still do the single Rust→JS copy). Calling
+   * it twice for the same index yields the second call an empty mesh.
+   */
+  takeMesh(index: number): MeshDataJs | undefined;
   /**
    * Get RTC offset X (for converting local coords back to world coords)
    * Add this to local X coordinates to get world X coordinates
@@ -413,6 +423,12 @@ export class MeshDataJs {
    * Get color as [r, g, b, a] array
    */
   readonly color: Float32Array;
+  /**
+   * Per-element local-frame origin (Float64Array[3], WebGL Y-up, metres):
+   * world position of vertex i = `origin + positions[3i..3i+3]`. Returns
+   * [0,0,0] when positions are absolute (legacy / local frame off).
+   */
+  readonly origin: Float64Array;
   /**
    * Get indices as Uint32Array (copy to JS)
    */
@@ -538,10 +554,53 @@ export class SpacePlateHandle {
    * surviving room.
    */
   mergeFaces(edge: number): any;
+  /**
+   * The face outline offset to a wall boundary, as flat `[x0, y0, …]`: each
+   * edge is moved by its own wall's half-thickness — inward when `inset`
+   * (the net / inner face), outward otherwise (the gross / outer face).
+   * Shared room↔room edges are pinned when pushing outward. Falls back to the
+   * centreline outline when no offset applies — so it's always a sane ring.
+   * (For a `center` boundary just use `faceOutline`.)
+   */
+  netOutline(face: number, inset: boolean): Float64Array;
+  /**
+   * Remove a wall edge, choosing the right semantics from its two faces:
+   * two real rooms → union them; a bridge / spur / outer-only wall → delete
+   * it and auto-clean the orphaned inner lines and nodes it leaves; a real
+   * enclosing wall (room ↔ exterior) → rejected (`BordersExterior`). This is
+   * the "remove this wall and tidy up" affordance for the orphan cruft the
+   * non-destructive wall arrangement leaves behind. Returns the rooms it
+   * changed (empty if the edge bounded no room).
+   */
+  removeEdge(edge: number): any;
   /**
    * Flat outline `[x0, y0, x1, y1, …]` of a face (no repeated closing vertex).
    */
   faceOutline(face: number): Float64Array;
+  /**
+   * Face-based gap-room boundary as flat `[x0, y0, …]`: each edge pushed
+   * OUTWARD (into the wall) by `factor × the source wall's half-thickness`.
+   * `0` → net (the gap / inner faces); `1` → centre axis (½ thickness, the
+   * editable node line on the wall mid); `2` → gross outer face.
+   */
+  gapBoundary(face: number, factor: number): Float64Array;
+  /**
+   * Dissolve a degree-2 vertex, welding its two edges into one straight
+   * edge between the neighbours — the inverse of `splitEdge`, and the
+   * "delete this corner / node" affordance. Returns the rooms it changed.
+   * Rejects a wall junction (degree ≥ 3) or a weld that would duplicate an
+   * edge.
+   */
+  dissolveVertex(v: number): any;
+  /**
+   * FACE-BASED build: rooms are the gaps between wall footprint rectangles.
+   * `rectCoords` is flat `[x0, y0, x1, y1, x2, y2, x3, y3, …]` — 8 f64 per wall
+   * (its 4 plan-rectangle corners, CCW). A bounded arrangement face is a room
+   * only if its centroid is outside every rectangle (a gap, not a wall
+   * interior). The room outline IS the net (inner-face) area; `gapBoundary`
+   * gives the centre axis (½ thickness) and the gross outer face.
+   */
+  static fromWallRects(rect_coords: Float64Array, snap_tolerance: number, min_area: number): SpacePlateHandle;
   /**
    * The room on the far side of a half-edge (its twin's face), or
    * `undefined`. O(1) — the "who's across this wall" query.
@@ -566,9 +625,27 @@ export class SpacePlateHandle {
    *
    * `segCoords`: `[ax, ay, bx, by, …]` (length a multiple of 4).
    * `segSources`: one `i32` per segment, `-1` for none.
+   * `segHalfThickness`: one `f64` per segment — half the wall's thickness in
+   * metres, carried onto the derived edges for `netOutline`. Pass an empty
+   * array (or all zeros) when thickness is unknown (centreline only).
    * `snapTolerance` / `minArea`: pass `<= 0` to take the defaults.
    */
-  constructor(seg_coords: Float64Array, seg_sources: Int32Array, snap_tolerance: number, min_area: number);
+  constructor(seg_coords: Float64Array, seg_sources: Int32Array, seg_half_thickness: Float64Array, snap_tolerance: number, min_area: number);
+  /**
+   * Sweep the whole plate clean: remove dangling spur walls, isolated nodes,
+   * and redundant collinear nodes — the "clean up orphans" / eraser action.
+   * Area-neutral and idempotent. Returns how many topology elements were
+   * pruned (0 = the plate was already clean); the caller re-renders via
+   * `snapshot` like any other edit.
+   */
+  prune(): number;
+  /**
+   * Author a new room from a flat ring `[x0, y0, x1, y1, …]` (no repeated
+   * closing vertex). `source` `-1` marks a user-drawn room. Winding is
+   * normalised to CCW; returns the new room patch. The room is its own
+   * connected component — it does not merge into existing topology.
+   */
+  addFace(coords: Float64Array, source: number): any;
   /**
    * Face ids of every live room.
    */
@@ -835,7 +912,7 @@ export interface InitOutput {
   readonly gridaxisjs_start: (a: number) => number;
   readonly gridaxisjs_tag: (a: number, b: number) => void;
   readonly ifcapi_buildPrePassOnce: (a: number, b: number, c: number) => number;
-  readonly ifcapi_buildPrePassStreaming: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+  readonly ifcapi_buildPrePassStreaming: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
   readonly ifcapi_clearPrePassCache: (a: number) => void;
   readonly ifcapi_extractProfiles: (a: number, b: number, c: number, d: number) => number;
   readonly ifcapi_getMemory: (a: number) => number;
@@ -845,7 +922,7 @@ export interface InitOutput {
   readonly ifcapi_parseGridAxes: (a: number, b: number, c: number) => number;
   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) => 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_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;
@@ -865,6 +942,7 @@ export interface InitOutput {
   readonly meshcollection_rtcOffsetX: (a: number) => number;
   readonly meshcollection_rtcOffsetY: (a: number) => number;
   readonly meshcollection_rtcOffsetZ: (a: number) => number;
+  readonly meshcollection_takeMesh: (a: number, b: number) => number;
   readonly meshcollection_totalTriangles: (a: number) => number;
   readonly meshcollection_totalVertices: (a: number) => number;
   readonly meshdatajs_color: (a: number, b: number) => void;
@@ -874,6 +952,7 @@ export interface InitOutput {
   readonly meshdatajs_ifcType: (a: number, b: number) => void;
   readonly meshdatajs_indices: (a: number) => number;
   readonly meshdatajs_normals: (a: number) => number;
+  readonly meshdatajs_origin: (a: number) => number;
   readonly meshdatajs_positions: (a: number) => number;
   readonly meshdatajs_shadingColor: (a: number, b: number) => void;
   readonly meshdatajs_textureHeight: (a: number) => number;
@@ -890,7 +969,6 @@ export interface InitOutput {
   readonly meshoutlinejs_contourCount: (a: number) => number;
   readonly profilecollection_get: (a: number, b: number) => number;
   readonly profilecollection_length: (a: number) => number;
-  readonly profileentryjs_expressId: (a: number) => number;
   readonly profileentryjs_extrusionDepth: (a: number) => number;
   readonly profileentryjs_extrusionDir: (a: number) => number;
   readonly profileentryjs_holeCounts: (a: number) => number;
@@ -899,15 +977,22 @@ export interface InitOutput {
   readonly profileentryjs_modelIndex: (a: number) => number;
   readonly profileentryjs_outerPoints: (a: number) => number;
   readonly profileentryjs_transform: (a: number) => number;
+  readonly spaceplatehandle_addFace: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly spaceplatehandle_boundingElements: (a: number, b: number, c: number) => void;
+  readonly spaceplatehandle_dissolveVertex: (a: number, b: number, c: number) => void;
   readonly spaceplatehandle_dragVertex: (a: number, b: number, c: number, d: number, e: number) => void;
   readonly spaceplatehandle_duplicate: (a: number) => number;
   readonly spaceplatehandle_faceArea: (a: number, b: number) => number;
   readonly spaceplatehandle_faceOutline: (a: number, b: number, c: number) => void;
   readonly spaceplatehandle_findVertexNear: (a: number, b: number, c: number, d: number) => number;
+  readonly spaceplatehandle_fromWallRects: (a: number, b: number, c: number, d: number, e: number) => void;
+  readonly spaceplatehandle_gapBoundary: (a: number, b: number, c: number, d: number) => void;
   readonly spaceplatehandle_mergeFaces: (a: number, b: number, c: number) => void;
   readonly spaceplatehandle_neighborAcross: (a: number, b: number) => number;
-  readonly spaceplatehandle_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+  readonly spaceplatehandle_netOutline: (a: number, b: number, c: number, d: number) => void;
+  readonly spaceplatehandle_new: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+  readonly spaceplatehandle_prune: (a: number) => number;
+  readonly spaceplatehandle_removeEdge: (a: number, b: number, c: number) => void;
   readonly spaceplatehandle_roomCount: (a: number) => number;
   readonly spaceplatehandle_roomIds: (a: number, b: number) => void;
   readonly spaceplatehandle_setFaceHeight: (a: number, b: number, c: number, d: number, e: number) => void;
@@ -966,6 +1051,7 @@ export interface InitOutput {
   readonly init: () => void;
   readonly symbolicpolyline_pointCount: (a: number) => number;
   readonly get_memory: () => number;
+  readonly profileentryjs_expressId: (a: number) => number;
   readonly symbolicfillarea_expressId: (a: number) => number;
   readonly symbolicpolyline_worldY: (a: number) => number;
   readonly symbolictext_colorB: (a: number) => number;

package/pkg/ifc-lite.js

@@ -146,6 +146,16 @@ function passArrayF64ToWasm0(arg, malloc) {
     return ptr;
 }
 
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
 function passStringToWasm0(arg, malloc, realloc) {
     if (realloc === undefined) {
         const buf = cachedTextEncoder.encode(arg);
@@ -641,9 +651,13 @@ export class IfcAPI {
      * @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}
      */
-    processGeometryBatch(data, jobs_flat, unit_scale, rtc_x, rtc_y, rtc_z, needs_shift, void_keys, void_counts, void_values, style_ids, style_colors) {
+    processGeometryBatch(data, 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 = passArray8ToWasm0(data, wasm.__wbindgen_export);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passArray32ToWasm0(jobs_flat, wasm.__wbindgen_export);
@@ -658,7 +672,13 @@ export class IfcAPI {
         const len5 = WASM_VECTOR_LEN;
         const ptr6 = passArray8ToWasm0(style_colors, wasm.__wbindgen_export);
         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);
+        var ptr7 = isLikeNone(material_element_ids) ? 0 : passArray32ToWasm0(material_element_ids, wasm.__wbindgen_export);
+        var len7 = WASM_VECTOR_LEN;
+        var ptr8 = isLikeNone(material_color_counts) ? 0 : passArray32ToWasm0(material_color_counts, wasm.__wbindgen_export);
+        var len8 = WASM_VECTOR_LEN;
+        var ptr9 = isLikeNone(material_colors_rgba) ? 0 : passArray8ToWasm0(material_colors_rgba, wasm.__wbindgen_export);
+        var len9 = 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, !isLikeNone(plane_angle_to_radians), isLikeNone(plane_angle_to_radians) ? 0 : plane_angle_to_radians, ptr7, len7, ptr8, len8, ptr9, len9);
         return MeshCollection.__wrap(ret);
     }
     /**
@@ -688,14 +708,18 @@ export class IfcAPI {
      * @param {Uint8Array} data
      * @param {Function} on_event
      * @param {number} chunk_size
+     * @param {string[] | null | undefined} disabled_type_names
+     * @param {boolean} skip_type_geometry
      * @returns {any}
      */
-    buildPrePassStreaming(data, on_event, chunk_size) {
+    buildPrePassStreaming(data, on_event, chunk_size, disabled_type_names, skip_type_geometry) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
-            wasm.ifcapi_buildPrePassStreaming(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(on_event), chunk_size);
+            var ptr1 = isLikeNone(disabled_type_names) ? 0 : passArrayJsValueToWasm0(disabled_type_names, wasm.__wbindgen_export);
+            var len1 = WASM_VECTOR_LEN;
+            wasm.ifcapi_buildPrePassStreaming(retptr, this.__wbg_ptr, ptr0, len0, addBorrowedObject(on_event), chunk_size, ptr1, len1, skip_type_geometry);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1124,7 +1148,8 @@ export class MeshCollection {
         return takeObject(ret);
     }
     /**
-     * Get mesh at index
+     * Get mesh at index (clones — non-destructive). Prefer `takeMesh` on the
+     * hot streaming path; this stays for callers that read meshes more than once.
      * @param {number} index
      * @returns {MeshDataJs | undefined}
      */
@@ -1140,6 +1165,20 @@ export class MeshCollection {
         const ret = wasm.meshcollection_length(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * #1097 perf: MOVE the mesh at `index` out of the collection (the Vec
+     * buffers are `std::mem::take`-n, leaving an empty stub). The streaming
+     * worker reads each mesh exactly once, so moving avoids the full vertex-
+     * data clone `get` pays — one fewer copy of positions/normals/indices/uvs/
+     * texture per mesh (the JS getters still do the single Rust→JS copy). Calling
+     * it twice for the same index yields the second call an empty mesh.
+     * @param {number} index
+     * @returns {MeshDataJs | undefined}
+     */
+    takeMesh(index) {
+        const ret = wasm.meshcollection_takeMesh(this.__wbg_ptr, index);
+        return ret === 0 ? undefined : MeshDataJs.__wrap(ret);
+    }
 }
 if (Symbol.dispose) MeshCollection.prototype[Symbol.dispose] = MeshCollection.prototype.free;
 
@@ -1292,6 +1331,16 @@ export class MeshDataJs {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Per-element local-frame origin (Float64Array[3], WebGL Y-up, metres):
+     * world position of vertex i = `origin + positions[3i..3i+3]`. Returns
+     * [0,0,0] when positions are absolute (legacy / local frame off).
+     * @returns {Float64Array}
+     */
+    get origin() {
+        const ret = wasm.meshdatajs_origin(this.__wbg_ptr);
+        return takeObject(ret);
+    }
     /**
      * Get indices as Uint32Array (copy to JS)
      * @returns {Uint32Array}
@@ -1473,7 +1522,7 @@ export class ProfileEntryJs {
      * @returns {number}
      */
     get expressId() {
-        const ret = wasm.profileentryjs_expressId(this.__wbg_ptr);
+        const ret = wasm.meshdatajs_textureWidth(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -1679,6 +1728,56 @@ export class SpacePlateHandle {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * The face outline offset to a wall boundary, as flat `[x0, y0, …]`: each
+     * edge is moved by its own wall's half-thickness — inward when `inset`
+     * (the net / inner face), outward otherwise (the gross / outer face).
+     * Shared room↔room edges are pinned when pushing outward. Falls back to the
+     * centreline outline when no offset applies — so it's always a sane ring.
+     * (For a `center` boundary just use `faceOutline`.)
+     * @param {number} face
+     * @param {boolean} inset
+     * @returns {Float64Array}
+     */
+    netOutline(face, inset) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spaceplatehandle_netOutline(retptr, this.__wbg_ptr, face, inset);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Remove a wall edge, choosing the right semantics from its two faces:
+     * two real rooms → union them; a bridge / spur / outer-only wall → delete
+     * it and auto-clean the orphaned inner lines and nodes it leaves; a real
+     * enclosing wall (room ↔ exterior) → rejected (`BordersExterior`). This is
+     * the "remove this wall and tidy up" affordance for the orphan cruft the
+     * non-destructive wall arrangement leaves behind. Returns the rooms it
+     * changed (empty if the edge bounded no room).
+     * @param {number} edge
+     * @returns {any}
+     */
+    removeEdge(edge) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spaceplatehandle_removeEdge(retptr, this.__wbg_ptr, edge);
+            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);
+        }
+    }
     /**
      * Flat outline `[x0, y0, x1, y1, …]` of a face (no repeated closing vertex).
      * @param {number} face
@@ -1697,6 +1796,81 @@ export class SpacePlateHandle {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Face-based gap-room boundary as flat `[x0, y0, …]`: each edge pushed
+     * OUTWARD (into the wall) by `factor × the source wall's half-thickness`.
+     * `0` → net (the gap / inner faces); `1` → centre axis (½ thickness, the
+     * editable node line on the wall mid); `2` → gross outer face.
+     * @param {number} face
+     * @param {number} factor
+     * @returns {Float64Array}
+     */
+    gapBoundary(face, factor) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spaceplatehandle_gapBoundary(retptr, this.__wbg_ptr, face, factor);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayF64FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 8, 8);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Dissolve a degree-2 vertex, welding its two edges into one straight
+     * edge between the neighbours — the inverse of `splitEdge`, and the
+     * "delete this corner / node" affordance. Returns the rooms it changed.
+     * Rejects a wall junction (degree ≥ 3) or a weld that would duplicate an
+     * edge.
+     * @param {number} v
+     * @returns {any}
+     */
+    dissolveVertex(v) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.spaceplatehandle_dissolveVertex(retptr, this.__wbg_ptr, v);
+            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);
+        }
+    }
+    /**
+     * FACE-BASED build: rooms are the gaps between wall footprint rectangles.
+     * `rectCoords` is flat `[x0, y0, x1, y1, x2, y2, x3, y3, …]` — 8 f64 per wall
+     * (its 4 plan-rectangle corners, CCW). A bounded arrangement face is a room
+     * only if its centroid is outside every rectangle (a gap, not a wall
+     * interior). The room outline IS the net (inner-face) area; `gapBoundary`
+     * gives the centre axis (½ thickness) and the gross outer face.
+     * @param {Float64Array} rect_coords
+     * @param {number} snap_tolerance
+     * @param {number} min_area
+     * @returns {SpacePlateHandle}
+     */
+    static fromWallRects(rect_coords, snap_tolerance, min_area) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(rect_coords, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.spaceplatehandle_fromWallRects(retptr, ptr0, len0, snap_tolerance, min_area);
+            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 SpacePlateHandle.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * The room on the far side of a half-edge (its twin's face), or
      * `undefined`. O(1) — the "who's across this wall" query.
@@ -1755,20 +1929,26 @@ export class SpacePlateHandle {
      *
      * `segCoords`: `[ax, ay, bx, by, …]` (length a multiple of 4).
      * `segSources`: one `i32` per segment, `-1` for none.
+     * `segHalfThickness`: one `f64` per segment — half the wall's thickness in
+     * metres, carried onto the derived edges for `netOutline`. Pass an empty
+     * array (or all zeros) when thickness is unknown (centreline only).
      * `snapTolerance` / `minArea`: pass `<= 0` to take the defaults.
      * @param {Float64Array} seg_coords
      * @param {Int32Array} seg_sources
+     * @param {Float64Array} seg_half_thickness
      * @param {number} snap_tolerance
      * @param {number} min_area
      */
-    constructor(seg_coords, seg_sources, snap_tolerance, min_area) {
+    constructor(seg_coords, seg_sources, seg_half_thickness, snap_tolerance, min_area) {
         try {
             const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
             const ptr0 = passArrayF64ToWasm0(seg_coords, wasm.__wbindgen_export);
             const len0 = WASM_VECTOR_LEN;
             const ptr1 = passArray32ToWasm0(seg_sources, wasm.__wbindgen_export);
             const len1 = WASM_VECTOR_LEN;
-            wasm.spaceplatehandle_new(retptr, ptr0, len0, ptr1, len1, snap_tolerance, min_area);
+            const ptr2 = passArrayF64ToWasm0(seg_half_thickness, wasm.__wbindgen_export);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.spaceplatehandle_new(retptr, ptr0, len0, ptr1, len1, ptr2, len2, snap_tolerance, min_area);
             var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
             var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
             var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
@@ -1782,6 +1962,44 @@ export class SpacePlateHandle {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sweep the whole plate clean: remove dangling spur walls, isolated nodes,
+     * and redundant collinear nodes — the "clean up orphans" / eraser action.
+     * Area-neutral and idempotent. Returns how many topology elements were
+     * pruned (0 = the plate was already clean); the caller re-renders via
+     * `snapshot` like any other edit.
+     * @returns {number}
+     */
+    prune() {
+        const ret = wasm.spaceplatehandle_prune(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Author a new room from a flat ring `[x0, y0, x1, y1, …]` (no repeated
+     * closing vertex). `source` `-1` marks a user-drawn room. Winding is
+     * normalised to CCW; returns the new room patch. The room is its own
+     * connected component — it does not merge into existing topology.
+     * @param {Float64Array} coords
+     * @param {number} source
+     * @returns {any}
+     */
+    addFace(coords, source) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayF64ToWasm0(coords, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.spaceplatehandle_addFace(retptr, this.__wbg_ptr, ptr0, len0, source);
+            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);
+        }
+    }
     /**
      * Face ids of every live room.
      * @returns {Uint32Array}
@@ -1996,7 +2214,7 @@ export class SymbolicFillArea {
      * @returns {number}
      */
     get expressId() {
-        const ret = wasm.profileentryjs_expressId(this.__wbg_ptr);
+        const ret = wasm.meshdatajs_textureWidth(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2404,7 +2622,7 @@ export class SymbolicText {
      * @returns {number}
      */
     get expressId() {
-        const ret = wasm.profileentryjs_expressId(this.__wbg_ptr);
+        const ret = wasm.meshdatajs_textureWidth(this.__wbg_ptr);
         return ret >>> 0;
     }
     /**
@@ -2694,6 +2912,14 @@ function __wbg_get_imports() {
         const ret = wasm.memory;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+        const obj = getObject(arg1);
+        const ret = typeof(obj) === 'string' ? obj : undefined;
+        var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        var len1 = WASM_VECTOR_LEN;
+        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    };
     imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
         throw new Error(getStringFromWasm0(arg0, arg1));
     };
@@ -2727,6 +2953,10 @@ function __wbg_get_imports() {
         const ret = new Error();
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_df1173567d5ff028 = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_from_slice_41e2764a343e3cb1 = function(arg0, arg1) {
         const ret = new Float32Array(getArrayF32FromWasm0(arg0, arg1));
         return addHeapObject(ret);
@@ -2735,6 +2965,10 @@ function __wbg_get_imports() {
         const ret = new BigUint64Array(getArrayU64FromWasm0(arg0, arg1));
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_new_from_slice_9a48ef80d2a51f94 = function(arg0, arg1) {
+        const ret = new Float64Array(getArrayF64FromWasm0(arg0, arg1));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_new_from_slice_db0691b69e9d3891 = function(arg0, arg1) {
         const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
         return addHeapObject(ret);
@@ -2751,10 +2985,6 @@ function __wbg_get_imports() {
         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_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
         getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
     };
@@ -2768,12 +2998,12 @@ function __wbg_get_imports() {
     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_set_name_df69b75cb0b4de8a = function(arg0, arg1, arg2) {
+        getObject(arg0).name = getStringFromWasm0(arg1, arg2);
+    };
     imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
         const ret = getObject(arg1).stack;
         const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);