@pascal-app/core 1.0.1 → 1.0.4

package/dist/commands/structure/set-room-floor-construction.js

@@ -0,0 +1,72 @@
+import { roomDrawnFloor } from '../../lib/room-drawn-floor.js';
+import { MIN_SLAB_THICKNESS } from '../../schema/nodes/slab.js';
+import { FloorFoundationPatch, setFloorFoundation } from './set-floor-foundation.js';
+import { conflict, requireZone } from './shared.js';
+export function setRoomFloorConstruction(nodes, input) {
+    const zone = requireZone(nodes, input.zoneId);
+    // A drawn-slab floor is edited on the slab the room visibly stands on.
+    const drawn = roomDrawnFloor(nodes, zone.id);
+    const options = Object.values(nodes).filter((node) => node.type === 'slab' &&
+        node.parentId === zone.parentId &&
+        (node.id === zone.floor?.sourceSlabId ||
+            node.id === drawn?.slabId ||
+            (node.plateRole === 'base' && (node.zoneIds ?? []).includes(zone.id))));
+    const selected = input.slabId
+        ? options.find((plate) => plate.id === input.slabId)
+        : (options.find((plate) => plate.id === (drawn?.slabId ?? zone.floor?.sourceSlabId)) ??
+            (options.length === 1 ? options[0] : undefined));
+    if (!selected)
+        return conflict('room-floor-owner', [zone.id, ...options.map((plate) => plate.id)], options.length
+            ? `This room spans more than one floor construction. Choose slabId from: ${options.map((plate) => plate.id).join(', ')}.`
+            : 'This room has no associated floor construction.');
+    const patch = FloorFoundationPatch.parse(input.patch);
+    if (selected.plateRole === 'base') {
+        const key = zone.floor?.footprint;
+        if (!key)
+            return setFloorFoundation(nodes, { slabId: selected.id, patch });
+        const plates = Object.values(nodes).filter((node) => node.type === 'slab' &&
+            node.parentId === zone.parentId &&
+            node.plateRole === 'base' &&
+            !!node.zoneIds?.some((id) => {
+                const room = nodes[id];
+                return room?.type === 'zone' && room.floor?.footprint === key;
+            }));
+        return setFloorFoundation(nodes, {
+            slabIds: [
+                selected.id,
+                ...plates.filter((plate) => plate.id !== selected.id).map((plate) => plate.id),
+            ],
+            patch,
+            sameConstruction: true,
+        });
+    }
+    if (patch.foundation !== undefined ||
+        patch.foundationHeight !== undefined ||
+        patch.floorHeight === null)
+        return conflict('room-authored-floor-construction', [zone.id, selected.id], 'An authored slab has no foundation or automatic height to restore. Supply a numeric floorHeight to move its top, or edit thickness and finishes.');
+    const elevation = patch.floorHeight === undefined ? undefined : patch.floorHeight;
+    return {
+        changes: [
+            {
+                op: 'update',
+                id: selected.id,
+                data: {
+                    ...(elevation === undefined ? {} : { elevation }),
+                    ...(patch.thickness === undefined
+                        ? {}
+                        : { thickness: Math.max(MIN_SLAB_THICKNESS, patch.thickness) }),
+                    ...(patch.slots === undefined ? {} : { slots: { ...selected.slots, ...patch.slots } }),
+                },
+            },
+            ...(elevation !== undefined && zone.floor?.elevation !== undefined
+                ? [
+                    {
+                        op: 'update',
+                        id: zone.id,
+                        data: { floor: { ...zone.floor, elevation } },
+                    },
+                ]
+                : []),
+        ],
+    };
+}

package/dist/commands/structure/set-wall-geometry.d.ts

@@ -0,0 +1,10 @@
+import { type Point, type StructureMintId, type StructureNodes, type StructurePlan } from './shared.js';
+export declare function setWallGeometry(nodes: StructureNodes, input: {
+    wallId: string;
+    start?: Point;
+    end?: Point;
+    thickness?: number;
+    justification?: 'a' | 'b' | null;
+    mintId: StructureMintId;
+}): StructurePlan;
+//# sourceMappingURL=set-wall-geometry.d.ts.map

package/dist/commands/structure/set-wall-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-wall-geometry.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-wall-geometry.ts"],"names":[],"mappings":"AAGA,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,KAAK,CAAA;IACb,GAAG,CAAC,EAAE,KAAK,CAAA;IACX,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,aAAa,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,IAAI,CAAA;IAChC,MAAM,EAAE,eAAe,CAAA;CACxB,GACA,aAAa,CA6Df"}

package/dist/commands/structure/set-wall-geometry.js

@@ -0,0 +1,52 @@
+import { WallNode } from '../../schema/index.js';
+import { planWallJustification } from '../../systems/wall/wall-frame.js';
+import { getPlannedLinkedWallUpdates, planWallMoveJunctions } from '../../systems/wall/wall-move.js';
+import { applyToScratch, conflict, diffStructure, } from './shared.js';
+export function setWallGeometry(nodes, input) {
+    const original = nodes[input.wallId];
+    if (original?.type !== 'wall')
+        throw Error('Select a wall.');
+    let scratch = { ...nodes };
+    if (input.justification !== undefined)
+        scratch = applyToScratch(scratch, {
+            create: [],
+            delete: [],
+            update: planWallJustification(nodes, original.id, input.justification ?? undefined),
+        });
+    const wall = scratch[original.id];
+    const start = input.start ?? wall.start, end = input.end ?? wall.end;
+    const next = WallNode.parse({
+        ...wall,
+        start,
+        end,
+        ...(input.thickness !== undefined ? { thickness: input.thickness } : {}),
+    });
+    if (!([...start, ...end].every(Number.isFinite) &&
+        Math.hypot(end[0] - start[0], end[1] - start[1]) >= 0.05 &&
+        (next.thickness ?? 0.1) > 0))
+        throw Error('Invalid wall geometry.');
+    if (input.start || input.end) {
+        const linked = Object.values(scratch).filter((n) => n.type === 'wall' && n.parentId === wall.parentId && n.id !== wall.id);
+        const plan = planWallMoveJunctions(linked, wall.start, wall.end, start, end);
+        const consumed = plan.wallsToDelete.map((n) => n.id);
+        const hosted = Object.values(scratch).filter((n) => consumed.includes(n.parentId));
+        if (hosted.length)
+            return conflict('hosted-openings', hosted.map((n) => n.id), 'Moving this junction would remove a wall with hosted objects.');
+        scratch = applyToScratch(scratch, {
+            update: getPlannedLinkedWallUpdates(plan, wall.start, wall.end, start, end).map(({ id, ...data }) => ({ id, data })),
+            delete: consumed,
+            create: plan.bridgePlans.map((bridge) => ({
+                node: WallNode.parse({
+                    ...bridge.wall,
+                    id: input.mintId('wall'),
+                    children: [],
+                    start: bridge.originalPoint,
+                    end: bridge.movedEndpoint === 'start' ? start : end,
+                }),
+                parentId: wall.parentId,
+            })),
+        });
+    }
+    scratch[wall.id] = next;
+    return { changes: diffStructure(nodes, scratch) };
+}

package/dist/commands/structure/set-zone-edges.d.ts

@@ -0,0 +1,14 @@
+import { type WallNode } from '../../schema/index.js';
+import { type MezzanineEdgeInput } from './resize-mezzanine.js';
+import { type SpanRef, type StructureMintId, type StructureNodes, type StructurePlan } from './shared.js';
+export declare function setZoneEdges(nodes: StructureNodes, input: MezzanineEdgeInput | {
+    zoneId: string;
+    edges: Array<{
+        spanRef: SpanRef;
+        kind: 'wall' | 'separator';
+        wall?: Pick<Partial<WallNode>, 'thickness' | 'height' | 'justification'>;
+    }>;
+    dropOpenings?: boolean;
+    mintId: StructureMintId;
+}): StructurePlan;
+//# sourceMappingURL=set-zone-edges.d.ts.map

package/dist/commands/structure/set-zone-edges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-zone-edges.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-zone-edges.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAA;AAI3E,OAAO,EAAE,KAAK,kBAAkB,EAAmB,MAAM,oBAAoB,CAAA;AAC7E,OAAO,EAOL,KAAK,OAAO,EACZ,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EAEnB,MAAM,UAAU,CAAA;AAEjB,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,EACrB,KAAK,EACD,kBAAkB,GAClB;IACE,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,KAAK,CAAC;QACX,OAAO,EAAE,OAAO,CAAA;QAChB,IAAI,EAAE,MAAM,GAAG,WAAW,CAAA;QAC1B,IAAI,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,eAAe,CAAC,CAAA;KACzE,CAAC,CAAA;IACF,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,MAAM,EAAE,eAAe,CAAA;CACxB,GACJ,aAAa,CAiKf"}

package/dist/commands/structure/set-zone-edges.js

@@ -0,0 +1,143 @@
+import { sampleWallPointsForRoomDetection } from '../../lib/room-graph.js';
+import { SeparatorNode } from '../../schema/index.js';
+import { getWallCurveLength } from '../../systems/wall/wall-curve.js';
+import { planWallDivision } from '../../systems/wall/wall-operations.js';
+import { planWallInsertion } from '../../systems/wall/wall-topology.js';
+import { resizeMezzanine } from './resize-mezzanine.js';
+import { applyToScratch, at, conflict, diffStructure, requireZone, roomFace, sharedSpan, } from './shared.js';
+export function setZoneEdges(nodes, input) {
+    if ('edgeIndex' in input)
+        return resizeMezzanine(nodes, input);
+    const zone = requireZone(nodes, input.zoneId);
+    if (zone.floor?.support === 'open')
+        return conflict('invalid-edge', [zone.id], 'Use edgeIndex and distance to push a mezzanine edge.');
+    const face = roomFace(nodes, zone);
+    let scratch = { ...nodes };
+    const edges = [...input.edges].sort((a, b) => a.spanRef.boundaryId.localeCompare(b.spanRef.boundaryId) || b.spanRef.t0 - a.spanRef.t0);
+    for (let i = 1; i < edges.length; i++) {
+        const left = edges[i - 1].spanRef, right = edges[i].spanRef;
+        if (left.boundaryId === right.boundaryId && right.t1 > left.t0 + 1e-6)
+            return conflict('overlapping-spans', [left.boundaryId], 'Boundary edits must not overlap.');
+    }
+    for (const edge of edges) {
+        const span = edge.spanRef;
+        if (!face?.spans.some((s) => s.boundaryId === span.boundaryId &&
+            s.face === span.face &&
+            span.t0 >= s.t0 - 1e-6 &&
+            span.t1 <= s.t1 + 1e-6 &&
+            span.t1 > span.t0))
+            return conflict('invalid-span', [span.boundaryId], 'The span is not on this room boundary.');
+        const boundary = scratch[span.boundaryId];
+        if (boundary?.type !== 'wall' && boundary?.type !== 'separator')
+            return conflict('stale-span', [span.boundaryId], 'Replan against the current boundary.');
+        if (boundary.type === edge.kind)
+            continue;
+        const original = nodes[span.boundaryId];
+        if (original?.type !== 'wall' && original?.type !== 'separator')
+            throw Error('Missing boundary.');
+        const originalLength = original.type === 'wall'
+            ? getWallCurveLength(original)
+            : Math.hypot(original.end[0] - original.start[0], original.end[1] - original.start[1]);
+        const currentLength = boundary.type === 'wall'
+            ? getWallCurveLength(boundary)
+            : Math.hypot(boundary.end[0] - boundary.start[0], boundary.end[1] - boundary.start[1]);
+        const t0 = (span.t0 * originalLength) / currentLength, t1 = (span.t1 * originalLength) / currentLength;
+        if (boundary.type === 'separator') {
+            const start = at(boundary.start, boundary.end, t0), end = at(boundary.start, boundary.end, t1);
+            const inserted = planWallInsertion(scratch, {
+                levelId: zone.parentId,
+                start,
+                end,
+                joinRadius: 0.001,
+                wallDefaults: edge.wall,
+                mintId: () => input.mintId('wall'),
+            });
+            if (!inserted.ok)
+                return conflict(inserted.reason, [boundary.id], 'Cannot replace this separator with a wall.');
+            scratch = applyToScratch(scratch, inserted.plan.changes);
+            delete scratch[boundary.id];
+            for (const [from, to] of [
+                [0, t0],
+                [t1, 1],
+            ])
+                if (to - from > 1e-6) {
+                    const remainder = SeparatorNode.parse({
+                        ...boundary,
+                        id: from === 0 ? boundary.id : input.mintId('separator'),
+                        start: at(boundary.start, boundary.end, from),
+                        end: at(boundary.start, boundary.end, to),
+                    });
+                    scratch[remainder.id] = remainder;
+                }
+        }
+        else {
+            if (sharedSpan(nodes, zone, span))
+                continue;
+            const length = getWallCurveLength(boundary);
+            const attachments = Object.values(scratch).filter((n) => n.parentId === boundary.id || ('wallId' in n && n.wallId === boundary.id));
+            const removed = attachments.filter((n) => 'position' in n &&
+                Array.isArray(n.position) &&
+                n.position[0] +
+                    ('width' in n && typeof n.width === 'number'
+                        ? n.width / 2
+                        : n.type === 'item'
+                            ? (n.asset.dimensions[0] * n.scale[0]) / 2
+                            : 0) >=
+                    t0 * length &&
+                n.position[0] -
+                    ('width' in n && typeof n.width === 'number'
+                        ? n.width / 2
+                        : n.type === 'item'
+                            ? (n.asset.dimensions[0] * n.scale[0]) / 2
+                            : 0) <=
+                    t1 * length);
+            if (removed.length && !input.dropOpenings)
+                return conflict('hosted-openings', removed.map((n) => n.id), 'Removing this wall also removes its hosted openings and objects. Pass dropOpenings to confirm.');
+            const removedIds = new Set(removed.map((n) => n.id));
+            let found = true;
+            while (found) {
+                found = false;
+                for (const n of Object.values(scratch))
+                    if (n.parentId && removedIds.has(n.parentId) && !removedIds.has(n.id)) {
+                        removedIds.add(n.id);
+                        found = true;
+                    }
+            }
+            for (const id of removedIds)
+                delete scratch[id];
+            scratch[boundary.id] = {
+                ...boundary,
+                children: boundary.children.filter((id) => !removed.some((n) => n.id === id)),
+            };
+            let targetId = boundary.id;
+            try {
+                for (const t of [t1, t0])
+                    if (t > 1e-6 && t < 1 - 1e-6) {
+                        const division = planWallDivision(scratch, boundary.id, t * length, () => input.mintId('wall'));
+                        scratch = applyToScratch(scratch, division.changes);
+                        if (t === t0)
+                            targetId = division.changes.create[0].node.id;
+                    }
+            }
+            catch (error) {
+                return conflict('occupied-split', [boundary.id], String(error));
+            }
+            const target = scratch[targetId];
+            if (target?.type !== 'wall')
+                return conflict('invalid-span', [boundary.id], 'Could not isolate the wall span.');
+            delete scratch[target.id];
+            const points = sampleWallPointsForRoomDetection(target);
+            for (let i = 1; i < points.length; i++) {
+                const start = points[i - 1], end = points[i];
+                const separator = SeparatorNode.parse({
+                    id: input.mintId('separator'),
+                    parentId: zone.parentId,
+                    start: [start.x, start.y],
+                    end: [end.x, end.y],
+                });
+                scratch[separator.id] = separator;
+            }
+        }
+    }
+    return { changes: diffStructure(nodes, scratch) };
+}

package/dist/commands/structure/set-zone-intent.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export declare const ZoneIntentPatch: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    floor: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        footprint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        thickness: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        elevation: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        finish: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>>>;
+        regions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strict>>>;
+    ceiling: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        regions: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            finish: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        }, z.core.$strip>>>>;
+    }, z.core.$strict>>>;
+    floorStepFinish: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    floorStepOverrides: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        step: z.ZodOptional<z.ZodNumber>;
+        finish: z.ZodString;
+    }, z.core.$strip>>>>;
+    floorEdgeFinish: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    wallMaterial: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    hasFloor: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    hasCeiling: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type ZoneIntentPatch = z.infer<typeof ZoneIntentPatch>;
+export declare function setZoneIntent(nodes: StructureNodes, input: {
+    zoneId: string;
+    patch: ZoneIntentPatch;
+}): StructurePlan;
+//# sourceMappingURL=set-zone-intent.d.ts.map

package/dist/commands/structure/set-zone-intent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-zone-intent.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/set-zone-intent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,OAAO,EAAe,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAI/E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAwB1B,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAE7D,wBAAgB,aAAa,CAC3B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAE,GAChD,aAAa,CAuFf"}

package/dist/commands/structure/set-zone-intent.js

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import { floorIntentConflicts } from '../../lib/floor-intent-changes.js';
+import { ownFloorIntentChanges } from '../../lib/own-floor-intent.js';
+import { drawnFloorElevationConflict } from '../../lib/room-drawn-floor.js';
+import { roundFloorElevation } from '../../lib/room-floor-feasibility.js';
+import { ZoneNode } from '../../schema/index.js';
+import { mezzanineElevationConflict } from './mezzanine-content.js';
+import { requireZone } from './shared.js';
+const floor = ZoneNode.shape.floor.unwrap();
+const ceiling = ZoneNode.shape.ceiling.unwrap();
+export const ZoneIntentPatch = z.strictObject({
+    name: z.string().nullable().optional(),
+    floor: z
+        .strictObject({
+        footprint: floor.shape.footprint.unwrap().nullable().optional(),
+        thickness: floor.shape.thickness.unwrap().nullable().optional(),
+        elevation: floor.shape.elevation.unwrap().nullable().optional(),
+        finish: floor.shape.finish.unwrap().nullable().optional(),
+        regions: floor.shape.regions.unwrap().nullable().optional(),
+    })
+        .nullable()
+        .optional(),
+    ceiling: z
+        .strictObject({
+        regions: ceiling.shape.regions.unwrap().nullable().optional(),
+    })
+        .nullable()
+        .optional(),
+    floorStepFinish: z.string().nullable().optional(),
+    floorStepOverrides: ZoneNode.shape.floorStepOverrides.unwrap().nullable().optional(),
+    floorEdgeFinish: z.string().nullable().optional(),
+    wallMaterial: z.string().nullable().optional(),
+    hasFloor: z.boolean().nullable().optional(),
+    hasCeiling: z.boolean().nullable().optional(),
+});
+export function setZoneIntent(nodes, input) {
+    const zone = requireZone(nodes, input.zoneId);
+    const patch = ZoneIntentPatch.parse(input.patch);
+    const requestedKey = patch.floor?.footprint;
+    if (requestedKey &&
+        requestedKey !== 'new' &&
+        requestedKey !== zone.floor?.footprint &&
+        !Object.values(nodes).some((node) => node.type === 'zone' &&
+            node.parentId === zone.parentId &&
+            node.floor?.footprint === requestedKey))
+        return {
+            changes: [],
+            conflicts: [
+                {
+                    code: 'room-floor-footprint',
+                    nodeIds: [zone.id],
+                    message: 'Choose an existing floor key on this level, or "new".',
+                },
+            ],
+        };
+    const data = {};
+    for (const key of ['floorStepFinish', 'floorEdgeFinish'])
+        if (patch[key] !== undefined)
+            data[key] = patch[key] ?? undefined;
+    if (patch.floorStepOverrides !== undefined)
+        data.floorStepOverrides = patch.floorStepOverrides?.length
+            ? patch.floorStepOverrides
+            : undefined;
+    if (patch.name !== undefined)
+        data.name = patch.name ?? '';
+    if (patch.wallMaterial !== undefined)
+        data.wallMaterial = patch.wallMaterial ?? undefined;
+    for (const key of ['hasFloor', 'hasCeiling'])
+        if (patch[key] !== undefined)
+            data[key] = patch[key] === false ? false : undefined;
+    if (patch.floor !== undefined) {
+        data.floor = patch.floor === null ? undefined : { ...zone.floor };
+        if (patch.floor)
+            for (const key of ['elevation', 'finish', 'regions', 'thickness', 'footprint']) {
+                const value = patch.floor[key];
+                if (value === null)
+                    delete data.floor[key];
+                else if (value !== undefined)
+                    Object.assign(data.floor, {
+                        [key]: key === 'elevation' && typeof value === 'number' ? roundFloorElevation(value) : value,
+                    });
+            }
+    }
+    if (patch.ceiling !== undefined) {
+        const regions = patch.ceiling === null ? null : patch.ceiling.regions;
+        if (regions === null)
+            data.ceiling = undefined;
+        else if (regions !== undefined)
+            data.ceiling = { ...zone.ceiling, regions };
+    }
+    if (zone.floor?.support === 'open') {
+        if (patch.floor === null || patch.floor?.elevation === null)
+            return {
+                changes: [],
+                conflicts: [
+                    {
+                        code: 'mezzanine-intent',
+                        nodeIds: [zone.id],
+                        message: 'A mezzanine must retain its open support and explicit elevation.',
+                    },
+                ],
+            };
+        const invalid = mezzanineElevationConflict(nodes, { ...zone, ...data });
+        if (invalid)
+            return { changes: [], conflicts: [invalid] };
+    }
+    // A drawn-slab floor keeps its height on the slab; a room height would move nothing.
+    if (typeof data.floor?.elevation === 'number' && data.floor.elevation !== zone.floor?.elevation) {
+        const drawn = drawnFloorElevationConflict(nodes, zone.id);
+        if (drawn)
+            return { changes: [], conflicts: [drawn] };
+    }
+    if (zone.floor?.support !== 'open' &&
+        (patch.floor === null || patch.floor?.elevation !== undefined)) {
+        const conflicts = floorIntentConflicts(nodes, [{ id: zone.id, data }]);
+        if (conflicts.length)
+            return { changes: [], conflicts };
+    }
+    ZoneNode.parse({ ...zone, ...data });
+    const own = ownFloorIntentChanges(nodes, Object.keys(data).length ? [{ id: zone.id, data }] : []);
+    return {
+        changes: own.updates.map((update) => ({ op: 'update', ...update })),
+        ...(own.conflicts.length ? { conflicts: own.conflicts } : {}),
+    };
+}