@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1,109 @@
+import { getFloorPlacedFootprints } from '../../hooks/spatial-grid/floor-placed-footprints.js';
+import { GROUND_SUPPORT_ID } from '../../hooks/spatial-grid/support-host-id.js';
+import { resolvedFootprintPlane } from '../../lib/floor-foundation-datum.js';
+import { itemOverlapsPolygon } from '../../lib/item-polygon-overlap.js';
+import { area, difference } from '../../lib/polygon-boolean.js';
+import { getRenderableSlabPolygon } from '../../lib/slab-polygon.js';
+import { proceduralFootprint } from '../../procedural-items/query.js';
+import { nodeRegistry } from '../../registry/index.js';
+import { getScaledDimensions, } from '../../schema/index.js';
+import { getStoredLevelHeight } from '../../services/storey.js';
+import { isDerivedNode } from '../../store/derived-node-guard.js';
+import { pointInPolygon } from '../../systems/slab/slab-support.js';
+import { getStairFloorPlacedFootprints } from '../../systems/stair/stair-floor-footprints.js';
+import { roomFace } from './shared.js';
+export function isFloorPlacedIntent(node) {
+    if (isDerivedNode(node) || !('position' in node) || !Array.isArray(node.position))
+        return false;
+    const definition = nodeRegistry.get(node.type);
+    if (definition) {
+        const capability = definition.capabilities?.floorPlaced;
+        return !!capability && (!capability.applies || capability.applies(node));
+    }
+    // Headless authorities do not load renderer definitions.
+    if (node.type === 'item')
+        return !node.asset.attachTo;
+    if (node.type === 'procedural-item')
+        return !node.recipe.mounting;
+    if (node.type === 'duct-terminal')
+        return node.mount === 'floor';
+    return [
+        'cabinet',
+        'cabinet-module',
+        'shelf',
+        'stair',
+        'column',
+        'block',
+        'spawn',
+        'hvac-equipment',
+    ].includes(node.type);
+}
+export function containedMezzanines(nodes, host) {
+    if (host.floor?.support === 'open')
+        return [];
+    const face = roomFace(nodes, host);
+    const footprint = {
+        outer: face?.referencePolygon ?? host.polygon,
+        holes: face?.holes ?? host.holes,
+    };
+    return Object.values(nodes).filter((node) => node.type === 'zone' &&
+        node.floor?.support === 'open' &&
+        node.parentId === host.parentId &&
+        area(difference({ outer: node.polygon, holes: node.holes }, footprint)) <= 1e-6);
+}
+export function mezzanineElevationConflict(nodes, zone) {
+    const level = zone.parentId ? nodes[zone.parentId] : undefined;
+    const thickness = zone.floor?.thickness ?? 0.2;
+    const elevation = zone.floor?.elevation;
+    const maximum = level?.type === 'level'
+        ? resolvedFootprintPlane(nodes, zone, getStoredLevelHeight(level)) - 0.3
+        : 0;
+    return elevation === undefined ||
+        !Number.isFinite(elevation) ||
+        elevation <= thickness ||
+        elevation > maximum
+        ? {
+            code: 'mezzanine-elevation',
+            nodeIds: [zone.id],
+            message: `Mezzanine elevation must be greater than thickness (${thickness} m) and at most ${maximum} m.`,
+        }
+        : undefined;
+}
+export function electedIntentPlate(nodes, node) {
+    if (node.supportSlabId === GROUND_SUPPORT_ID)
+        return undefined;
+    const capability = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
+    const rotation = Array.isArray(node.rotation)
+        ? node.rotation
+        : [0, node.rotation, 0];
+    const dimensions = node.type === 'item'
+        ? getScaledDimensions(node)
+        : [
+            'width' in node && typeof node.width === 'number' ? node.width : 0.6,
+            1,
+            'depth' in node && typeof node.depth === 'number' ? node.depth : 0.6,
+        ];
+    const footprints = capability
+        ? getFloorPlacedFootprints(capability, node, { nodes })
+        : node.type === 'stair'
+            ? getStairFloorPlacedFootprints(node, nodes)
+            : node.type === 'procedural-item'
+                ? [proceduralFootprint(node)]
+                : [{ dimensions, rotation }];
+    const siblings = Object.values(nodes).filter((n) => n.parentId === node.parentId);
+    const slabs = siblings.filter((n) => n.type === 'slab');
+    const walls = siblings.filter((n) => n.type === 'wall');
+    const supported = slabs.filter((slab) => {
+        const polygon = getRenderableSlabPolygon(slab, {
+            walls,
+            siblingSlabs: slabs.filter((n) => n.id !== slab.id),
+        });
+        return footprints.some((footprint) => {
+            const position = footprint.position ?? node.position;
+            return (itemOverlapsPolygon(position, footprint.dimensions, footprint.rotation, polygon, 0.01) &&
+                !slab.holes.some((hole) => pointInPolygon(position[0], position[2], hole)));
+        });
+    });
+    return (supported.find((slab) => slab.id === node.supportSlabId) ??
+        supported.sort((a, b) => b.elevation - a.elevation)[0]);
+}

package/dist/commands/structure/plan-mezzanine-stair.d.ts

@@ -0,0 +1,7 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export type MezzanineStairPlan = StructurePlan & {
+    stairId?: string;
+    edgeIndex?: number;
+};
+export declare function planMezzanineStair(nodes: StructureNodes, mezzanineZoneId: string): MezzanineStairPlan;
+//# sourceMappingURL=plan-mezzanine-stair.d.ts.map

package/dist/commands/structure/plan-mezzanine-stair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-mezzanine-stair.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/plan-mezzanine-stair.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAGjB,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzF,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,eAAe,EAAE,MAAM,GACtB,kBAAkB,CA6HpB"}

package/dist/commands/structure/plan-mezzanine-stair.js

@@ -0,0 +1,127 @@
+import { planFootprintCorners } from '../../lib/plan-footprint.js';
+import { area, difference, intersection, union } from '../../lib/polygon-boolean.js';
+import { roomFloorPlate } from '../../lib/room-floor-plate.js';
+import { getScaledDimensions, StairNode, StairSegmentNode } from '../../schema/index.js';
+import { stairFootprintAABB } from '../../systems/stair/stair-footprint.js';
+import { createSizedStairFlight, DEFAULT_STAIR_DESIGN_TARGETS, } from '../../systems/stair/stair-sizing.js';
+import { conflict, requireZone, } from './shared.js';
+import { mezzanineHostClearance } from './validate-mezzanine.js';
+export function planMezzanineStair(nodes, mezzanineZoneId) {
+    const zone = requireZone(nodes, mezzanineZoneId);
+    const host = nodes[zone.hostZoneId ?? ''];
+    if (zone.floor?.support !== 'open' || host?.type !== 'zone')
+        throw Error('Select a mezzanine with a host room.');
+    const refuse = () => conflict('no-room-for-stair', [zone.id], 'No mezzanine edge has enough free host floor for a straight stair.');
+    const slabs = Object.values(nodes).filter((node) => node.type === 'slab');
+    const deck = slabs.find((node) => node.zoneIds?.includes(zone.id));
+    const floor = roomFloorPlate(slabs, host.id);
+    if (!deck || !floor)
+        return refuse();
+    const rise = deck.elevation - floor.elevation;
+    if (!(rise > 0))
+        return refuse();
+    const defaults = createSizedStairFlight(rise);
+    const stepCount = defaults.stepCount;
+    const preferredRun = defaults.length;
+    const minimumRun = stepCount * DEFAULT_STAIR_DESIGN_TARGETS.minimumGoing;
+    const width = defaults.width;
+    const obstacles = [];
+    for (const node of Object.values(nodes)) {
+        if (node.parentId !== zone.parentId)
+            continue;
+        if (node.type === 'zone' && node.floor?.support === 'open')
+            obstacles.push(node.polygon);
+        if (node.type === 'item' && !node.asset.attachTo)
+            obstacles.push(planFootprintCorners(node.position, getScaledDimensions(node), node.rotation[1]));
+        if (node.type === 'stair') {
+            const box = stairFootprintAABB(node, nodes);
+            if (box)
+                obstacles.push([
+                    [box.minX, box.minZ],
+                    [box.maxX, box.minZ],
+                    [box.maxX, box.maxZ],
+                    [box.minX, box.maxZ],
+                ]);
+        }
+    }
+    const free = difference(mezzanineHostClearance(nodes, host), union(obstacles));
+    const winding = Math.sign(zone.polygon.reduce((sum, p, i) => {
+        const q = zone.polygon[(i + 1) % zone.polygon.length];
+        return sum + p[0] * q[1] - q[0] * p[1];
+    }, 0));
+    const candidates = [];
+    const extent = Math.hypot(Math.max(...host.polygon.map(([x]) => x)) - Math.min(...host.polygon.map(([x]) => x)), Math.max(...host.polygon.map(([, z]) => z)) - Math.min(...host.polygon.map(([, z]) => z)));
+    for (const [edgeIndex, start] of zone.polygon.entries()) {
+        const end = zone.polygon[(edgeIndex + 1) % zone.polygon.length];
+        const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+        if (length < width)
+            continue;
+        const tangent = [(end[0] - start[0]) / length, (end[1] - start[1]) / length];
+        const normal = [winding * tangent[1], -winding * tangent[0]];
+        for (const along of [...new Set([length / 2, width / 2, length - width / 2])]) {
+            const arrival = [start[0] + tangent[0] * along, start[1] + tangent[1] * along];
+            const footprint = (depth) => [
+                [-width / 2, 0],
+                [width / 2, 0],
+                [width / 2, depth],
+                [-width / 2, depth],
+            ].map(([x, z]) => [
+                arrival[0] + tangent[0] * x + normal[0] * z,
+                arrival[1] + tangent[1] * x + normal[1] * z,
+            ]);
+            const fits = (depth) => {
+                const polygon = footprint(depth);
+                return (area(difference(polygon, free)) <= 1e-6 &&
+                    area(difference(polygon, { outer: floor.polygon, holes: floor.holes })) <= 1e-6 &&
+                    area(intersection(polygon, zone.polygon)) <= 1e-6);
+            };
+            if (!fits(minimumRun))
+                continue;
+            let lo = minimumRun, hi = extent;
+            for (let i = 0; i < 16; i++) {
+                const mid = (lo + hi) / 2;
+                if (fits(mid))
+                    lo = mid;
+                else
+                    hi = mid;
+            }
+            candidates.push({ edgeIndex, arrival, normal, freeRun: lo });
+        }
+    }
+    const best = candidates.sort((a, b) => b.freeRun - a.freeRun)[0];
+    if (!best)
+        return refuse();
+    const run = Math.min(preferredRun, best.freeRun);
+    const stair = StairNode.parse({
+        parentId: zone.parentId,
+        name: 'Mezzanine stair',
+        uniformRisers: true,
+        fromLevelId: zone.parentId,
+        supportSlabId: floor.id,
+        deckSlabId: deck.id,
+        width,
+        stepCount,
+        position: [
+            best.arrival[0] + best.normal[0] * run + 0,
+            0,
+            best.arrival[1] + best.normal[1] * run + 0,
+        ],
+        rotation: Math.atan2(-best.normal[0], -best.normal[1]) + 0,
+    });
+    const segment = StairSegmentNode.parse({
+        ...defaults,
+        parentId: stair.id,
+        height: rise,
+        length: run,
+        stepCount,
+    });
+    stair.children = [segment.id];
+    return {
+        stairId: stair.id,
+        edgeIndex: best.edgeIndex,
+        changes: [
+            { op: 'create', node: stair },
+            { op: 'create', node: segment },
+        ],
+    };
+}

package/dist/commands/structure/plan-wall-deletion.d.ts

@@ -0,0 +1,9 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+/** Plans user deletion, including room-preserving boundaries, before reconciliation. */
+export declare function planWallDeletion(nodes: StructureNodes, input: {
+    nodeIds: readonly string[];
+    mintId: (kind: 'separator') => string;
+    /** Authored batch state, so replacement walls/separators do not get duplicated. */
+    nextNodes?: StructureNodes;
+}): StructurePlan;
+//# sourceMappingURL=plan-wall-deletion.d.ts.map

package/dist/commands/structure/plan-wall-deletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-wall-deletion.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/plan-wall-deletion.ts"],"names":[],"mappings":"AAKA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB,wFAAwF;AACxF,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1B,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,CAAA;IACrC,mFAAmF;IACnF,SAAS,CAAC,EAAE,cAAc,CAAA;CAC3B,GACA,aAAa,CAmKf"}

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 },
+    });
+}