@pascal-app/core 1.0.1 → 1.0.4

package/dist/commands/structure/plan-wall-deletion.js

@@ -0,0 +1,151 @@
+import { area, intersection } from '../../lib/polygon-boolean.js';
+import { extractRooms, sampleWallPointsForRoomDetection } from '../../lib/room-graph.js';
+import { SeparatorNode } from '../../schema/index.js';
+import { omitUndefined } from '../../utils/omit-undefined.js';
+import { planZoneRemoval } from './delete-zone.js';
+import { at, boundaries, project, roomFace, } from './shared.js';
+/** Plans user deletion, including room-preserving boundaries, before reconciliation. */
+export function planWallDeletion(nodes, input) {
+    const deleted = new Set(input.nodeIds);
+    const collect = () => {
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const previous of Object.values(nodes)) {
+                const node = input.nextNodes?.[previous.id] ?? previous;
+                if (deleted.has(node.id)) {
+                    if ('children' in node && Array.isArray(node.children))
+                        for (const id of node.children)
+                            if (!deleted.has(id)) {
+                                const child = input.nextNodes?.[id];
+                                if (child && child.parentId !== nodes[id]?.parentId && child.parentId !== node.id)
+                                    continue;
+                                deleted.add(id);
+                                changed = true;
+                            }
+                }
+                else if ((node.parentId && deleted.has(node.parentId)) ||
+                    ((node.type === 'door' || node.type === 'window') &&
+                        node.wallId &&
+                        deleted.has(node.wallId))) {
+                    deleted.add(node.id);
+                    changed = true;
+                }
+            }
+        }
+    };
+    collect();
+    const walls = Object.values(nodes).filter((n) => n.type === 'wall' && deleted.has(n.id));
+    const changes = [];
+    for (const levelId of new Set(walls.map((wall) => wall.parentId))) {
+        if (!levelId || deleted.has(levelId))
+            continue;
+        const faces = extractRooms(boundaries(nodes, levelId));
+        const rooms = Object.values(nodes).flatMap((zone) => {
+            if (zone.type !== 'zone' || zone.spaceRole !== 'room' || zone.parentId !== levelId)
+                return [];
+            const face = roomFace(nodes, zone, faces);
+            if (!face)
+                return [];
+            const stored = { outer: zone.polygon, holes: zone.holes };
+            const current = { outer: face.referencePolygon, holes: face.holes };
+            const overlap = area(intersection(stored, current));
+            if (overlap / Math.max(area([stored]) + area([current]) - overlap, 1e-9) < 0.9)
+                return [];
+            return [{ zone, spans: face.spans }];
+        });
+        const replacements = boundaries(input.nextNodes ?? nodes, levelId).filter((n) => !deleted.has(n.id));
+        // Topology planners replace walls in their own patches. Only fill uncovered
+        // portions, using the same sampled reference lines as the room graph.
+        const uncovered = (start, end) => {
+            let ranges = [[0, 1]];
+            for (const boundary of replacements) {
+                const points = boundary.type === 'wall'
+                    ? sampleWallPointsForRoomDetection(boundary).map((p) => [p.x, p.y])
+                    : [boundary.start, boundary.end];
+                for (let i = 1; i < points.length; i++) {
+                    const a = project(points[i - 1], start, end), b = project(points[i], start, end);
+                    const onLine = (p) => Math.abs((p[0] - start[0]) * (end[1] - start[1]) - (p[1] - start[1]) * (end[0] - start[0])) < 1e-7;
+                    if (!onLine(points[i - 1]) || !onLine(points[i]))
+                        continue;
+                    const lo = Math.min(a.t, b.t), hi = Math.max(a.t, b.t);
+                    ranges = ranges.flatMap(([from, to]) => {
+                        if (hi <= from || lo >= to)
+                            return [[from, to]];
+                        return [
+                            ...(lo > from ? [[from, lo]] : []),
+                            ...(hi < to ? [[hi, to]] : []),
+                        ];
+                    });
+                }
+            }
+            return ranges;
+        };
+        for (const { zone, spans } of rooms) {
+            const wallSpans = spans.filter((s) => s.kind === 'wall');
+            // Removing the final wall individually leaves a valid separator-only terrace.
+            if (deleted.has(zone.id) ||
+                new Set(wallSpans.map((s) => s.boundaryId)).size < 2 ||
+                !wallSpans.every((s) => deleted.has(s.boundaryId)))
+                continue;
+            if (wallSpans.some((span) => {
+                const boundary = nodes[span.boundaryId];
+                if (boundary?.type !== 'wall' && boundary?.type !== 'separator')
+                    return false;
+                return (uncovered(at(boundary.start, boundary.end, span.t0), at(boundary.start, boundary.end, span.t1)).reduce((sum, [a, b]) => sum + b - a, 0) <
+                    1 - 1e-7);
+            }))
+                continue;
+            deleted.add(zone.id);
+            const payload = planZoneRemoval(nodes, { zoneId: zone.id, contents: 'delete' }).payload;
+            for (const id of [...payload.itemIds, ...payload.separatorIds])
+                deleted.add(id);
+        }
+        for (const wall of walls) {
+            if (wall.parentId !== levelId)
+                continue;
+            const spans = rooms.flatMap(({ zone, spans }) => spans.filter((s) => s.boundaryId === wall.id).map((s) => ({ ...s, zoneId: zone.id })));
+            const stations = [...new Set(spans.flatMap((s) => [s.t0, s.t1]))].sort((a, b) => a - b);
+            const points = sampleWallPointsForRoomDetection(wall);
+            for (let i = 1; i < stations.length; i++) {
+                const t0 = stations[i - 1], t1 = stations[i], mid = (t0 + t1) / 2;
+                const owners = [
+                    ...new Set(spans
+                        .filter((s) => !deleted.has(s.zoneId) && s.t0 < mid && s.t1 > mid)
+                        .map((s) => s.zoneId)),
+                ];
+                if (owners.length !== 1 || deleted.has(owners[0]))
+                    continue;
+                for (let j = 1; j < points.length; j++) {
+                    const a = [points[j - 1].x, points[j - 1].y];
+                    const b = [points[j].x, points[j].y];
+                    const from = project(a, wall.start, wall.end).t, to = project(b, wall.start, wall.end).t;
+                    const lo = Math.max(t0, from), hi = Math.min(t1, to);
+                    if (hi - lo < 1e-7)
+                        continue;
+                    const start = at(a, b, (lo - from) / (to - from)), end = at(a, b, (hi - from) / (to - from));
+                    for (const [u, v] of uncovered(start, end))
+                        changes.push({
+                            op: 'create',
+                            node: omitUndefined(SeparatorNode.parse({
+                                id: input.mintId('separator'),
+                                parentId: levelId,
+                                start: at(start, end, u),
+                                end: at(start, end, v),
+                            })),
+                        });
+                }
+            }
+        }
+    }
+    collect();
+    for (const node of Object.values(input.nextNodes ?? nodes))
+        if (node.type === 'unit' && !deleted.has(node.id) && node.members.some((id) => deleted.has(id)))
+            changes.push({
+                op: 'update',
+                id: node.id,
+                data: { members: node.members.filter((id) => !deleted.has(id)) },
+            });
+    changes.push(...[...deleted].map((id) => ({ op: 'delete', id: id })));
+    return { changes };
+}

package/dist/commands/structure/rebase-floor-reference.d.ts

@@ -0,0 +1,7 @@
+import type { StructureNodes, StructurePlan } from './shared.js';
+export declare function rebaseFloorReference(nodes: StructureNodes, input: {
+    slabId?: string;
+    slabIds?: string[];
+    referenceFloorElevation: number | null;
+}): StructurePlan;
+//# sourceMappingURL=rebase-floor-reference.d.ts.map

package/dist/commands/structure/rebase-floor-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rebase-floor-reference.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/rebase-floor-reference.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7D,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,uBAAuB,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,GACrF,aAAa,CAyFf"}

package/dist/commands/structure/rebase-floor-reference.js

@@ -0,0 +1,90 @@
+import { floorPlateAtGroundContact, footprintLift } from '../../lib/floor-foundation-datum.js';
+import { levelConstructionDisplacements, upperStoreyFootprints, } from '../../lib/floor-foundation-stack.js';
+import { roundFloorElevation } from '../../lib/room-floor-feasibility.js';
+import { getAuthoredLevelElevations, getLevelElevations } from '../../services/storey.js';
+export function rebaseFloorReference(nodes, input) {
+    if (!!input.slabId === !!input.slabIds?.length)
+        throw new Error('Supply slabId or a non-empty slabIds array.');
+    const plates = [...new Set(input.slabIds ?? [input.slabId])].map((id) => {
+        const plate = nodes[id];
+        if (plate?.type !== 'slab' || plate.plateRole !== 'base')
+            throw new Error(`Base plate not found: ${id}`);
+        return plate;
+    });
+    const reference = input.referenceFloorElevation;
+    if (reference !== null && !Number.isFinite(reference))
+        throw new Error('The floor reference must be a finite level-local elevation.');
+    const nextPlates = plates.map((plate) => ({
+        ...plate,
+        referenceFloorElevation: reference ?? undefined,
+        ...(floorPlateAtGroundContact(nodes, plate) && plate.floorHeight === undefined
+            ? { floorHeight: plate.elevation }
+            : {}),
+    }));
+    let draft = {
+        ...nodes,
+        ...Object.fromEntries(nextPlates.map((plate) => [plate.id, plate])),
+    };
+    const supports = upperStoreyFootprints(nodes);
+    const beforeDisplacement = levelConstructionDisplacements(nodes, supports);
+    const afterDisplacement = levelConstructionDisplacements(draft, supports);
+    for (const [levelId, owners] of supports) {
+        const shifts = owners.map((owner) => {
+            const nextOwner = draft[owner.id];
+            return ((afterDisplacement.get(owner.parentId) ?? 0) +
+                footprintLift(draft, nextOwner) -
+                (beforeDisplacement.get(owner.parentId) ?? 0) -
+                footprintLift(nodes, owner));
+        });
+        if (shifts.some((shift) => Math.abs(shift - shifts[0]) > 1e-6))
+            return {
+                changes: [],
+                conflicts: [
+                    {
+                        code: 'floor-reference-shared-storey',
+                        nodeIds: [levelId, ...owners.map((owner) => owner.id)],
+                        message: 'This storey spans floor references that would move by different amounts. Rebase the supporting footprints together.',
+                    },
+                ],
+            };
+    }
+    const before = getLevelElevations(nodes);
+    const ordered = [...getAuthoredLevelElevations(nodes)].sort((a, b) => a[1].ordinal - b[1].ordinal);
+    for (const [levelId] of ordered) {
+        const level = draft[levelId];
+        if (level?.type !== 'level')
+            continue;
+        const delta = (before.get(levelId)?.baseY ?? 0) - (getLevelElevations(draft).get(levelId)?.baseY ?? 0);
+        if (Math.abs(delta) <= 1e-6)
+            continue;
+        draft = {
+            ...draft,
+            [levelId]: {
+                ...level,
+                baseElevation: roundFloorElevation((level.baseElevation ?? 0) + delta),
+            },
+        };
+    }
+    const changes = [
+        ...nextPlates.map((nextPlate, index) => ({
+            op: 'update',
+            id: nextPlate.id,
+            data: {
+                referenceFloorElevation: nextPlate.referenceFloorElevation,
+                ...(nextPlate.floorHeight !== plates[index].floorHeight
+                    ? { floorHeight: nextPlate.floorHeight }
+                    : {}),
+            },
+        })),
+        ...ordered.flatMap(([levelId]) => {
+            const old = nodes[levelId];
+            const next = draft[levelId];
+            return old?.type === 'level' &&
+                next?.type === 'level' &&
+                old.baseElevation !== next.baseElevation
+                ? [{ op: 'update', id: old.id, data: { baseElevation: next.baseElevation } }]
+                : [];
+        }),
+    ];
+    return { changes };
+}

package/dist/commands/structure/resize-mezzanine.d.ts

@@ -0,0 +1,8 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export type MezzanineEdgeInput = {
+    zoneId: string;
+    edgeIndex: number;
+    distance: number;
+};
+export declare function resizeMezzanine(nodes: StructureNodes, input: MezzanineEdgeInput): StructurePlan;
+//# sourceMappingURL=resize-mezzanine.d.ts.map

package/dist/commands/structure/resize-mezzanine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resize-mezzanine.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/resize-mezzanine.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAGjB,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAExF,wBAAgB,eAAe,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,kBAAkB,GAAG,aAAa,CAgD/F"}

package/dist/commands/structure/resize-mezzanine.js

@@ -0,0 +1,43 @@
+import { polygonInteriorPoint } from '../../lib/polygon-label.js';
+import { conflict, requireZone, } from './shared.js';
+import { validateMezzanine } from './validate-mezzanine.js';
+export function resizeMezzanine(nodes, input) {
+    const zone = requireZone(nodes, input.zoneId);
+    if (zone.floor?.support !== 'open')
+        return conflict('invalid-edge', [zone.id], 'Polygon edge pushes require a mezzanine.');
+    const { edgeIndex, distance } = input;
+    if (!Number.isInteger(edgeIndex) ||
+        edgeIndex < 0 ||
+        edgeIndex >= zone.polygon.length ||
+        !Number.isFinite(distance))
+        return conflict('invalid-edge', [zone.id], 'Use a polygon edge index and a finite distance in metres.');
+    const polygon = zone.polygon.map((p) => [...p]);
+    const nextIndex = (edgeIndex + 1) % polygon.length;
+    const start = polygon[edgeIndex], end = polygon[nextIndex];
+    const dx = end[0] - start[0], dz = end[1] - start[1], length = Math.hypot(dx, dz);
+    if (length < 1e-6)
+        return conflict('too-small', [zone.id], 'The edge has no length.');
+    const winding = Math.sign(polygon.reduce((sum, p, i) => {
+        const q = polygon[(i + 1) % polygon.length];
+        return sum + p[0] * q[1] - q[0] * p[1];
+    }, 0));
+    for (const index of [edgeIndex, nextIndex]) {
+        const point = polygon[index];
+        polygon[index] = [
+            point[0] + ((winding * dz) / length) * distance + 0,
+            point[1] - ((winding * dx) / length) * distance + 0,
+        ];
+    }
+    const invalid = validateMezzanine(nodes, { ...zone, polygon }, zone.id);
+    if (invalid)
+        return { changes: [], conflicts: [invalid] };
+    return {
+        changes: [
+            {
+                op: 'update',
+                id: zone.id,
+                data: { polygon, seed: polygonInteriorPoint({ polygon }, true) },
+            },
+        ],
+    };
+}

package/dist/commands/structure/rotate-zone.d.ts

@@ -0,0 +1,8 @@
+import { type StructureNodes } from './shared.js';
+import { type TransformZoneInput } from './transform-zone.js';
+export type RotateZoneInput = Pick<TransformZoneInput, 'zoneId' | 'mintId' | 'force'> & {
+    quarterTurns: 1 | -1;
+    gridStep?: number;
+};
+export declare function rotateZone(nodes: StructureNodes, input: RotateZoneInput): import("./transform-zone.js").ZoneTransformPlan;
+//# sourceMappingURL=rotate-zone.d.ts.map

package/dist/commands/structure/rotate-zone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rotate-zone.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/rotate-zone.ts"],"names":[],"mappings":"AACA,OAAO,EAAqC,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AACjF,OAAO,EAAE,KAAK,kBAAkB,EAAiB,MAAM,kBAAkB,CAAA;AAEzE,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,kBAAkB,EAAE,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC,GAAG;IACtF,YAAY,EAAE,CAAC,GAAG,CAAC,CAAC,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,gDAyBvE"}

package/dist/commands/structure/rotate-zone.js

@@ -0,0 +1,28 @@
+import { polygonCentroid } from '../../lib/polygon-label.js';
+import { requireZone, roomFace } from './shared.js';
+import { transformZone } from './transform-zone.js';
+export function rotateZone(nodes, input) {
+    const gridStep = input.gridStep ?? 0.5;
+    if (!(Number.isFinite(gridStep) && gridStep > 0) || ![1, -1].includes(input.quarterTurns))
+        throw Error('Use quarterTurns 1 or -1 and a positive finite gridStep.');
+    const zone = requireZone(nodes, input.zoneId);
+    if (zone.floor?.support === 'open')
+        return transformZone(nodes, { ...input, rotate: { angle: (input.quarterTurns * Math.PI) / 2 } });
+    const face = roomFace(nodes, zone);
+    if (!face)
+        return transformZone(nodes, input);
+    const pivot = polygonCentroid({ outer: face.referencePolygon, holes: face.holes });
+    const first = face.referencePolygon[0];
+    const rotated = [
+        pivot[0] + input.quarterTurns * (first[1] - pivot[1]),
+        pivot[1] - input.quarterTurns * (first[0] - pivot[0]),
+    ];
+    const translate = rotated.map((value) => Math.round(value / gridStep) * gridStep - value);
+    return transformZone(nodes, {
+        zoneId: input.zoneId,
+        mintId: input.mintId,
+        force: input.force,
+        translate,
+        rotate: { angle: (input.quarterTurns * Math.PI) / 2, pivot },
+    });
+}

package/dist/commands/structure/set-floor-foundation.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import type { StructureNodes, StructurePlan } from './shared.js';
+export declare const FloorFoundationPatch: z.ZodObject<{
+    thickness: z.ZodOptional<z.ZodNumber>;
+    foundationHeight: z.ZodOptional<z.ZodNumber>;
+    floorHeight: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    foundation: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            solid: "solid";
+            none: "none";
+        }>;
+        material: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+                custom: "custom";
+                white: "white";
+                brick: "brick";
+                concrete: "concrete";
+                wood: "wood";
+                glass: "glass";
+                metal: "metal";
+                plaster: "plaster";
+                tile: "tile";
+                marble: "marble";
+            }>>>;
+            properties: z.ZodOptional<z.ZodObject<{
+                color: z.ZodDefault<z.ZodString>;
+                roughness: z.ZodDefault<z.ZodNumber>;
+                metalness: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+                transparent: z.ZodDefault<z.ZodBoolean>;
+                side: z.ZodDefault<z.ZodEnum<{
+                    front: "front";
+                    back: "back";
+                    double: "double";
+                }>>;
+            }, z.core.$strip>>;
+            texture: z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+                repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                scale: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>>;
+    }, z.core.$strip>>;
+    slots: z.ZodOptional<z.ZodObject<{
+        edge: z.ZodOptional<z.ZodString>;
+        riser: z.ZodOptional<z.ZodString>;
+        underside: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FloorFoundationPatch = z.infer<typeof FloorFoundationPatch>;
+/** A new solid foundation's finish: mid grey, apart from the white edge band and the walls. */
+export declare const DEFAULT_FOUNDATION_MATERIAL = "library:preset-midgrey";
+/** A footprint switched to "Raised on a foundation" without a height starts this high. */
+export declare const DEFAULT_FOUNDATION_HEIGHT = 0.3;
+export declare function setFloorFoundation(nodes: StructureNodes, input: {
+    slabId?: string;
+    slabIds?: string[];
+    patch: FloorFoundationPatch;
+    sameConstruction?: boolean;
+}): StructurePlan;
+//# sourceMappingURL=set-floor-foundation.d.ts.map

package/dist/commands/structure/set-floor-foundation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-floor-foundation.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-floor-foundation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAiC/B,CAAA;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAEvE,+FAA+F;AAC/F,eAAO,MAAM,2BAA2B,2BAA2B,CAAA;AAEnE,0FAA0F;AAC1F,eAAO,MAAM,yBAAyB,MAAM,CAAA;AAoD5C,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,EAAE,oBAAoB,CAAA;IAC3B,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,GACA,aAAa,CA2Ff"}

package/dist/commands/structure/set-floor-foundation.js

@@ -0,0 +1,162 @@
+import { z } from 'zod';
+import { floorPlateHoldsUnderside, groundFloorConstruction, supportDerivedFloorHeight, upperFloorHeightControl, } from '../../lib/floor-foundation-datum.js';
+import { expandFloorIntentChanges, floorIntentConflicts } from '../../lib/floor-intent-changes.js';
+import { roundFloorElevation } from '../../lib/room-floor-feasibility.js';
+import { SlabNode } from '../../schema/index.js';
+import { MIN_GROUND_FLOOR_THICKNESS, MIN_SLAB_THICKNESS } from '../../schema/nodes/slab.js';
+export const FloorFoundationPatch = z.strictObject({
+    thickness: z
+        .number()
+        .finite()
+        .min(0)
+        .optional()
+        .describe('Slab thickness in meters. On the ground it sits on the foundation (or the ground) and grows upward: a thicker slab raises the floor top and everything on it. Never below 0.01 m (smaller values are clamped). Upstairs the underside stays on the walls below.'),
+    foundationHeight: z
+        .number()
+        .finite()
+        .min(0)
+        .optional()
+        .describe('Ground-bearing floors only: height of the foundation under the slab, in meters. 0 = on the ground (no foundation); > 0 = raised on a solid foundation. The floor top is derived: grade + foundationHeight + thickness.'),
+    floorHeight: z
+        .number()
+        .finite()
+        .nullable()
+        .optional()
+        .describe('Legacy: a target floor top in level-local meters. On the ground it is mapped to foundationHeight = top - grade - thickness (never below 0); null = on the ground. Prefer thickness and foundationHeight.'),
+    foundation: SlabNode.shape.foundation,
+    slots: z
+        .strictObject({
+        edge: z.string().optional(),
+        riser: z.string().optional(),
+        underside: z.string().optional(),
+    })
+        .optional(),
+});
+/** A new solid foundation's finish: mid grey, apart from the white edge band and the walls. */
+export const DEFAULT_FOUNDATION_MATERIAL = 'library:preset-midgrey';
+/** A footprint switched to "Raised on a foundation" without a height starts this high. */
+export const DEFAULT_FOUNDATION_HEIGHT = 0.3;
+/** Foundations this low count as on the ground. */
+const ON_GROUND = 0.0005;
+const touchesGroundConstruction = (patch) => patch.thickness !== undefined ||
+    patch.foundationHeight !== undefined ||
+    Object.hasOwn(patch, 'floorHeight') ||
+    patch.foundation !== undefined;
+/**
+ * A ground-bearing plate's write, bottom up: the foundation stands on the
+ * grade, the slab on the foundation, so the top is always
+ * grade + foundationHeight + thickness and nothing floats or sinks. The top is
+ * written explicitly, so a plate that followed the automatic top keeps its
+ * underside on the foundation when its thickness changes.
+ */
+function groundPatch(nodes, plate, patch) {
+    const { floorHeight, foundationHeight: requestedHeight, ...rest } = patch;
+    if (!touchesGroundConstruction(patch))
+        return rest;
+    const current = groundFloorConstruction(nodes, plate);
+    const thickness = roundFloorElevation(Math.max(MIN_GROUND_FLOOR_THICKNESS, patch.thickness ?? plate.thickness));
+    const requested = requestedHeight ??
+        (Object.hasOwn(patch, 'floorHeight')
+            ? floorHeight == null
+                ? 0
+                : floorHeight - current.grade - thickness
+            : patch.foundation?.type === 'none'
+                ? 0
+                : patch.foundation?.type === 'solid' && current.foundationHeight <= ON_GROUND
+                    ? DEFAULT_FOUNDATION_HEIGHT
+                    : current.foundationHeight);
+    const foundationHeight = roundFloorElevation(Math.max(0, requested));
+    const solid = foundationHeight > ON_GROUND;
+    const foundation = { ...plate.foundation, ...patch.foundation, type: solid ? 'solid' : 'none' };
+    if (solid && !foundation.material)
+        foundation.material = DEFAULT_FOUNDATION_MATERIAL;
+    return {
+        ...rest,
+        thickness,
+        floorHeight: roundFloorElevation(current.grade + (solid ? foundationHeight : 0) + thickness),
+        foundation: foundation,
+    };
+}
+export function setFloorFoundation(nodes, input) {
+    if (!!input.slabId === !!input.slabIds?.length)
+        throw new Error('Supply slabId or a non-empty slabIds array.');
+    const plates = [...new Set(input.slabIds ?? [input.slabId])].map((id) => {
+        const plate = nodes[id];
+        if (plate?.type !== 'slab' || plate.plateRole !== 'base')
+            throw new Error(`Base plate not found: ${id}`);
+        return plate;
+    });
+    const requested = FloorFoundationPatch.parse(input.patch);
+    const primary = plates[0];
+    const topOf = (plate) => plate.floorHeight ?? plate.elevation;
+    const primarySupported = floorPlateHoldsUnderside(nodes, primary);
+    if (primarySupported && (requested.foundationHeight ?? 0) > ON_GROUND)
+        return {
+            changes: [],
+            conflicts: [
+                {
+                    code: 'floor-foundation-level',
+                    nodeIds: [primary.id],
+                    message: 'Only a plate at ground contact can have a solid foundation.',
+                },
+            ],
+        };
+    // How far the primary plate's top moves: every other plate of a group moves by as much.
+    const delta = primarySupported
+        ? Object.hasOwn(requested, 'floorHeight')
+            ? (requested.floorHeight ?? supportDerivedFloorHeight(nodes, primary)) - topOf(primary)
+            : requested.thickness === undefined
+                ? undefined
+                : requested.thickness - primary.thickness
+        : touchesGroundConstruction(requested)
+            ? groundPatch(nodes, primary, requested).floorHeight - topOf(primary)
+            : undefined;
+    const thin = plates.find((plate) => floorPlateHoldsUnderside(nodes, plate) &&
+        delta !== undefined &&
+        plate.thickness + delta < MIN_SLAB_THICKNESS - 1e-6);
+    if (thin)
+        return {
+            changes: [],
+            conflicts: [
+                {
+                    code: 'floor-plate-thickness',
+                    nodeIds: [thin.id],
+                    message: `The floor plate ${thin.id} cannot move that far: its thickness must remain at least ${MIN_SLAB_THICKNESS} m.`,
+                },
+            ],
+        };
+    const { floorHeight: _top, foundationHeight: _foundation, ...upperRequested } = requested;
+    const changes = plates.map((plate, index) => {
+        const supported = floorPlateHoldsUnderside(nodes, plate);
+        const own = index === 0 || input.sameConstruction;
+        let data;
+        if (supported) {
+            const patch = own ? { ...upperRequested } : {};
+            if (delta !== undefined)
+                patch.thickness = upperFloorHeightControl(nodes, plate, roundFloorElevation(topOf(plate) + delta)).write.thickness;
+            data = patch;
+        }
+        else
+            data = own
+                ? groundPatch(nodes, plate, requested)
+                : delta === undefined
+                    ? {}
+                    : groundPatch(nodes, plate, {
+                        foundationHeight: Math.max(0, groundFloorConstruction(nodes, plate).foundationHeight + delta),
+                    });
+        return {
+            id: plate.id,
+            data: {
+                ...data,
+                ...(data.foundation ? { foundation: { ...plate.foundation, ...data.foundation } } : {}),
+                ...(data.slots ? { slots: { ...plate.slots, ...data.slots } } : {}),
+            },
+        };
+    });
+    const updates = expandFloorIntentChanges(nodes, changes);
+    const conflicts = floorIntentConflicts(nodes, updates);
+    return {
+        changes: conflicts.length ? [] : updates.map((update) => ({ op: 'update', ...update })),
+        conflicts,
+    };
+}

package/dist/commands/structure/set-room-floor-construction.d.ts

@@ -0,0 +1,8 @@
+import { FloorFoundationPatch } from './set-floor-foundation.js';
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export declare function setRoomFloorConstruction(nodes: StructureNodes, input: {
+    zoneId: string;
+    slabId?: string;
+    patch: typeof FloorFoundationPatch._output;
+}): StructurePlan;
+//# sourceMappingURL=set-room-floor-construction.d.ts.map

package/dist/commands/structure/set-room-floor-construction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-room-floor-construction.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-room-floor-construction.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,oBAAoB,EAAsB,MAAM,wBAAwB,CAAA;AACjF,OAAO,EAAyB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAEzF,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,oBAAoB,CAAC,OAAO,CAAA;CAAE,GACrF,aAAa,CAkFf"}