@pascal-app/core 1.0.3 → 1.0.4

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

@@ -0,0 +1,46 @@
+import { area, difference, intersection, union } from '../../lib/polygon-boolean.js';
+import { segmentsIntersect } from '../../lib/polygon-relations.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../../systems/wall/wall-footprint.js';
+import { mezzanineElevationConflict } from './mezzanine-content.js';
+import { roomFace } from './shared.js';
+export function mezzanineHostClearance(nodes, host) {
+    const face = roomFace(nodes, host);
+    if (!face)
+        return [];
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === host.parentId);
+    const miters = calculateLevelMiters(walls);
+    return difference({ outer: face.referencePolygon, holes: face.holes }, union(walls.map((wall) => getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y]))));
+}
+export function validateMezzanine(nodes, zone, excludeId) {
+    const fail = (code, message, nodeIds = [zone.id]) => ({
+        code,
+        message,
+        nodeIds,
+    });
+    const polygon = zone.polygon;
+    if (polygon.length < 3 || !polygon.flat().every(Number.isFinite))
+        return fail('too-small', 'A mezzanine needs a finite polygon of at least 1 m².');
+    if (polygon.some((start, i) => polygon.some((other, j) => j > i + 1 &&
+        !(i === 0 && j === polygon.length - 1) &&
+        segmentsIntersect(start, polygon[(i + 1) % polygon.length], other, polygon[(j + 1) % polygon.length]))))
+        return fail('self-intersecting', 'Mezzanine edges must not cross.');
+    if (area([{ outer: polygon, holes: zone.holes }]) < 1)
+        return fail('too-small', 'A mezzanine must have at least 1 m² of floor.');
+    // Intent may reach wall reference lines; the structure kernel clips derived plates to wall faces.
+    const host = nodes[zone.hostZoneId ?? ''];
+    const face = host?.type === 'zone' ? roomFace(nodes, host) : undefined;
+    if (host?.type !== 'zone' ||
+        host.floor?.support === 'open' ||
+        host.parentId !== zone.parentId ||
+        !face ||
+        area(difference({ outer: polygon, holes: zone.holes }, { outer: face.referencePolygon, holes: face.holes })) > 1e-6)
+        return fail('outside-host', 'The mezzanine must stay inside its host room’s reference boundary.');
+    const overlapping = Object.values(nodes).filter((node) => node.type === 'zone' &&
+        node.id !== excludeId &&
+        node.floor?.support === 'open' &&
+        node.parentId === zone.parentId &&
+        area(intersection({ outer: polygon, holes: zone.holes }, { outer: node.polygon, holes: node.holes })) > 1e-6);
+    if (overlapping.length)
+        return fail('overlaps-mezzanine', 'Mezzanines must not overlap.', overlapping.map((node) => node.id));
+    return mezzanineElevationConflict(nodes, zone);
+}

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

@@ -0,0 +1,8 @@
+import type { BoundaryNode } from '../../lib/room-topology-index.js';
+import type { AnyNode, WallNode } from '../../schema/index.js';
+import { type Point, type StructureConflict, type StructureNodes } from './shared.js';
+export declare function boundaryStation(wall: BoundaryNode, point: Point): number;
+export declare function boundaryPoint(wall: BoundaryNode, t: number): Point;
+export declare function dropCrossingCuts(nodes: StructureNodes, moving: Set<string>, levelId: string): Map<string, number[]>;
+export declare function clearOpeningCuts(nodes: Record<string, AnyNode>, wall: WallNode, cuts: number[], force: boolean): StructureConflict | undefined;
+//# sourceMappingURL=zone-crossings.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zone-crossings.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/zone-crossings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAMrD,OAAO,EAAkB,KAAK,KAAK,EAAE,KAAK,iBAAiB,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AAGlG,wBAAgB,eAAe,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,UAO/D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAIlE;AA0DD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,yBAqB3F;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,MAAM,EAAE,EACd,KAAK,EAAE,OAAO,GACb,iBAAiB,GAAG,SAAS,CAiF/B"}

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

@@ -0,0 +1,162 @@
+import { getWallArcData, getWallCurveFrameAt, getWallCurveLength, } from '../../systems/wall/wall-curve.js';
+import { at, boundaries } from './shared.js';
+import { wallAttachments, wallStation } from './zone-wall-merge.js';
+export function boundaryStation(wall, point) {
+    const arc = wall.type === 'wall' ? getWallArcData(wall) : null;
+    if (!arc)
+        return wallStation(wall, point);
+    let angle = (Math.atan2(point[1] - arc.center.y, point[0] - arc.center.x) - arc.startAngle) * arc.direction;
+    while (angle < -1e-8)
+        angle += 2 * Math.PI;
+    return angle / Math.abs(arc.delta);
+}
+export function boundaryPoint(wall, t) {
+    if (wall.type === 'separator')
+        return at(wall.start, wall.end, t);
+    const { point } = getWallCurveFrameAt(wall, t);
+    return [point.x, point.y];
+}
+function crossings(a, b) {
+    const aa = a.type === 'wall' ? getWallArcData(a) : null;
+    const bb = b.type === 'wall' ? getWallArcData(b) : null;
+    let points = [];
+    if (aa && bb) {
+        const dx = bb.center.x - aa.center.x, dz = bb.center.y - aa.center.y, distance = Math.hypot(dx, dz);
+        if (distance < 1e-8 ||
+            distance > aa.radius + bb.radius + 1e-8 ||
+            distance < Math.abs(aa.radius - bb.radius) - 1e-8)
+            return [];
+        const along = (aa.radius ** 2 - bb.radius ** 2 + distance ** 2) / (2 * distance);
+        const offset = Math.sqrt(Math.max(0, aa.radius ** 2 - along ** 2));
+        points = [-1, 1].map((side) => [
+            aa.center.x + (along * dx) / distance - (side * offset * dz) / distance,
+            aa.center.y + (along * dz) / distance + (side * offset * dx) / distance,
+        ]);
+    }
+    else if (aa || bb) {
+        const arc = (aa ?? bb), line = aa ? b : a;
+        const dx = line.end[0] - line.start[0], dz = line.end[1] - line.start[1];
+        const x = line.start[0] - arc.center.x, z = line.start[1] - arc.center.y;
+        const length2 = dx * dx + dz * dz, dot = x * dx + z * dz;
+        const discriminant = dot * dot - length2 * (x * x + z * z - arc.radius * arc.radius);
+        if (discriminant < -1e-8 || length2 < 1e-12)
+            return [];
+        points = [-1, 1].map((side) => at(line.start, line.end, (-dot + side * Math.sqrt(Math.max(0, discriminant))) / length2));
+    }
+    else {
+        const ax = a.end[0] - a.start[0], az = a.end[1] - a.start[1];
+        const bx = b.end[0] - b.start[0], bz = b.end[1] - b.start[1];
+        const determinant = ax * bz - az * bx;
+        if (Math.abs(determinant) < 1e-9) {
+            if (Math.abs((b.start[0] - a.start[0]) * az - (b.start[1] - a.start[1]) * ax) < 1e-8)
+                points = [a.start, a.end, b.start, b.end];
+        }
+        else {
+            const t = ((b.start[0] - a.start[0]) * bz - (b.start[1] - a.start[1]) * bx) / determinant;
+            points = [at(a.start, a.end, t)];
+        }
+    }
+    return points.filter((point) => [a, b].every((wall) => {
+        const t = boundaryStation(wall, point);
+        return t >= -1e-6 && t <= 1 + 1e-6;
+    }));
+}
+export function dropCrossingCuts(nodes, moving, levelId) {
+    const walls = boundaries(nodes, levelId);
+    const cuts = new Map();
+    for (let i = 0; i < walls.length; i++)
+        for (let j = i + 1; j < walls.length; j++) {
+            const a = walls[i], b = walls[j];
+            if (!moving.has(a.id) && !moving.has(b.id))
+                continue;
+            for (const point of crossings(a, b))
+                for (const wall of [a, b]) {
+                    const t = boundaryStation(wall, point);
+                    if (t <= 1e-6 || t >= 1 - 1e-6)
+                        continue;
+                    const values = cuts.get(wall.id) ?? [];
+                    if (!values.some((value) => Math.abs(value - t) < 1e-6))
+                        values.push(t);
+                    cuts.set(wall.id, values.sort((a, b) => a - b));
+                }
+        }
+    return cuts;
+}
+export function clearOpeningCuts(nodes, wall, cuts, force) {
+    const length = getWallCurveLength(wall);
+    const stations = cuts
+        .filter((t) => t > 1e-6 && t < 1 - 1e-6)
+        .map((t) => {
+        const point = boundaryPoint(wall, t);
+        const tangent = getWallCurveFrameAt(wall, t).tangent;
+        const padding = boundaries(nodes, wall.parentId).reduce((pad, other) => {
+            if (other.type !== 'wall' || other.id === wall.id)
+                return pad;
+            const station = boundaryStation(other, point);
+            if (station < -1e-6 || station > 1 + 1e-6)
+                return pad;
+            const frame = getWallCurveFrameAt(other, station);
+            if (Math.hypot(frame.point.x - point[0], frame.point.y - point[1]) > 1e-6 ||
+                Math.abs(tangent.x * frame.tangent.y - tangent.y * frame.tangent.x) < 1e-6)
+                return pad;
+            return Math.max(pad, (other.thickness ?? 0.1) / 2);
+        }, 0);
+        return [t * length - padding, t * length + padding];
+    })
+        .sort((a, b) => a[0] - b[0]);
+    const openings = wallAttachments(nodes, wall).filter((node) => node.type === 'door' || node.type === 'window');
+    const occupied = openings.filter((node) => stations.some(([lo, hi]) => hi > node.position[0] - node.width / 2 + 1e-5 &&
+        lo < node.position[0] + node.width / 2 - 1e-5));
+    if (!occupied.length)
+        return;
+    const refused = () => ({
+        code: 'occupied-split',
+        nodeIds: [wall.id, ...occupied.map((node) => node.id)],
+        message: force
+            ? 'No space on the wall fits the opening clear of every crossing.'
+            : 'A crossing falls inside a door or window. Force moves the opening along its wall if it fits.',
+    });
+    if (!force)
+        return refused();
+    const fixed = openings
+        .filter((node) => !occupied.includes(node))
+        .map((node) => [node.position[0] - node.width / 2, node.position[0] + node.width / 2]);
+    occupied.sort((a, b) => b.width - a.width || a.id.localeCompare(b.id));
+    const arrange = (index, placed) => {
+        const node = occupied[index];
+        if (!node)
+            return [];
+        const half = node.width / 2;
+        const candidates = new Set();
+        let ranges = [[half, length - half]];
+        for (const [lo, hi] of [...stations, ...placed])
+            ranges = ranges.flatMap(([a, b]) => {
+                const left = lo - half, right = hi + half;
+                if (right <= a || left >= b)
+                    return [[a, b]];
+                return [
+                    [a, Math.min(b, left)],
+                    [Math.max(a, right), b],
+                ].filter(([a, b]) => b >= a - 1e-8);
+            });
+        for (const [lo, hi] of ranges)
+            if (hi >= lo - 1e-8) {
+                candidates.add(Math.max(lo, Math.min(hi, node.position[0])));
+                candidates.add(lo);
+                candidates.add(Math.max(lo, hi));
+            }
+        // Trying interval edges as well as the nearest pose avoids rejecting a fit
+        // just because an earlier opening occupied the only space for another.
+        for (const station of [...candidates].sort((a, b) => Math.abs(a - node.position[0]) - Math.abs(b - node.position[0]) || a - b)) {
+            const rest = arrange(index + 1, [...placed, [station - half, station + half]]);
+            if (rest)
+                return [station, ...rest];
+        }
+    };
+    const relocated = arrange(0, fixed);
+    if (!relocated)
+        return refused();
+    occupied.forEach((node, i) => {
+        nodes[node.id] = { ...node, position: [relocated[i], node.position[1], node.position[2]] };
+    });
+}

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

@@ -0,0 +1,4 @@
+import type { AnyNode } from '../../schema/index.js';
+export declare function snapDroppedWalls(nodes: Record<string, AnyNode>, moving: Set<string>, levelId: string): void;
+export declare function preserveDroppedRoomSeeds(nodes: Record<string, AnyNode>, placedZoneId: string): void;
+//# sourceMappingURL=zone-drop.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zone-drop.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/zone-drop.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,cAAc,CAAA;AAI/D,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,EACnB,OAAO,EAAE,MAAM,QA8BhB;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,MAAM,QAkC5F"}

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

@@ -0,0 +1,68 @@
+import { area, containsPoint, difference, intersection } from '../../lib/polygon-boolean.js';
+import { polygonInteriorPoint } from '../../lib/polygon-label.js';
+import { extractRooms } from '../../lib/room-graph.js';
+import { at, boundaries, project } from './shared.js';
+import { collinearOverlap, wallStation } from './zone-wall-merge.js';
+export function snapDroppedWalls(nodes, moving, levelId) {
+    for (const id of moving) {
+        const wall = nodes[id];
+        if (wall?.type !== 'wall')
+            continue;
+        const destination = Object.values(nodes)
+            .filter((node) => node.type === 'wall' &&
+            node.parentId === levelId &&
+            !moving.has(node.id) &&
+            collinearOverlap(wall, node))
+            .sort((a, b) => project(wall.start, a.start, a.end).distance -
+            project(wall.start, b.start, b.end).distance || a.id.localeCompare(b.id))[0];
+        if (!destination)
+            continue;
+        const snap = (point) => {
+            const onWall = project(point, wall.start, wall.end);
+            if (onWall.distance > 1e-6)
+                return point;
+            return at(destination.start, destination.end, wallStation(destination, point));
+        };
+        for (const movingId of moving) {
+            const node = nodes[movingId];
+            if (node.type === 'wall' || node.type === 'separator')
+                nodes[movingId] = { ...node, start: snap(node.start), end: snap(node.end) };
+        }
+    }
+}
+export function preserveDroppedRoomSeeds(nodes, placedZoneId) {
+    const placed = nodes[placedZoneId];
+    const dropped = [{ outer: placed.polygon, holes: placed.holes ?? [] }];
+    const faces = extractRooms(boundaries(nodes, placed.parentId)).map((face) => ({
+        face,
+        polygon: [{ outer: face.referencePolygon, holes: face.holes }],
+    }));
+    for (const zone of Object.values(nodes)) {
+        if (zone.type !== 'zone' || zone.parentId !== placed.parentId)
+            continue;
+        const moving = zone.id === placedZoneId;
+        if (!moving && zone.seed && !containsPoint(dropped, zone.seed))
+            continue;
+        const old = [{ outer: zone.polygon, holes: zone.holes ?? [] }];
+        const candidates = faces
+            .map(({ face, polygon }) => ({
+            face,
+            overlap: area(intersection(polygon, old)),
+            outside: area(intersection(polygon, difference(old, dropped))),
+            size: area(polygon),
+        }))
+            .filter(({ overlap }) => overlap > 1e-6);
+        // Prefer whole resulting faces inside the owner's intent; snapped boundaries
+        // may protrude slightly, so overlap supplies a fallback when none fit exactly.
+        const owned = candidates.filter(({ overlap, size }) => overlap >= size - 1e-5);
+        const available = owned.length ? owned : candidates;
+        const outside = moving ? [] : available.filter(({ outside, size }) => outside >= size - 1e-5);
+        const target = (outside.length ? outside : available).sort((a, b) => b.overlap - a.overlap || a.face.id.localeCompare(b.face.id))[0];
+        if (!target)
+            continue;
+        const polygon = { polygon: target.face.referencePolygon, holes: target.face.holes };
+        if (zone.seed && containsPoint([{ outer: polygon.polygon, holes: polygon.holes }], zone.seed))
+            continue;
+        nodes[zone.id] = { ...zone, seed: polygonInteriorPoint(polygon) };
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { AnyNode } from '../../schema/index.js';
+import { type StructureConflict, type StructureMintId } from './shared.js';
+export declare function insertDroppedBoundaries(nodes: Record<string, AnyNode>, moving: Set<string>, levelId: string, idMap: Record<string, string[]>, mintId: StructureMintId, force: boolean, stationary: Set<string>): StructureConflict | undefined;
+//# sourceMappingURL=zone-insertion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zone-insertion.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/zone-insertion.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAuB,MAAM,cAAc,CAAA;AAGhE,OAAO,EAAc,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAAE,MAAM,UAAU,CAAA;AAcnF,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,EACnB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EAC/B,MAAM,EAAE,eAAe,EACvB,KAAK,EAAE,OAAO,EACd,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,GACtB,iBAAiB,GAAG,SAAS,CAwN/B"}

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

@@ -0,0 +1,200 @@
+import { getWallArcData, getWallCurveLength } from '../../systems/wall/wall-curve.js';
+import { planWallInsertion } from '../../systems/wall/wall-topology.js';
+import { boundaries } from './shared.js';
+import { boundaryPoint, boundaryStation, clearOpeningCuts, dropCrossingCuts, } from './zone-crossings.js';
+import { remapWallReferences, splitCollinearWalls, wallAttachments, wallSlice, } from './zone-wall-merge.js';
+export function insertDroppedBoundaries(nodes, moving, levelId, idMap, mintId, force, stationary) {
+    const replace = (source, pieces) => {
+        const ordered = pieces.sort((a, b) => boundaryStation(source, a.start) - boundaryStation(source, b.start));
+        const ranges = ordered.map((piece) => [boundaryStation(source, piece.start), boundaryStation(source, piece.end)]);
+        if (source.type === 'wall') {
+            const conflict = clearOpeningCuts(nodes, source, ranges.flat(), force);
+            if (conflict)
+                return conflict;
+        }
+        const targets = ordered.map((piece, i) => {
+            const id = i === 0 ? source.id : source.type === 'wall' ? piece.id : mintId('separator');
+            const [lo, hi] = ranges[i];
+            return source.type === 'wall'
+                ? wallSlice(source, piece.start, piece.end, id, [lo, hi])
+                : { ...source, id: id, start: piece.start, end: piece.end };
+        });
+        const children = source.type === 'wall' ? wallAttachments(nodes, source) : [];
+        for (const child of children) {
+            const position = 'position' in child && Array.isArray(child.position) ? child.position : undefined;
+            const length = getWallCurveLength(source);
+            const t = position ? position[0] / length : 0.5;
+            const index = Math.max(0, ranges.findIndex(([lo, hi]) => t >= lo - 1e-6 && t <= hi + 1e-6));
+            const host = targets[index];
+            nodes[child.id] = {
+                ...child,
+                parentId: host.id,
+                ...('wallId' in child ? { wallId: host.id } : {}),
+                ...(position
+                    ? { position: [position[0] - ranges[index][0] * length, position[1], position[2]] }
+                    : {}),
+                ...('wallT' in child
+                    ? { wallT: (t - ranges[index][0]) / (ranges[index][1] - ranges[index][0]) }
+                    : {}),
+            };
+        }
+        if (source.type === 'wall')
+            remapWallReferences(nodes, source, targets);
+        else
+            for (const zone of Object.values(nodes))
+                if (zone.type === 'zone' && zone.boundarySeparatorIds.includes(source.id))
+                    nodes[zone.id] = {
+                        ...zone,
+                        boundarySeparatorIds: zone.boundarySeparatorIds.flatMap((id) => id === source.id ? targets.map((node) => node.id) : [id]),
+                    };
+        for (const [key, values] of Object.entries(idMap))
+            idMap[key] = [
+                ...new Set(values.flatMap((id) => (id === source.id ? targets.map((node) => node.id) : [id]))),
+            ];
+        idMap[source.id] ??= targets.map((node) => node.id);
+        delete nodes[source.id];
+        for (const target of targets)
+            nodes[target.id] = target;
+        if (moving.has(source.id))
+            for (const target of targets)
+                moving.add(target.id);
+        if (stationary.has(source.id))
+            for (const target of targets)
+                stationary.add(target.id);
+    };
+    const bounds = (wall) => {
+        const points = [wall.start, wall.end];
+        const arc = wall.type === 'wall' ? getWallArcData(wall) : null;
+        if (arc)
+            for (const angle of [0, Math.PI / 2, Math.PI, -Math.PI / 2]) {
+                const point = [
+                    arc.center.x + arc.radius * Math.cos(angle),
+                    arc.center.y + arc.radius * Math.sin(angle),
+                ];
+                const t = boundaryStation(wall, point);
+                if (t >= 0 && t <= 1)
+                    points.push(point);
+            }
+        return [
+            Math.min(...points.map((p) => p[0])),
+            Math.min(...points.map((p) => p[1])),
+            Math.max(...points.map((p) => p[0])),
+            Math.max(...points.map((p) => p[1])),
+        ];
+    };
+    const curves = boundaries(nodes, levelId)
+        .filter((node) => moving.has(node.id) && node.type === 'wall' && node.curveOffset)
+        .map(bounds);
+    const queue = boundaries(nodes, levelId)
+        .filter((node) => {
+        if (moving.has(node.id))
+            return true;
+        const box = bounds(node);
+        return curves.some((curve) => box[0] <= curve[2] + 1e-6 &&
+            box[2] >= curve[0] - 1e-6 &&
+            box[1] <= curve[3] + 1e-6 &&
+            box[3] >= curve[1] - 1e-6);
+    })
+        .map((node) => node.id);
+    while (queue.length) {
+        const source = nodes[queue.shift()];
+        if (!source ||
+            (source.type !== 'wall' && source.type !== 'separator') ||
+            (source.type === 'wall' && source.curveOffset))
+            continue;
+        const others = boundaries(nodes, levelId).filter((node) => node.id !== source.id && (moving.has(source.id) || moving.has(node.id)));
+        // Opening clearance is checked before geometry planning. Virtual boundaries use
+        // the same crossing planner; their split pieces are restored as separators.
+        const geometry = Object.fromEntries(others.map((node) => [node.id, { ...node, type: 'wall', children: [] }]));
+        const inserted = planWallInsertion(geometry, {
+            levelId: source.parentId,
+            start: source.start,
+            end: source.end,
+            joinRadius: 1e-7,
+            wallDefaults: { ...source, type: 'wall' },
+            mintId: () => mintId('wall'),
+        });
+        if (!inserted.ok)
+            continue;
+        const { plan } = inserted;
+        if (!plan.changes.delete.length && plan.insertedWalls.length === 1)
+            continue;
+        const replacements = plan.changes.create
+            .map(({ node }) => node)
+            .filter((node) => !plan.insertedWalls.some((inserted) => inserted.id === node.id));
+        for (const id of plan.changes.delete) {
+            const original = nodes[id];
+            const pieces = replacements.filter((piece) => [piece.start, piece.end].every((point) => {
+                const t = boundaryStation(original, point), onLine = boundaryPoint(original, t);
+                return (t >= -1e-6 &&
+                    t <= 1 + 1e-6 &&
+                    Math.hypot(point[0] - onLine[0], point[1] - onLine[1]) < 1e-5);
+            }));
+            if (!pieces.length)
+                throw Error(`Missing crossing replacements for ${id}`);
+            const conflict = replace(original, pieces);
+            if (conflict)
+                return conflict;
+            if (moving.has(id))
+                queue.push(...(idMap[id] ?? []));
+        }
+        const conflict = replace(source, plan.insertedWalls);
+        if (conflict)
+            return conflict;
+        if (moving.has(source.id))
+            queue.push(...(idMap[source.id] ?? []));
+    }
+    // The insertion primitive draws straight segments. Arc/arc crossings and
+    // sub-centimetre remnants still need exact cuts on their original curves.
+    for (const [id, cuts] of dropCrossingCuts(nodes, moving, levelId)) {
+        const source = nodes[id];
+        const parameters = [0, ...cuts, 1];
+        const conflict = replace(source, parameters.slice(1).map((hi, i) => ({
+            id: mintId('wall'),
+            start: boundaryPoint(source, parameters[i]),
+            end: boundaryPoint(source, hi),
+        })));
+        if (conflict)
+            return conflict;
+    }
+    const samePoint = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]) < 1e-6;
+    const segments = boundaries(nodes, levelId);
+    for (let i = 0; i < segments.length; i++)
+        for (let j = i + 1; j < segments.length; j++) {
+            let a = nodes[segments[i].id];
+            let b = nodes[segments[j].id];
+            if (!a ||
+                !b ||
+                (!moving.has(a.id) && !moving.has(b.id)) ||
+                (a.type === 'wall' && a.curveOffset) ||
+                (b.type === 'wall' && b.curveOffset))
+                continue;
+            if (!((samePoint(a.start, b.start) && samePoint(a.end, b.end)) ||
+                (samePoint(a.start, b.end) && samePoint(a.end, b.start))))
+                continue;
+            if (a.type === 'wall' && b.type === 'wall') {
+                if (stationary.has(b.id) && !stationary.has(a.id))
+                    [a, b] = [b, a];
+                splitCollinearWalls(nodes, b, a, mintId);
+            }
+            else {
+                if (b.type === 'wall' || (a.type === 'separator' && stationary.has(b.id)))
+                    [a, b] = [b, a];
+                for (const zone of Object.values(nodes))
+                    if (zone.type === 'zone' && zone.boundarySeparatorIds.includes(b.id))
+                        nodes[zone.id] = {
+                            ...zone,
+                            boundarySeparatorIds: zone.boundarySeparatorIds.flatMap((id) => id === b.id ? (a.type === 'separator' ? [a.id] : []) : [id]),
+                            boundaryWallIds: a.type === 'wall'
+                                ? [...new Set([...zone.boundaryWallIds, a.id])]
+                                : zone.boundaryWallIds,
+                        };
+                delete nodes[b.id];
+            }
+            for (const [id, targets] of Object.entries(idMap))
+                idMap[id] = [...new Set(targets.map((target) => (target === b.id ? a.id : target)))];
+            idMap[b.id] ??= [a.id];
+            if (moving.has(b.id))
+                moving.add(a.id);
+        }
+}

package/dist/commands/structure/zone-transform-content.d.ts

@@ -0,0 +1,6 @@
+import type { AnyNode, ZoneNode } from '../../schema/index.js';
+import { type StructureNodes } from './shared.js';
+export declare function collectTransformContents(nodes: StructureNodes, zone: ZoneNode): Set<string>;
+export declare function includeDescendants(nodes: StructureNodes, ids: Set<string>): void;
+export declare function repairTransformChildren(nodes: Record<string, AnyNode>, before: StructureNodes): void;
+//# sourceMappingURL=zone-transform-content.d.ts.map

package/dist/commands/structure/zone-transform-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone-transform-content.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/zone-transform-content.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAY,QAAQ,EAAE,MAAM,cAAc,CAAA;AAI/D,OAAO,EAAiC,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AAI7E,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,eAqF7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,cAAc,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,QAUzE;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,cAAc,QA8B7F"}

package/dist/commands/structure/zone-transform-content.js

@@ -0,0 +1,117 @@
+import { containsPoint, difference, distanceToBoundary, union } from '../../lib/polygon-boolean.js';
+import { isDerivedNode } from '../../store/derived-node-guard.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../../systems/wall/wall-footprint.js';
+import { containedMezzanines, electedIntentPlate, isFloorPlacedIntent } from './mezzanine-content.js';
+import { project, roomFace } from './shared.js';
+const isIntent = (node) => !isDerivedNode(node);
+export function collectTransformContents(nodes, zone) {
+    if (zone.floor?.support === 'open') {
+        return new Set(Object.values(nodes)
+            .filter((node) => {
+            if (!isIntent(node))
+                return false;
+            if (node.type === 'floor-opening' && node.hostZoneId === zone.id)
+                return true;
+            const parent = nodes[node.parentId ?? ''];
+            if (parent?.type === 'ceiling' && parent.zoneId === zone.id)
+                return true;
+            return (node.parentId === zone.parentId &&
+                isFloorPlacedIntent(node) &&
+                !!electedIntentPlate(nodes, node)?.zoneIds?.includes(zone.id));
+        })
+            .map((node) => node.id));
+    }
+    const ids = new Set(containedMezzanines(nodes, zone).map((node) => node.id));
+    const face = roomFace(nodes, zone);
+    const footprint = [
+        { outer: face?.referencePolygon ?? zone.polygon, holes: face?.holes ?? zone.holes },
+    ];
+    const walls = Object.values(nodes).filter((node) => node.type === 'wall' && node.parentId === zone.parentId);
+    const boundaryWalls = walls.filter((wall) => face?.spans.some((span) => span.boundaryId === wall.id));
+    const miters = calculateLevelMiters(walls);
+    const clear = difference(footprint, union(boundaryWalls.map((wall) => getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y]))));
+    const inside = (point) => {
+        if (!containsPoint(footprint, point))
+            return false;
+        if (containsPoint(clear, point))
+            return true;
+        const nearest = boundaryWalls
+            .map((wall) => ({ wall, distance: project(point, wall.start, wall.end).distance }))
+            .sort((a, b) => a.distance - b.distance)[0];
+        return (!!nearest && distanceToBoundary(clear, point) <= (nearest.wall.thickness ?? 0.1) / 2 + 1e-6);
+    };
+    const furnishingKinds = new Set(['item', 'procedural-item', 'cabinet', 'shelf', 'stair']);
+    for (const node of Object.values(nodes)) {
+        if (node.parentId === zone.parentId && isIntent(node)) {
+            if (node.type === 'floor-opening' &&
+                !node.hostZoneId &&
+                node.polygon.every((point) => containsPoint(clear, point)))
+                ids.add(node.id);
+            if (furnishingKinds.has(node.type) &&
+                'position' in node &&
+                Array.isArray(node.position) &&
+                !('wallId' in node && node.wallId) &&
+                inside([node.position[0], node.position[2]]))
+                ids.add(node.id);
+            if ((node.type === 'slab' || node.type === 'ceiling') &&
+                node.polygon.length >= 3 &&
+                node.polygon.every((p) => containsPoint(footprint, p)))
+                ids.add(node.id);
+        }
+        const parent = node.parentId ? nodes[node.parentId] : undefined;
+        if (parent &&
+            isDerivedNode(parent) &&
+            furnishingKinds.has(node.type) &&
+            'position' in node &&
+            Array.isArray(node.position) &&
+            parent.parentId === zone.parentId &&
+            inside([node.position[0], node.position[2]]))
+            ids.add(node.id);
+    }
+    return ids;
+}
+export function includeDescendants(nodes, ids) {
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const node of Object.values(nodes))
+            if (!isDerivedNode(node) && node.parentId && ids.has(node.parentId) && !ids.has(node.id)) {
+                ids.add(node.id);
+                changed = true;
+            }
+    }
+}
+export function repairTransformChildren(nodes, before) {
+    const affected = new Set();
+    const byParent = new Map();
+    for (const node of Object.values(nodes)) {
+        if (node.parentId) {
+            const children = byParent.get(node.parentId) ?? [];
+            children.push(node.id);
+            byParent.set(node.parentId, children);
+        }
+        if (node !== before[node.id]) {
+            affected.add(node.id);
+            if (node.parentId)
+                affected.add(node.parentId);
+            const previousParent = before[node.id]?.parentId;
+            if (previousParent)
+                affected.add(previousParent);
+        }
+    }
+    for (const node of Object.values(before))
+        if (!nodes[node.id] && node.parentId)
+            affected.add(node.parentId);
+    for (const id of affected) {
+        const node = nodes[id];
+        if (!node || isDerivedNode(node) || !('children' in node) || !Array.isArray(node.children))
+            continue;
+        const children = new Set(byParent.get(id) ?? []);
+        const ordered = [
+            ...node.children.filter((id) => children.has(id)),
+            ...[...children].filter((id) => !node.children.includes(id)),
+        ];
+        if (JSON.stringify(ordered) !== JSON.stringify(node.children))
+            nodes[node.id] = { ...node, children: ordered };
+    }
+}