@pascal-app/core 1.0.1 → 1.0.4

package/dist/lib/polygon-boolean.d.ts

@@ -0,0 +1,17 @@
+export type Ring = [number, number][];
+export type Polygon = {
+    outer: Ring;
+    holes: Ring[];
+};
+export type MultiPolygon = Polygon[];
+export type PolygonInput = Ring | Polygon | MultiPolygon;
+export declare function union(inputs: readonly PolygonInput[]): MultiPolygon;
+export declare function difference(a: PolygonInput, b: PolygonInput, options?: {
+    throwOnError?: boolean;
+}): MultiPolygon;
+export declare function intersection(a: PolygonInput, b: PolygonInput): MultiPolygon;
+export declare function area(multi: MultiPolygon): number;
+/** Polygon boundaries, including hole rims, belong to the polygon. */
+export declare function containsPoint(multi: MultiPolygon, p: [number, number]): boolean;
+export declare function distanceToBoundary(multi: MultiPolygon, p: [number, number]): number;
+//# sourceMappingURL=polygon-boolean.d.ts.map

package/dist/lib/polygon-boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-boolean.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-boolean.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;AACrC,MAAM,MAAM,OAAO,GAAG;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,IAAI,EAAE,CAAA;CAAE,CAAA;AACpD,MAAM,MAAM,YAAY,GAAG,OAAO,EAAE,CAAA;AACpC,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,OAAO,GAAG,YAAY,CAAA;AAoIxD,wBAAgB,KAAK,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CAKnE;AAED,wBAAgB,UAAU,CACxB,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,EACf,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAO,GACvC,YAAY,CAUd;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,YAAY,CA2B3E;AAED,wBAAgB,IAAI,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAQhD;AAgCD,sEAAsE;AACtE,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAW/E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAMnF"}

package/dist/lib/polygon-boolean.js

@@ -0,0 +1,195 @@
+import clipping from 'polygon-clipping';
+const SCALE = 10_000;
+const MIN_AREA = 1e-6;
+// Relative to the first vertex: absolute products at large coordinates (1e9 m
+// offsets) cancel catastrophically and turn a zero-area sliver into square metres.
+function signedArea(ring) {
+    const origin = ring[0];
+    if (!origin)
+        return 0;
+    const [ox, oz] = origin;
+    return (ring.reduce((sum, p, i) => {
+        const q = ring[(i + 1) % ring.length];
+        return sum + (p[0] - ox) * (q[1] - oz) - (q[0] - ox) * (p[1] - oz);
+    }, 0) / 2);
+}
+function comparePoints(a, b) {
+    return a[0] - b[0] || a[1] - b[1];
+}
+function dedupeRing(points) {
+    return points.filter((p, i) => comparePoints(p, points[(i + 1) % points.length]) !== 0);
+}
+function cleanRing(points, ccw) {
+    let ring = dedupeRing(points);
+    let changed = true;
+    while (changed && ring.length >= 3) {
+        changed = false;
+        ring = ring.filter((b, i) => {
+            const a = ring[(i + ring.length - 1) % ring.length];
+            const c = ring[(i + 1) % ring.length];
+            const cross = (b[0] - a[0]) * (c[1] - b[1]) - (b[1] - a[1]) * (c[0] - b[0]);
+            const between = (b[0] - a[0]) * (b[0] - c[0]) + (b[1] - a[1]) * (b[1] - c[1]) < 0;
+            if (Math.abs(cross) > 1e-12 || !between)
+                return true;
+            changed = true;
+            return false;
+        });
+    }
+    if (ring.length < 3)
+        return [];
+    if (signedArea(ring) > 0 !== ccw)
+        ring.reverse();
+    let first = 0;
+    for (let i = 1; i < ring.length; i++) {
+        if (comparePoints(ring[i], ring[first]) < 0)
+            first = i;
+    }
+    return [...ring.slice(first), ...ring.slice(0, first)];
+}
+function compareRings(a, b) {
+    for (let i = 0; i < Math.min(a.length, b.length); i++) {
+        const order = comparePoints(a[i], b[i]);
+        if (order)
+            return order;
+    }
+    return a.length - b.length;
+}
+function polygons(input) {
+    if (!Array.isArray(input))
+        return [input];
+    if (!input.length)
+        return [];
+    return Array.isArray(input[0]) ? [{ outer: input, holes: [] }] : input;
+}
+function quantised(input) {
+    return polygons(input).flatMap(({ outer, holes }) => {
+        const rings = [outer, ...holes].map((ring) => dedupeRing(ring.map(([x, z]) => {
+            const point = [
+                Math.round(x * SCALE) / SCALE,
+                Math.round(z * SCALE) / SCALE,
+            ];
+            if (![x, z, ...point].every(Number.isFinite))
+                throw new Error('Non-finite polygon coordinate');
+            return point.map((value) => (value === 0 ? 0 : value));
+        })));
+        if (rings[0].length < 3)
+            return [];
+        return [rings.filter((ring) => ring.length >= 3)];
+    });
+}
+function normalise(result) {
+    return result
+        .flatMap(([shell, ...voids]) => {
+        const outer = cleanRing(shell, true);
+        const holes = voids
+            .map((ring) => cleanRing(ring, false))
+            .filter((ring) => Math.abs(signedArea(ring)) >= MIN_AREA)
+            .sort(compareRings);
+        const polygon = { outer, holes };
+        return area([polygon]) >= MIN_AREA ? [polygon] : [];
+    })
+        .sort((a, b) => compareRings(a.outer, b.outer));
+}
+const warnedCallSites = new Set();
+function clip(operation, inputs, run, throwOnError = false) {
+    try {
+        return normalise(run(inputs.map(quantised)));
+    }
+    catch (error) {
+        if (throwOnError)
+            throw error;
+        if (process.env.NODE_ENV !== 'production') {
+            const caller = new Error('Polygon clipping caller').stack
+                ?.split('\n')
+                .slice(1)
+                .find((line) => !(line.includes('/polygon-boolean.ts:') || line.includes('/polygon-boolean.js:')));
+            const site = `${operation}:${caller ?? 'unknown'}`;
+            if (!warnedCallSites.has(site)) {
+                warnedCallSites.add(site);
+                console.warn(`[polygon-boolean] ${operation} failed at ${caller?.trim() ?? 'unknown caller'}`, error);
+            }
+        }
+        return [];
+    }
+}
+export function union(inputs) {
+    return clip('union', inputs, (polygons) => {
+        const valid = polygons.filter((multi) => multi.length);
+        return valid.length ? clipping.union(valid[0], ...valid.slice(1)) : [];
+    });
+}
+export function difference(a, b, options = {}) {
+    return clip('difference', [a, b], ([left, right]) => {
+        if (!left.length)
+            return [];
+        return right.length ? clipping.difference(left, right) : clipping.union(left);
+    }, options.throwOnError);
+}
+export function intersection(a, b) {
+    const bounds = (input) => {
+        let minX = Infinity, minZ = Infinity, maxX = -Infinity, maxZ = -Infinity;
+        for (const { outer } of polygons(input))
+            for (const [x, z] of outer) {
+                minX = Math.min(minX, x);
+                minZ = Math.min(minZ, z);
+                maxX = Math.max(maxX, x);
+                maxZ = Math.max(maxZ, z);
+            }
+        return [minX, minZ, maxX, maxZ];
+    };
+    const ab = bounds(a), bb = bounds(b);
+    if (ab[2] + 1 / SCALE < bb[0] ||
+        bb[2] + 1 / SCALE < ab[0] ||
+        ab[3] + 1 / SCALE < bb[1] ||
+        bb[3] + 1 / SCALE < ab[1])
+        return [];
+    return clip('intersection', [a, b], ([left, right]) => left.length && right.length ? clipping.intersection(left, right) : []);
+}
+export function area(multi) {
+    return multi.reduce((sum, polygon) => sum +
+        Math.abs(signedArea(polygon.outer)) -
+        polygon.holes.reduce((holes, ring) => holes + Math.abs(signedArea(ring)), 0), 0);
+}
+function ringDistance(ring, p) {
+    let distance = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < ring.length; i++) {
+        const a = ring[i], b = ring[(i + 1) % ring.length];
+        const dx = b[0] - a[0], dz = b[1] - a[1];
+        const lengthSq = dx * dx + dz * dz;
+        const t = lengthSq
+            ? Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dz) / lengthSq))
+            : 0;
+        distance = Math.min(distance, Math.hypot(p[0] - a[0] - t * dx, p[1] - a[1] - t * dz));
+    }
+    return distance;
+}
+function insideRing(ring, p) {
+    let inside = false;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const a = ring[i], b = ring[j];
+        if (a[1] > p[1] !== b[1] > p[1] &&
+            p[0] < ((b[0] - a[0]) * (p[1] - a[1])) / (b[1] - a[1]) + a[0])
+            inside = !inside;
+    }
+    return inside;
+}
+/** Polygon boundaries, including hole rims, belong to the polygon. */
+export function containsPoint(multi, p) {
+    for (const { outer, holes } of multi) {
+        if (ringDistance(outer, p) <= 1e-10)
+            return true;
+        let insideHole = false;
+        for (const hole of holes) {
+            if (ringDistance(hole, p) <= 1e-10)
+                return true;
+            if (insideRing(hole, p))
+                insideHole = true;
+        }
+        if (!insideHole && insideRing(outer, p))
+            return true;
+    }
+    return false;
+}
+export function distanceToBoundary(multi, p) {
+    return multi.reduce((distance, { outer, holes }) => Math.min(distance, ...[outer, ...holes].map((ring) => ringDistance(ring, p))), Number.POSITIVE_INFINITY);
+}

package/dist/lib/polygon-label.d.ts

@@ -0,0 +1,7 @@
+import { type Polygon, type Ring } from './polygon-boolean.js';
+export declare function polygonCentroid(polygon: Polygon): [number, number];
+export declare function polygonInteriorPoint(face: {
+    polygon: Ring;
+    holes?: Ring[];
+}, preferCentroid?: boolean): [number, number];
+//# sourceMappingURL=polygon-label.d.ts.map

package/dist/lib/polygon-label.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-label.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-label.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2C,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAEpG,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAuBlE;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CAAE,EACvC,cAAc,UAAQ,GACrB,CAAC,MAAM,EAAE,MAAM,CAAC,CAgElB"}

package/dist/lib/polygon-label.js

@@ -0,0 +1,94 @@
+import { area, containsPoint, distanceToBoundary } from './polygon-boolean.js';
+export function polygonCentroid(polygon) {
+    let weight = 0;
+    let x = 0;
+    let y = 0;
+    for (const [index, ring] of [polygon.outer, ...polygon.holes].entries()) {
+        let crossSum = 0;
+        let ringX = 0;
+        let ringY = 0;
+        for (let i = 0; i < ring.length; i++) {
+            const a = ring[i];
+            const b = ring[(i + 1) % ring.length];
+            const cross = a[0] * b[1] - b[0] * a[1];
+            crossSum += cross;
+            ringX += (a[0] + b[0]) * cross;
+            ringY += (a[1] + b[1]) * cross;
+        }
+        if (crossSum === 0)
+            continue;
+        const sign = Math.sign(crossSum) * (index === 0 ? 1 : -1);
+        weight += sign * crossSum;
+        x += sign * ringX;
+        y += sign * ringY;
+    }
+    return [x / (3 * weight), y / (3 * weight)];
+}
+export function polygonInteriorPoint(face, preferCentroid = false) {
+    const polygon = [{ outer: face.polygon, holes: face.holes ?? [] }];
+    if (face.polygon.length < 3 || area(polygon) <= 0)
+        return face.polygon[0] ?? [0, 0];
+    const centroid = polygonCentroid(polygon[0]);
+    if (preferCentroid &&
+        containsPoint(polygon, centroid) &&
+        distanceToBoundary(polygon, centroid) > 0)
+        return centroid;
+    const xs = face.polygon.map(([x]) => x);
+    const ys = face.polygon.map(([, y]) => y);
+    const minX = Math.min(...xs);
+    const minY = Math.min(...ys);
+    const maxX = Math.max(...xs);
+    const maxY = Math.max(...ys);
+    const cell = (x, y, half) => {
+        const point = [x, y];
+        const distance = distanceToBoundary(polygon, point) * (containsPoint(polygon, point) ? 1 : -1);
+        return { point, half, distance, max: distance + half * Math.SQRT2 };
+    };
+    const queue = [];
+    const push = (candidate) => {
+        let index = queue.length;
+        queue.push(candidate);
+        while (index > 0) {
+            const parent = (index - 1) >> 1;
+            if (queue[parent].max >= candidate.max)
+                break;
+            queue[index] = queue[parent];
+            index = parent;
+        }
+        queue[index] = candidate;
+    };
+    const pop = () => {
+        const first = queue[0];
+        const last = queue.pop();
+        if (queue.length) {
+            let index = 0;
+            while (index * 2 + 1 < queue.length) {
+                let child = index * 2 + 1;
+                if (child + 1 < queue.length && queue[child + 1].max > queue[child].max)
+                    child++;
+                if (last.max >= queue[child].max)
+                    break;
+                queue[index] = queue[child];
+                index = child;
+            }
+            queue[index] = last;
+        }
+        return first;
+    };
+    let best = cell(face.polygon[0][0], face.polygon[0][1], 0);
+    push(cell((minX + maxX) / 2, (minY + maxY) / 2, Math.max(maxX - minX, maxY - minY) / 2));
+    // Branch and bound finds the pole to 1 mm without assuming the face is convex or hole-free.
+    while (queue.length) {
+        const current = pop();
+        if (current.distance > best.distance)
+            best = current;
+        if (current.max - best.distance <= 0.001)
+            continue;
+        const half = current.half / 2;
+        for (const dx of [-half, half]) {
+            for (const dy of [-half, half])
+                push(cell(current.point[0] + dx, current.point[1] + dy, half));
+        }
+    }
+    return best.point;
+}

package/dist/lib/room-drawn-floor.d.ts

@@ -0,0 +1,29 @@
+import type { AnyNode } from '../schema/index.js';
+/**
+ * A room whose floor is a hand-drawn slab (legacy or authored), not a generated
+ * plate. Plate derivation skips such a room (see `buildFloorPlates`), so a
+ * room floor height would move nothing: the slab itself is what to edit.
+ */
+export type RoomDrawnFloor = {
+    /** The slab the room's floor was taken from (`floor.sourceSlabId`). */
+    sourceId: string;
+    /** The drawn slab the room visibly stands on: the one showing over most of its floor. */
+    slabId: string;
+    /** Other rooms that slab also floors. */
+    sharedZoneIds: string[];
+    /** More than one drawn slab shows in the room; `slabId` is the largest. */
+    ambiguous: boolean;
+};
+type Nodes = Readonly<Record<string, AnyNode>>;
+export declare function roomDrawnFloor(nodes: Nodes, zoneId: string): RoomDrawnFloor | null;
+/**
+ * The refusal for a floor height on a drawn-slab room: the height lives on the
+ * slab, so the room names it instead of storing a height nothing reads.
+ */
+export declare function drawnFloorElevationConflict(nodes: Nodes, zoneId: string): {
+    code: "room-drawn-floor";
+    nodeIds: string[];
+    message: string;
+} | null;
+export {};
+//# sourceMappingURL=room-drawn-floor.d.ts.map

package/dist/lib/room-drawn-floor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-drawn-floor.d.ts","sourceRoot":"","sources":["../../src/lib/room-drawn-floor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,WAAW,CAAA;AAU5D;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAA;IAChB,yFAAyF;IACzF,MAAM,EAAE,MAAM,CAAA;IACd,yCAAyC;IACzC,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,2EAA2E;IAC3E,SAAS,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,KAAK,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;AAY9C,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAQlF;AA8DD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM;;;;SAUvE"}

package/dist/lib/room-drawn-floor.js

@@ -0,0 +1,88 @@
+import { area, difference, intersection, union, } from './polygon-boolean.js';
+const isDrawnSlab = (node) => node?.type === 'slab' && !node.plateRole && node.boundary !== 'auto' && !node.autoFromWalls;
+const footprint = (node) => ({
+    outer: node.polygon,
+    holes: node.holes ?? [],
+});
+const memo = new WeakMap();
+export function roomDrawnFloor(nodes, zoneId) {
+    let cache = memo.get(nodes);
+    if (!cache) {
+        cache = new Map();
+        memo.set(nodes, cache);
+    }
+    if (!cache.has(zoneId))
+        cache.set(zoneId, computeRoomDrawnFloor(nodes, zoneId));
+    return cache.get(zoneId);
+}
+function computeRoomDrawnFloor(nodes, zoneId) {
+    const zone = nodes[zoneId];
+    // A switched-off floor (`hasFloor: false`) still names its slab: the drawn
+    // slab stays visible, so the room stands on it all the same.
+    if (zone?.type !== 'zone' ||
+        !zone.parentId ||
+        zone.floor?.support === 'open' ||
+        !zone.floor?.sourceSlabId)
+        return null;
+    const source = nodes[zone.floor.sourceSlabId];
+    if (!isDrawnSlab(source) || source.parentId !== zone.parentId)
+        return null;
+    const room = footprint(zone);
+    // The same overlap that keeps the room out of plate derivation.
+    if (area(intersection(room, footprint(source))) <= 1e-4)
+        return null;
+    const roomArea = area([room]);
+    const slabs = Object.values(nodes)
+        .filter((node) => isDrawnSlab(node) &&
+        node.parentId === zone.parentId &&
+        node.visible !== false &&
+        node.support !== 'open' &&
+        !node.recessed)
+        .sort((a, b) => b.elevation - a.elevation || a.id.localeCompare(b.id));
+    // Top down: each slab shows where no higher slab already covers the room.
+    let covered = [];
+    const shown = [];
+    for (const slab of slabs) {
+        const inRoom = intersection(footprint(slab), room);
+        if (area(inRoom) <= 1e-4)
+            continue;
+        const visible = covered.length ? area(difference(inRoom, covered)) : area(inRoom);
+        covered = union([...covered, ...inRoom]);
+        if (visible > 1e-4)
+            shown.push({ slab, visible });
+    }
+    shown.sort((a, b) => b.visible - a.visible || b.slab.elevation - a.slab.elevation);
+    const slab = shown[0]?.slab ?? source;
+    const minor = Math.max(0.05, roomArea * 0.02);
+    const sharedZoneIds = Object.values(nodes)
+        .filter((node) => node.type === 'zone' &&
+        node.id !== zone.id &&
+        node.parentId === zone.parentId &&
+        node.spaceRole === 'room' &&
+        node.floor?.support !== 'open' &&
+        area(intersection(footprint(node), footprint(slab))) > 0.05)
+        .map((node) => node.id)
+        .sort();
+    return {
+        sourceId: source.id,
+        slabId: slab.id,
+        sharedZoneIds,
+        ambiguous: shown.filter((entry) => entry.visible > minor).length > 1,
+    };
+}
+/**
+ * The refusal for a floor height on a drawn-slab room: the height lives on the
+ * slab, so the room names it instead of storing a height nothing reads.
+ */
+export function drawnFloorElevationConflict(nodes, zoneId) {
+    const floor = roomDrawnFloor(nodes, zoneId);
+    if (!floor)
+        return null;
+    const slab = nodes[floor.slabId];
+    const name = slab.name?.trim() || 'a drawn slab';
+    return {
+        code: 'room-drawn-floor',
+        nodeIds: [zoneId, floor.slabId],
+        message: `This room's floor is ${name === 'a drawn slab' ? name : `the drawn slab "${name}"`} (${floor.slabId}). Its height is the slab's: change that slab's elevation instead.`,
+    };
+}

package/dist/lib/room-floor-choices.d.ts

@@ -0,0 +1,11 @@
+import type { AnyNode } from '../schema/index.js';
+export type RoomFloorChoice = {
+    key: string | null;
+    plateId: string;
+    name: string;
+    current: boolean;
+    drawn?: boolean;
+    mezzanine?: boolean;
+};
+export declare function roomFloorChoices(nodes: Readonly<Record<string, AnyNode>>, zoneId: string): RoomFloorChoice[];
+//# sourceMappingURL=room-floor-choices.d.ts.map

package/dist/lib/room-floor-choices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-floor-choices.d.ts","sourceRoot":"","sources":["../../src/lib/room-floor-choices.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAY,MAAM,WAAW,CAAA;AAMlD,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IAClB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,SAAS,CAAC,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,GACb,eAAe,EAAE,CAqDnB"}

package/dist/lib/room-floor-choices.js

@@ -0,0 +1,60 @@
+import { boundaries, roomFace } from '../commands/structure/shared.js';
+import { floorFootprintName } from './floor-footprint-name.js';
+import { floorRoomFaces } from './floor-room-faces.js';
+import { area, intersection, union } from './polygon-boolean.js';
+import { roomDrawnFloor } from './room-drawn-floor.js';
+export function roomFloorChoices(nodes, zoneId) {
+    const zone = nodes[zoneId];
+    if (zone?.type !== 'zone' || zone.spaceRole !== 'room' || !zone.parentId)
+        return [];
+    const drawn = roomDrawnFloor(nodes, zoneId);
+    const faces = floorRoomFaces(boundaries(nodes, zone.parentId));
+    const face = roomFace(nodes, zone, faces);
+    const adjacent = new Set([zoneId]);
+    for (const room of Object.values(nodes)) {
+        if (room.type !== 'zone' || room.parentId !== zone.parentId)
+            continue;
+        if (roomFace(nodes, room, faces)?.spans.some((other) => face?.spans.some((span) => span.boundaryId === other.boundaryId &&
+            span.face !== other.face &&
+            Math.min(span.t1, other.t1) - Math.max(span.t0, other.t0) > 1e-6)))
+            adjacent.add(room.id);
+    }
+    const footprint = { outer: zone.polygon, holes: zone.holes };
+    const plates = Object.values(nodes).filter((node) => {
+        if (node.type !== 'slab' || node.parentId !== zone.parentId)
+            return false;
+        if (node.id === drawn?.slabId)
+            return true;
+        if (node.support === 'open')
+            return !!node.zoneIds?.includes(zoneId);
+        if (node.plateRole !== 'base')
+            return false;
+        if (node.zoneIds?.some((id) => adjacent.has(id)))
+            return true;
+        const plate = { outer: node.polygon, holes: node.holes };
+        return area(intersection(footprint, plate)) > 1e-6 || union([footprint, plate]).length === 1;
+    });
+    const choices = plates
+        .map((plate) => {
+        const owner = (plate.zoneIds ?? [])
+            .map((id) => nodes[id])
+            .find((node) => node?.type === 'zone');
+        return {
+            key: owner?.type === 'zone' ? (owner.floor?.footprint ?? null) : null,
+            plateId: plate.id,
+            name: floorFootprintName(nodes, plate),
+            current: drawn ? plate.id === drawn.slabId : !!plate.zoneIds?.includes(zoneId),
+            ...(plate.id === drawn?.slabId ? { drawn: true } : {}),
+            ...(plate.support === 'open' ? { mezzanine: true } : {}),
+        };
+    })
+        .sort((a, b) => Number(b.current) - Number(a.current) || a.plateId.localeCompare(b.plateId));
+    const seen = new Set();
+    return choices.filter((choice) => {
+        const identity = choice.key ?? choice.plateId;
+        if (seen.has(identity))
+            return false;
+        seen.add(identity);
+        return true;
+    });
+}

package/dist/lib/room-floor-feasibility.d.ts

@@ -0,0 +1,25 @@
+import type { AnyNode } from '../schema/index.js';
+import { MIN_GROUND_FLOOR_THICKNESS, MIN_SLAB_THICKNESS } from '../schema/nodes/slab.js';
+export declare const FLOOR_ELEVATION_EPSILON = 0.001;
+export { MIN_GROUND_FLOOR_THICKNESS, MIN_SLAB_THICKNESS };
+export type RoomFloorConflict = {
+    code: 'floor-foundation-level' | 'floor-foundation-shared-storey' | 'floor-plate-thickness' | 'floor-wall-fit' | 'floor-headroom' | 'floor-opening-fit' | 'floor-window-sill' | 'floor-sunken-depth' | 'floor-low-headroom' | 'floor-door-step' | 'floor-door-swing';
+    nodeIds: string[];
+    message: string;
+    severity: 'error' | 'warning';
+    excess?: number;
+};
+export declare function getRoomBaseElevation(nodes: Readonly<Record<string, AnyNode>>, zoneId: string): number;
+export declare function automaticRoomBaseElevations(nodes: Readonly<Record<string, AnyNode>>, levelId: string): ReadonlyMap<string, number>;
+export declare function checkRoomFloor(nodes: Readonly<Record<string, AnyNode>>, zoneId: string, proposedElevation: number): {
+    conflicts: RoomFloorConflict[];
+    minElevation: number;
+    maxElevation: number;
+    elevation: number;
+    clamped: boolean;
+};
+export declare function roundFloorElevation(elevation: number): number;
+export declare function getRoomRelativeFloorElevation(nodes: Readonly<Record<string, AnyNode>>, zoneId: string): number;
+export declare function roomFloorElevationFromRelative(nodes: Readonly<Record<string, AnyNode>>, zoneId: string, height: number): number;
+export declare function clampRoomFloorHandle(nodes: Readonly<Record<string, AnyNode>>, zoneId: string, proposed: number): number;
+//# sourceMappingURL=room-floor-feasibility.d.ts.map

package/dist/lib/room-floor-feasibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-floor-feasibility.d.ts","sourceRoot":"","sources":["../../src/lib/room-floor-feasibility.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,WAAW,CAAA;AAC5D,OAAO,EAEL,0BAA0B,EAC1B,kBAAkB,EACnB,MAAM,sBAAsB,CAAA;AAgB7B,eAAO,MAAM,uBAAuB,QAAQ,CAAA;AAC5C,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,CAAA;AAEzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,EACA,wBAAwB,GACxB,gCAAgC,GAChC,uBAAuB,GACvB,gBAAgB,GAChB,gBAAgB,GAChB,mBAAmB,GACnB,mBAAmB,GACnB,oBAAoB,GACpB,oBAAoB,GACpB,iBAAiB,GACjB,kBAAkB,CAAA;IACtB,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAID,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,GACb,MAAM,CA8CR;AAID,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAoE7B;AAID,wBAAgB,cAAc,CAC5B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,iBAAiB,EAAE,MAAM;;;;;;EAa1B;AA4KD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE7D;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,GACb,MAAM,CAMR;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,MAAM,CAER;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAWR"}