@pascal-app/core 1.0.3 → 1.0.4

package/dist/commands/structure/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/shared.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAA;AACvE,OAAO,KAAK,EAAsB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AAG3E,MAAM,MAAM,UAAU,GAAG,SAAS,CAAA;AAClC,MAAM,MAAM,cAAc,GAAG,UAAU,CAAA;AACvC,MAAM,MAAM,eAAe,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,WAAW,KAAK,MAAM,CAAA;AAC7E,MAAM,MAAM,iBAAiB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAA;AACpF,MAAM,MAAM,aAAa,GAAG;IAC1B,OAAO,EAAE,UAAU,EAAE,CAAA;IACrB,SAAS,CAAC,EAAE,iBAAiB,EAAE,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;CACjC,CAAA;AACD,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AACpC,MAAM,MAAM,OAAO,GAAG,IAAI,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;AAE7E,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,GAAG,mBAAmB,CAQxF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAQ/E;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,GAAG,UAAU,EAAE,CAwBzF;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CAExF;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,CAIvE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CAKjF;AAOD,wBAAgB,QAAQ,CACtB,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,QAAQ,EACd,KAAK,kCAAkD,6CA6BxD;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,WAc9E;AAED,wBAAgB,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,GAAG,KAAK,CAE7D;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK;;;;EAS7D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,WAEvD"}

package/dist/commands/structure/shared.js

@@ -0,0 +1,102 @@
+import { roomPolygonKey } from '../../lib/floor-room-faces.js';
+import { area, containsPoint, intersection } from '../../lib/polygon-boolean.js';
+import { extractRooms } from '../../lib/room-graph.js';
+import { omitUndefined } from '../../utils/omit-undefined.js';
+export function structureChangeBatch(changes) {
+    return {
+        create: changes.flatMap((c) => c.op === 'create' ? [{ node: c.node, parentId: c.node.parentId }] : []),
+        update: changes.flatMap((c) => (c.op === 'update' ? [{ id: c.id, data: c.data }] : [])),
+        delete: changes.flatMap((c) => (c.op === 'delete' ? [c.id] : [])),
+    };
+}
+export function applyToScratch(nodes, batch) {
+    const next = { ...nodes };
+    for (const id of batch.delete)
+        delete next[id];
+    for (const { node, parentId } of batch.create)
+        next[node.id] = { ...node, parentId: parentId ?? node.parentId };
+    for (const { id, data } of batch.update)
+        if (next[id])
+            next[id] = { ...next[id], ...data };
+    return next;
+}
+export function diffStructure(before, after) {
+    return [
+        ...Object.values(after)
+            .filter((node) => !before[node.id])
+            .map((node) => ({ op: 'create', node: omitUndefined(node) })),
+        ...Object.values(after)
+            .filter((node) => before[node.id] && node !== before[node.id])
+            .flatMap((node) => {
+            const previous = before[node.id];
+            const data = Object.fromEntries([...new Set([...Object.keys(previous), ...Object.keys(node)])]
+                .filter((key) => JSON.stringify(previous[key]) !==
+                JSON.stringify(node[key]))
+                .map((key) => [key, omitUndefined(node[key])]));
+            return Object.keys(data).length ? [{ op: 'update', id: node.id, data }] : [];
+        }),
+        ...Object.values(before)
+            .filter((node) => !after[node.id])
+            .map((node) => ({ op: 'delete', id: node.id })),
+    ];
+}
+export function conflict(code, nodeIds, message) {
+    return { changes: [], conflicts: [{ code, nodeIds, message }] };
+}
+export function requireZone(nodes, id) {
+    const zone = nodes[id];
+    if (zone?.type !== 'zone' || zone.spaceRole !== 'room')
+        throw Error(`Room not found: ${id}`);
+    return zone;
+}
+export function boundaries(nodes, levelId) {
+    return Object.values(nodes).filter((n) => n.parentId === levelId && (n.type === 'wall' || n.type === 'separator'));
+}
+const faceMatches = new WeakMap();
+export function roomFace(nodes, zone, faces = extractRooms(boundaries(nodes, zone.parentId))) {
+    if (zone.floor?.support === 'open')
+        return undefined;
+    let matches = faceMatches.get(faces);
+    if (!matches) {
+        matches = new Map();
+        faceMatches.set(faces, matches);
+    }
+    const key = roomPolygonKey(zone.polygon, zone.holes);
+    if (matches.has(key))
+        return matches.get(key);
+    const exact = faces.find((face) => roomPolygonKey(face.referencePolygon, face.holes) === key);
+    if (exact) {
+        matches.set(key, exact);
+        return exact;
+    }
+    const scored = faces.map((face) => ({
+        face,
+        overlap: area(intersection({ outer: zone.polygon, holes: zone.holes }, { outer: face.referencePolygon, holes: face.holes })),
+    }));
+    const result = scored.sort((a, b) => b.overlap - a.overlap)[0]?.overlap
+        ? scored[0].face
+        : undefined;
+    matches.set(key, result);
+    return result;
+}
+export function sharedSpan(nodes, zone, span) {
+    return Object.values(nodes).some((other) => other.type === 'zone' &&
+        other.id !== zone.id &&
+        other.parentId === zone.parentId &&
+        other.spaceRole === 'room' &&
+        roomFace(nodes, other)?.spans.some((s) => s.boundaryId === span.boundaryId &&
+            s.face !== span.face &&
+            Math.min(s.t1, span.t1) - Math.max(s.t0, span.t0) > 1e-6));
+}
+export function at(start, end, t) {
+    return [start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t];
+}
+export function project(point, start, end) {
+    const dx = end[0] - start[0], dz = end[1] - start[1];
+    const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / (dx * dx + dz * dz)));
+    const result = at(start, end, t);
+    return { point: result, t, distance: Math.hypot(result[0] - point[0], result[1] - point[1]) };
+}
+export function pointInRoom(zone, point) {
+    return containsPoint([{ outer: zone.polygon, holes: zone.holes }], point);
+}

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

@@ -0,0 +1,23 @@
+import type { AnyNode } from '../../schema/index.js';
+import type { CeilingHostAssignment, SupportHostAssignment } from './apply-zone-transform.js';
+import { type Point, type StructureNodes, type StructurePlan } from './shared.js';
+export type TransformZoneInput = {
+    zoneId: string;
+    translate?: Point;
+    /** Radians about Y; rotation precedes translation. Defaults to the room's area centroid. */
+    rotate?: {
+        angle: number;
+        pivot?: Point;
+    };
+    force?: boolean;
+    mintId: (kind: AnyNode['type']) => string;
+};
+export type ZoneTransformPlan = StructurePlan & {
+    zoneId: string;
+    idMap: Record<string, string[]>;
+    ceilingHosts?: CeilingHostAssignment[];
+    supportHosts?: SupportHostAssignment[];
+};
+export declare function transformZone(nodes: StructureNodes, input: TransformZoneInput): ZoneTransformPlan;
+export declare function planZoneTransform(nodes: StructureNodes, input: TransformZoneInput, duplicate: boolean): ZoneTransformPlan;
+//# sourceMappingURL=transform-zone.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transform-zone.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/transform-zone.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAsB,MAAM,cAAc,CAAA;AAI/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AAC1F,OAAO,EAML,KAAK,KAAK,EAIV,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAiBjB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,KAAK,CAAA;IACjB,4FAA4F;IAC5F,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,KAAK,CAAA;KAAE,CAAA;IACzC,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,MAAM,CAAA;CAC1C,CAAA;AACD,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG;IAC9C,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;IAC/B,YAAY,CAAC,EAAE,qBAAqB,EAAE,CAAA;IACtC,YAAY,CAAC,EAAE,qBAAqB,EAAE,CAAA;CACvC,CAAA;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,kBAAkB,GAAG,iBAAiB,CAEjG;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,kBAAkB,EACzB,SAAS,EAAE,OAAO,GACjB,iBAAiB,CAsdnB"}

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

@@ -0,0 +1,472 @@
+import { polygonCentroid } from '../../lib/polygon-label.js';
+import { getRoomBaseElevation } from '../../lib/room-floor-feasibility.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 { planWallDivision } from '../../systems/wall/wall-operations.js';
+import { applyToScratch, at, boundaries, conflict, diffStructure, requireZone, roomFace, } from './shared.js';
+import { validateMezzanine } from './validate-mezzanine.js';
+import { clearOpeningCuts, dropCrossingCuts } from './zone-crossings.js';
+import { preserveDroppedRoomSeeds, snapDroppedWalls } from './zone-drop.js';
+import { insertDroppedBoundaries } from './zone-insertion.js';
+import { collectTransformContents, includeDescendants, repairTransformChildren, } from './zone-transform-content.js';
+import { collinearOverlap, splitCollinearWalls, wallAttachments, wallSlice, } from './zone-wall-merge.js';
+export function transformZone(nodes, input) {
+    return planZoneTransform(nodes, input, false);
+}
+export function planZoneTransform(nodes, input, duplicate) {
+    const zone = requireZone(nodes, input.zoneId);
+    const mezzanine = zone.floor?.support === 'open';
+    const face = mezzanine
+        ? { id: zone.id, referencePolygon: zone.polygon, holes: zone.holes, spans: [] }
+        : roomFace(nodes, zone);
+    const idMap = {};
+    const failed = (code, ids, message) => ({
+        ...conflict(code, ids, message),
+        zoneId: zone.id,
+        idMap: {},
+    });
+    if (!face)
+        return failed('open-room', [zone.id], 'The room needs an enclosed boundary before it can move.');
+    const angle = input.rotate?.angle ?? 0, translate = input.translate ?? [0, 0];
+    const pivot = input.rotate?.pivot ?? polygonCentroid({ outer: face.referencePolygon, holes: face.holes });
+    if (![angle, ...translate, ...pivot].every(Number.isFinite))
+        throw Error('Room transforms must be finite.');
+    if (!duplicate && angle === 0 && translate.every((v) => v === 0))
+        return { changes: [], zoneId: zone.id, idMap: { [zone.id]: [zone.id] } };
+    const exact = (value) => (Math.abs(value) < 1e-12 ? 0 : value);
+    const cosine = exact(Math.cos(angle)), sine = exact(Math.sin(angle));
+    const transform = ([x, z]) => [
+        pivot[0] + cosine * (x - pivot[0]) + sine * (z - pivot[1]) + translate[0] + 0,
+        pivot[1] - sine * (x - pivot[0]) + cosine * (z - pivot[1]) + translate[1] + 0,
+    ];
+    if (mezzanine) {
+        const invalid = validateMezzanine(nodes, {
+            ...zone,
+            polygon: zone.polygon.map(transform),
+            holes: zone.holes.map((hole) => hole.map(transform)),
+        }, duplicate ? undefined : zone.id);
+        if (invalid)
+            return { changes: [], conflicts: [invalid], zoneId: zone.id, idMap: {} };
+    }
+    const allocated = new Set(Object.keys(nodes));
+    const mintId = (kind) => {
+        const minted = input.mintId(kind);
+        const id = kind === 'stair-segment' ? minted.replace(/^stair-segment_/, 'sseg_') : minted;
+        if (!id.startsWith(`${kind === 'stair-segment' ? 'sseg' : kind}_`) || allocated.has(id))
+            throw Error(`Invalid or reused ${kind} id: ${id}`);
+        allocated.add(id);
+        return id;
+    };
+    let scratch = { ...nodes };
+    const ceilingHosts = [];
+    const supportHosts = [];
+    const moving = new Set();
+    const plain = new Set();
+    const sourceFor = new Map();
+    const allFaces = extractRooms(boundaries(nodes, zone.parentId));
+    const boundaryIds = [...new Set(face.spans.map((span) => span.boundaryId))];
+    const materialCopies = new Set();
+    for (const boundaryId of boundaryIds) {
+        const original = nodes[boundaryId];
+        if (!original || (original.type !== 'wall' && original.type !== 'separator'))
+            continue;
+        const spans = face.spans.filter((span) => span.boundaryId === boundaryId);
+        const opposite = allFaces
+            .filter((other) => other.id !== face.id)
+            .flatMap((other) => other.spans)
+            .filter((span) => span.boundaryId === boundaryId && spans.some((own) => own.face !== span.face));
+        const cuts = [
+            ...new Set([
+                0,
+                1,
+                ...spans.flatMap((span) => [span.t0, span.t1]),
+                ...opposite.flatMap((span) => [span.t0, span.t1]),
+            ]),
+        ].sort((a, b) => a - b);
+        const ranges = [];
+        for (let i = 1; i < cuts.length; i++) {
+            const lo = cuts[i - 1], hi = cuts[i], mid = (lo + hi) / 2;
+            if (hi - lo < 1e-6 || !spans.some((span) => mid >= span.t0 && mid <= span.t1))
+                continue;
+            const shared = opposite.some((span) => mid >= span.t0 && mid <= span.t1);
+            const previous = ranges.at(-1);
+            if (previous && previous.shared === shared && Math.abs(previous.hi - lo) < 1e-6)
+                previous.hi = hi;
+            else
+                ranges.push({ lo, hi, shared });
+        }
+        const segments = [{ lo: 0, hi: 1, id: original.id }];
+        const needsDivision = !duplicate &&
+            ranges.some((range) => !range.shared) &&
+            (ranges.length > 1 || ranges[0].lo > 1e-6 || ranges[0].hi < 1 - 1e-6);
+        if (needsDivision) {
+            const splits = [...new Set(ranges.flatMap((range) => [range.lo, range.hi]))]
+                .filter((t) => t > 1e-6 && t < 1 - 1e-6)
+                .sort((a, b) => b - a);
+            if (original.type === 'wall') {
+                const blocked = clearOpeningCuts(scratch, original, splits, input.force ?? false);
+                if (blocked)
+                    return { changes: [], conflicts: [blocked], idMap: {}, zoneId: zone.id };
+            }
+            try {
+                for (const t of splits) {
+                    const first = segments[0], current = scratch[first.id];
+                    let id;
+                    if (current.type === 'wall') {
+                        const division = planWallDivision(scratch, current.id, t * getWallCurveLength(original), () => mintId('wall'));
+                        scratch = applyToScratch(scratch, division.changes);
+                        id = division.changes.create[0].node.id;
+                    }
+                    else {
+                        id = mintId('separator');
+                        const point = at(original.start, original.end, t);
+                        scratch[id] = { ...current, id: id, start: point };
+                        scratch[current.id] = { ...current, end: point };
+                    }
+                    segments.push({ lo: t, hi: first.hi, id });
+                    first.hi = t;
+                }
+            }
+            catch (error) {
+                return failed('occupied-split', [boundaryId], String(error));
+            }
+        }
+        idMap[boundaryId] = [];
+        for (const { lo, hi, shared } of ranges) {
+            let boundary = scratch[segments.find((segment) => (lo + hi) / 2 >= segment.lo && (lo + hi) / 2 <= segment.hi).id];
+            if (duplicate || shared) {
+                const id = mintId(original.type);
+                const point = (t) => {
+                    if (original.type === 'separator')
+                        return at(original.start, original.end, t);
+                    const frame = getWallCurveFrameAt(original, t);
+                    return [frame.point.x, frame.point.y];
+                };
+                boundary =
+                    original.type === 'wall'
+                        ? wallSlice(original, point(lo), point(hi), id, [lo, hi])
+                        : { ...original, id: id, start: point(lo), end: point(hi) };
+                scratch[id] = boundary;
+                sourceFor.set(id, original.id);
+                if (shared) {
+                    plain.add(id);
+                    materialCopies.add(id);
+                }
+                else if (original.type === 'wall') {
+                    const length = getWallCurveLength(original);
+                    for (const child of wallAttachments(nodes, original)) {
+                        const t = 'position' in child && Array.isArray(child.position)
+                            ? child.position[0] / length
+                            : 0.5;
+                        if (t < lo - 1e-6 || t > hi + 1e-6)
+                            continue;
+                        const childId = mintId(child.type);
+                        scratch[childId] = {
+                            ...child,
+                            id: childId,
+                            parentId: id,
+                            wallId: id,
+                            ...('position' in child && Array.isArray(child.position)
+                                ? {
+                                    position: [
+                                        child.position[0] - lo * length,
+                                        child.position[1],
+                                        child.position[2],
+                                    ],
+                                }
+                                : {}),
+                            ...('wallT' in child ? { wallT: (t - lo) / (hi - lo) } : {}),
+                        };
+                        sourceFor.set(childId, child.id);
+                        idMap[child.id] = [childId];
+                        moving.add(childId);
+                    }
+                }
+            }
+            moving.add(boundary.id);
+            idMap[boundaryId].push(boundary.id);
+        }
+    }
+    const contents = collectTransformContents(nodes, zone);
+    if (duplicate) {
+        // Copy descendants from the source graph before remapping parents, including nested wall items.
+        const sources = new Set([
+            ...contents,
+            ...[...sourceFor].filter(([id]) => !plain.has(id)).map(([, source]) => source),
+        ]);
+        for (const id of boundaryIds)
+            sources.delete(id);
+        includeDescendants(nodes, sources);
+        for (const id of sources) {
+            if (idMap[id])
+                continue;
+            const node = nodes[id];
+            const copyId = mintId(node.type);
+            scratch[copyId] = { ...node, id: copyId };
+            moving.add(copyId);
+            sourceFor.set(copyId, id);
+            idMap[id] = [copyId];
+        }
+    }
+    else {
+        for (const id of contents)
+            moving.add(id);
+        includeDescendants(scratch, moving);
+    }
+    const resultZoneId = duplicate ? mintId('zone') : zone.id;
+    idMap[zone.id] = [resultZoneId];
+    scratch[resultZoneId] = {
+        ...zone,
+        id: resultZoneId,
+        ...(duplicate ? { name: nextRoomName(nodes, zone.name) } : {}),
+    };
+    moving.add(resultZoneId);
+    sourceFor.set(resultZoneId, zone.id);
+    for (const id of moving) {
+        const node = scratch[id];
+        let next = { ...node };
+        const sourceId = sourceFor.get(id) ?? id;
+        const source = nodes[sourceId] ?? node;
+        if (duplicate && source.parentId && idMap[source.parentId])
+            next.parentId = idMap[source.parentId][0];
+        for (const key of ['supportSlabId', 'deckSlabId', 'wallId', 'hostZoneId']) {
+            const ref = source[key];
+            if (typeof ref !== 'string')
+                continue;
+            if (duplicate && idMap[ref])
+                Object.assign(next, { [key]: idMap[ref][0] });
+            else if (duplicate && nodes[ref] && isDerivedNode(nodes[ref])) {
+                const slab = nodes[ref];
+                if (slab?.type === 'slab' && (key === 'supportSlabId' || key === 'deckSlabId')) {
+                    const copiedZone = slab.zoneIds?.map((id) => idMap[id]?.[0]).find(Boolean);
+                    if (copiedZone)
+                        supportHosts.push({ nodeId: next.id, zoneId: copiedZone, field: key });
+                }
+                Object.assign(next, { [key]: undefined });
+            }
+        }
+        if (duplicate && next.type === 'floor-opening' && next.ownerId) {
+            const copiedOwner = idMap[next.ownerId]?.[0];
+            next.ownerId = copiedOwner;
+            if (!copiedOwner && next.source === 'plugin:pool')
+                next.source = 'manual';
+        }
+        const parent = next.parentId ? scratch[next.parentId] : undefined;
+        const inheritedPose = parent && moving.has(parent.id) && ('position' in parent || parent.type === 'wall');
+        if (next.type === 'wall' || next.type === 'separator')
+            next = { ...next, start: transform(next.start), end: transform(next.end) };
+        if ('polygon' in next && Array.isArray(next.polygon)) {
+            next = {
+                ...next,
+                polygon: next.polygon.map(transform),
+                ...('holes' in next && Array.isArray(next.holes)
+                    ? { holes: next.holes.map((hole) => hole.map(transform)) }
+                    : {}),
+            };
+        }
+        if ('position' in next && Array.isArray(next.position) && !inheritedPose) {
+            const point = transform([next.position[0], next.position[2]]);
+            let y = next.position[1];
+            if (duplicate && parent && isDerivedNode(parent)) {
+                if (parent.type === 'ceiling') {
+                    ceilingHosts.push({
+                        nodeId: next.id,
+                        zoneId: idMap[parent.zoneId ?? '']?.[0] ?? resultZoneId,
+                        offsetY: y,
+                    });
+                    y += parent.height ?? 2.7;
+                }
+                next.parentId = zone.parentId;
+            }
+            next = {
+                ...next,
+                position: [point[0], y + 0, point[1]],
+                ...('rotation' in next
+                    ? {
+                        rotation: Array.isArray(next.rotation)
+                            ? [next.rotation[0] + 0, next.rotation[1] + angle + 0, next.rotation[2] + 0]
+                            : typeof next.rotation === 'number'
+                                ? next.rotation + angle + 0
+                                : next.rotation,
+                    }
+                    : {}),
+            };
+        }
+        if (next.type === 'zone')
+            next = {
+                ...next,
+                ...(next.floor?.support === 'open' && !mezzanine ? { hostZoneId: resultZoneId } : {}),
+                seed: transform(next.seed ??
+                    polygonCentroid({
+                        outer: node.type === 'zone' ? node.polygon : zone.polygon,
+                        holes: [],
+                    })),
+                boundaryWallIds: (next.boundaryWallIds ?? []).flatMap((id) => idMap[id] ?? [id]),
+                boundarySeparatorIds: (next.boundarySeparatorIds ?? []).flatMap((id) => idMap[id] ?? [id]),
+                ...(next.wallOverrides
+                    ? {
+                        wallOverrides: next.wallOverrides.flatMap((entry) => (idMap[entry.wallId] ?? [entry.wallId]).map((wallId) => ({ ...entry, wallId }))),
+                    }
+                    : {}),
+                // A copied door carries its step paint to the copy.
+                ...(next.floorStepOverrides
+                    ? {
+                        floorStepOverrides: next.floorStepOverrides.map((entry) => ({
+                            ...entry,
+                            key: idMap[entry.key]?.[0] ?? entry.key,
+                        })),
+                    }
+                    : {}),
+                ...(next.floor
+                    ? {
+                        floor: {
+                            ...next.floor,
+                            ...(duplicate && next.floor.footprint
+                                ? { elevation: next.floor.elevation ?? getRoomBaseElevation(nodes, sourceId) }
+                                : {}),
+                            ...(duplicate && next.floor.sourceSlabId
+                                ? {
+                                    sourceSlabId: idMap[next.floor.sourceSlabId]?.[0],
+                                }
+                                : {}),
+                            ...(next.floor.regions
+                                ? {
+                                    regions: next.floor.regions.map((region) => ({
+                                        ...region,
+                                        polygon: region.polygon.map(transform),
+                                    })),
+                                }
+                                : {}),
+                        },
+                    }
+                    : {}),
+                ...(next.ceiling?.regions
+                    ? {
+                        ceiling: {
+                            ...next.ceiling,
+                            regions: next.ceiling.regions.map((region) => ({
+                                ...region,
+                                polygon: region.polygon.map(transform),
+                            })),
+                        },
+                    }
+                    : {}),
+            };
+        scratch[id] = next;
+        idMap[sourceId] ??= [id];
+    }
+    if (mezzanine) {
+        repairTransformChildren(scratch, nodes);
+        return {
+            changes: diffStructure(nodes, scratch),
+            zoneId: resultZoneId,
+            idMap,
+            ceilingHosts,
+            supportHosts,
+        };
+    }
+    const stationary = new Set(boundaries(scratch, zone.parentId)
+        .filter((node) => !moving.has(node.id))
+        .map((node) => node.id));
+    snapDroppedWalls(scratch, moving, zone.parentId);
+    const preserveFinish = (wallId) => {
+        const current = scratch[resultZoneId];
+        const wall = scratch[wallId];
+        if (wall?.type !== 'wall' || current.wallMaterial)
+            return;
+        const overrides = [...(current.wallOverrides ?? [])];
+        for (const span of face.spans) {
+            if (!idMap[span.boundaryId]?.includes(wallId))
+                continue;
+            const finish = wall.slots?.[span.face];
+            if (finish && !overrides.some((entry) => entry.wallId === wallId && entry.face === span.face))
+                overrides.push({ wallId, face: span.face, finish });
+        }
+        if (overrides.length !== (current.wallOverrides?.length ?? 0))
+            scratch[resultZoneId] = { ...current, wallOverrides: overrides };
+    };
+    for (const wallId of materialCopies)
+        preserveFinish(wallId);
+    const conflicts = [];
+    if (!duplicate) {
+        const plates = new Set(Object.values(nodes)
+            .filter((node) => node.type === 'slab' &&
+            node.parentId === zone.parentId &&
+            (node.zoneIds?.some((id) => moving.has(id)) || moving.has(node.id)))
+            .map((node) => node.id));
+        for (const node of Object.values(nodes))
+            if (node.type === 'stair' &&
+                node.parentId !== zone.parentId &&
+                node.deckSlabId &&
+                plates.has(node.deckSlabId))
+                conflicts.push({
+                    code: 'deck-reference',
+                    nodeIds: [node.id, node.deckSlabId],
+                    message: 'A stair on another level uses the moving room’s floor as its destination deck.',
+                });
+    }
+    if (conflicts.length && !input.force)
+        return { changes: [], conflicts, idMap: {}, zoneId: resultZoneId };
+    for (const [id, cuts] of dropCrossingCuts(scratch, moving, zone.parentId)) {
+        const wall = scratch[id];
+        if (wall?.type !== 'wall')
+            continue;
+        const blocked = clearOpeningCuts(scratch, wall, cuts, input.force ?? false);
+        if (blocked)
+            return { changes: [], conflicts: [blocked], idMap: {}, zoneId: resultZoneId };
+    }
+    const queue = [...moving].filter((id) => scratch[id]?.type === 'wall');
+    while (queue.length) {
+        const id = queue.shift(), placed = scratch[id];
+        if (placed?.type !== 'wall')
+            continue;
+        const destination = Object.values(scratch).find((node) => node.type === 'wall' &&
+            node.parentId === zone.parentId &&
+            !moving.has(node.id) &&
+            collinearOverlap(placed, node));
+        if (!destination)
+            continue;
+        preserveFinish(placed.id);
+        const split = splitCollinearWalls(scratch, placed, destination, mintId);
+        const replacements = split.get(placed);
+        moving.add(destination.id);
+        for (const [sourceWall, targets] of split) {
+            if (stationary.has(sourceWall.id))
+                for (const target of targets)
+                    stationary.add(target.id);
+            for (const [sourceId, ids] of Object.entries(idMap))
+                idMap[sourceId] = [
+                    ...new Set(ids.flatMap((old) => (old === sourceWall.id ? targets.map((wall) => wall.id) : [old]))),
+                ];
+            idMap[sourceWall.id] ??= targets.map((wall) => wall.id);
+        }
+        for (const tail of replacements.slice(1)) {
+            moving.add(tail.id);
+            queue.push(tail.id);
+        }
+    }
+    const blocked = insertDroppedBoundaries(scratch, moving, zone.parentId, idMap, mintId, input.force ?? false, stationary);
+    if (blocked)
+        return { changes: [], conflicts: [blocked], idMap: {}, zoneId: resultZoneId };
+    preserveDroppedRoomSeeds(scratch, resultZoneId);
+    repairTransformChildren(scratch, nodes);
+    return {
+        changes: diffStructure(nodes, scratch),
+        ...(conflicts.length ? { conflicts } : {}),
+        idMap,
+        zoneId: resultZoneId,
+        ...(ceilingHosts.length ? { ceilingHosts } : {}),
+        ...(supportHosts.length ? { supportHosts } : {}),
+    };
+}
+function nextRoomName(nodes, name) {
+    const base = name.replace(/ \d+$/, '') || 'Room';
+    const used = new Set(Object.values(nodes)
+        .filter((node) => node.type === 'zone')
+        .map((node) => node.name));
+    let number = 2;
+    while (used.has(`${base} ${number}`))
+        number++;
+    return `${base} ${number}`;
+}

package/dist/commands/structure/validate-mezzanine.d.ts

@@ -0,0 +1,5 @@
+import type { ZoneNode } from '../../schema/index.js';
+import { type StructureConflict, type StructureNodes } from './shared.js';
+export declare function mezzanineHostClearance(nodes: StructureNodes, host: ZoneNode): import("../../index.js").MultiPolygon;
+export declare function validateMezzanine(nodes: StructureNodes, zone: ZoneNode, excludeId?: string): StructureConflict | undefined;
+//# sourceMappingURL=validate-mezzanine.d.ts.map

package/dist/commands/structure/validate-mezzanine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-mezzanine.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/validate-mezzanine.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGtD,OAAO,EAAwB,KAAK,iBAAiB,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AAE5F,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,gCAW3E;AAED,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,QAAQ,EACd,SAAS,CAAC,EAAE,MAAM,GACjB,iBAAiB,GAAG,SAAS,CAkE/B"}