@ifc-lite/create 1.14.5 → 1.15.1

package/dist/in-store/_emit-helpers.js

@@ -0,0 +1,147 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+/**
+ * Shared sub-graph emitters for the in-store element builders.
+ *
+ * Every IFC element that lands on a storey shares the same prologue
+ * (IfcCartesianPoint → IfcAxis2Placement3D → IfcLocalPlacement) and
+ * the same epilogue (IfcShapeRepresentation → IfcProductDefinitionShape
+ * → IfcRelContainedInSpatialStructure). Extracting those into pure
+ * helpers keeps each builder focused on the one part that's actually
+ * unique — the profile + element-line attribute order.
+ *
+ * All helpers operate purely through the StoreEditor; no parser
+ * access, no I/O.
+ */
+import { generateIfcGuid } from '@ifc-lite/encoding';
+const POINT_EPSILON = 1e-6;
+/**
+ * Emit an IfcLocalPlacement chained to a parent. Wraps the cartesian
+ * point + axis-placement bookkeeping. Pass `Axis` and/or `RefDirection`
+ * as `[x, y, z]` to override defaults (otherwise IFC fills them with
+ * world up / world X).
+ */
+export function emitLocalPlacement(editor, parentPlacementId, location, axis, refDirection) {
+    const originPt = editor.addEntity('IfcCartesianPoint', [location]).expressId;
+    const axisRef = axis !== undefined
+        ? `#${editor.addEntity('IfcDirection', [axis]).expressId}`
+        : null;
+    const refDirRef = refDirection !== undefined
+        ? `#${editor.addEntity('IfcDirection', [refDirection]).expressId}`
+        : null;
+    const axisPlacement = editor.addEntity('IfcAxis2Placement3D', [
+        `#${originPt}`,
+        axisRef,
+        refDirRef,
+    ]).expressId;
+    return editor.addEntity('IfcLocalPlacement', [
+        `#${parentPlacementId}`,
+        `#${axisPlacement}`,
+    ]).expressId;
+}
+/**
+ * Emit a centred rectangle profile. `centerX`/`centerY` shift the
+ * profile's local origin — useful for slab-style "spans 0..W × 0..D"
+ * placements where the centre sits at (W/2, D/2).
+ */
+export function emitRectangleProfile(editor, width, depth, centerX = 0, centerY = 0) {
+    const originPt = editor.addEntity('IfcCartesianPoint', [[centerX, centerY]]).expressId;
+    const pos = editor.addEntity('IfcAxis2Placement2D', [`#${originPt}`, null]).expressId;
+    return editor.addEntity('IfcRectangleProfileDef', [
+        '.AREA.',
+        null,
+        `#${pos}`,
+        width,
+        depth,
+    ]).expressId;
+}
+/**
+ * Emit an arbitrary closed profile from a 2D polyline. Auto-closes if
+ * the input doesn't already terminate at the start point.
+ */
+export function emitPolygonProfile(editor, curve) {
+    if (curve.length < 3) {
+        throw new Error('emitPolygonProfile: outline needs at least 3 points');
+    }
+    const first = curve[0];
+    const last = curve[curve.length - 1];
+    const closed = Math.abs(first[0] - last[0]) < POINT_EPSILON &&
+        Math.abs(first[1] - last[1]) < POINT_EPSILON;
+    const sequence = closed ? curve : [...curve, first];
+    const pointIds = sequence.map((pt) => editor.addEntity('IfcCartesianPoint', [[pt[0], pt[1]]]).expressId);
+    const polylineId = editor.addEntity('IfcPolyline', [pointIds.map((id) => `#${id}`)]).expressId;
+    return editor.addEntity('IfcArbitraryClosedProfileDef', [
+        '.AREA.',
+        null,
+        `#${polylineId}`,
+    ]).expressId;
+}
+/**
+ * Emit an IfcExtrudedAreaSolid extruding `profileId` along local +Z
+ * for `depth` metres. Standard prologue for any swept-solid element.
+ */
+export function emitExtrudedSolid(editor, profileId, depth) {
+    const originPt = editor.addEntity('IfcCartesianPoint', [[0, 0, 0]]).expressId;
+    const axis = editor.addEntity('IfcAxis2Placement3D', [`#${originPt}`, null, null]).expressId;
+    const direction = editor.addEntity('IfcDirection', [[0, 0, 1]]).expressId;
+    return editor.addEntity('IfcExtrudedAreaSolid', [
+        `#${profileId}`,
+        `#${axis}`,
+        `#${direction}`,
+        depth,
+    ]).expressId;
+}
+/**
+ * Emit a "Body" IfcShapeRepresentation + IfcProductDefinitionShape
+ * pair from a single solid. Returns both ids so callers can record
+ * them in their build result for downstream tooling.
+ */
+export function emitBodyRepresentation(editor, bodyContextId, solidId) {
+    const shapeRepId = editor.addEntity('IfcShapeRepresentation', [
+        `#${bodyContextId}`,
+        'Body',
+        'SweptSolid',
+        [`#${solidId}`],
+    ]).expressId;
+    const productShapeId = editor.addEntity('IfcProductDefinitionShape', [
+        null,
+        null,
+        [`#${shapeRepId}`],
+    ]).expressId;
+    return { shapeRepId, productShapeId };
+}
+/**
+ * Emit a fresh IfcRelContainedInSpatialStructure that anchors a single
+ * element to its storey. Easier than mutating an existing rel — STEP
+ * importers fold parallel rels back into one container at parse time.
+ */
+export function emitRelContainedInSpatialStructure(editor, ownerHistoryId, elementId, storeyId) {
+    return editor.addEntity('IfcRelContainedInSpatialStructure', [
+        generateIfcGuid(),
+        `#${ownerHistoryId}`,
+        null,
+        null,
+        [`#${elementId}`],
+        `#${storeyId}`,
+    ]).expressId;
+}
+/**
+ * Build the leading attributes shared by every IfcElement subclass
+ * (GlobalId → OwnerHistory → Name → Description → ObjectType →
+ * ObjectPlacement → Representation → Tag). Callers append their
+ * type-specific tail (PredefinedType, OperationType, etc.).
+ */
+export function ifcElementHeader(ownerHistoryId, placementId, productShapeId, params, defaultName) {
+    return [
+        generateIfcGuid(),
+        `#${ownerHistoryId}`,
+        params.Name ?? defaultName,
+        params.Description ?? null,
+        params.ObjectType ?? null,
+        `#${placementId}`,
+        `#${productShapeId}`,
+        params.Tag ?? null,
+    ];
+}
+//# sourceMappingURL=_emit-helpers.js.map

package/dist/in-store/_emit-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_emit-helpers.js","sourceRoot":"","sources":["../../src/in-store/_emit-helpers.ts"],"names":[],"mappings":"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"}

package/dist/in-store/anchor.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Spatial anchor for in-store builders — the set of references that any
+ * element being added to an existing parsed model needs in order to slot
+ * into the existing IFC graph correctly.
+ *
+ * Resolution from a parsed `IfcDataStore` lives in the backend layer
+ * (where `@ifc-lite/parser` is already a dependency); the builder
+ * functions in this module operate purely on these resolved ids.
+ */
+export type SpatialAnchorSchema = 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5';
+export interface SpatialAnchor {
+    /** IfcOwnerHistory expressId — referenced by every IfcRoot. */
+    ownerHistoryId: number;
+    /** IfcGeometricRepresentationSubContext for 'Body' (or its IfcGeometricRepresentationContext fallback). */
+    bodyContextId: number;
+    /** IfcGeometricRepresentationSubContext for 'Axis' (or its IfcGeometricRepresentationContext fallback). */
+    axisContextId: number;
+    /** The target IfcBuildingStorey expressId. */
+    storeyId: number;
+    /** The IfcLocalPlacement that the storey itself sits on. New element placements are chained from this. */
+    storeyPlacementId: number;
+    /**
+     * Target schema. Builders use this to decide which optional STEP arguments
+     * to emit — e.g. `IfcColumn.PredefinedType` only exists from IFC4 onward.
+     * Defaults to `'IFC4'` when unset for backward compatibility.
+     */
+    schema?: SpatialAnchorSchema;
+}
+//# sourceMappingURL=anchor.d.ts.map

package/dist/in-store/anchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.d.ts","sourceRoot":"","sources":["../../src/in-store/anchor.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AAEH,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;AAExE,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,cAAc,EAAE,MAAM,CAAC;IACvB,2GAA2G;IAC3G,aAAa,EAAE,MAAM,CAAC;IACtB,2GAA2G;IAC3G,aAAa,EAAE,MAAM,CAAC;IACtB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,0GAA0G;IAC1G,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,MAAM,CAAC,EAAE,mBAAmB,CAAC;CAC9B"}

package/dist/in-store/anchor.js

@@ -0,0 +1,5 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+export {};
+//# sourceMappingURL=anchor.js.map

package/dist/in-store/anchor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchor.js","sourceRoot":"","sources":["../../src/in-store/anchor.ts"],"names":[],"mappings":"AAAA;;+DAE+D"}

package/dist/in-store/auto-space-detect.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Detect enclosed regions from a set of 2D wall axis segments.
+ *
+ * Pipeline:
+ *   1. Snap close vertices within `snapTolerance` (collapses tiny gaps
+ *      between wall ends that should meet at a corner).
+ *   2. Resolve pairwise segment intersections — each crossing splits
+ *      both segments into shorter pieces meeting at the new vertex.
+ *   3. Build a half-edge graph (DCEL): every undirected segment
+ *      becomes two opposing directed half-edges; per vertex, the
+ *      half-edges leaving it are ordered by polar angle so we can
+ *      find the next CCW-around-a-face neighbour in O(1).
+ *   4. Walk minimum cycles by always taking the leftmost turn. Each
+ *      half-edge belongs to exactly one face cycle.
+ *   5. Drop the outer (unbounded) face — the one with the most-
+ *      negative signed area.
+ *   6. Filter the remaining faces by `minArea`.
+ *
+ * Pure: no IFC dependencies. Output is a list of CCW polygons
+ * (`outline`) plus the signed area of each. Callers feed these into
+ * the per-storey IfcSpace builder.
+ */
+export type Vec2 = [number, number];
+export interface Segment {
+    a: Vec2;
+    b: Vec2;
+}
+export interface DetectedSpace {
+    /** CCW outline (no implicit closing edge — first vertex isn't repeated). */
+    outline: Vec2[];
+    /** Absolute polygon area, m². */
+    area: number;
+}
+export interface DetectOptions {
+    /** Distance below which two endpoints are merged. Default 0.05 m. */
+    snapTolerance?: number;
+    /** Faces below this area are dropped. Default 0.5 m². */
+    minArea?: number;
+    /**
+     * When true, the detector emits `console.debug` messages tracing the
+     * pipeline (vertex/edge counts, face areas, drop reasons). Surfaces
+     * the data needed to diagnose "no enclosed regions detected" without
+     * touching the algorithm.
+     */
+    debug?: boolean;
+}
+export interface DetectStats {
+    inputSegments: number;
+    vertices: number;
+    segmentsAfterSplit: number;
+    edges: number;
+    faces: number;
+    outerFacesDropped: number;
+    belowMinAreaDropped: number;
+    /** Largest detected interior face area (m²). 0 when no face passed. */
+    largestArea: number;
+}
+export declare function detectEnclosedAreas(segments: Segment[], options?: DetectOptions): DetectedSpace[];
+/**
+ * Same pipeline as `detectEnclosedAreas`, but returns the per-stage
+ * counts alongside the spaces so callers can surface diagnostic
+ * information (used by the orchestrator + viewer Auto Spaces panel).
+ */
+export declare function detectEnclosedAreasWithStats(segments: Segment[], options?: DetectOptions): {
+    spaces: DetectedSpace[];
+    stats: DetectStats;
+};
+//# sourceMappingURL=auto-space-detect.d.ts.map

package/dist/in-store/auto-space-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-space-detect.d.ts","sourceRoot":"","sources":["../../src/in-store/auto-space-detect.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEpC,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,IAAI,CAAC;IACR,CAAC,EAAE,IAAI,CAAC;CACT;AAED,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,OAAO,EAAE,IAAI,EAAE,CAAC;IAChB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,qEAAqE;IACrE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;CACrB;AA8BD,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,aAAkB,GAC1B,aAAa,EAAE,CAEjB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,aAAkB,GAC1B;IAAE,MAAM,EAAE,aAAa,EAAE,CAAC;IAAC,KAAK,EAAE,WAAW,CAAA;CAAE,CAyUjD"}

package/dist/in-store/auto-space-detect.js

@@ -0,0 +1,393 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+const DEFAULT_SNAP = 0.05;
+const DEFAULT_MIN_AREA = 0.5;
+const EPS = 1e-9;
+export function detectEnclosedAreas(segments, options = {}) {
+    return detectEnclosedAreasWithStats(segments, options).spaces;
+}
+/**
+ * Same pipeline as `detectEnclosedAreas`, but returns the per-stage
+ * counts alongside the spaces so callers can surface diagnostic
+ * information (used by the orchestrator + viewer Auto Spaces panel).
+ */
+export function detectEnclosedAreasWithStats(segments, options = {}) {
+    const snap = options.snapTolerance ?? DEFAULT_SNAP;
+    const minArea = options.minArea ?? DEFAULT_MIN_AREA;
+    const debug = !!options.debug;
+    const log = debug ? (...args) => console.debug('[auto-space-detect]', ...args) : () => { };
+    const stats = {
+        inputSegments: segments.length,
+        vertices: 0,
+        segmentsAfterSplit: 0,
+        edges: 0,
+        faces: 0,
+        outerFacesDropped: 0,
+        belowMinAreaDropped: 0,
+        largestArea: 0,
+    };
+    log(`input: ${segments.length} segments, snapTolerance=${snap}, minArea=${minArea}`);
+    if (segments.length < 3) {
+        log('input below 3 segments — no faces possible');
+        return { spaces: [], stats };
+    }
+    // ── 1. Snap endpoints ──
+    // Spatial hash keyed on a snap-sized grid so endpoint resolution stays
+    // O(1) average instead of O(N) linear scans. We probe the cell + its 8
+    // neighbours so a query point near a cell boundary still finds matches
+    // on the other side.
+    const vertices = [];
+    const cellSize = Math.max(snap, EPS);
+    const grid = new Map();
+    const cellKey = (cx, cy) => `${cx},${cy}`;
+    const lookup = (pt) => {
+        const snapSq2 = snap * snap;
+        const cx = Math.floor(pt[0] / cellSize);
+        const cy = Math.floor(pt[1] / cellSize);
+        for (let dx = -1; dx <= 1; dx++) {
+            for (let dy = -1; dy <= 1; dy++) {
+                const bucket = grid.get(cellKey(cx + dx, cy + dy));
+                if (!bucket)
+                    continue;
+                for (const id of bucket) {
+                    const ddx = vertices[id].pt[0] - pt[0];
+                    const ddy = vertices[id].pt[1] - pt[1];
+                    if (ddx * ddx + ddy * ddy <= snapSq2)
+                        return id;
+                }
+            }
+        }
+        const id = vertices.length;
+        vertices.push({ id, pt: [pt[0], pt[1]] });
+        const key = cellKey(cx, cy);
+        const bucket = grid.get(key);
+        if (bucket)
+            bucket.push(id);
+        else
+            grid.set(key, [id]);
+        return id;
+    };
+    // Initial vertex set: every endpoint, snapped.
+    const indexedSegs = [];
+    for (const seg of segments) {
+        const ai = lookup(seg.a);
+        const bi = lookup(seg.b);
+        if (ai === bi)
+            continue; // zero-length, post-snap
+        indexedSegs.push([ai, bi]);
+    }
+    log(`after snap: ${vertices.length} vertices, ${indexedSegs.length} segments`);
+    // ── 1b. Snap dangling endpoints onto nearby edge interiors ──
+    // Walls extracted from real IFC files often DON'T share corner
+    // vertices: each wall's axis runs centreline-to-centreline, but
+    // adjacent perpendicular walls have axes ending at the inside
+    // face of the partner wall — so the endpoints land on each
+    // other's interior, not at the same point. A pure endpoint snap
+    // misses this; we project each unique endpoint onto every nearby
+    // segment and, when within snap tolerance, mark the projection
+    // as the canonical vertex (and queue the host segment to be
+    // split there).
+    const splitSegs = [];
+    for (let i = 0; i < indexedSegs.length; i++) {
+        splitSegs.push([...indexedSegs[i]]);
+    }
+    const snapSq = snap * snap;
+    let tjunctionPasses = 0;
+    let tjunctionsApplied = false;
+    do {
+        tjunctionsApplied = false;
+        tjunctionPasses++;
+        // Snapshot endpoints we need to test — segs grow during the loop,
+        // but the new pieces share endpoints with the originals so we
+        // don't have to re-scan them.
+        const endpointIds = new Set();
+        for (const [a, b] of splitSegs) {
+            endpointIds.add(a);
+            endpointIds.add(b);
+        }
+        for (const vid of endpointIds) {
+            const p = vertices[vid].pt;
+            for (let s = 0; s < splitSegs.length; s++) {
+                const [a, b] = splitSegs[s];
+                if (a === vid || b === vid)
+                    continue;
+                const proj = closestPointOnSegment(p, vertices[a].pt, vertices[b].pt);
+                if (!proj)
+                    continue;
+                const dx = proj.point[0] - p[0];
+                const dy = proj.point[1] - p[1];
+                if (dx * dx + dy * dy > snapSq)
+                    continue;
+                // Strictly interior — skip projections that land on the
+                // segment endpoints (those are handled by the regular vertex
+                // snap and would degenerate the split).
+                if (proj.t < 1e-6 || proj.t > 1 - 1e-6)
+                    continue;
+                // Insert the dangling endpoint as the split vertex (its
+                // coords are already in `vertices[vid]`); split the host edge.
+                splitSegs[s] = [a, vid];
+                splitSegs.push([vid, b]);
+                tjunctionsApplied = true;
+                break;
+            }
+            if (tjunctionsApplied)
+                break;
+        }
+    } while (tjunctionsApplied && tjunctionPasses < Math.max(50, indexedSegs.length * 5));
+    log(`T-junction snap: ${tjunctionPasses} pass(es)`);
+    // Collect every interior crossing in a single O(N²) pass, recording
+    // the parametric position along each host segment, then split each
+    // segment at all of its collected crossings in one go. Splits don't
+    // alter geometry — they only subdivide — so further passes are
+    // unnecessary. Replaces the previous "split one pair, restart the
+    // whole scan" loop, which was O(N³) on dense wall sets.
+    //
+    // For each original segment we keep a sorted list of (t, vertexId).
+    // Endpoints (t=0 and t=1) are the existing endpoint vertex ids.
+    const seedSegs = splitSegs.slice();
+    const segSplits = seedSegs.map(([a, b]) => [
+        { t: 0, v: a },
+        { t: 1, v: b },
+    ]);
+    // Optional bbox-based pruning: skip pair checks whose AABBs miss.
+    // Keep simple — cost is dominated by segmentIntersection which already
+    // returns null for non-crossings; the bbox pre-check is just to avoid
+    // the math in the easy 90% case.
+    const segBBoxes = seedSegs.map(([a, b]) => {
+        const ax = vertices[a].pt[0], ay = vertices[a].pt[1];
+        const bx = vertices[b].pt[0], by = vertices[b].pt[1];
+        return {
+            minX: Math.min(ax, bx),
+            maxX: Math.max(ax, bx),
+            minY: Math.min(ay, by),
+            maxY: Math.max(ay, by),
+        };
+    });
+    for (let i = 0; i < seedSegs.length; i++) {
+        const [ai, bi] = seedSegs[i];
+        const bi_box = segBBoxes[i];
+        for (let j = i + 1; j < seedSegs.length; j++) {
+            const [aj, bj] = seedSegs[j];
+            if (ai === aj || ai === bj || bi === aj || bi === bj)
+                continue;
+            const bj_box = segBBoxes[j];
+            if (bi_box.maxX < bj_box.minX || bj_box.maxX < bi_box.minX ||
+                bi_box.maxY < bj_box.minY || bj_box.maxY < bi_box.minY)
+                continue;
+            const ip = segmentIntersectionParam(vertices[ai].pt, vertices[bi].pt, vertices[aj].pt, vertices[bj].pt);
+            if (!ip)
+                continue;
+            const newIdx = lookup(ip.point);
+            const isI_endpoint = newIdx === ai || newIdx === bi;
+            const isJ_endpoint = newIdx === aj || newIdx === bj;
+            if (!isI_endpoint)
+                segSplits[i].push({ t: ip.t, v: newIdx });
+            if (!isJ_endpoint)
+                segSplits[j].push({ t: ip.u, v: newIdx });
+        }
+    }
+    splitSegs.length = 0;
+    for (const splits of segSplits) {
+        if (splits.length <= 2) {
+            // No interior crossings — keep the segment as-is.
+            splitSegs.push([splits[0].v, splits[1].v]);
+            continue;
+        }
+        splits.sort((a, b) => a.t - b.t);
+        for (let k = 0; k < splits.length - 1; k++) {
+            const a = splits[k].v;
+            const b = splits[k + 1].v;
+            if (a !== b)
+                splitSegs.push([a, b]);
+        }
+    }
+    // Deduplicate (a, b) and (b, a) pairs.
+    const undirected = new Set();
+    const finalSegs = [];
+    for (const [a, b] of splitSegs) {
+        if (a === b)
+            continue;
+        const key = a < b ? `${a}-${b}` : `${b}-${a}`;
+        if (undirected.has(key))
+            continue;
+        undirected.add(key);
+        finalSegs.push([a, b]);
+    }
+    stats.vertices = vertices.length;
+    stats.segmentsAfterSplit = finalSegs.length;
+    log(`after intersect-split: ${finalSegs.length} unique edges`);
+    if (finalSegs.length < 3) {
+        log('after split: fewer than 3 edges — no faces possible');
+        return { spaces: [], stats };
+    }
+    // ── 3. Build half-edge graph ──
+    const edges = [];
+    const vertexEdges = vertices.map(() => []);
+    for (const [a, b] of finalSegs) {
+        const dxA = vertices[b].pt[0] - vertices[a].pt[0];
+        const dyA = vertices[b].pt[1] - vertices[a].pt[1];
+        const fwd = edges.length;
+        const bwd = edges.length + 1;
+        edges.push({
+            id: fwd,
+            origin: a,
+            dest: b,
+            twin: bwd,
+            angle: Math.atan2(dyA, dxA),
+            face: -1,
+            next: -1,
+            dx: dxA,
+            dy: dyA,
+        });
+        edges.push({
+            id: bwd,
+            origin: b,
+            dest: a,
+            twin: fwd,
+            angle: Math.atan2(-dyA, -dxA),
+            face: -1,
+            next: -1,
+            dx: -dxA,
+            dy: -dyA,
+        });
+        vertexEdges[a].push(fwd);
+        vertexEdges[b].push(bwd);
+    }
+    // Sort each vertex's outgoing edges by angle so we can compute
+    // "next around face" via the leftmost-turn rule in O(1).
+    for (const list of vertexEdges) {
+        list.sort((p, q) => edges[p].angle - edges[q].angle);
+    }
+    // ── 4. Walk faces ──
+    // Around a face (CCW interior), the next half-edge after entering
+    // a vertex along edge `e` is the half-edge whose origin is the
+    // entered vertex AND whose direction is the *clockwise* neighbour
+    // of e.twin's direction in the cyclic angle ordering.
+    //
+    //     prev = e
+    //     v = e.dest
+    //     fanIdx = position of e.twin in vertexEdges[v]
+    //     next = vertexEdges[v][(fanIdx - 1 + len) % len]
+    for (const e of edges) {
+        if (e.next !== -1)
+            continue;
+        const v = e.dest;
+        const fan = vertexEdges[v];
+        const idx = fan.indexOf(e.twin);
+        if (idx < 0)
+            continue; // structurally impossible, but defensive
+        const nextIdx = (idx - 1 + fan.length) % fan.length;
+        e.next = fan[nextIdx];
+    }
+    let faceCount = 0;
+    const faceCycles = [];
+    for (const e of edges) {
+        if (e.face !== -1)
+            continue;
+        const cycle = [];
+        let cur = e.id;
+        let safety = 0;
+        while (cur !== -1 && edges[cur].face === -1 && safety++ < edges.length + 4) {
+            edges[cur].face = faceCount;
+            cycle.push(cur);
+            cur = edges[cur].next;
+            if (cur === e.id)
+                break;
+        }
+        faceCycles.push(cycle);
+        faceCount++;
+    }
+    const faceAreas = faceCycles.map((cycle, idx) => {
+        let signed = 0;
+        for (const eid of cycle) {
+            const eg = edges[eid];
+            const p = vertices[eg.origin].pt;
+            const q = vertices[eg.dest].pt;
+            signed += p[0] * q[1] - q[0] * p[1];
+        }
+        signed *= 0.5;
+        return { idx, signed, area: Math.abs(signed) };
+    });
+    stats.edges = edges.length;
+    stats.faces = faceCycles.length;
+    log(`half-edge graph: ${edges.length} half-edges, ${faceCycles.length} faces total`);
+    // ── 6. Drop outer faces + filter by min area + emit CCW outlines ──
+    // With the leftmost-turn walk every interior (enclosed) face winds
+    // CCW (signed area > 0); the unbounded face surrounding each
+    // connected component winds CW (signed area < 0). Drop the
+    // negatives — that handles the multi-component case naturally,
+    // since each component contributes its own outer face.
+    const out = [];
+    for (const f of faceAreas) {
+        if (f.signed <= 0) {
+            stats.outerFacesDropped++;
+            continue;
+        }
+        if (f.area < minArea) {
+            stats.belowMinAreaDropped++;
+            log(`face #${f.idx}: dropped (area=${f.area.toFixed(3)} < minArea=${minArea})`);
+            continue;
+        }
+        const cycle = faceCycles[f.idx];
+        const outline = cycle.map((eid) => {
+            const v = vertices[edges[eid].origin].pt;
+            return [v[0], v[1]];
+        });
+        out.push({ outline, area: f.area });
+        if (f.area > stats.largestArea)
+            stats.largestArea = f.area;
+    }
+    // Stable sort: largest area first so the UI shows "main rooms" up top.
+    out.sort((a, b) => b.area - a.area);
+    log(`detected ${out.length} interior region(s); dropped ${stats.outerFacesDropped} outer + ${stats.belowMinAreaDropped} below min-area`);
+    return { spaces: out, stats };
+}
+/**
+ * Closest point on segment ab to a query point q, plus the
+ * parametric distance `t ∈ [0, 1]` along ab. Returns null for
+ * zero-length segments.
+ */
+function closestPointOnSegment(q, a, b) {
+    const dx = b[0] - a[0];
+    const dy = b[1] - a[1];
+    const len2 = dx * dx + dy * dy;
+    if (len2 < 1e-12)
+        return null;
+    let t = ((q[0] - a[0]) * dx + (q[1] - a[1]) * dy) / len2;
+    if (t < 0)
+        t = 0;
+    else if (t > 1)
+        t = 1;
+    return { point: [a[0] + t * dx, a[1] + t * dy], t };
+}
+/**
+ * Proper-segment intersection test in 2D. Returns the crossing point
+ * plus the parametric positions on both segments when they cross
+ * inside both (excluding shared endpoints at parameter 0 or 1, which
+ * produce no new vertex). Uses a small parametric tolerance so two
+ * near-coincident endpoints don't register as a fresh interior crossing.
+ */
+function segmentIntersectionParam(p1, p2, p3, p4) {
+    const x1 = p1[0], y1 = p1[1];
+    const x2 = p2[0], y2 = p2[1];
+    const x3 = p3[0], y3 = p3[1];
+    const x4 = p4[0], y4 = p4[1];
+    const denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
+    if (Math.abs(denom) < EPS)
+        return null; // parallel / coincident
+    const t = ((x1 - x3) * (y3 - y4) - (y1 - y3) * (x3 - x4)) / denom;
+    const u = -((x1 - x2) * (y1 - y3) - (y1 - y2) * (x1 - x3)) / denom;
+    // Allow exact endpoints (t == 0 / 1) so a T-junction registers and
+    // splits the through-segment, but skip when both segments meet
+    // *only* at a shared endpoint (no new vertex needed).
+    const tol = 1e-7;
+    if (t < -tol || t > 1 + tol)
+        return null;
+    if (u < -tol || u > 1 + tol)
+        return null;
+    if ((t < tol || t > 1 - tol) && (u < tol || u > 1 - tol))
+        return null;
+    return { point: [x1 + t * (x2 - x1), y1 + t * (y2 - y1)], t, u };
+}
+//# sourceMappingURL=auto-space-detect.js.map