@pascal-app/core 1.0.1 → 1.0.4

package/dist/lib/floor-footprint-name.d.ts

@@ -0,0 +1,11 @@
+import type { AnyNode, SlabNode } from '../schema/index.js';
+/**
+ * What a base-plate footprint is called everywhere (panel, "Sits on", scene
+ * graph, MCP messages). Never "Floor N": that reads as a level. A name the
+ * user gave the plate wins; the level's largest multi-room footprint is the
+ * "Shared floor". Keyed floors use their creator's current name while that
+ * room remains on the key, including disconnected pieces. Otherwise use the
+ * largest named room ("Kitchen floor"), or "Floor area" with no rooms.
+ */
+export declare function floorFootprintName(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): string;
+//# sourceMappingURL=floor-footprint-name.d.ts.map

package/dist/lib/floor-footprint-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-footprint-name.d.ts","sourceRoot":"","sources":["../../src/lib/floor-footprint-name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAY,MAAM,WAAW,CAAA;AAS5D;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,GACd,MAAM,CAiCR"}

package/dist/lib/floor-footprint-name.js

@@ -0,0 +1,52 @@
+import { floorFootprintCreatorId } from './floor-footprint-key.js';
+import { area } from './polygon-boolean.js';
+const GENERATED_NAME = /^(floor plate|slab|floor)\b|slab$/i;
+const polygonArea = (outer, holes = []) => area([{ outer, holes }]);
+/**
+ * What a base-plate footprint is called everywhere (panel, "Sits on", scene
+ * graph, MCP messages). Never "Floor N": that reads as a level. A name the
+ * user gave the plate wins; the level's largest multi-room footprint is the
+ * "Shared floor". Keyed floors use their creator's current name while that
+ * room remains on the key, including disconnected pieces. Otherwise use the
+ * largest named room ("Kitchen floor"), or "Floor area" with no rooms.
+ */
+export function floorFootprintName(nodes, plate) {
+    const own = plate.name?.trim();
+    if (own && !GENERATED_NAME.test(own))
+        return own;
+    const rooms = (plate.zoneIds ?? [])
+        .flatMap((id) => {
+        const zone = nodes[id];
+        return zone?.type === 'zone' && zone.spaceRole === 'room' && zone.floor?.support !== 'open'
+            ? [zone]
+            : [];
+    })
+        .sort((a, b) => polygonArea(b.polygon) - polygonArea(a.polygon) || a.id.localeCompare(b.id));
+    if (rooms.length > 1 &&
+        !rooms.some((room) => room.floor?.footprint) &&
+        isLargestFootprint(nodes, plate))
+        return 'Shared floor';
+    const key = rooms.find((room) => room.floor?.footprint)?.floor?.footprint;
+    const creatorId = key && floorFootprintCreatorId(key);
+    const creator = creatorId ? nodes[creatorId] : undefined;
+    const creatorName = creator?.type === 'zone' &&
+        creator.spaceRole === 'room' &&
+        creator.parentId === plate.parentId &&
+        creator.floor?.footprint === key &&
+        creator.floor?.support !== 'open' &&
+        !creator.floor?.sourceSlabId &&
+        creator.hasFloor !== false
+        ? creator.name?.trim()
+        : undefined;
+    const named = creatorName || rooms.map((room) => room.name?.trim()).find(Boolean);
+    if (!named)
+        return rooms.some((room) => room.floor?.footprint) ? 'Shared floor' : 'Floor area';
+    return /\bfloor$/i.test(named) ? named : `${named} floor`;
+}
+function isLargestFootprint(nodes, plate) {
+    const largest = Object.values(nodes)
+        .filter((node) => node.type === 'slab' && node.plateRole === 'base' && node.parentId === plate.parentId)
+        .sort((a, b) => polygonArea(b.polygon, b.holes) - polygonArea(a.polygon, a.holes) ||
+        a.id.localeCompare(b.id))[0];
+    return !largest || largest.id === plate.id;
+}

package/dist/lib/floor-foundation-datum.d.ts

@@ -0,0 +1,31 @@
+import type { AnyNode, SlabNode } from '../schema/index.js';
+export declare function automaticFloorHeight(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): number;
+export declare function supportDerivedFloorHeight(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): number;
+export declare function floorFootprintSupportClass(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): 'supported' | 'ground-bearing';
+export declare function floorPlateAtGroundContact(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): boolean;
+export declare function floorPlateHoldsUnderside(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): boolean;
+/**
+ * A ground-bearing footprint's construction, bottom up: the grade, the
+ * foundation on it, the slab on the foundation, so the top is always
+ * grade + foundationHeight + thickness. The foundation height is derived from
+ * the stored top; a legacy plate whose slab reaches below grade reads 0.
+ */
+export declare function groundFloorConstruction(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): {
+    grade: number;
+    top: number;
+    thickness: number;
+    foundationHeight: number;
+};
+export declare function floorPlateGestureMinimum(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): number;
+export declare function footprintLift(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): number;
+export declare function upperFloorHeightControl(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode, targetTop?: number): {
+    currentTop: number;
+    minimumTop: number;
+    write: {
+        thickness: number;
+    };
+    advice?: 'thick-floor';
+} | null;
+export declare function resolvedFootprintPlane(nodes: Readonly<Record<string, AnyNode>>, node: AnyNode, storedHeight: number): number;
+export declare function footprintSupportsNode(base: SlabNode, node: AnyNode, nodes: Readonly<Record<string, AnyNode>>): boolean;
+//# sourceMappingURL=floor-foundation-datum.d.ts.map

package/dist/lib/floor-foundation-datum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-foundation-datum.d.ts","sourceRoot":"","sources":["../../src/lib/floor-foundation-datum.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAclD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,GACd,MAAM,CAER;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,GACd,MAAM,CA+BR;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,GACd,WAAW,GAAG,gBAAgB,CA+BhC;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,GACd,OAAO,CAMT;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,GACd,OAAO,CAET;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,GACd;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,gBAAgB,EAAE,MAAM,CAAA;CAAE,CAK7E;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,GACd,MAAM,CAER;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,CAM/F;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,EACf,SAAS,GAAE,MAA6C,GACvD;IACD,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,KAAK,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAA;IAC5B,MAAM,CAAC,EAAE,aAAa,CAAA;CACvB,GAAG,IAAI,CAYP;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,IAAI,EAAE,OAAO,EACb,YAAY,EAAE,MAAM,GACnB,MAAM,CAUR;AAID,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,OAAO,CAgBT"}

package/dist/lib/floor-foundation-datum.js

@@ -0,0 +1,226 @@
+import { DEFAULT_SLAB_ELEVATION, MIN_SLAB_THICKNESS } from '../schema/nodes/slab.js';
+import { wallOverlapsSlabFootprint } from '../systems/slab/slab-support.js';
+import { getWallArcData } from '../systems/wall/wall-curve.js';
+import { wallOpeningBand } from './floor-opening-footprints.js';
+import { area, containsPoint, difference, intersection, union } from './polygon-boolean.js';
+import { automaticRoomBaseElevations } from './room-floor-feasibility.js';
+import { isLevelAtSiteDatum } from './terrain-support-query.js';
+const heights = new WeakMap();
+export function automaticFloorHeight(nodes, plate) {
+    return plate.referenceFloorElevation ?? supportDerivedFloorHeight(nodes, plate);
+}
+export function supportDerivedFloorHeight(nodes, plate) {
+    const sources = Object.values(nodes).filter((node) => node.type === 'site' ||
+        node.type === 'building' ||
+        node.type === 'level' ||
+        (node.parentId === plate.parentId &&
+            (node.type === 'wall' ||
+                node.type === 'separator' ||
+                node.type === 'zone' ||
+                (node.type === 'slab' && !node.autoFromWalls && node.boundary !== 'auto'))));
+    const zoneIds = JSON.stringify(plate.zoneIds);
+    let memo = heights.get(nodes);
+    if (!memo) {
+        memo = new Map();
+        heights.set(nodes, memo);
+    }
+    const hit = memo.get(plate.id);
+    if (hit &&
+        hit.zoneIds === zoneIds &&
+        hit.sources.length === sources.length &&
+        sources.every((node, i) => node === hit.sources[i]))
+        return hit.height;
+    const placements = automaticRoomBaseElevations(nodes, plate.parentId);
+    const values = (plate.zoneIds ?? []).map((id) => placements.get(id) ?? 0.05);
+    const height = values.length ? Math.max(...values) : 0.05;
+    memo.set(plate.id, { sources, zoneIds, height });
+    return height;
+}
+export function floorFootprintSupportClass(nodes, plate) {
+    const level = nodes[plate.parentId];
+    if (level?.type !== 'level')
+        return 'ground-bearing';
+    const buildingId = (levelId, parentId) => (parentId && nodes[parentId]?.type === 'building' ? parentId : undefined) ??
+        Object.values(nodes).find((node) => node.type === 'building' && node.children.includes(levelId))?.id ??
+        null;
+    const owner = buildingId(level.id, level.parentId);
+    const required = Math.max(1.5, area([{ outer: plate.polygon, holes: plate.holes ?? [] }]) * 0.5);
+    const overlaps = [];
+    for (const candidate of Object.values(nodes)) {
+        if (candidate.type !== 'slab' || candidate.plateRole !== 'base' || candidate.id === plate.id)
+            continue;
+        const lower = nodes[candidate.parentId];
+        if (lower?.type === 'level' &&
+            buildingId(lower.id, lower.parentId) === owner &&
+            lower.level < level.level &&
+            candidate.zoneIds?.some((id) => nodes[id]?.type === 'zone' && nodes[id].spaceRole === 'room')) {
+            overlaps.push(...intersection({ outer: candidate.polygon, holes: candidate.holes ?? [] }, { outer: plate.polygon, holes: plate.holes ?? [] }));
+        }
+    }
+    return overlaps.length && area(union(overlaps)) >= required ? 'supported' : 'ground-bearing';
+}
+export function floorPlateAtGroundContact(nodes, plate) {
+    return (!!plate.parentId &&
+        isLevelAtSiteDatum(nodes, plate.parentId) &&
+        floorFootprintSupportClass(nodes, plate) === 'ground-bearing');
+}
+export function floorPlateHoldsUnderside(nodes, plate) {
+    return !floorPlateAtGroundContact(nodes, plate);
+}
+/**
+ * A ground-bearing footprint's construction, bottom up: the grade, the
+ * foundation on it, the slab on the foundation, so the top is always
+ * grade + foundationHeight + thickness. The foundation height is derived from
+ * the stored top; a legacy plate whose slab reaches below grade reads 0.
+ */
+export function groundFloorConstruction(nodes, plate) {
+    const grade = supportDerivedFloorHeight(nodes, plate) - DEFAULT_SLAB_ELEVATION;
+    const top = plate.floorHeight ?? plate.elevation;
+    const foundationHeight = Math.round((top - grade - plate.thickness) * 1e6) / 1e6;
+    return { grade, top, thickness: plate.thickness, foundationHeight: Math.max(0, foundationHeight) };
+}
+export function floorPlateGestureMinimum(nodes, plate) {
+    return upperFloorHeightControl(nodes, plate)?.minimumTop ?? Number.NEGATIVE_INFINITY;
+}
+export function footprintLift(nodes, plate) {
+    return floorPlateHoldsUnderside(nodes, plate)
+        ? (plate.floorHeight ?? plate.elevation) - automaticFloorHeight(nodes, plate)
+        : plate.floorHeight !== undefined
+            ? plate.floorHeight - automaticFloorHeight(nodes, plate)
+            : 0;
+}
+export function upperFloorHeightControl(nodes, plate, targetTop = plate.floorHeight ?? plate.elevation) {
+    if (!floorPlateHoldsUnderside(nodes, plate))
+        return null;
+    const currentTop = plate.floorHeight ?? plate.elevation;
+    const underside = currentTop - plate.thickness;
+    const thickness = targetTop - underside;
+    const restingUnderside = automaticFloorHeight(nodes, plate) - DEFAULT_SLAB_ELEVATION;
+    return {
+        currentTop,
+        minimumTop: underside < restingUnderside - 0.001 ? currentTop : underside + MIN_SLAB_THICKNESS,
+        write: { thickness },
+        ...(thickness > 0.4 ? { advice: 'thick-floor' } : {}),
+    };
+}
+export function resolvedFootprintPlane(nodes, node, storedHeight) {
+    const lifts = Object.values(nodes).flatMap((plate) => plate.type === 'slab' &&
+        plate.plateRole === 'base' &&
+        plate.parentId === node.parentId &&
+        footprintSupportsNode(plate, node, nodes)
+        ? [footprintLift(nodes, plate)]
+        : []);
+    return storedHeight + (lifts.length ? Math.max(...lifts) : 0);
+}
+const overlaps = new WeakMap();
+export function footprintSupportsNode(base, node, nodes) {
+    let byBase = overlaps.get(nodes);
+    if (!byBase) {
+        byBase = new WeakMap();
+        overlaps.set(nodes, byBase);
+    }
+    let byNode = byBase.get(base);
+    if (!byNode) {
+        byNode = new WeakMap();
+        byBase.set(base, byNode);
+    }
+    const hit = byNode.get(node);
+    if (hit !== undefined)
+        return hit;
+    const result = computeFootprintSupport(base, node, nodes);
+    byNode.set(node, result);
+    return result;
+}
+const boundsMemo = new WeakMap();
+const ceilingWallBands = new WeakMap();
+function ceilingSupportInterior(base, node, nodes) {
+    if (node.type !== 'ceiling')
+        return false;
+    let levels = ceilingWallBands.get(nodes);
+    if (!levels) {
+        levels = new Map();
+        ceilingWallBands.set(nodes, levels);
+    }
+    let bands = levels.get(base.parentId);
+    if (!bands) {
+        bands = union(Object.values(nodes).flatMap((wall) => wall.type === 'wall' && wall.parentId === base.parentId
+            ? [wallOpeningBand(wall, 0, 1)]
+            : []));
+        levels.set(base.parentId, bands);
+    }
+    // Captured ceilings can cross a party wall by a wall-thickness sliver.
+    // Only overlap extending into the room carries that ceiling with the floor.
+    return (area(difference(intersection({ outer: base.polygon, holes: base.holes }, { outer: node.polygon, holes: node.holes }), bands)) > 1e-6);
+}
+function polygonBounds(polygon) {
+    const cached = boundsMemo.get(polygon);
+    if (cached)
+        return cached;
+    const result = [
+        Math.min(...polygon.map(([x]) => x)),
+        Math.min(...polygon.map(([, z]) => z)),
+        Math.max(...polygon.map(([x]) => x)),
+        Math.max(...polygon.map(([, z]) => z)),
+    ];
+    boundsMemo.set(polygon, result);
+    return result;
+}
+function polygonsOverlap(base, polygon) {
+    const a = polygonBounds(base.polygon), b = polygonBounds(polygon);
+    return (a[0] < b[2] &&
+        b[0] < a[2] &&
+        a[1] < b[3] &&
+        b[1] < a[3] &&
+        area(intersection({ outer: base.polygon, holes: base.holes ?? [] }, polygon)) > 1e-6);
+}
+function computeFootprintSupport(base, node, nodes) {
+    if (node.type === 'wall') {
+        const bounds = polygonBounds(base.polygon);
+        const margin = node.thickness ?? 0.15;
+        const arc = getWallArcData(node);
+        const xs = arc
+            ? [arc.center.x - arc.radius, arc.center.x + arc.radius]
+            : [node.start[0], node.end[0]];
+        const zs = arc
+            ? [arc.center.y - arc.radius, arc.center.y + arc.radius]
+            : [node.start[1], node.end[1]];
+        if (Math.max(...xs) + margin < bounds[0] ||
+            Math.min(...xs) - margin > bounds[2] ||
+            Math.max(...zs) + margin < bounds[1] ||
+            Math.min(...zs) - margin > bounds[3])
+            return false;
+        return wallOverlapsSlabFootprint(node, base.polygon, base.holes);
+    }
+    if (node.type === 'ceiling' && node.parentId === base.parentId)
+        return polygonsOverlap(base, node.polygon) && ceilingSupportInterior(base, node, nodes);
+    if (node.type === 'slab' || node.type === 'zone' || node.type === 'ceiling')
+        return polygonsOverlap(base, node.polygon);
+    if (node.type === 'roof') {
+        const segments = node.children
+            .map((id) => nodes[id])
+            .filter((segment) => segment?.type === 'roof-segment');
+        if (!segments.length)
+            return containsPoint([{ outer: base.polygon, holes: base.holes ?? [] }], [node.position[0], node.position[2]]);
+        return segments.some((segment) => {
+            if (segment.type !== 'roof-segment')
+                return false;
+            const corners = [
+                [-1, -1],
+                [1, -1],
+                [1, 1],
+                [-1, 1],
+            ];
+            const polygon = corners.map(([sx, sz]) => {
+                const x = (sx * segment.width) / 2, z = (sz * segment.depth) / 2;
+                const rx = segment.position[0] + x * Math.cos(segment.rotation) + z * Math.sin(segment.rotation);
+                const rz = segment.position[2] - x * Math.sin(segment.rotation) + z * Math.cos(segment.rotation);
+                return [
+                    node.position[0] + rx * Math.cos(node.rotation) + rz * Math.sin(node.rotation),
+                    node.position[2] - rx * Math.sin(node.rotation) + rz * Math.cos(node.rotation),
+                ];
+            });
+            return polygonsOverlap(base, polygon);
+        });
+    }
+    return false;
+}

package/dist/lib/floor-foundation-stack.d.ts

@@ -0,0 +1,16 @@
+import type { AnyNode, AnyNodeId, SlabNode } from '../schema/index.js';
+import { type RoomFloorConflict } from './room-floor-feasibility.js';
+type Update = {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+};
+export declare function isMeaningfulFloorFootprint(nodes: Readonly<Record<string, AnyNode>>, plate: SlabNode): boolean;
+export declare function upperStoreyFootprints(nodes: Readonly<Record<string, AnyNode>>): ReadonlyMap<string, SlabNode[]>;
+export declare function levelConstructionDisplacements(nodes: Readonly<Record<string, AnyNode>>, supports?: ReadonlyMap<string, SlabNode[]>): Map<string, number>;
+export declare function changedLevelConstructionDisplacements(before: Readonly<Record<string, AnyNode>>, after: Readonly<Record<string, AnyNode>>): Set<string>;
+export declare function footprintStackChanges(nodes: Readonly<Record<string, AnyNode>>, changes: readonly Update[]): {
+    updates: Update[];
+    conflicts: RoomFloorConflict[];
+};
+export {};
+//# sourceMappingURL=floor-foundation-stack.d.ts.map

package/dist/lib/floor-foundation-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-foundation-stack.d.ts","sourceRoot":"","sources":["../../src/lib/floor-foundation-stack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAU7D,OAAO,EAAE,KAAK,iBAAiB,EAAuB,MAAM,0BAA0B,CAAA;AAEtF,KAAK,MAAM,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAEvD,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,QAAQ,GACd,OAAO,CAKT;AAID,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,CAyDjC;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,QAAQ,GAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAgC,GACvE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAYrB;AAED,wBAAgB,qCAAqC,CACnD,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACzC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,GAAG,CAAC,MAAM,CAAC,CAsCb;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,iBAAiB,EAAE,CAAA;CAAE,CAsHvD"}

package/dist/lib/floor-foundation-stack.js

@@ -0,0 +1,214 @@
+import { getAuthoredLevelElevations } from '../services/storey.js';
+import { floorFootprintName } from './floor-footprint-name.js';
+import { automaticFloorHeight, floorPlateHoldsUnderside, footprintLift, footprintSupportsNode, } from './floor-foundation-datum.js';
+import { area } from './polygon-boolean.js';
+import { roundFloorElevation } from './room-floor-feasibility.js';
+export function isMeaningfulFloorFootprint(nodes, plate) {
+    return (area([{ outer: plate.polygon, holes: plate.holes }]) >= 1.5 &&
+        !!plate.zoneIds?.some((id) => nodes[id]?.type === 'zone' && nodes[id].spaceRole === 'room'));
+}
+const supportMemo = new WeakMap();
+export function upperStoreyFootprints(nodes) {
+    const values = Object.values(nodes);
+    const cached = supportMemo.get(nodes);
+    if (cached &&
+        cached.sources.length === values.length &&
+        values.every((node, index) => node === cached.sources[index]))
+        return cached.result;
+    const elevations = getAuthoredLevelElevations(nodes);
+    const bases = values.filter((node) => node.type === 'slab' && node.plateRole === 'base' && isMeaningfulFloorFootprint(nodes, node));
+    const basesByLevel = new Map();
+    for (const base of bases)
+        if (base.parentId) {
+            const group = basesByLevel.get(base.parentId) ?? [];
+            group.push(base);
+            basesByLevel.set(base.parentId, group);
+        }
+    const contentsByLevel = new Map();
+    for (const node of values)
+        if (node.parentId &&
+            (node.type === 'slab' ||
+                node.type === 'zone' ||
+                node.type === 'ceiling' ||
+                node.type === 'wall')) {
+            const group = contentsByLevel.get(node.parentId) ?? [];
+            group.push(node);
+            contentsByLevel.set(node.parentId, group);
+        }
+    const result = new Map();
+    for (const [id, upper] of elevations) {
+        const lowerLevels = [...elevations]
+            .filter(([, entry]) => entry.buildingId === upper.buildingId && entry.ordinal < upper.ordinal)
+            .sort((a, b) => b[1].ordinal - a[1].ordinal);
+        if (!lowerLevels.length)
+            continue;
+        const contents = [...(contentsByLevel.get(id) ?? [])].sort((a, b) => Number(a.type === 'wall') - Number(b.type === 'wall'));
+        const owners = new Map();
+        for (const node of contents)
+            for (const [lowerId] of lowerLevels) {
+                const covering = (basesByLevel.get(lowerId) ?? []).filter((base) => footprintSupportsNode(base, node, nodes));
+                if (!covering.length)
+                    continue;
+                for (const base of covering)
+                    owners.set(base.id, base);
+                break;
+            }
+        result.set(id, [...owners.values()]);
+    }
+    supportMemo.set(nodes, { sources: values, result });
+    return result;
+}
+export function levelConstructionDisplacements(nodes, supports = upperStoreyFootprints(nodes)) {
+    const elevations = getAuthoredLevelElevations(nodes);
+    const result = new Map();
+    for (const [id] of [...elevations].sort((a, b) => a[1].ordinal - b[1].ordinal)) {
+        const lifts = (supports.get(id) ?? []).map((base) => (result.get(base.parentId) ?? 0) +
+            footprintLift(nodes, (nodes[base.id]?.type === 'slab' ? nodes[base.id] : base)));
+        result.set(id, lifts.length ? Math.max(...lifts) : 0);
+    }
+    return result;
+}
+export function changedLevelConstructionDisplacements(before, after) {
+    const changed = new Set();
+    const fields = [
+        'floorHeight',
+        'referenceFloorElevation',
+        'elevation',
+        'polygon',
+        'holes',
+        'zoneIds',
+        'parentId',
+        'plateRole',
+    ];
+    const ids = new Set([...Object.keys(before), ...Object.keys(after)]);
+    let geometryChanged = false;
+    let anyChanged = false;
+    for (const id of ids) {
+        const old = before[id], next = after[id];
+        if (old === next || (old?.type !== 'slab' && next?.type !== 'slab'))
+            continue;
+        if (old?.type !== 'slab' || next?.type !== 'slab') {
+            geometryChanged = true;
+            anyChanged = true;
+            continue;
+        }
+        const different = fields.filter((field) => JSON.stringify(old[field]) !== JSON.stringify(next[field]));
+        if (different.some((field) => field !== 'floorHeight' && field !== 'elevation'))
+            geometryChanged = true;
+        if (different.length)
+            anyChanged = true;
+    }
+    if (!anyChanged)
+        return changed;
+    const supports = geometryChanged ? undefined : upperStoreyFootprints(before);
+    const old = levelConstructionDisplacements(before, supports);
+    const next = levelConstructionDisplacements(after, supports);
+    for (const id of new Set([...old.keys(), ...next.keys()]))
+        if (Math.abs((old.get(id) ?? 0) - (next.get(id) ?? 0)) > 1e-6)
+            changed.add(id);
+    return changed;
+}
+export function footprintStackChanges(nodes, changes) {
+    const deltas = new Map();
+    for (const { id, data } of changes) {
+        const plate = nodes[id];
+        if (plate?.type !== 'slab' ||
+            plate.plateRole !== 'base' ||
+            (!Object.hasOwn(data, 'floorHeight') && !Object.hasOwn(data, 'elevation')))
+            continue;
+        const delta = roundFloorElevation((data.elevation ??
+            data.floorHeight ??
+            automaticFloorHeight(nodes, plate)) - (plate.floorHeight ?? plate.elevation));
+        if (delta)
+            deltas.set(id, delta);
+    }
+    if (!deltas.size)
+        return { updates: [], conflicts: [] };
+    const values = Object.values(nodes);
+    const bases = values.filter((node) => node.type === 'slab' && node.plateRole === 'base' && isMeaningfulFloorFootprint(nodes, node));
+    const supports = upperStoreyFootprints(nodes);
+    const conflicts = [];
+    const updates = [];
+    const displacement = new Map();
+    const elevations = getAuthoredLevelElevations(nodes);
+    const oldDisplacement = levelConstructionDisplacements(nodes);
+    for (const [id, owners] of [...elevations.keys()]
+        .map((levelId) => [levelId, supports.get(levelId) ?? []])
+        .sort((a, b) => (elevations.get(a[0])?.ordinal ?? Infinity) - (elevations.get(b[0])?.ordinal ?? Infinity))) {
+        if (nodes[id]?.type !== 'level')
+            continue;
+        const shifts = owners.map((base) => (displacement.get(base.parentId) ?? 0) +
+            footprintLift(nodes, base) +
+            (deltas.get(base.id) ?? 0));
+        displacement.set(id, shifts.length ? Math.max(...shifts) : 0);
+        const moved = owners.find((base) => deltas.has(base.id));
+        const reference = shifts[moved ? owners.indexOf(moved) : 0];
+        const other = owners.find((base, index) => Math.abs(shifts[index] - reference) > 1e-6);
+        const affected = owners.some((base) => deltas.has(base.id) ||
+            Math.abs((displacement.get(base.parentId) ?? 0) - (oldDisplacement.get(base.parentId) ?? 0)) > 1e-6);
+        if (other && affected) {
+            const subject = 'upper floor';
+            conflicts.push({
+                code: 'floor-foundation-shared-storey',
+                severity: 'error',
+                nodeIds: [id, ...owners.map((base) => base.id)],
+                message: `The ${subject} also sits over ${floorFootprintName(nodes, other)}; raise both or neither.`,
+            });
+            continue;
+        }
+        if (!moved)
+            continue;
+        const delta = deltas.get(moved.id);
+        if (nodes[id]?.type !== 'level')
+            continue;
+        const contents = values
+            .filter((node) => node.parentId === id && node.type !== 'roof')
+            .sort((a, b) => Number(a.type === 'wall') - Number(b.type === 'wall'));
+        for (const plate of values) {
+            if (plate.type !== 'slab' ||
+                plate.plateRole !== 'base' ||
+                plate.parentId !== moved.parentId ||
+                isMeaningfulFloorFootprint(nodes, plate) ||
+                changes.some((change) => change.id === plate.id) ||
+                updates.some((change) => change.id === plate.id))
+                continue;
+            if (contents.some((node) => footprintSupportsNode(plate, node, nodes)))
+                updates.push({
+                    id: plate.id,
+                    data: floorPlateHoldsUnderside(nodes, plate)
+                        ? {
+                            floorHeight: undefined,
+                            elevation: roundFloorElevation((plate.floorHeight ?? plate.elevation) + delta),
+                            thickness: roundFloorElevation(plate.thickness + delta),
+                        }
+                        : { floorHeight: roundFloorElevation((plate.floorHeight ?? plate.elevation) + delta) },
+                });
+        }
+    }
+    const affected = (base) => deltas.has(base.id) ||
+        Math.abs((displacement.get(base.parentId) ?? 0) - (oldDisplacement.get(base.parentId) ?? 0)) >
+            1e-6;
+    const shifted = (base) => (displacement.get(base.parentId) ?? 0) +
+        footprintLift(nodes, base) +
+        (deltas.get(base.id) ?? 0);
+    for (const node of values) {
+        if (node.type !== 'roof' && node.type !== 'ceiling')
+            continue;
+        const candidates = bases.filter((base) => base.parentId === node.parentId);
+        if (!candidates.some((base) => affected(base) && footprintSupportsNode(base, node, nodes)))
+            continue;
+        const owners = candidates.filter((base) => footprintSupportsNode(base, node, nodes));
+        if (owners.length < 2)
+            continue;
+        const reference = shifted(owners.find((base) => deltas.has(base.id)) ?? owners[0]);
+        const other = owners.find((base) => Math.abs(shifted(base) - reference) > 1e-6);
+        if (other)
+            conflicts.push({
+                code: 'floor-foundation-shared-storey',
+                severity: 'error',
+                nodeIds: [node.id, ...owners.map((base) => base.id)],
+                message: `The ${node.type} also sits over ${floorFootprintName(nodes, other)}; raise both or neither.`,
+            });
+    }
+    return { updates, conflicts };
+}

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

@@ -0,0 +1,10 @@
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+import { type RoomFloorConflict } from './room-floor-feasibility.js';
+type Update = {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+};
+export declare function expandFloorIntentChanges(nodes: Readonly<Record<string, AnyNode>>, updates: readonly Update[]): Update[];
+export declare function floorIntentConflicts(nodes: Readonly<Record<string, AnyNode>>, updates: readonly Update[], created?: readonly AnyNode[], deleted?: readonly string[]): RoomFloorConflict[];
+export {};
+//# sourceMappingURL=floor-intent-changes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floor-intent-changes.d.ts","sourceRoot":"","sources":["../../src/lib/floor-intent-changes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EAOV,MAAM,WAAW,CAAA;AAuBlB,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAA;AAEjC,KAAK,MAAM,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAkCvD,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,MAAM,EAAE,CA6IV;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,OAAO,GAAE,SAAS,OAAO,EAAO,EAChC,OAAO,GAAE,SAAS,MAAM,EAAO,uBA2VhC"}