@pascal-app/core 1.0.1 → 1.0.4

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): {
+    distance: number;
+    point: Point;
+    boundaryId: `wall_${string}` | `separator_${string}`;
+    direction: Point;
+    t: 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"}

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

@@ -0,0 +1,186 @@
+import { area, containsPoint, difference, union } from '../../lib/polygon-boolean.js';
+import { segmentsIntersect } from '../../lib/polygon-relations.js';
+import { extractRooms } from '../../lib/room-graph.js';
+import { SeparatorNode } from '../../schema/index.js';
+import { getWallCurveFrameAt } from '../../systems/wall/wall-curve.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../../systems/wall/wall-footprint.js';
+import { at, boundaries, project, requireZone, roomFace, } from './shared.js';
+export function createZoneDivisionContext(nodes, zoneId) {
+    const zone = requireZone(nodes, zoneId);
+    const boundaryNodes = boundaries(nodes, zone.parentId);
+    const faces = extractRooms(boundaryNodes);
+    return { zoneId, boundaryNodes, face: roomFace(nodes, zone, faces), roomCount: faces.length };
+}
+export function snapZoneBoundary(nodes, zoneId, point, gridStep = 0, context = createZoneDivisionContext(nodes, zoneId), 
+// Set when the pointer landed on a boundary's own surface. The cut belongs on
+// that boundary however thick it is, so the proximity cap — which only exists
+// to reject pointers floating in the middle of the room — does not apply.
+boundaryId) {
+    const face = context.face;
+    if (!point.every(Number.isFinite))
+        throw Error('Invalid cut coordinates.');
+    if (!face)
+        throw Error('The room must be enclosed.');
+    const named = boundaryId ? face.spans.filter((span) => span.boundaryId === boundaryId) : [];
+    const candidates = (named.length ? named : face.spans).flatMap((span) => {
+        const node = nodes[span.boundaryId];
+        if (node?.type !== 'wall' && node?.type !== 'separator')
+            return [];
+        const pointAt = (t) => {
+            if (node.type === 'separator')
+                return at(node.start, node.end, t);
+            const { point: p } = getWallCurveFrameAt(node, t);
+            return [p.x, p.y];
+        };
+        const samples = node.type === 'wall' && node.curveOffset ? 64 : 1;
+        return Array.from({ length: samples }, (_, i) => {
+            const a = pointAt(span.t0 + ((span.t1 - span.t0) * i) / samples);
+            const b = pointAt(span.t0 + ((span.t1 - span.t0) * (i + 1)) / samples);
+            const projected = project(point, a, b);
+            const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            const t = gridStep > 0 && samples === 1
+                ? Math.max(0, Math.min(1, (Math.round((projected.t * length) / gridStep) * gridStep) / length))
+                : projected.t;
+            return {
+                ...projected,
+                point: at(a, b, t),
+                boundaryId: node.id,
+                direction: [(b[0] - a[0]) / length, (b[1] - a[1]) / length],
+            };
+        });
+    });
+    const nearest = candidates.sort((a, b) => a.distance - b.distance || a.boundaryId.localeCompare(b.boundaryId))[0];
+    if (!nearest || !Number.isFinite(nearest.distance))
+        return null;
+    if (!named.length && nearest.distance > 1)
+        return null;
+    const distance = Math.hypot(nearest.point[0] - point[0], nearest.point[1] - point[1]);
+    return named.length || distance <= 1 ? { ...nearest, distance } : null;
+}
+function overlapsSegment(a, b, c, d) {
+    const dx = b[0] - a[0], dz = b[1] - a[1];
+    const length = Math.hypot(dx, dz);
+    if ([c, d].some((p) => Math.abs((p[0] - a[0]) * dz - (p[1] - a[1]) * dx) > 1e-8 * length))
+        return false;
+    const station = (p) => ((p[0] - a[0]) * dx + (p[1] - a[1]) * dz) / length;
+    const t0 = station(c), t1 = station(d);
+    return Math.min(length, Math.max(t0, t1)) - Math.max(0, Math.min(t0, t1)) > 1e-8;
+}
+function segmentDistance(a, b, c, d) {
+    if (segmentsIntersect(a, b, c, d))
+        return 0;
+    return Math.min(project(a, c, d).distance, project(b, c, d).distance, project(c, a, b).distance, project(d, a, b).distance);
+}
+export function divideZone(nodes, input, context = createZoneDivisionContext(nodes, input.zoneId)) {
+    const zone = requireZone(nodes, input.zoneId);
+    const reject = (code, message) => ({
+        changes: [],
+        separatorIds: [],
+        conflicts: [{ code, nodeIds: [zone.id], message }],
+    });
+    const source = input.path ?? input.cut;
+    const closed = input.closed ?? false;
+    if ((input.path && input.cut) || !source || source.length < (closed ? 3 : 2))
+        return reject('invalid-path', 'Supply one path with at least two points, or three for an island.');
+    if (source.some((p) => p.length !== 2 || !p.every(Number.isFinite)))
+        throw Error('Invalid cut coordinates.');
+    const face = context.face;
+    if (!face)
+        return reject('open-room', 'The room must be enclosed.');
+    const rings = [face.referencePolygon, ...face.holes].map((ring) => [...ring]);
+    const points = source.map(([x, z]) => [x, z]);
+    if (!closed) {
+        const first = snapZoneBoundary(nodes, zone.id, points[0], 0, context, input.startBoundaryId);
+        const last = snapZoneBoundary(nodes, zone.id, points.at(-1), 0, context, input.endBoundaryId);
+        if (!first || !last)
+            return reject('snap-distance', 'Move within 1 m of a room boundary.');
+        points[0] = first.point;
+        points[points.length - 1] = last.point;
+        // The graph's adaptive curve samples are coarser than endpoint snapping.
+        // Include the snapped station so its tiny chord deviation is not an exit.
+        for (const snapped of [first, last]) {
+            const boundary = nodes[snapped.boundaryId];
+            if (boundary?.type !== 'wall' || !boundary.curveOffset)
+                continue;
+            const closest = rings
+                .flatMap((ring) => ring.map((a, i) => ({
+                ring,
+                i,
+                ...project(snapped.point, a, ring[(i + 1) % ring.length]),
+            })))
+                .sort((a, b) => a.distance - b.distance)[0];
+            if (closest && closest.t > 1e-8 && closest.t < 1 - 1e-8)
+                closest.ring.splice(closest.i + 1, 0, snapped.point);
+        }
+    }
+    const segments = points
+        .slice(0, closed ? points.length : -1)
+        .map((start, i) => [start, points[(i + 1) % points.length]]);
+    if (segments.some(([a, b]) => Math.hypot(b[0] - a[0], b[1] - a[1]) < 0.05 - 1e-9))
+        return reject('short-cut', 'Each segment must be at least 5 cm long.');
+    for (let i = 0; i < segments.length; i++) {
+        const [a, b] = segments[i];
+        for (let j = i + 1; j < segments.length; j++) {
+            const [c, d] = segments[j];
+            const adjacent = j === i + 1 || (closed && i === 0 && j === segments.length - 1);
+            if (overlapsSegment(a, b, c, d) || (!adjacent && segmentsIntersect(a, b, c, d)))
+                return reject('self-intersection', 'The path must not cross or retrace itself.');
+        }
+    }
+    if (closed && area([{ outer: points, holes: [] }]) < 0.25 - 1e-9)
+        return reject('small-island', 'An island must cover at least 0.25 m².');
+    const footprint = { outer: rings[0], holes: rings.slice(1) };
+    const boundarySegments = [footprint.outer, ...footprint.holes].flatMap((ring) => ring.map((a, i) => [a, ring[(i + 1) % ring.length]]));
+    for (const [index, [start, end]] of segments.entries()) {
+        if (boundarySegments.some(([a, b]) => overlapsSegment(start, end, a, b)))
+            return reject('boundary-overlap', 'The path must not run along an existing boundary.');
+        for (const [a, b] of boundarySegments) {
+            if (!segmentsIntersect(start, end, a, b))
+                continue;
+            const dx = end[0] - start[0], dz = end[1] - start[1];
+            const sx = b[0] - a[0], sz = b[1] - a[1];
+            const denominator = dx * sz - dz * sx;
+            const t = Math.abs(denominator) > 1e-9
+                ? ((a[0] - start[0]) * sz - (a[1] - start[1]) * sx) / denominator
+                : project(a, start, end).t;
+            const endpoint = !closed &&
+                ((index === 0 && Math.abs(t) < 1e-6) ||
+                    (index === segments.length - 1 && Math.abs(t - 1) < 1e-6));
+            if (!endpoint)
+                return reject('outside-room', 'Only the ends of an open path may touch the room boundary.');
+        }
+        if (!containsPoint([footprint], at(start, end, 0.5)))
+            return reject('outside-room', 'The entire path must stay inside the room, outside its holes.');
+    }
+    if (closed) {
+        const walls = context.boundaryNodes.filter((node) => node.type === 'wall');
+        const miters = calculateLevelMiters(walls);
+        const wallPolygons = walls.map((wall) => getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y]));
+        const clear = difference(footprint, union(wallPolygons));
+        if (area(difference(points, clear)) > 1e-8)
+            return reject('outside-room', 'The island must fit entirely inside the clear room polygon.');
+        const wallSegments = wallPolygons.flatMap((ring) => ring.map((a, i) => [a, ring[(i + 1) % ring.length]]));
+        if (segments.some(([a, b]) => wallSegments.some(([c, d]) => segmentDistance(a, b, c, d) < 0.05 - 1e-8)))
+            return reject('wall-clearance', 'Keep the island at least 5 cm from wall faces.');
+    }
+    const ids = new Set();
+    const separators = segments.map(([start, end]) => {
+        const separator = SeparatorNode.parse({
+            id: input.mintId('separator'),
+            parentId: zone.parentId,
+            start,
+            end,
+        });
+        if (nodes[separator.id] || ids.has(separator.id))
+            throw Error(`Duplicate separator id: ${separator.id}`);
+        ids.add(separator.id);
+        return separator;
+    });
+    if (extractRooms([...context.boundaryNodes, ...separators]).length !== context.roomCount + 1)
+        return reject('invalid-cut', 'The path must divide this room into exactly two rooms.');
+    return {
+        changes: separators.map((node) => ({ op: 'create', node })),
+        separatorIds: separators.map((node) => node.id),
+        separatorId: separators[0].id,
+    };
+}

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

@@ -0,0 +1,7 @@
+import { type Point, type StructureNodes } from './shared.js';
+import { type TransformZoneInput } from './transform-zone.js';
+export type DuplicateZoneInput = Omit<TransformZoneInput, 'translate'> & {
+    translate: Point;
+};
+export declare function duplicateZone(nodes: StructureNodes, input: DuplicateZoneInput): import("./transform-zone.js").ZoneTransformPlan;
+//# sourceMappingURL=duplicate-zone.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duplicate-zone.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/duplicate-zone.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAe,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AACvE,OAAO,EAAqB,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAE7E,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAAG;IAAE,SAAS,EAAE,KAAK,CAAA;CAAE,CAAA;AAE7F,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,kBAAkB,gDAkB7E"}

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

@@ -0,0 +1,21 @@
+import { requireZone } from './shared.js';
+import { planZoneTransform } from './transform-zone.js';
+export function duplicateZone(nodes, input) {
+    const zone = requireZone(nodes, input.zoneId);
+    const first = planZoneTransform(nodes, input, true);
+    if (zone.floor?.support !== 'open' || !first.conflicts?.length)
+        return first;
+    const xs = zone.polygon.map(([x]) => x), zs = zone.polygon.map(([, z]) => z);
+    const width = Math.max(...xs) - Math.min(...xs), depth = Math.max(...zs) - Math.min(...zs);
+    for (const translate of [
+        [width, 0],
+        [0, depth],
+        [-width, 0],
+        [0, -depth],
+    ]) {
+        const plan = planZoneTransform(nodes, { ...input, translate }, true);
+        if (!plan.conflicts?.length)
+            return plan;
+    }
+    return first;
+}

package/dist/commands/structure/floor-opening.d.ts

@@ -0,0 +1,36 @@
+import { type Ring } from '../../lib/polygon-boolean.js';
+import { FloorOpeningNode } from '../../schema/index.js';
+import type { StructureNodes, StructurePlan } from './shared.js';
+export type CutFloorOpeningInput = {
+    levelId?: string;
+    zoneId?: string;
+    levelIds?: string[];
+    polygon?: Ring;
+    rect?: {
+        x: number;
+        z: number;
+        width: number;
+        depth: number;
+    };
+    drawnOn?: 'floor' | 'ceiling';
+    cutsPrimary?: boolean;
+    cutsAdjacent?: boolean;
+    source?: string;
+    ownerId?: string;
+    mintId: (kind: 'floor-opening') => string;
+};
+export type FloorOpeningHint = {
+    code: 'manual-ceiling';
+    openingId: string;
+    surfaceIds: string[];
+    message: string;
+};
+export declare function floorOpeningHints(nodes: StructureNodes, opening: FloorOpeningNode): FloorOpeningHint[];
+export declare function cutFloorOpening(nodes: StructureNodes, input: CutFloorOpeningInput): StructurePlan & {
+    openingIds: string[];
+    hints: FloorOpeningHint[];
+};
+export declare function removeFloorOpening(nodes: StructureNodes, id: string): StructurePlan & {
+    openingId: string;
+};
+//# sourceMappingURL=floor-opening.d.ts.map

package/dist/commands/structure/floor-opening.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-opening.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/floor-opening.ts"],"names":[],"mappings":"AACA,OAAO,EAAsB,KAAK,IAAI,EAAS,MAAM,2BAA2B,CAAA;AAChF,OAAO,EAAgC,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC7E,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7D,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,OAAO,CAAC,EAAE,IAAI,CAAA;IACd,IAAI,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAA;IAC7D,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC7B,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,CAAC,IAAI,EAAE,eAAe,KAAK,MAAM,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,gBAAgB,CAAA;IACtB,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAMD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,gBAAgB,GACxB,gBAAgB,EAAE,CAwBpB;AAmBD,wBAAgB,eAAe,CAC7B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,oBAAoB,GAC1B,aAAa,GAAG;IAAE,UAAU,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,gBAAgB,EAAE,CAAA;CAAE,CAoErE;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,EAAE,EAAE,MAAM,GACT,aAAa,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAmBvC"}