@pascal-app/core 1.0.6 → 1.1.0

package/dist/systems/roof/roof-elevation.js

@@ -1,7 +1,9 @@
-import { resolveLevelId } from '../../lib/node-ancestry.js';
+import { findLevelAncestorId, resolveLevelId } from '../../lib/node-ancestry.js';
 import { wallSupportForNodes } from '../../lib/opening-floor-datum.js';
+import { queryNodes } from '../../runtime/node-queries.js';
+import { isRailingWall } from '../../schema/nodes/railing-wall.js';
 import { coveredStoreyId, servesAsRoofLevel } from '../../services/roof-level.js';
-import { findLevelBelowId, getLevelElevations, getWallTop } from '../../services/storey.js';
+import { findLevelAboveId, findLevelBelowId, getLevelElevations, getWallTop, } from '../../services/storey.js';
 import { wallOverlapsSlabFootprint } from '../slab/slab-support.js';
 import { getWallArcData } from '../wall/wall-curve.js';
 import { resolveRoomRoofFootprintOnLevel } from './roof-footprint.js';
@@ -10,7 +12,8 @@ export function resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevatio
     const sourceLevelY = elevations.get(sourceLevelId)?.baseY ?? 0;
     const targetLevelY = elevations.get(targetLevelId)?.baseY ?? 0;
     const support = wallSupportForNodes(wall, nodes);
-    return sourceLevelY + getWallTop(wall, sourceLevelId, nodes, support.elevation) - targetLevelY;
+    const top = Math.max(getWallTop(wall, sourceLevelId, nodes, support.elevation, 0), getWallTop(wall, sourceLevelId, nodes, support.elevation, 1));
+    return sourceLevelY + top - targetLevelY;
 }
 /**
  * The walls among `wallIds` a roof stands on: those under its segments' footprints, closed room or
@@ -65,12 +68,15 @@ function wallsUnderRoof(roof, nodes, wallIds) {
             footprints.some((polygon) => wallOverlapsSlabFootprint(wall, polygon)));
     });
 }
-/** The tallest of these walls' tops, from `targetLevelId`'s floor; undefined for none. */
+/**
+ * The tallest of these walls' tops, from `targetLevelId`'s floor; undefined for none. A railing is a
+ * guard round a deck or a porch, not a wall: no roof stands on its top.
+ */
 function highestWallTop(targetLevelId, wallIds, nodes, elevations) {
     let highest;
     for (const id of wallIds) {
         const wall = nodes[id];
-        if (wall?.type !== 'wall')
+        if (wall?.type !== 'wall' || isRailingWall(wall))
             continue;
         const top = resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevations);
         highest = highest === undefined ? top : Math.max(highest, top);
@@ -122,3 +128,79 @@ export function roofWallTop(roof, nodes, levelId) {
         return null;
     return (highestWallTop(resolveLevelId(roof, nodes), wallIds, nodes, getLevelElevations(nodes)) ?? null);
 }
+const ROOF_ELEVATION_EPSILON = 1e-4;
+/** Kinds whose change can move a wall-supported roof. */
+export function isRoofElevationInput(node) {
+    return (node?.type === 'roof' ||
+        node?.type === 'wall' ||
+        node?.type === 'slab' ||
+        node?.type === 'level' ||
+        node?.type === 'building' ||
+        node?.type === 'site');
+}
+/** Wall-supported roofs whose stored Y no longer sits on their walls, and where it should. */
+export function planRoofElevationUpdates(nodes, only) {
+    const updates = [];
+    for (const node of queryNodes(nodes, { type: 'roof' })) {
+        if (node.support?.kind !== 'walls' || (only && !only.has(node.id)))
+            continue;
+        const elevation = resolveRoofElevation(node, nodes);
+        if (Math.abs(node.position[1] - elevation) <= ROOF_ELEVATION_EPSILON)
+            continue;
+        updates.push({
+            id: node.id,
+            data: { position: [node.position[0], elevation, node.position[2]] },
+        });
+    }
+    return updates;
+}
+/**
+ * The roofs an edit can move, from the nodes it changed. A roof rests on the walls of its own level
+ * or the level below, so: a changed roof (or segment); for a changed wall, the roofs on its level
+ * and the level above; for a changed slab, the levels whose walls it touches (its own, which it
+ * carries, and the one below, whose plane-bound tops it caps) and every level above it in its
+ * building (a base plate lifts them). Null, for every roof, when a level, building or site changed.
+ */
+export function roofsAffectedBy(before, after, changedIds) {
+    const roofs = new Set();
+    const levels = new Set();
+    for (const id of changedIds)
+        for (const nodes of [before, after]) {
+            const node = nodes[id];
+            if (!node)
+                continue;
+            if (node.type === 'level' || node.type === 'building' || node.type === 'site')
+                return null;
+            if (node.type === 'roof')
+                roofs.add(id);
+            else if (node.type === 'roof-segment' && node.parentId)
+                roofs.add(node.parentId);
+            else if (node.type === 'wall' || node.type === 'slab') {
+                const levelId = findLevelAncestorId(id, nodes);
+                if (!levelId)
+                    return null;
+                const elevations = getLevelElevations(nodes);
+                levels.add(levelId);
+                if (node.type === 'wall') {
+                    const above = findLevelAboveId(levelId, elevations);
+                    if (above)
+                        levels.add(above);
+                    continue;
+                }
+                const below = findLevelBelowId(levelId, elevations);
+                if (below)
+                    levels.add(below);
+                const own = elevations.get(levelId);
+                for (const [otherId, other] of elevations)
+                    if (own && other.buildingId === own.buildingId && other.ordinal > own.ordinal)
+                        levels.add(otherId);
+            }
+        }
+    if (levels.size)
+        for (const roof of queryNodes(after, { type: 'roof' })) {
+            const levelId = findLevelAncestorId(roof.id, after);
+            if (levelId && levels.has(levelId))
+                roofs.add(roof.id);
+        }
+    return roofs;
+}

package/dist/systems/roof/roof-footprint.d.ts

@@ -1,17 +1,58 @@
-import type { AnyNode, LevelNode, WallNode } from '../../schema/index.js';
+import type { AnyNode, LevelNode, SeparatorNode, WallNode, ZoneNode } from '../../schema/index.js';
 export type RoofFootprintTarget = {
     id: string;
     polygon: Array<[number, number]>;
+    /** The walls it stands on: a room's walls; a porch's, deck's or patio's house walls. */
     wallIds: WallNode['id'][];
+    /**
+     * A porch's, deck's or patio's invisible walls and railings along its outside edge: the edge the
+     * roof's outer face stands on, not walls it stands on (`outdoorRoomRoofOutline`).
+     */
+    edgeIds?: string[];
+    /** The level the room is on. */
+    levelId?: LevelNode['id'];
     center: [number, number];
     width: number;
     depth: number;
     rotation: number;
     rectangular: boolean;
 };
+type P = [number, number];
+/** What runs along an edge of a room's roof outline: a wall, a railing or an invisible wall. */
+export type RoofOutlineEdge = {
+    kind: 'wall' | 'railing' | 'separator';
+    id: string;
+} | null;
+/**
+ * The outside edge of a porch, deck or patio (`lib/outdoor-room`) a roof over it lines up with,
+ * in its level's plan: the room's outline with each edge on a railing moved out to the railing's
+ * outside face (to its posts' outer corners where two railings meet). An edge on an invisible wall
+ * stays on its line, which is the room's edge, and one on the house wall the room leans on stays
+ * on the wall's centre line, as a room's walls do in the house's own roof footprint. `edges[i]`
+ * runs from `polygon[i]` to `polygon[i + 1]`: what runs along it, null on the short jog where a
+ * railing runs on into an invisible wall along one line.
+ */
+export declare function outdoorRoomRoofOutline(zone: Pick<ZoneNode, 'polygon'>, walls: readonly WallNode[], separators: readonly SeparatorNode[]): {
+    polygon: P[];
+    edges: RoofOutlineEdge[];
+};
 export declare function fitRoofFootprint(id: string, polygon: Array<[number, number]>, wallIds: WallNode['id'][]): RoofFootprintTarget | null;
+/**
+ * The Room pick's footprint at `point`, on the level or else the level below: the porch, deck or
+ * patio there, to its outside edge (`resolveOutdoorRoomRoofFootprintOnLevel`), else the smallest
+ * room the level's walls enclose (`resolveRoomRoofFootprintOnLevel`).
+ */
 export declare function resolveRoomRoofFootprint(levelId: LevelNode['id'], nodes: Readonly<Record<string, AnyNode>>, point: [number, number], options?: {
     rectangularOnly?: boolean;
 }): RoofFootprintTarget | null;
+/**
+ * The porch, deck or patio at `point` on `levelId` (the smallest), as a roof over it stands: its
+ * outside edge (`outdoorRoomRoofOutline`), standing on the house walls it leans on, its invisible
+ * walls and railings the edge its outer face lines up with. Null where no such room is. Indoors the
+ * Room pick reads the walls alone, so an invisible wall splitting a room off inside the house
+ * never shrinks the house's roof to it.
+ */
+export declare function resolveOutdoorRoomRoofFootprintOnLevel(levelId: LevelNode['id'], nodes: Readonly<Record<string, AnyNode>>, point: [number, number]): RoofFootprintTarget | null;
 export declare function resolveRoomRoofFootprintOnLevel(levelId: LevelNode['id'], nodes: Readonly<Record<string, AnyNode>>, point: [number, number]): RoofFootprintTarget | null;
+export {};
 //# sourceMappingURL=roof-footprint.d.ts.map

package/dist/systems/roof/roof-footprint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-footprint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGhE,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAA;IACzB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AAWD,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,GACxB,mBAAmB,GAAG,IAAI,CAqD5B;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1C,mBAAmB,GAAG,IAAI,CAW5B;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,mBAAmB,GAAG,IAAI,CAW5B"}
+{"version":3,"file":"roof-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-footprint.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAOzF,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,wFAAwF;IACxF,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAA;IACzB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,gCAAgC;IAChC,OAAO,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACzB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AAED,KAAK,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEzB,gGAAgG;AAChG,MAAM,MAAM,eAAe,GAAG;IAAE,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,WAAW,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAA;AAyD3F;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,EAC/B,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,UAAU,EAAE,SAAS,aAAa,EAAE,GACnC;IAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAAC,KAAK,EAAE,eAAe,EAAE,CAAA;CAAE,CAiD5C;AAWD,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,GACxB,mBAAmB,GAAG,IAAI,CAqD5B;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1C,mBAAmB,GAAG,IAAI,CAe5B;AAED;;;;;;GAMG;AACH,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,mBAAmB,GAAG,IAAI,CAsB5B;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,mBAAmB,GAAG,IAAI,CAW5B"}

package/dist/systems/roof/roof-footprint.js

@@ -1,6 +1,125 @@
+import { isOutdoorRoomType } from '../../lib/outdoor-room.js';
 import { pointInPolygon as pointInPolygon2D } from '../../lib/polygon-relations.js';
 import { detectSpacesForLevel } from '../../lib/space-detection.js';
+import { isRailingWall } from '../../schema/nodes/railing-wall.js';
 import { getLevelBelow } from '../../services/storey.js';
+import { isCurvedWall } from '../wall/wall-curve.js';
+import { getWallThickness } from '../wall/wall-footprint.js';
+import { getWallBodyLine } from '../wall/wall-frame.js';
+/** A room's outline edge this near a boundary's line, and parallel to it, runs along it (m). */
+const ON_BOUNDARY = 0.01;
+/** What runs along the room edge `a` → `b`: the nearest straight wall or invisible wall on it. */
+function boundaryAlong(a, b, walls, separators) {
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    if (length < 1e-9)
+        return null;
+    const dir = [(b[0] - a[0]) / length, (b[1] - a[1]) / length];
+    const mid = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+    const lines = [
+        // A wall drawn by a face runs its rooms along its body's centre, half its thickness off it.
+        ...walls.flatMap((wall) => {
+            if (isCurvedWall(wall))
+                return [];
+            const body = getWallBodyLine(wall);
+            return [
+                {
+                    kind: isRailingWall(wall) ? 'railing' : 'wall',
+                    id: wall.id,
+                    start: [body.start.x, body.start.y],
+                    end: [body.end.x, body.end.y],
+                    thickness: getWallThickness(wall),
+                },
+            ];
+        }),
+        ...separators.map((separator) => ({
+            kind: 'separator',
+            id: separator.id,
+            start: separator.start,
+            end: separator.end,
+            thickness: 0,
+        })),
+    ];
+    let found = null;
+    let nearest = ON_BOUNDARY;
+    for (const line of lines) {
+        const run = [line.end[0] - line.start[0], line.end[1] - line.start[1]];
+        const span = Math.hypot(run[0], run[1]);
+        if (span < 1e-6)
+            continue;
+        const u = [run[0] / span, run[1] / span];
+        if (Math.abs(u[0] * dir[1] - u[1] * dir[0]) > 1e-3)
+            continue;
+        const rel = [mid[0] - line.start[0], mid[1] - line.start[1]];
+        const across = Math.abs(rel[0] * u[1] - rel[1] * u[0]);
+        const along = rel[0] * u[0] + rel[1] * u[1];
+        if (across > nearest || along < -ON_BOUNDARY || along > span + ON_BOUNDARY)
+            continue;
+        found = { kind: line.kind, id: line.id, thickness: line.thickness };
+        nearest = across;
+    }
+    return found;
+}
+/**
+ * The outside edge of a porch, deck or patio (`lib/outdoor-room`) a roof over it lines up with,
+ * in its level's plan: the room's outline with each edge on a railing moved out to the railing's
+ * outside face (to its posts' outer corners where two railings meet). An edge on an invisible wall
+ * stays on its line, which is the room's edge, and one on the house wall the room leans on stays
+ * on the wall's centre line, as a room's walls do in the house's own roof footprint. `edges[i]`
+ * runs from `polygon[i]` to `polygon[i + 1]`: what runs along it, null on the short jog where a
+ * railing runs on into an invisible wall along one line.
+ */
+export function outdoorRoomRoofOutline(zone, walls, separators) {
+    const points = zone.polygon.filter((point, index, all) => {
+        const next = all[(index + 1) % all.length];
+        return Math.hypot(next[0] - point[0], next[1] - point[1]) > 1e-9;
+    });
+    const n = points.length;
+    if (n < 3)
+        return { polygon: points, edges: points.map(() => null) };
+    let area = 0;
+    for (let i = 0; i < n; i++) {
+        const a = points[i];
+        const b = points[(i + 1) % n];
+        area += a[0] * b[1] - b[0] * a[1];
+    }
+    const turn = area > 0 ? 1 : -1;
+    const sides = points.map((a, i) => {
+        const b = points[(i + 1) % n];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const dir = [(b[0] - a[0]) / length, (b[1] - a[1]) / length];
+        const boundary = boundaryAlong(a, b, walls, separators);
+        const edge = boundary && { kind: boundary.kind, id: boundary.id };
+        return {
+            dir,
+            out: [dir[1] * turn, -dir[0] * turn],
+            offset: boundary?.kind === 'railing' ? boundary.thickness / 2 : 0,
+            edge,
+        };
+    });
+    const polygon = [];
+    const edges = [];
+    sides.forEach((side, i) => {
+        const prev = sides[(i - 1 + n) % n];
+        const vertex = points[i];
+        const from = [vertex[0] + prev.out[0] * prev.offset, vertex[1] + prev.out[1] * prev.offset];
+        const to = [vertex[0] + side.out[0] * side.offset, vertex[1] + side.out[1] * side.offset];
+        const denom = prev.dir[0] * side.dir[1] - prev.dir[1] * side.dir[0];
+        if (Math.abs(denom) > 1e-9) {
+            // Where the two edges' moved lines meet.
+            const t = ((to[0] - from[0]) * side.dir[1] - (to[1] - from[1]) * side.dir[0]) / denom;
+            polygon.push([from[0] + prev.dir[0] * t, from[1] + prev.dir[1] * t]);
+        }
+        else {
+            polygon.push(from);
+            if (Math.hypot(to[0] - from[0], to[1] - from[1]) > 1e-9) {
+                edges.push(null);
+                polygon.push(to);
+            }
+        }
+        edges.push(side.edge);
+    });
+    return { polygon, edges };
+}
 function polygonArea(polygon) {
     return Math.abs(polygon.reduce((area, point, index) => {
         const next = polygon[(index + 1) % polygon.length];
@@ -54,20 +173,57 @@ export function fitRoofFootprint(id, polygon, wallIds) {
         rectangular: polygonArea(polygon) / best.area >= 0.96,
     };
 }
+/**
+ * The Room pick's footprint at `point`, on the level or else the level below: the porch, deck or
+ * patio there, to its outside edge (`resolveOutdoorRoomRoofFootprintOnLevel`), else the smallest
+ * room the level's walls enclose (`resolveRoomRoofFootprintOnLevel`).
+ */
 export function resolveRoomRoofFootprint(levelId, nodes, point, options = {}) {
-    const activeTarget = resolveRoomRoofFootprintOnLevel(levelId, nodes, point);
+    const onLevel = (id) => {
+        const target = resolveOutdoorRoomRoofFootprintOnLevel(id, nodes, point) ??
+            resolveRoomRoofFootprintOnLevel(id, nodes, point);
+        return target && { ...target, levelId: id };
+    };
+    const activeTarget = onLevel(levelId);
     if (activeTarget && (!options.rectangularOnly || activeTarget.rectangular))
         return activeTarget;
     if (activeTarget)
         return null;
     const levelBelow = getLevelBelow(levelId, nodes);
-    const levelBelowTarget = levelBelow
-        ? resolveRoomRoofFootprintOnLevel(levelBelow.id, nodes, point)
-        : null;
+    const levelBelowTarget = levelBelow ? onLevel(levelBelow.id) : null;
     return levelBelowTarget && (!options.rectangularOnly || levelBelowTarget.rectangular)
         ? levelBelowTarget
         : null;
 }
+/**
+ * The porch, deck or patio at `point` on `levelId` (the smallest), as a roof over it stands: its
+ * outside edge (`outdoorRoomRoofOutline`), standing on the house walls it leans on, its invisible
+ * walls and railings the edge its outer face lines up with. Null where no such room is. Indoors the
+ * Room pick reads the walls alone, so an invisible wall splitting a room off inside the house
+ * never shrinks the house's roof to it.
+ */
+export function resolveOutdoorRoomRoofFootprintOnLevel(levelId, nodes, point) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const children = level.children.map((id) => nodes[id]);
+    const zone = children
+        .filter((node) => node?.type === 'zone' &&
+        isOutdoorRoomType(node.roomType) &&
+        node.polygon.length >= 3 &&
+        pointInPolygon2D(point, node.polygon))
+        .sort((left, right) => polygonArea(left.polygon) - polygonArea(right.polygon))[0];
+    if (!zone)
+        return null;
+    const walls = children.filter((node) => node?.type === 'wall');
+    const separators = children.filter((node) => node?.type === 'separator');
+    const { polygon, edges } = outdoorRoomRoofOutline(zone, walls, separators);
+    const ids = (kinds) => [
+        ...new Set(edges.flatMap((edge) => (edge && kinds.includes(edge.kind) ? [edge.id] : []))),
+    ];
+    const target = fitRoofFootprint(zone.id, polygon, ids(['wall']));
+    return target && { ...target, edgeIds: ids(['railing', 'separator']) };
+}
 export function resolveRoomRoofFootprintOnLevel(levelId, nodes, point) {
     const level = nodes[levelId];
     if (level?.type !== 'level')