@pascal-app/core 1.0.3 → 1.0.5

package/dist/lib/floor-intent-changes.js

@@ -0,0 +1,461 @@
+import { boundaries, roomFace } from '../commands/structure/shared.js';
+import { DEFAULT_SLAB_ELEVATION } from '../schema/nodes/slab.js';
+import { findLevelBelowId, getLevelElevations, getWallCoveringSlabUnderside, getWallTop, } from '../services/storey.js';
+import { automaticFloorHeight, floorPlateAtGroundContact, floorPlateHoldsUnderside, footprintSupportsNode, supportDerivedFloorHeight, } from './floor-foundation-datum.js';
+import { changedLevelConstructionDisplacements, footprintStackChanges, } from './floor-foundation-stack.js';
+import { floorRoomFaces } from './floor-room-faces.js';
+import { getOpeningFloorTarget, wallSupportForNodes } from './opening-floor-datum.js';
+import { area, intersection } from './polygon-boolean.js';
+import { checkRoomFloor, getRoomBaseElevation, roundFloorElevation, } from './room-floor-feasibility.js';
+/**
+ * The opening a created one repeats: same kind, size and place on a wall
+ * running the same line, as in a duplicated level. The copy is judged like
+ * its source, refused only when it fits worse, so copying a level never fails
+ * on an opening the original already has.
+ */
+function copiedOpening(nodes, draft, opening) {
+    const wall = draft[opening.parentId];
+    if (wall?.type !== 'wall')
+        return undefined;
+    const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+    return Object.values(nodes).find((node) => {
+        if (node.type !== opening.type ||
+            node.width !== opening.width ||
+            node.height !== opening.height ||
+            !same(node.position, opening.position))
+            return false;
+        const host = nodes[node.parentId];
+        return (host?.type === 'wall' &&
+            same(host.start, wall.start) &&
+            same(host.end, wall.end) &&
+            same(host.curveOffset, wall.curveOffset));
+    });
+}
+export function expandFloorIntentChanges(nodes, updates) {
+    const intent = updates.map((update) => {
+        const plate = nodes[update.id];
+        const patch = update.data;
+        if (plate?.type !== 'slab' || plate.plateRole !== 'base')
+            return update;
+        // A reference rebase can need an explicit current top even when that top
+        // equals the old resting height; normalizing it away would move the floor.
+        if (Object.hasOwn(patch, 'referenceFloorElevation'))
+            return update;
+        const supported = floorPlateHoldsUnderside(nodes, plate);
+        if (supported) {
+            if (!Object.hasOwn(patch, 'floorHeight') &&
+                patch.thickness === undefined &&
+                patch.elevation === undefined)
+                return update;
+            const currentTop = plate.floorHeight ?? plate.elevation;
+            const nextTop = patch.floorHeight !== undefined
+                ? (patch.floorHeight ?? automaticFloorHeight(nodes, plate))
+                : patch.elevation !== undefined
+                    ? patch.elevation
+                    : currentTop + (patch.thickness ?? plate.thickness) - plate.thickness;
+            return {
+                ...update,
+                data: {
+                    ...update.data,
+                    floorHeight: undefined,
+                    thickness: roundFloorElevation(plate.thickness + nextTop - currentTop),
+                    elevation: roundFloorElevation(nextTop),
+                },
+            };
+        }
+        if (Object.hasOwn(patch, 'floorHeight')) {
+            const resting = supportDerivedFloorHeight(nodes, plate);
+            const atRest = patch.floorHeight == null || Math.abs(patch.floorHeight - resting) <= 0.001;
+            const keepExplicitRest = plate.referenceFloorElevation !== undefined &&
+                Math.abs(plate.referenceFloorElevation - resting) > 0.001;
+            // The store guard can expand a normalized plan again. Its cleared height
+            // must not erase the foundation already resolved for a raised top. The
+            // slab sits on the foundation, so only a top above grade + thickness has one.
+            const foundationHeight = (patch.floorHeight ?? resting) -
+                (resting - DEFAULT_SLAB_ELEVATION) -
+                (patch.thickness ?? plate.thickness);
+            const foundation = foundationHeight <= 0.0005
+                ? { ...plate.foundation, ...patch.foundation, type: 'none' }
+                : (patch.foundation ??
+                    (patch.floorHeight == null
+                        ? { ...plate.foundation, type: 'none' }
+                        : plate.foundation?.type === 'solid'
+                            ? plate.foundation
+                            : {
+                                type: 'solid',
+                                material: plate.foundation?.material ?? 'library:preset-midgrey',
+                            }));
+            return {
+                ...update,
+                data: {
+                    ...update.data,
+                    floorHeight: atRest && !keepExplicitRest ? undefined : (patch.floorHeight ?? resting),
+                    ...(foundation ? { foundation } : {}),
+                },
+            };
+        }
+        return update;
+    });
+    const stack = footprintStackChanges(nodes, intent);
+    const constructionUpdates = [...intent, ...stack.updates];
+    const result = [...constructionUpdates];
+    for (const update of constructionUpdates) {
+        const plate = nodes[update.id];
+        if (plate?.type !== 'slab' ||
+            plate.plateRole !== 'base' ||
+            (!Object.hasOwn(update.data, 'floorHeight') && !Object.hasOwn(update.data, 'elevation')))
+            continue;
+        const patch = update.data;
+        const delta = (patch.elevation ?? patch.floorHeight ?? automaticFloorHeight(nodes, plate)) -
+            (plate.floorHeight ?? plate.elevation);
+        if (!delta)
+            continue;
+        for (const zone of Object.values(nodes)) {
+            if (zone.type !== 'zone' ||
+                !(plate.zoneIds?.includes(zone.id) ||
+                    (zone.parentId === plate.parentId &&
+                        zone.floor?.support === 'open' &&
+                        area(intersection(plate.polygon, zone.polygon)) > 1e-6)) ||
+                zone.floor?.elevation === undefined)
+                continue;
+            const index = result.findIndex((u) => u.id === zone.id);
+            const data = index >= 0 ? result[index].data : {};
+            if (data.floor && Object.hasOwn(data.floor, 'elevation'))
+                continue;
+            const floor = data.floor ?? zone.floor;
+            if (floor?.elevation === undefined)
+                continue;
+            const translated = {
+                id: zone.id,
+                data: {
+                    ...data,
+                    floor: { ...floor, elevation: roundFloorElevation(floor.elevation + delta) },
+                },
+            };
+            if (index >= 0)
+                result[index] = translated;
+            else
+                result.push(translated);
+        }
+        for (const node of Object.values(nodes)) {
+            if (node.parentId !== plate.parentId)
+                continue;
+            let data;
+            if (node.type === 'roof' &&
+                (!node.support || node.support.kind === 'level') &&
+                footprintSupportsNode(plate, node, nodes))
+                data = {
+                    position: [
+                        node.position[0],
+                        roundFloorElevation(node.position[1] + delta),
+                        node.position[2],
+                    ],
+                };
+            if (node.type === 'ceiling' &&
+                node.height !== undefined &&
+                footprintSupportsNode(plate, node, nodes))
+                data = { height: roundFloorElevation(node.height + delta) };
+            if (!data)
+                continue;
+            const existing = result.find((entry) => entry.id === node.id);
+            if (!existing)
+                result.push({ id: node.id, data });
+            else if (!Object.keys(data).some((key) => Object.hasOwn(existing.data, key)))
+                existing.data = { ...existing.data, ...data };
+        }
+    }
+    return result;
+}
+export function floorIntentConflicts(nodes, updates, created = [], deleted = []) {
+    const stack = footprintStackChanges(nodes, updates);
+    if (stack.conflicts.length)
+        return stack.conflicts;
+    const groundOnly = updates.flatMap(({ id, data }) => {
+        const plate = nodes[id];
+        if (plate?.type !== 'slab' || plate.plateRole !== 'base')
+            return [];
+        const patch = data;
+        if (floorPlateAtGroundContact(nodes, plate))
+            return [];
+        if (patch.foundation?.type === 'solid')
+            return [
+                {
+                    code: 'floor-foundation-level',
+                    severity: 'error',
+                    nodeIds: [id],
+                    message: 'Only a plate at ground contact can have a solid foundation.',
+                },
+            ];
+        return [];
+    });
+    if (groundOnly.length)
+        return groundOnly;
+    const draft = { ...nodes };
+    for (const id of deleted)
+        delete draft[id];
+    for (const node of created) {
+        draft[node.id] = node;
+    }
+    for (const { id, data } of updates)
+        if (draft[id])
+            draft[id] = { ...draft[id], ...data };
+    for (const node of created) {
+        const parent = node.parentId && draft[node.parentId];
+        if (parent && 'children' in parent)
+            draft[parent.id] = {
+                ...parent,
+                children: [...new Set([...parent.children, node.id])],
+            };
+    }
+    for (const { id, data } of updates) {
+        const plate = draft[id];
+        if (plate?.type === 'slab' &&
+            plate.plateRole === 'base' &&
+            Object.hasOwn(data, 'floorHeight') &&
+            !Object.hasOwn(data, 'elevation'))
+            draft[id] = { ...plate, elevation: plate.floorHeight ?? automaticFloorHeight(nodes, plate) };
+    }
+    const changedDisplacements = changedLevelConstructionDisplacements(nodes, draft);
+    const baseHeightChanges = updates.filter(({ id, data }) => nodes[id]?.type === 'slab' &&
+        nodes[id].plateRole === 'base' &&
+        (Object.hasOwn(data, 'floorHeight') || Object.hasOwn(data, 'elevation')));
+    if (!created.length &&
+        !changedDisplacements.size &&
+        baseHeightChanges.length &&
+        baseHeightChanges.every(({ id, data }) => floorPlateAtGroundContact(nodes, nodes[id]) &&
+            Object.keys(data).every((key) => ['floorHeight', 'foundation', 'slots', 'name'].includes(key) ||
+                data[key] === nodes[id][key]))) {
+        const translated = new Map(expandFloorIntentChanges(nodes, baseHeightChanges).map((update) => [update.id, update.data]));
+        if (updates.every(({ id, data }) => Object.entries(data).every(([key, value]) => ['slots', 'foundation', 'name'].includes(key) ||
+            JSON.stringify(value) === JSON.stringify(translated.get(id)?.[key]))))
+            return [];
+    }
+    const verticalBases = updates.flatMap(({ id, data }) => {
+        const plate = nodes[id];
+        return plate?.type === 'slab' &&
+            plate.plateRole === 'base' &&
+            ['floorHeight', 'thickness', 'polygon', 'holes'].some((key) => Object.hasOwn(data, key))
+            ? [{ plate, data: data }]
+            : [];
+    });
+    const baseDeltas = verticalBases.map(({ plate, data }) => Object.hasOwn(data, 'elevation')
+        ? roundFloorElevation(data.elevation - plate.elevation)
+        : Object.hasOwn(data, 'floorHeight')
+            ? roundFloorElevation((data.floorHeight ?? automaticFloorHeight(nodes, plate)) -
+                (plate.floorHeight ?? plate.elevation))
+            : 0);
+    const matchesBaseDelta = (delta) => baseDeltas.some((baseDelta) => Math.abs(baseDelta - delta) <= 1e-6);
+    const baseOnly = !created.length &&
+        verticalBases.length > 0 &&
+        updates.every(({ id, data }) => {
+            const node = nodes[id];
+            if (node?.type === 'slab' && node.plateRole === 'base')
+                return Object.keys(data).every((key) => [
+                    'floorHeight',
+                    'elevation',
+                    'thickness',
+                    'polygon',
+                    'holes',
+                    'foundation',
+                    'slots',
+                    'name',
+                ].includes(key));
+            if (node?.type === 'zone') {
+                const floor = data.floor;
+                return (Object.keys(data).every((key) => key === 'floor') &&
+                    floor?.elevation !== undefined &&
+                    matchesBaseDelta(floor.elevation - (node.floor?.elevation ?? 0)));
+            }
+            if (node?.type === 'ceiling')
+                return (Object.keys(data).every((key) => key === 'height') &&
+                    typeof data.height === 'number' &&
+                    matchesBaseDelta(data.height - (node.height ?? 0)));
+            if (node?.type === 'roof') {
+                const position = data.position;
+                return (Object.keys(data).every((key) => key === 'position') &&
+                    Array.isArray(position) &&
+                    matchesBaseDelta(position[1] - node.position[1]));
+            }
+            return false;
+        });
+    const loweringPlates = verticalBases.filter(({ plate, data }) => {
+        if (Object.hasOwn(data, 'polygon') || Object.hasOwn(data, 'holes'))
+            return true;
+        const top = Object.hasOwn(data, 'elevation')
+            ? data.elevation
+            : Object.hasOwn(data, 'floorHeight')
+                ? (data.floorHeight ?? automaticFloorHeight(nodes, plate))
+                : (plate.floorHeight ?? plate.elevation);
+        return (top - (data.thickness ?? plate.thickness) <
+            (plate.floorHeight ?? plate.elevation) - plate.thickness - 1e-6);
+    });
+    if (baseOnly && !loweringPlates.length)
+        return [];
+    const levels = new Set();
+    const relevant = [
+        'floor',
+        'floorHeight',
+        'thickness',
+        'height',
+        'verticalAnchor',
+        'width',
+        'position',
+        'start',
+        'end',
+        'curveOffset',
+        'justification',
+        'supportSlabId',
+        'supportOffset',
+        'parentId',
+        'children',
+        'hasFloor',
+        'elevation',
+        'baseElevation',
+        'polygon',
+        'holes',
+        'level',
+    ];
+    if (!baseOnly) {
+        for (const { id, data } of [
+            ...updates,
+            ...created.map((node) => ({ id: node.id, data: node })),
+        ]) {
+            if (!relevant.some((key) => Object.hasOwn(data, key)))
+                continue;
+            for (const graph of [nodes, draft]) {
+                let node = graph[id];
+                const visited = new Set();
+                while (node && node.type !== 'level' && !visited.has(node.id)) {
+                    visited.add(node.id);
+                    node = node.parentId ? graph[node.parentId] : undefined;
+                }
+                if (node?.type === 'level')
+                    levels.add(node.id);
+            }
+        }
+    }
+    if (!baseOnly)
+        for (const id of changedDisplacements)
+            levels.add(id);
+    if (updates.some(({ id, data }) => {
+        const plate = nodes[id] ?? draft[id];
+        return (plate?.type === 'slab' &&
+            plate.plateRole === 'base' &&
+            ['thickness', 'floorHeight', 'polygon', 'holes'].some((field) => Object.hasOwn(data, field)));
+    })) {
+        for (const graph of [nodes, draft]) {
+            const elevations = getLevelElevations(graph);
+            for (const { id, data } of updates) {
+                const plate = graph[id];
+                if (plate?.type !== 'slab' ||
+                    plate.plateRole !== 'base' ||
+                    !['thickness', 'floorHeight', 'polygon', 'holes'].some((field) => Object.hasOwn(data, field)))
+                    continue;
+                const levelId = plate.parentId;
+                if (!levelId)
+                    continue;
+                const below = findLevelBelowId(levelId, elevations);
+                if (below)
+                    levels.add(below);
+            }
+        }
+    }
+    if (baseOnly && !levels.size)
+        return [];
+    const edited = new Set([...updates.map((u) => u.id), ...created.map((n) => n.id)]);
+    const zoneOnly = [...edited].every((id) => draft[id]?.type === 'zone');
+    const affectedWalls = new Set();
+    const spans = (graph, zone) => roomFace(graph, zone, floorRoomFaces(boundaries(graph, zone.parentId)))?.spans ?? [];
+    if (zoneOnly)
+        for (const id of edited)
+            for (const graph of [nodes, draft]) {
+                const zone = graph[id];
+                if (zone?.type === 'zone') {
+                    if (zone.boundaryWallIds?.length)
+                        for (const id of zone.boundaryWallIds)
+                            affectedWalls.add(id);
+                    else
+                        for (const span of spans(graph, zone))
+                            affectedWalls.add(span.boundaryId);
+                }
+            }
+    const ids = Object.values(draft).flatMap((node) => node.type === 'zone' &&
+        levels.has(node.parentId) &&
+        (!baseOnly || verticalBases.some(({ plate }) => footprintSupportsNode(plate, node, draft))) &&
+        (!zoneOnly ||
+            edited.has(node.id) ||
+            (node.boundaryWallIds?.some((id) => affectedWalls.has(id)) ??
+                spans(draft, node).some((span) => affectedWalls.has(span.boundaryId))))
+        ? [node.id]
+        : []);
+    const conflicts = [...ids].flatMap((id) => {
+        const zone = draft[id];
+        if (zone.floor?.support === 'open' || zone.spaceRole !== 'room' || zone.hasFloor === false)
+            return [];
+        const elevation = zone.floor?.elevation ?? getRoomBaseElevation(draft, zone.id);
+        const check = checkRoomFloor(draft, id, elevation);
+        const previous = nodes[id];
+        const oldElevation = previous?.type === 'zone'
+            ? (previous.floor?.elevation ?? getRoomBaseElevation(nodes, id))
+            : elevation;
+        const before = previous?.type === 'zone' ? checkRoomFloor(nodes, id, oldElevation) : undefined;
+        return check.conflicts.filter((c) => c.severity === 'error' &&
+            c.code !== 'floor-opening-fit' &&
+            !before?.conflicts.some((old) => old.code === c.code &&
+                JSON.stringify(old.nodeIds) === JSON.stringify(c.nodeIds) &&
+                (c.excess ?? Infinity) <= (old.excess ?? 0) + 1e-6));
+    });
+    for (const node of Object.values(draft)) {
+        if (node.type !== 'door' && node.type !== 'window')
+            continue;
+        const wall = draft[node.parentId];
+        if (wall?.type !== 'wall' ||
+            !levels.has(wall.parentId) ||
+            (baseOnly && !verticalBases.some(({ plate }) => footprintSupportsNode(plate, wall, draft))) ||
+            (zoneOnly && !affectedWalls.has(wall.id)))
+            continue;
+        const excess = (graph, opening) => {
+            const host = graph[opening.parentId];
+            if (host?.type !== 'wall')
+                return -Infinity;
+            return (getOpeningFloorTarget(host, opening, graph) +
+                opening.position[1] +
+                opening.height / 2 -
+                getWallTop(host, host.parentId, graph, wallSupportForNodes(host, graph).elevation));
+        };
+        const after = excess(draft, node);
+        const previous = nodes[node.id] ?? copiedOpening(nodes, draft, node);
+        const before = previous?.type === 'door' || previous?.type === 'window' ? excess(nodes, previous) : -Infinity;
+        if (after > 1e-6 &&
+            after > before + 1e-6 &&
+            !conflicts.some((c) => c.code === 'floor-opening-fit' && c.nodeIds.includes(node.id)))
+            conflicts.push({
+                code: 'floor-opening-fit',
+                severity: 'error',
+                nodeIds: [node.id],
+                excess: after,
+                message: `The ${node.type} does not fit: it exceeds its wall top by ${roundFloorElevation(after)} m.`,
+            });
+    }
+    for (const node of Object.values(draft)) {
+        if (node.type !== 'wall' ||
+            node.height === undefined ||
+            !levels.has(node.parentId) ||
+            !loweringPlates.some(({ plate }) => footprintSupportsNode(plate, node, draft)))
+            continue;
+        const excess = (graph, wall) => getWallTop(wall, wall.parentId, graph, wallSupportForNodes(wall, graph).elevation) -
+            (getWallCoveringSlabUnderside(wall, wall.parentId, graph) ?? Infinity);
+        const after = excess(draft, node);
+        const previous = nodes[node.id];
+        const before = previous?.type === 'wall' ? excess(nodes, previous) : -Infinity;
+        if (after > 1e-6 && after > before + 1e-6)
+            conflicts.push({
+                code: 'floor-wall-fit',
+                severity: 'error',
+                nodeIds: [node.id],
+                excess: after,
+                message: `The wall top exceeds the floor above by ${roundFloorElevation(after)} m.`,
+            });
+    }
+    return conflicts;
+}

package/dist/lib/floor-opening-footprints.d.ts

@@ -0,0 +1,24 @@
+import type { AnyNode, DoorNode, WallNode, WindowNode } from '../schema/index.js';
+import type { PlateRoom } from './floor-plates.js';
+import { type MultiPolygon, type Ring } from './polygon-boolean.js';
+export declare function isFloorAnchoredOpening(opening: Pick<DoorNode | WindowNode, 'position' | 'height'> & Partial<Pick<DoorNode | WindowNode, 'verticalAnchor'>>): boolean;
+/**
+ * The wall's `from`–`to` span as a plan band reaching well past both faces
+ * (and any justification offset). A wall cutter must overshoot the body it
+ * removes: a cutter whose sides coincide with the wall faces leaves the CSG
+ * subtraction coplanar, which silently drops the cut.
+ */
+export declare function wallOpeningBand(wall: WallNode, from: number, to: number): Ring;
+export declare function wallOpeningFootprint(wall: WallNode, footprint: Ring, from: number, to: number): MultiPolygon;
+export declare function openingAperture(wall: WallNode, opening: Pick<DoorNode | WindowNode, 'position' | 'width'>, footprints: ReadonlyMap<string, Ring>): MultiPolygon;
+export type OpeningLanding = {
+    openingId: string;
+    wallId: string;
+    zoneId: string;
+    elevation: number;
+    polygons: MultiPolygon;
+    exterior: boolean;
+};
+export declare function openingLandings(rooms: PlateRoom[], elevationOf: (room: PlateRoom) => number, nodes: Readonly<Record<string, AnyNode>>, apertures?: ReadonlyMap<string, MultiPolygon>): OpeningLanding[];
+export declare function floorOpeningFootprints(rooms: PlateRoom[], elevationOf: (room: PlateRoom) => number, nodes: Readonly<Record<string, AnyNode>>): Map<string, MultiPolygon>;
+//# sourceMappingURL=floor-opening-footprints.d.ts.map

package/dist/lib/floor-opening-footprints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-opening-footprints.d.ts","sourceRoot":"","sources":["../../src/lib/floor-opening-footprints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAExE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE/C,OAAO,EAA4B,KAAK,YAAY,EAAE,KAAK,IAAI,EAAS,MAAM,mBAAmB,CAAA;AAEjG,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,QAAQ,CAAC,GACzD,OAAO,CAAC,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,gBAAgB,CAAC,CAAC,WAIzD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,CAc9E;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,IAAI,EACf,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,YAAY,CAGd;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,EAC1D,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,GACpC,YAAY,CAwBd;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,YAAY,CAAA;IACtB,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,SAAS,EAAE,EAClB,WAAW,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAM,EACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,SAAS,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,YAAY,CAAC,GAC5C,cAAc,EAAE,CAkFlB;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,SAAS,EAAE,EAClB,WAAW,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,MAAM,EACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAQ3B"}

package/dist/lib/floor-opening-footprints.js

@@ -0,0 +1,127 @@
+import { getWallCurveFrameAt, getWallCurveLength, isCurvedWall } from '../systems/wall/wall-curve.js';
+import { openingFitsAtDatum } from './opening-floor-datum.js';
+import { difference, intersection, union } from './polygon-boolean.js';
+export function isFloorAnchoredOpening(opening) {
+    if (opening.verticalAnchor)
+        return opening.verticalAnchor === 'floor';
+    return opening.position[1] - opening.height / 2 <= 0.01;
+}
+/**
+ * The wall's `from`–`to` span as a plan band reaching well past both faces
+ * (and any justification offset). A wall cutter must overshoot the body it
+ * removes: a cutter whose sides coincide with the wall faces leaves the CSG
+ * subtraction coplanar, which silently drops the cut.
+ */
+export function wallOpeningBand(wall, from, to) {
+    if (to <= from)
+        return [];
+    const count = isCurvedWall(wall) ? Math.max(2, Math.ceil((to - from) * 96)) : 1;
+    const width = Math.max(wall.thickness ?? 0.15, 0.15) * 2;
+    const sides = [1, -1].map((sign) => Array.from({ length: count + 1 }, (_, i) => {
+        const frame = getWallCurveFrameAt(wall, from + ((to - from) * i) / count);
+        return [
+            frame.point.x + frame.normal.x * width * sign,
+            frame.point.y + frame.normal.y * width * sign,
+        ];
+    }));
+    return [...sides[0], ...sides[1].reverse()];
+}
+export function wallOpeningFootprint(wall, footprint, from, to) {
+    if (to <= from || !footprint.length)
+        return [];
+    return intersection(footprint, wallOpeningBand(wall, from, to));
+}
+export function openingAperture(wall, opening, footprints) {
+    const length = getWallCurveLength(wall);
+    if (length < 1e-9)
+        return [];
+    const from = Math.max(0, (opening.position[0] - opening.width / 2) / length);
+    const to = Math.min(1, (opening.position[0] + opening.width / 2) / length);
+    const aperture = wallOpeningFootprint(wall, footprints.get(wall.id) ?? [], from, to);
+    const points = aperture.flatMap((part) => part.outer);
+    const xs = points.map((p) => p[0]), zs = points.map((p) => p[1]);
+    const minX = Math.min(...xs) - 0.0001, maxX = Math.max(...xs) + 0.0001;
+    const minZ = Math.min(...zs) - 0.0001, maxZ = Math.max(...zs) + 0.0001;
+    const neighbours = [...footprints]
+        .filter(([id, ring]) => id !== wall.id &&
+        Math.max(...ring.map((p) => p[0])) >= minX &&
+        Math.min(...ring.map((p) => p[0])) <= maxX &&
+        Math.max(...ring.map((p) => p[1])) >= minZ &&
+        Math.min(...ring.map((p) => p[1])) <= maxZ)
+        .map(([, ring]) => ring);
+    return difference(aperture, neighbours.length ? union(neighbours) : []);
+}
+export function openingLandings(rooms, elevationOf, nodes, apertures) {
+    const result = [];
+    const context = rooms[0]?.context;
+    if (!context)
+        return result;
+    for (const wall of context.walls.values()) {
+        const length = getWallCurveLength(wall);
+        if (length < 1e-9)
+            continue;
+        const spans = rooms.flatMap((room) => room.spans.filter((span) => span.boundaryId === wall.id).map((span) => ({ room, span })));
+        for (const id of wall.children ?? []) {
+            const opening = nodes[id];
+            if ((opening?.type !== 'door' && opening?.type !== 'window') ||
+                !isFloorAnchoredOpening(opening))
+                continue;
+            const chord = (station) => {
+                const { point } = getWallCurveFrameAt(wall, station / length);
+                const dx = wall.end[0] - wall.start[0], dz = wall.end[1] - wall.start[1];
+                return (((point.x - wall.start[0]) * dx + (point.y - wall.start[1]) * dz) / (dx * dx + dz * dz));
+            };
+            const from = Math.max(0, chord(opening.position[0] - opening.width / 2));
+            const to = Math.min(1, chord(opening.position[0] + opening.width / 2));
+            const cuts = [
+                ...new Set([
+                    from,
+                    to,
+                    ...spans.flatMap(({ span }) => [span.t0, span.t1]).filter((t) => t > from && t < to),
+                ]),
+            ].sort((a, b) => a - b);
+            const facing = spans.filter(({ span }) => Math.min(to, span.t1) - Math.max(from, span.t0) > 1e-7);
+            const carried = cuts
+                .slice(1)
+                .every((end, i) => ['a', 'b'].every((face) => facing.some(({ span }) => span.face === face &&
+                span.t0 <= (end + cuts[i]) / 2 &&
+                span.t1 >= (end + cuts[i]) / 2)));
+            const exterior = facing.length > 0 &&
+                facing.every(({ room, span }) => room.zone.id === facing[0].room.zone.id && span.face === facing[0].span.face) &&
+                cuts
+                    .slice(1)
+                    .every((end, i) => facing.some(({ span }) => span.t0 <= (end + cuts[i]) / 2 && span.t1 >= (end + cuts[i]) / 2));
+            if (!carried && !exterior)
+                continue;
+            const owner = facing
+                .map(({ room }) => room)
+                .sort((a, b) => {
+                const delta = elevationOf(b) - elevationOf(a);
+                return Math.abs(delta) > 0.001 ? delta : a.zone.id.localeCompare(b.zone.id);
+            })[0];
+            if (!owner)
+                continue;
+            if (!openingFitsAtDatum(wall, opening, elevationOf(owner), nodes))
+                continue;
+            result.push({
+                openingId: id,
+                wallId: wall.id,
+                zoneId: owner.zone.id,
+                elevation: elevationOf(owner),
+                exterior,
+                polygons: apertures?.get(id) ?? openingAperture(wall, opening, context.wallFootprints),
+            });
+        }
+    }
+    return result;
+}
+export function floorOpeningFootprints(rooms, elevationOf, nodes) {
+    const result = new Map();
+    for (const landing of openingLandings(rooms, elevationOf, nodes)) {
+        // Exterior ownership changes paint, not the existing step footprint.
+        if (landing.exterior)
+            continue;
+        result.set(landing.zoneId, union([result.get(landing.zoneId) ?? [], landing.polygons]));
+    }
+    return result;
+}

package/dist/lib/floor-opening-intent.d.ts

@@ -0,0 +1,16 @@
+import type { AnyNode, FloorOpeningNode } from '../schema/index.js';
+export type FloorOpeningSurface = 'floor' | 'ceiling';
+type Target = {
+    levelId: string;
+    surface: FloorOpeningSurface;
+};
+export type FloorOpeningIndex = {
+    targets: Map<string, Target[]>;
+    surfaces: Map<string, FloorOpeningNode[]>;
+};
+export declare function createFloorOpeningIndex(nodes: Readonly<Record<string, AnyNode>>): FloorOpeningIndex;
+export declare function adjacentLevelId(nodes: Readonly<Record<string, AnyNode>>, levelId: string, direction: -1 | 1): string | undefined;
+export declare function floorOpeningTargets(nodes: Readonly<Record<string, AnyNode>>, opening: FloorOpeningNode, index?: FloorOpeningIndex): Target[];
+export declare function openingsForSurface(nodes: Readonly<Record<string, AnyNode>>, levelId: string, surface: FloorOpeningSurface, index?: FloorOpeningIndex): FloorOpeningNode[];
+export {};
+//# sourceMappingURL=floor-opening-intent.d.ts.map

package/dist/lib/floor-opening-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-opening-intent.d.ts","sourceRoot":"","sources":["../../src/lib/floor-opening-intent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAE1D,MAAM,MAAM,mBAAmB,GAAG,OAAO,GAAG,SAAS,CAAA;AACrD,KAAK,MAAM,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,mBAAmB,CAAA;CAAE,CAAA;AAC/D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC9B,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAAA;CAC1C,CAAA;AAqDD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,iBAAiB,CAuBnB;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,CAAC,CAAC,GAAG,CAAC,GAChB,MAAM,GAAG,SAAS,CAGpB;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,gBAAgB,EACzB,KAAK,CAAC,EAAE,iBAAiB,GACxB,MAAM,EAAE,CAEV;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,mBAAmB,EAC5B,KAAK,CAAC,EAAE,iBAAiB,GACxB,gBAAgB,EAAE,CAEpB"}