@pascal-app/core 1.0.3 → 1.0.5

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-zone.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/create-zone.ts"],"names":[],"mappings":"AAOA,OAAO,EAAiC,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,cAAc,CAAA;AAG1F,OAAO,EAAiB,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACvE,OAAO,EAIL,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EAEnB,MAAM,UAAU,CAAA;AAEjB,KAAK,IAAI,GACL;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,GAAG,GAAG,GAAG,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC3D;IAAE,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;CAAE,CAAA;AACjC,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,KAAK,EAAE,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,eAAe,CAAA;IACxB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,kHAAkH;IAClH,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,IAAI,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,WAAW,GAAG,eAAe,CAAC,CAAA;IACxE,MAAM,EAAE,eAAe,CAAA;CACxB,CAAA;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE;;;;IAiB5F;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,KAAK,EAAE,GACf,QAAQ,GAAG,SAAS,CA6BtB;AAgBD,wBAAgB,UAAU,CACxB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,eAAe,GACrB,aAAa,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAiItD"}

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

@@ -0,0 +1,175 @@
+import { newZone } from '../../lib/new-zone.js';
+import { area, intersection } from '../../lib/polygon-boolean.js';
+import { polygonInteriorPoint } from '../../lib/polygon-label.js';
+import { segmentsIntersect } from '../../lib/polygon-relations.js';
+import { extractRooms } from '../../lib/room-graph.js';
+import { isAllocatedRoomName } from '../../lib/room-name.js';
+import { adoptableFace, zoneFaceFits } from '../../lib/room-zone-adoption.js';
+import { SeparatorNode } from '../../schema/index.js';
+import { getWallCurveFrameAt } from '../../systems/wall/wall-curve.js';
+import { planWallInsertion, uncoveredWallSegments } from '../../systems/wall/wall-topology.js';
+import { setZoneIntent } from './set-zone-intent.js';
+import { applyToScratch, boundaries, diffStructure, structureChangeBatch, } from './shared.js';
+export function outdoorRoomConflicts(nodes, levelId, polygon) {
+    return Object.values(nodes).flatMap((node) => node.type === 'zone' &&
+        node.parentId === levelId &&
+        node.spaceRole === 'room' &&
+        node.enclosureStatus !== 'open' &&
+        node.floor?.support !== 'open' &&
+        area(intersection(polygon, { outer: node.polygon, holes: node.holes })) > 1e-6
+        ? [
+            {
+                code: 'outdoor-room-overlap',
+                nodeIds: [node.id],
+                message: `The terrace overlaps ${node.name || 'an existing room'}.`,
+            },
+        ]
+        : []);
+}
+/**
+ * The room walls already make where a room is drawn, to name rather than stack a second zone on
+ * (walls first, then create_room, gave every room a "Room N" twin). Only when every edge of the
+ * polygon runs along a wall, so nothing is built and the rooms stand as they are; the room the
+ * polygon fits by the reconciler's own adoption rule, and only while it keeps the name the
+ * reconciler gave it.
+ */
+export function walledRoomAt(nodes, levelId, polygon) {
+    const walls = boundaries(nodes, levelId).filter((n) => n.type === 'wall');
+    const walled = polygon.every((start, i) => {
+        const end = polygon[(i + 1) % polygon.length];
+        return (Math.hypot(end[0] - start[0], end[1] - start[1]) < 1e-8 ||
+            uncoveredWallSegments(start, end, walls).length === 0);
+    });
+    if (!walled)
+        return;
+    const rooms = Object.values(nodes).filter((node) => node.type === 'zone' &&
+        node.parentId === levelId &&
+        node.spaceRole === 'room' &&
+        node.autoFromWalls &&
+        node.enclosureStatus !== 'open');
+    const fit = adoptableFace(zoneFaceFits({ id: '', polygon }, rooms.map((room) => ({
+        key: room.id,
+        polygon: { outer: room.polygon, holes: room.holes ?? [] },
+        clear: { outer: [], holes: [] },
+    }))));
+    return fit && rooms[fit.face];
+}
+/**
+ * The walled room a drawn polygon names instead of stacking a zone on: one that still has the name
+ * the reconciler gave it, or any walled room when `adoptNamed` says its person's name may change.
+ */
+function walledRoomToName(nodes, levelId, polygon, adoptNamed = false) {
+    const room = walledRoomAt(nodes, levelId, polygon);
+    return room && (adoptNamed || isAllocatedRoomName(room.name)) ? room : undefined;
+}
+export function createZone(nodes, input) {
+    if (nodes[input.levelId]?.type !== 'level')
+        throw Error('Select an editable floor.');
+    if ([input.polygon, input.boundaryIds, input.edges].filter(Boolean).length !== 1)
+        throw Error('Supply exactly one polygon, boundary set or edge list.');
+    let scratch = { ...nodes };
+    let polygon = input.polygon;
+    let segments = [];
+    if (input.boundaryIds) {
+        const selected = boundaries(nodes, input.levelId).filter((n) => input.boundaryIds.includes(n.id));
+        const faces = extractRooms(selected);
+        if (selected.length !== input.boundaryIds.length || faces.length !== 1)
+            throw Error('The boundary set must enclose one room.');
+        polygon = faces[0].referencePolygon;
+    }
+    else if (input.edges) {
+        const edges = input.edges.map((edge) => {
+            if ('separator' in edge) {
+                segments.push(edge.separator);
+                return edge.separator;
+            }
+            const wall = nodes[edge.wallId];
+            if (wall?.type !== 'wall' ||
+                wall.parentId !== input.levelId ||
+                !(edge.t0 >= 0 && edge.t1 <= 1 && edge.t0 < edge.t1))
+                throw Error('Invalid wall edge.');
+            const count = wall.curveOffset ? 64 : 1;
+            const points = Array.from({ length: count + 1 }, (_, i) => {
+                const t = edge.t0 + ((edge.t1 - edge.t0) * i) / count;
+                const { point } = getWallCurveFrameAt(wall, t);
+                return [point.x, point.y];
+            });
+            return edge.face === 'a' ? points : points.reverse();
+        });
+        segments.push(...edges.map((edge, i) => [edge.at(-1), edges[(i + 1) % edges.length][0]]));
+        polygon = edges.flat();
+    }
+    else if (polygon)
+        segments = polygon.map((p, i) => [p, polygon[(i + 1) % polygon.length]]);
+    polygon = polygon?.filter((point, i, points) => {
+        const next = points[(i + 1) % points.length];
+        return Math.hypot(point[0] - next[0], point[1] - next[1]) > 1e-8;
+    });
+    if (!polygon ||
+        polygon.length < 3 ||
+        !polygon.flat().every(Number.isFinite) ||
+        area([{ outer: polygon, holes: [] }]) < 0.01 ||
+        polygon.some((a, i) => polygon.some((b, j) => j > i + 1 &&
+            !(i === 0 && j === polygon.length - 1) &&
+            segmentsIntersect(a, polygon[(i + 1) % polygon.length], b, polygon[(j + 1) % polygon.length]))))
+        throw Error('A room needs a valid polygon.');
+    const walledRoom = walledRoomToName(nodes, input.levelId, polygon, input.adoptNamed);
+    if (walledRoom) {
+        scratch[walledRoom.id] = { ...walledRoom, name: input.name ?? walledRoom.name };
+        if (input.intent)
+            scratch = applyToScratch(scratch, structureChangeBatch(setZoneIntent(scratch, { zoneId: walledRoom.id, patch: input.intent }).changes));
+        return {
+            changes: diffStructure(nodes, scratch),
+            zoneId: walledRoom.id,
+            renamed: walledRoom.name,
+        };
+    }
+    if (input.enclose === false) {
+        const conflicts = outdoorRoomConflicts(nodes, input.levelId, polygon);
+        if (conflicts.length)
+            return { changes: [], conflicts, zoneId: '' };
+    }
+    for (const [start, end] of segments) {
+        if (Math.hypot(end[0] - start[0], end[1] - start[1]) < 1e-8)
+            continue;
+        const walls = boundaries(scratch, input.levelId).filter((n) => n.type === 'wall');
+        for (const [a, b] of uncoveredWallSegments(start, end, walls)) {
+            if (input.enclose) {
+                const result = planWallInsertion(scratch, {
+                    levelId: input.levelId,
+                    start: a,
+                    end: b,
+                    joinRadius: 0.001,
+                    wallDefaults: input.wall,
+                    mintId: () => input.mintId('wall'),
+                });
+                if (!result.ok)
+                    throw Error(`Cannot enclose room: ${result.reason}`);
+                scratch = applyToScratch(scratch, result.plan.changes);
+            }
+            else {
+                const separator = SeparatorNode.parse({
+                    id: input.mintId('separator'),
+                    parentId: input.levelId,
+                    start: a,
+                    end: b,
+                });
+                scratch[separator.id] = separator;
+            }
+        }
+    }
+    const zone = newZone({
+        id: input.mintId('zone'),
+        parentId: input.levelId,
+        name: input.name ?? 'Room',
+        polygon,
+        seed: polygonInteriorPoint({ polygon }, true),
+        spaceRole: 'room',
+    });
+    if (scratch[zone.id])
+        throw Error(`Duplicate zone id: ${zone.id}`);
+    scratch[zone.id] = zone;
+    if (input.intent)
+        scratch = applyToScratch(scratch, structureChangeBatch(setZoneIntent(scratch, { zoneId: zone.id, patch: input.intent }).changes));
+    return { changes: diffStructure(nodes, scratch), zoneId: zone.id };
+}

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

@@ -0,0 +1,51 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export type DeleteZonePayload = {
+    zoneId: string;
+    name: string;
+    contents: 'delete' | 'keep';
+    /**
+     * `delete`: the room goes with the walls, separators and openings only it
+     * uses. `merge`: an area Divide made (a separator on its outline) goes back
+     * into the room across those separators; walls and items stay. `blocked`:
+     * every boundary is a wall another room shares — nothing of its own to
+     * remove, so deleting one of those walls is the way (a conflict, no changes).
+     */
+    mode: 'delete' | 'merge' | 'blocked';
+    /** `merge`: the room the area goes back into. */
+    mergedIntoZoneId?: string;
+    opensZoneIds: string[];
+    keptSharedSeparatorIds: string[];
+    wallIds: string[];
+    keptSharedWallIds: string[];
+    separatorIds: string[];
+    openingIds: string[];
+    itemIds: string[];
+};
+export declare const SHARED_WALLS_DELETE_MESSAGE = "To remove this room, delete one of its walls.";
+type ZoneInput = {
+    zoneId: string;
+    contents: 'delete' | 'keep';
+};
+type DeleteZonePlan = StructurePlan & {
+    payload: DeleteZonePayload;
+};
+/**
+ * Deletes a room the way its boundaries allow:
+ * - an area Divide made (a separator shared with a room on its outline) merges
+ *   back into that room — the one sharing the most separator length — by
+ *   removing those separators; its intent (name, finishes, regions) goes, its
+ *   walls and items stay, and mezzanines it hosts move to the merged room;
+ * - a room whose every boundary is a wall shared with other rooms is refused
+ *   (`shared-walls`): only deleting one of those walls can remove it;
+ * - otherwise the room goes with the walls, separators and openings only it
+ *   uses, and its items per `contents`.
+ */
+export declare function deleteZone(sourceNodes: StructureNodes, input: ZoneInput): DeleteZonePlan;
+/**
+ * The room removed with the walls, separators and openings only it uses (and
+ * its items per `contents`), whatever its neighbours. Wall deletion uses this
+ * directly for the rooms it takes down.
+ */
+export declare function planZoneRemoval(sourceNodes: StructureNodes, input: ZoneInput): DeleteZonePlan;
+export {};
+//# sourceMappingURL=delete-zone.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delete-zone.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/delete-zone.ts"],"names":[],"mappings":"AAWA,OAAO,EAOL,KAAK,cAAc,EACnB,KAAK,aAAa,EAGnB,MAAM,UAAU,CAAA;AAEjB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAA;IAC3B;;;;;;OAMG;IACH,IAAI,EAAE,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAA;IACpC,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,sBAAsB,EAAE,MAAM,EAAE,CAAA;IAChC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,iBAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB,CAAA;AA0CD,eAAO,MAAM,2BAA2B,kDAAkD,CAAA;AAE1F,KAAK,SAAS,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAAA;CAAE,CAAA;AAChE,KAAK,cAAc,GAAG,aAAa,GAAG;IAAE,OAAO,EAAE,iBAAiB,CAAA;CAAE,CAAA;AAEpE;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,WAAW,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,GAAG,cAAc,CA2BxF;AAqJD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,cAAc,EAAE,KAAK,EAAE,SAAS,GAAG,cAAc,CA4I7F"}

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

@@ -0,0 +1,354 @@
+import { area, containsPoint, intersection } from '../../lib/polygon-boolean.js';
+import { extractRooms } from '../../lib/room-graph.js';
+import { isDerivedNode } from '../../store/derived-node-guard.js';
+import { getWallCurveFrameAt, getWallCurveLength } from '../../systems/wall/wall-curve.js';
+import { containedMezzanines, electedIntentPlate, isFloorPlacedIntent, } from './mezzanine-content.js';
+import { applyToScratch, boundaries, diffStructure, pointInRoom, requireZone, roomFace, sharedSpan, structureChangeBatch, } from './shared.js';
+function levelPose(nodes, item, levelId) {
+    let position = [...item.position];
+    let yaw = Array.isArray(item.rotation) ? item.rotation[1] : item.rotation;
+    let parent = item.parentId ? nodes[item.parentId] : undefined;
+    const visited = new Set();
+    while (parent && parent.id !== levelId && !visited.has(parent.id)) {
+        visited.add(parent.id);
+        if (parent.type === 'wall') {
+            const frame = getWallCurveFrameAt(parent, position[0] / getWallCurveLength(parent));
+            position = [
+                frame.point.x + frame.normal.x * position[2],
+                position[1],
+                frame.point.y + frame.normal.y * position[2],
+            ];
+            yaw -= Math.atan2(frame.tangent.y, frame.tangent.x);
+        }
+        else if (parent.type === 'ceiling')
+            position[1] += parent.height ?? 2.7;
+        else if ('position' in parent && Array.isArray(parent.position)) {
+            const rotation = 'rotation' in parent && Array.isArray(parent.rotation) ? parent.rotation[1] : 0;
+            const c = Math.cos(rotation), s = Math.sin(rotation);
+            position = [
+                parent.position[0] + c * position[0] + s * position[2],
+                parent.position[1] + position[1],
+                parent.position[2] - s * position[0] + c * position[2],
+            ];
+            yaw += rotation;
+        }
+        parent = parent.parentId ? nodes[parent.parentId] : undefined;
+    }
+    return parent?.id === levelId
+        ? {
+            position,
+            rotation: Array.isArray(item.rotation)
+                ? [item.rotation[0], yaw, item.rotation[2]]
+                : yaw,
+        }
+        : null;
+}
+export const SHARED_WALLS_DELETE_MESSAGE = 'To remove this room, delete one of its walls.';
+/**
+ * Deletes a room the way its boundaries allow:
+ * - an area Divide made (a separator shared with a room on its outline) merges
+ *   back into that room — the one sharing the most separator length — by
+ *   removing those separators; its intent (name, finishes, regions) goes, its
+ *   walls and items stay, and mezzanines it hosts move to the merged room;
+ * - a room whose every boundary is a wall shared with other rooms is refused
+ *   (`shared-walls`): only deleting one of those walls can remove it;
+ * - otherwise the room goes with the walls, separators and openings only it
+ *   uses, and its items per `contents`.
+ */
+export function deleteZone(sourceNodes, input) {
+    const zone = requireZone(sourceNodes, input.zoneId);
+    const faces = extractRooms(boundaries(sourceNodes, zone.parentId));
+    const target = mergeTarget(sourceNodes, zone, faces);
+    if (target)
+        return mergeBack(sourceNodes, zone, target, input.contents);
+    const plan = planZoneRemoval(sourceNodes, input);
+    const spans = roomFace(sourceNodes, zone, faces)?.spans ?? [];
+    if (!spans.length || !spans.every((span) => sharedSpan(sourceNodes, zone, span)))
+        return plan;
+    return {
+        changes: [],
+        conflicts: [
+            {
+                code: 'shared-walls',
+                nodeIds: [zone.id, ...plan.payload.keptSharedWallIds],
+                message: SHARED_WALLS_DELETE_MESSAGE,
+            },
+        ],
+        payload: {
+            ...plan.payload,
+            mode: 'blocked',
+            opensZoneIds: [],
+            wallIds: [],
+            separatorIds: [],
+            openingIds: [],
+            itemIds: [],
+        },
+    };
+}
+/**
+ * The room an area Divide made goes back into: a room across a separator on
+ * the area's outline (never an island inside one of its holes), preferring the
+ * one sharing the most separator length, whose separators can go without
+ * changing any other room.
+ */
+function mergeTarget(nodes, zone, faces) {
+    const face = roomFace(nodes, zone, faces);
+    const separatorSpans = face?.spans.filter((span) => span.kind === 'separator') ?? [];
+    if (!(face && separatorSpans.length))
+        return null;
+    const insideHole = (point) => face.holes.some((hole) => containsPoint([{ outer: hole, holes: [] }], point));
+    const candidates = Object.values(nodes).flatMap((other) => {
+        if (other.type !== 'zone' ||
+            other.id === zone.id ||
+            other.parentId !== zone.parentId ||
+            other.spaceRole !== 'room' ||
+            other.floor?.support === 'open' ||
+            (other.seed && insideHole(other.seed)))
+            return [];
+        const otherSpans = roomFace(nodes, other, faces)?.spans ?? [];
+        let length = 0;
+        const separatorIds = new Set();
+        for (const span of separatorSpans)
+            for (const facing of otherSpans) {
+                if (facing.boundaryId !== span.boundaryId || facing.face === span.face)
+                    continue;
+                const overlap = Math.min(facing.t1, span.t1) - Math.max(facing.t0, span.t0);
+                const boundary = nodes[span.boundaryId];
+                if (overlap <= 1e-6 || boundary?.type !== 'separator')
+                    continue;
+                separatorIds.add(boundary.id);
+                length +=
+                    overlap *
+                        Math.hypot(boundary.end[0] - boundary.start[0], boundary.end[1] - boundary.start[1]);
+            }
+        return separatorIds.size ? [{ zone: other, separatorIds: [...separatorIds], length }] : [];
+    });
+    candidates.sort((a, b) => b.length - a.length || a.zone.id.localeCompare(b.zone.id));
+    const before = boundaries(nodes, zone.parentId);
+    for (const candidate of candidates) {
+        const removed = new Set(candidate.separatorIds);
+        const after = extractRooms(before.filter((node) => !removed.has(node.id)));
+        if (after.length === faces.length - 1)
+            return candidate;
+    }
+    return null;
+}
+function mergeBack(nodes, zone, target, contents) {
+    const levelId = zone.parentId;
+    const ceilings = new Set(Object.values(nodes)
+        .filter((n) => n.type === 'ceiling' && n.zoneId === zone.id)
+        .map((n) => n.id));
+    const items = Object.values(nodes).flatMap((n) => {
+        if (n.type !== 'item' && !isFloorPlacedIntent(n))
+            return [];
+        const pose = levelPose(nodes, n, levelId);
+        return pose && pointInRoom(zone, [pose.position[0], pose.position[2]])
+            ? [{ node: n, pose }]
+            : [];
+    });
+    const scratch = { ...nodes };
+    delete scratch[zone.id];
+    for (const id of target.separatorIds)
+        delete scratch[id];
+    for (const { node, pose } of items) {
+        const support = node.supportSlabId ? nodes[node.supportSlabId] : undefined;
+        // Its own floor goes with the area; the merged room's floor carries it.
+        const ownFloor = support?.type === 'slab' && !!support.zoneIds?.includes(zone.id);
+        // Its ceiling goes too; what hangs from it stays where it is, on the level.
+        const hung = !!node.parentId && ceilings.has(node.parentId);
+        if (hung)
+            scratch[node.id] = {
+                ...node,
+                ...pose,
+                parentId: levelId,
+                wallId: undefined,
+                wallT: undefined,
+                supportSlabId: undefined,
+            };
+        else if (ownFloor)
+            scratch[node.id] = { ...node, supportSlabId: undefined };
+    }
+    for (const node of Object.values(scratch)) {
+        if (node.type === 'zone' && node.hostZoneId === zone.id)
+            scratch[node.id] = { ...node, hostZoneId: target.zone.id };
+        if (node.type === 'floor-opening' && node.hostZoneId === zone.id)
+            scratch[node.id] = { ...node, hostZoneId: target.zone.id };
+        if (node.type === 'unit' && node.members.includes(zone.id))
+            scratch[node.id] = { ...node, members: node.members.filter((id) => id !== zone.id) };
+    }
+    return {
+        changes: diffStructure(nodes, pruneDeleted(nodes, scratch)),
+        payload: {
+            zoneId: zone.id,
+            name: zone.name,
+            contents,
+            mode: 'merge',
+            mergedIntoZoneId: target.zone.id,
+            opensZoneIds: [],
+            keptSharedSeparatorIds: [],
+            wallIds: [],
+            keptSharedWallIds: [],
+            separatorIds: target.separatorIds,
+            openingIds: [],
+            itemIds: items.map(({ node }) => node.id),
+        },
+    };
+}
+/** Removes what hangs from deleted nodes and drops deleted ids from `children`. */
+function pruneDeleted(nodes, scratch) {
+    const deleted = new Set(Object.keys(nodes).filter((id) => !scratch[id]));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const node of Object.values(scratch))
+            if (node.parentId && deleted.has(node.parentId)) {
+                delete scratch[node.id];
+                deleted.add(node.id);
+                changed = true;
+            }
+    }
+    for (const node of Object.values(scratch))
+        if (!isDerivedNode(node) &&
+            'children' in node &&
+            Array.isArray(node.children) &&
+            node.children.some((id) => deleted.has(id)))
+            scratch[node.id] = {
+                ...node,
+                children: node.children.filter((id) => !deleted.has(id)),
+            };
+    return scratch;
+}
+/**
+ * The room removed with the walls, separators and openings only it uses (and
+ * its items per `contents`), whatever its neighbours. Wall deletion uses this
+ * directly for the rooms it takes down.
+ */
+export function planZoneRemoval(sourceNodes, input) {
+    const zone = requireZone(sourceNodes, input.zoneId);
+    let nodes = sourceNodes;
+    const stackedItems = [];
+    for (const stacked of containedMezzanines(sourceNodes, zone)) {
+        const plan = planZoneRemoval(nodes, { zoneId: stacked.id, contents: input.contents });
+        nodes = applyToScratch(nodes, structureChangeBatch(plan.changes));
+        stackedItems.push(...plan.payload.itemIds);
+    }
+    const spans = roomFace(nodes, zone)?.spans ?? [];
+    const wallIds = [...new Set(spans.filter((s) => s.kind === 'wall').map((s) => s.boundaryId))];
+    const shared = spans.filter((span) => sharedSpan(nodes, zone, span));
+    const keptSharedWallIds = [
+        ...new Set(shared.filter((s) => s.kind === 'wall').map((s) => s.boundaryId)),
+    ];
+    const keptSharedSeparatorIds = [
+        ...new Set(shared.filter((s) => s.kind === 'separator').map((s) => s.boundaryId)),
+    ];
+    const removedWalls = wallIds.filter((id) => !keptSharedWallIds.includes(id));
+    const separatorIds = [
+        ...new Set(spans
+            .filter((s) => s.kind === 'separator' && !keptSharedSeparatorIds.includes(s.boundaryId))
+            .map((s) => s.boundaryId)),
+    ];
+    const openingIds = Object.values(nodes)
+        .filter((n) => (n.type === 'door' || n.type === 'window') &&
+        (removedWalls.includes(n.parentId ?? '') ||
+            ('wallId' in n && removedWalls.includes(n.wallId))))
+        .map((n) => n.id);
+    const floorOpeningIds = Object.values(nodes)
+        .filter((node) => node.type === 'floor-opening' &&
+        (node.hostZoneId === zone.id ||
+            (!node.hostZoneId &&
+                node.parentId === zone.parentId &&
+                node.polygon.every((point) => pointInRoom(zone, point)))))
+        .map((node) => node.id);
+    const items = Object.values(nodes).flatMap((n) => {
+        if (n.type !== 'item' && !isFloorPlacedIntent(n))
+            return [];
+        const pose = levelPose(nodes, n, zone.parentId);
+        if (zone.floor?.support === 'open') {
+            const parent = n.parentId ? nodes[n.parentId] : undefined;
+            const host = parent?.type === 'level' && isFloorPlacedIntent(n)
+                ? electedIntentPlate(nodes, n)
+                : undefined;
+            if (!(parent?.type === 'ceiling' && parent.zoneId === zone.id) &&
+                !(host?.type === 'slab' && host.zoneIds?.includes(zone.id)))
+                return [];
+            return pose ? [{ node: n, pose }] : [];
+        }
+        return pose &&
+            (pointInRoom(zone, [pose.position[0], pose.position[2]]) ||
+                removedWalls.includes(n.parentId ?? ''))
+            ? [{ node: n, pose }]
+            : [];
+    });
+    const payload = {
+        zoneId: zone.id,
+        mode: 'delete',
+        opensZoneIds: [],
+        keptSharedSeparatorIds,
+        name: zone.name,
+        contents: input.contents,
+        wallIds: removedWalls,
+        keptSharedWallIds,
+        separatorIds,
+        openingIds: [...openingIds, ...floorOpeningIds],
+        itemIds: [...new Set([...stackedItems, ...items.map(({ node }) => node.id)])],
+    };
+    const scratch = { ...nodes };
+    for (const id of [
+        zone.id,
+        ...removedWalls,
+        ...separatorIds,
+        ...openingIds,
+        ...floorOpeningIds,
+        ...(input.contents === 'delete' ? payload.itemIds : []),
+    ])
+        delete scratch[id];
+    const removedHosts = new Set([
+        ...removedWalls,
+        ...Object.values(nodes)
+            .filter((n) => n.type === 'ceiling' && n.zoneId === zone.id)
+            .map((n) => n.id),
+    ]);
+    if (input.contents === 'keep')
+        for (const { node, pose } of items) {
+            if (zone.floor?.support === 'open' &&
+                node.supportSlabId &&
+                nodes[node.supportSlabId]?.type === 'slab' &&
+                nodes[node.supportSlabId].zoneIds?.includes(zone.id))
+                scratch[node.id] = { ...node, supportSlabId: undefined };
+            if (!node.parentId || !removedHosts.has(node.parentId))
+                continue;
+            scratch[node.id] = {
+                ...node,
+                ...pose,
+                parentId: zone.parentId,
+                wallId: undefined,
+                wallT: undefined,
+                supportSlabId: undefined,
+            };
+        }
+    for (const node of Object.values(scratch))
+        if (node.type === 'unit' && node.members.includes(zone.id))
+            scratch[node.id] = { ...node, members: node.members.filter((id) => id !== zone.id) };
+    pruneDeleted(nodes, scratch);
+    const beforeFaces = extractRooms(boundaries(nodes, zone.parentId));
+    const afterFaces = extractRooms(boundaries(scratch, zone.parentId));
+    payload.opensZoneIds = Object.values(nodes).flatMap((other) => {
+        if (other.type !== 'zone' ||
+            other.spaceRole !== 'room' ||
+            other.id === zone.id ||
+            other.parentId !== zone.parentId)
+            return [];
+        const before = roomFace(nodes, other, beforeFaces);
+        if (!before)
+            return [];
+        const footprint = { outer: before.referencePolygon, holes: before.holes };
+        const size = area([footprint]);
+        const preserved = afterFaces.some((face) => {
+            const candidate = { outer: face.referencePolygon, holes: face.holes };
+            const overlap = area(intersection(footprint, candidate));
+            return overlap / Math.max(size + area([candidate]) - overlap, 1e-9) > 0.99999;
+        });
+        return preserved ? [] : [other.id];
+    });
+    return { changes: diffStructure(sourceNodes, scratch), payload };
+}

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

@@ -0,0 +1,38 @@
+import { type Point, type StructureMintId, type StructureNodes, type StructurePlan } from './shared.js';
+export declare function createZoneDivisionContext(nodes: StructureNodes, zoneId: string): {
+    zoneId: string;
+    boundaryNodes: import("../../index.js").BoundaryNode[];
+    face: import("../../index.js").ExtractedRoom | undefined;
+    roomCount: number;
+};
+export type ZoneDivisionContext = ReturnType<typeof createZoneDivisionContext>;
+export declare function snapZoneBoundary(nodes: StructureNodes, zoneId: string, point: Point, gridStep?: number, context?: {
+    zoneId: string;
+    boundaryNodes: import("../../index.js").BoundaryNode[];
+    face: import("../../index.js").ExtractedRoom | undefined;
+    roomCount: number;
+}, boundaryId?: string): {
+    t: number;
+    point: Point;
+    boundaryId: `separator_${string}` | `wall_${string}`;
+    direction: Point;
+    distance: number;
+} | null;
+export declare function divideZone(nodes: StructureNodes, input: {
+    zoneId: string;
+    path?: Point[];
+    cut?: [Point, Point];
+    closed?: boolean;
+    startBoundaryId?: string;
+    endBoundaryId?: string;
+    mintId: StructureMintId;
+}, context?: {
+    zoneId: string;
+    boundaryNodes: import("../../index.js").BoundaryNode[];
+    face: import("../../index.js").ExtractedRoom | undefined;
+    roomCount: number;
+}): StructurePlan & {
+    separatorIds: string[];
+    separatorId?: string;
+};
+//# sourceMappingURL=divide-zone.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"divide-zone.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/divide-zone.ts"],"names":[],"mappings":"AAMA,OAAO,EAGL,KAAK,KAAK,EAIV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM;;;;;EAK9E;AACD,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE9E,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,QAAQ,SAAI,EACZ,OAAO;;;;;CAA2C,EAIlD,UAAU,CAAC,EAAE,MAAM;;;;eA+BkD,KAAK;;SAW3E;AAwBD,wBAAgB,UAAU,CACxB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,KAAK,EAAE,CAAA;IACd,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;IACpB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,MAAM,EAAE,eAAe,CAAA;CACxB,EACD,OAAO;;;;;CAAiD,GACvD,aAAa,GAAG;IAAE,YAAY,EAAE,MAAM,EAAE,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CA+HlE"}