@pascal-app/core 1.0.1 → 1.0.4

package/dist/commands/structure/floor-opening.js

@@ -0,0 +1,124 @@
+import { adjacentLevelId, floorOpeningTargets } from '../../lib/floor-opening-intent.js';
+import { area, intersection, union } from '../../lib/polygon-boolean.js';
+import { FloorOpeningNode } from '../../schema/index.js';
+function surfaceFootprint(node) {
+    return { outer: node.polygon, holes: node.holes ?? [] };
+}
+export function floorOpeningHints(nodes, opening) {
+    const ceilingTargets = floorOpeningTargets(nodes, opening).filter((target) => target.surface === 'ceiling');
+    const surfaceIds = Object.values(nodes)
+        .filter((node) => node.type === 'ceiling' &&
+        node.boundary !== 'auto' &&
+        ceilingTargets.some((target) => target.levelId === node.parentId) &&
+        area(intersection(opening.polygon, surfaceFootprint(node))) > 1e-6)
+        .map((node) => node.id)
+        .sort();
+    return surfaceIds.length
+        ? [
+            {
+                code: 'manual-ceiling',
+                openingId: opening.id,
+                surfaceIds,
+                message: 'The adjacent ceiling is manual. Cut it in Edit ceiling.',
+            },
+        ]
+        : [];
+}
+function adjacentSurfaceExists(nodes, levelId, drawnOn, polygon) {
+    const adjacent = adjacentLevelId(nodes, levelId, drawnOn === 'floor' ? -1 : 1);
+    if (!adjacent)
+        return false;
+    return Object.values(nodes).some((node) => node.parentId === adjacent &&
+        (drawnOn === 'floor' ? node.type === 'ceiling' : node.type === 'slab') &&
+        (node.type === 'ceiling' || node.type === 'slab') &&
+        area(intersection(polygon, surfaceFootprint(node))) > 1e-6);
+}
+export function cutFloorOpening(nodes, input) {
+    const zone = input.zoneId ? nodes[input.zoneId] : undefined;
+    if (input.zoneId && (zone?.type !== 'zone' || zone.spaceRole !== 'room'))
+        throw Error(`Room not found: ${input.zoneId}`);
+    const levelIds = [...new Set(input.levelIds ?? [input.levelId ?? zone?.parentId ?? ''])];
+    if (!levelIds.length || levelIds.some((id) => nodes[id]?.type !== 'level'))
+        throw Error('Specify an existing levelId or room zoneId.');
+    if (zone && input.levelId && zone.parentId !== input.levelId)
+        throw Error('The room is not on the specified level.');
+    const polygon = input.polygon ??
+        (input.rect
+            ? [
+                [input.rect.x, input.rect.z],
+                [input.rect.x + input.rect.width, input.rect.z],
+                [input.rect.x + input.rect.width, input.rect.z + input.rect.depth],
+                [input.rect.x, input.rect.z + input.rect.depth],
+            ]
+            : undefined);
+    if (!polygon || polygon.length < 3 || !polygon.every((point) => point.every(Number.isFinite)))
+        throw Error('Supply a finite polygon with at least three vertices, or a rect.');
+    if (area(union([polygon])) <= 1e-6)
+        throw Error('The opening polygon has no area.');
+    const drawnOn = input.drawnOn ?? 'floor';
+    if (zone?.type === 'zone' && zone.floor?.support === 'open' && drawnOn !== 'floor')
+        throw Error('A mezzanine hatch must be drawn on its floor.');
+    const openings = levelIds.map((levelId) => {
+        const hostZoneId = zone?.type === 'zone' && zone.floor?.support === 'open' && zone.parentId === levelId
+            ? zone.id
+            : undefined;
+        const id = input.mintId('floor-opening');
+        if (nodes[id])
+            throw Error(`Duplicate opening id: ${id}`);
+        return FloorOpeningNode.parse({
+            id,
+            parentId: levelId,
+            name: 'Floor opening',
+            polygon,
+            ...(hostZoneId ? { hostZoneId } : {}),
+            source: input.source ?? 'manual',
+            ownerId: input.ownerId,
+            drawnOn,
+            cutsPrimary: input.cutsPrimary ?? true,
+            cutsAdjacent: hostZoneId !== undefined
+                ? false
+                : (input.cutsAdjacent ?? adjacentSurfaceExists(nodes, levelId, drawnOn, polygon)),
+        });
+    });
+    const levelUpdates = levelIds.map((levelId) => {
+        const level = nodes[levelId];
+        return {
+            op: 'update',
+            id: level.id,
+            data: {
+                children: [
+                    ...level.children,
+                    ...openings
+                        .filter((opening) => opening.parentId === levelId)
+                        .map((opening) => opening.id),
+                ],
+            },
+        };
+    });
+    return {
+        changes: [...openings.map((node) => ({ op: 'create', node })), ...levelUpdates],
+        openingIds: openings.map((opening) => opening.id),
+        hints: openings.flatMap((opening) => floorOpeningHints(nodes, opening)),
+    };
+}
+export function removeFloorOpening(nodes, id) {
+    const opening = nodes[id];
+    if (opening?.type !== 'floor-opening')
+        throw Error(`Floor opening not found: ${id}`);
+    const level = opening.parentId ? nodes[opening.parentId] : undefined;
+    return {
+        openingId: id,
+        changes: [
+            { op: 'delete', id: opening.id },
+            ...(level?.type === 'level'
+                ? [
+                    {
+                        op: 'update',
+                        id: level.id,
+                        data: { children: level.children.filter((child) => child !== id) },
+                    },
+                ]
+                : []),
+        ],
+    };
+}

package/dist/commands/structure/index.d.ts

@@ -0,0 +1,22 @@
+export { applyZoneTransformPlan, type CeilingHostAssignment, type HostedZoneTransformPlan, resolveZoneTransformHosts, type SupportHostAssignment, } from './apply-zone-transform.js';
+export { type CreateMezzanineInput, createMezzanine } from './create-mezzanine.js';
+export { type CreateZoneInput, createZone, outdoorRoomConflicts } from './create-zone.js';
+export { type DeleteZonePayload, deleteZone, SHARED_WALLS_DELETE_MESSAGE } from './delete-zone.js';
+export { createZoneDivisionContext, divideZone, snapZoneBoundary, type ZoneDivisionContext, } from './divide-zone.js';
+export { type DuplicateZoneInput, duplicateZone } from './duplicate-zone.js';
+export { type CutFloorOpeningInput, cutFloorOpening, type FloorOpeningHint, floorOpeningHints, removeFloorOpening, } from './floor-opening.js';
+export { type LockOutsideFacesInput, lockOutsideFaces } from './lock-outside-faces.js';
+export { mergeZones } from './merge-zones.js';
+export { type MezzanineStairPlan, planMezzanineStair } from './plan-mezzanine-stair.js';
+export { planWallDeletion } from './plan-wall-deletion.js';
+export { rebaseFloorReference } from './rebase-floor-reference.js';
+export type { MezzanineEdgeInput } from './resize-mezzanine.js';
+export { type RotateZoneInput, rotateZone } from './rotate-zone.js';
+export { DEFAULT_FOUNDATION_HEIGHT, DEFAULT_FOUNDATION_MATERIAL, FloorFoundationPatch, setFloorFoundation, } from './set-floor-foundation.js';
+export { setRoomFloorConstruction } from './set-room-floor-construction.js';
+export { setWallGeometry } from './set-wall-geometry.js';
+export { setZoneEdges } from './set-zone-edges.js';
+export { setZoneIntent, ZoneIntentPatch } from './set-zone-intent.js';
+export { type NodeChange, type Point, type SpanRef, type StructureConflict, type StructureMintId, type StructureNodes, type StructurePlan, structureChangeBatch, } from './shared.js';
+export { type TransformZoneInput, transformZone, type ZoneTransformPlan } from './transform-zone.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,yBAAyB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,KAAK,oBAAoB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAC/E,OAAO,EAAE,KAAK,eAAe,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AACtF,OAAO,EAAE,KAAK,iBAAiB,EAAE,UAAU,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAA;AAC/F,OAAO,EACL,yBAAyB,EACzB,UAAU,EACV,gBAAgB,EAChB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,kBAAkB,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AACzE,OAAO,EACL,KAAK,oBAAoB,EACzB,eAAe,EACf,KAAK,gBAAgB,EACrB,iBAAiB,EACjB,kBAAkB,GACnB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,KAAK,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACnF,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1C,OAAO,EAAE,KAAK,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AACpF,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,YAAY,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAA;AAC5D,OAAO,EAAE,KAAK,eAAe,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAChE,OAAO,EACL,yBAAyB,EACzB,2BAA2B,EAC3B,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAA;AACxE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAA;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,EACL,KAAK,UAAU,EACf,KAAK,KAAK,EACV,KAAK,OAAO,EACZ,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,oBAAoB,GACrB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAE,KAAK,kBAAkB,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/commands/structure/index.js

@@ -0,0 +1,20 @@
+export { applyZoneTransformPlan, resolveZoneTransformHosts, } from './apply-zone-transform.js';
+export { createMezzanine } from './create-mezzanine.js';
+export { createZone, outdoorRoomConflicts } from './create-zone.js';
+export { deleteZone, SHARED_WALLS_DELETE_MESSAGE } from './delete-zone.js';
+export { createZoneDivisionContext, divideZone, snapZoneBoundary, } from './divide-zone.js';
+export { duplicateZone } from './duplicate-zone.js';
+export { cutFloorOpening, floorOpeningHints, removeFloorOpening, } from './floor-opening.js';
+export { lockOutsideFaces } from './lock-outside-faces.js';
+export { mergeZones } from './merge-zones.js';
+export { planMezzanineStair } from './plan-mezzanine-stair.js';
+export { planWallDeletion } from './plan-wall-deletion.js';
+export { rebaseFloorReference } from './rebase-floor-reference.js';
+export { rotateZone } from './rotate-zone.js';
+export { DEFAULT_FOUNDATION_HEIGHT, DEFAULT_FOUNDATION_MATERIAL, FloorFoundationPatch, setFloorFoundation, } from './set-floor-foundation.js';
+export { setRoomFloorConstruction } from './set-room-floor-construction.js';
+export { setWallGeometry } from './set-wall-geometry.js';
+export { setZoneEdges } from './set-zone-edges.js';
+export { setZoneIntent, ZoneIntentPatch } from './set-zone-intent.js';
+export { structureChangeBatch, } from './shared.js';
+export { transformZone } from './transform-zone.js';

package/dist/commands/structure/lock-outside-faces.d.ts

@@ -0,0 +1,12 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export type LockOutsideFacesInput = {
+    levelId: string;
+    zoneIds?: never;
+} | {
+    zoneIds: string[];
+    levelId?: never;
+};
+export declare function lockOutsideFaces(nodes: StructureNodes, input: LockOutsideFacesInput): StructurePlan & {
+    wallIds: string[];
+};
+//# sourceMappingURL=lock-outside-faces.d.ts.map

package/dist/commands/structure/lock-outside-faces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock-outside-faces.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/lock-outside-faces.ts"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAEzF,MAAM,MAAM,qBAAqB,GAC7B;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,KAAK,CAAA;CAAE,GACpC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,KAAK,CAAA;CAAE,CAAA;AAE1C,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,qBAAqB,GAC3B,aAAa,GAAG;IAAE,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CA+BvC"}

package/dist/commands/structure/lock-outside-faces.js

@@ -0,0 +1,32 @@
+import { justificationForFaceOnLine, planWallJustification } from '../../systems/wall/wall-frame.js';
+import { roomSideFaces } from '../../systems/wall/wall-room-sides.js';
+import { requireZone, roomFace } from './shared.js';
+export function lockOutsideFaces(nodes, input) {
+    if (input.levelId && nodes[input.levelId]?.type !== 'level')
+        throw Error('Select an editable floor.');
+    const zones = input.zoneIds?.map((id) => requireZone(nodes, id)) ??
+        Object.values(nodes).filter((node) => node.type === 'zone' && node.spaceRole === 'room' && node.parentId === input.levelId);
+    const targets = new Set(input.levelId
+        ? Object.values(nodes)
+            .filter((node) => node.type === 'wall' && node.parentId === input.levelId)
+            .map((node) => node.id)
+        : []);
+    for (const zone of zones) {
+        if (zone.type !== 'zone')
+            continue;
+        for (const span of roomFace(nodes, zone)?.spans ?? [])
+            if (span.kind === 'wall')
+                targets.add(span.boundaryId);
+    }
+    const patches = [];
+    for (const wallId of targets) {
+        const { outside } = roomSideFaces(nodes, wallId);
+        if (!outside)
+            continue;
+        patches.push(...planWallJustification(nodes, wallId, justificationForFaceOnLine(outside)));
+    }
+    return {
+        changes: patches.map((patch) => ({ op: 'update', ...patch })),
+        wallIds: patches.map((patch) => patch.id),
+    };
+}

package/dist/commands/structure/merge-zones.d.ts

@@ -0,0 +1,5 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export declare function mergeZones(nodes: StructureNodes, input: {
+    zoneIds: [string, string];
+}): StructurePlan;
+//# sourceMappingURL=merge-zones.d.ts.map

package/dist/commands/structure/merge-zones.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-zones.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/merge-zones.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB,wBAAgB,UAAU,CACxB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IAAE,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GACnC,aAAa,CAoCf"}

package/dist/commands/structure/merge-zones.js

@@ -0,0 +1,22 @@
+import { extractRooms } from '../../lib/room-graph.js';
+import { boundaries, conflict, requireZone, roomFace, } from './shared.js';
+export function mergeZones(nodes, input) {
+    const [a, b] = input.zoneIds.map((id) => requireZone(nodes, id));
+    if (a.id === b.id || a.parentId !== b.parentId)
+        return conflict('different-levels', input.zoneIds, 'Select two different rooms on the same level.');
+    const left = roomFace(nodes, a)?.spans ?? [];
+    const right = roomFace(nodes, b)?.spans ?? [];
+    const common = left.filter((s) => right.some((r) => r.boundaryId === s.boundaryId &&
+        r.face !== s.face &&
+        Math.min(r.t1, s.t1) - Math.max(r.t0, s.t0) > 1e-6));
+    const separators = new Set(common.filter((s) => s.kind === 'separator').map((s) => s.boundaryId));
+    if (!separators.size)
+        return conflict('wall-boundary', common.map((s) => s.boundaryId), common.length
+            ? 'These rooms are separated by walls. Merge never removes walls.'
+            : 'These rooms do not share a separator.');
+    const before = boundaries(nodes, a.parentId);
+    const after = before.filter((n) => !separators.has(n.id));
+    if (extractRooms(after).length !== extractRooms(before).length - 1)
+        return conflict('shared-separator', [...separators], 'Removing these separators would affect additional rooms.');
+    return { changes: [...separators].map((id) => ({ op: 'delete', id: nodes[id].id })) };
+}

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

@@ -0,0 +1,16 @@
+import { type AnyNode, type SlabNode, type ZoneNode } from '../../schema/index.js';
+import { type StructureNodes } from './shared.js';
+export type PositionedIntent = AnyNode & {
+    position: [number, number, number];
+    rotation: number | [number, number, number];
+    supportSlabId?: string;
+};
+export declare function isFloorPlacedIntent(node: AnyNode): node is PositionedIntent;
+export declare function containedMezzanines(nodes: StructureNodes, host: ZoneNode): ZoneNode[];
+export declare function mezzanineElevationConflict(nodes: StructureNodes, zone: ZoneNode): {
+    code: string;
+    nodeIds: `zone_${string}`[];
+    message: string;
+} | undefined;
+export declare function electedIntentPlate(nodes: StructureNodes, node: PositionedIntent): SlabNode | undefined;
+//# sourceMappingURL=mezzanine-content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mezzanine-content.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/mezzanine-content.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,QAAQ,EAEb,KAAK,QAAQ,EACd,MAAM,cAAc,CAAA;AAKrB,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,UAAU,CAAA;AAExD,MAAM,MAAM,gBAAgB,GAAG,OAAO,GAAG;IACvC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,gBAAgB,CAsB3E;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAcrF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,cAAc,EAAE,IAAI,EAAE,QAAQ;;;;cAkB/E;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,gBAAgB,GACrB,QAAQ,GAAG,SAAS,CAyCtB"}

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

@@ -0,0 +1,109 @@
+import { getFloorPlacedFootprints } from '../../hooks/spatial-grid/floor-placed-footprints.js';
+import { GROUND_SUPPORT_ID } from '../../hooks/spatial-grid/support-host-id.js';
+import { resolvedFootprintPlane } from '../../lib/floor-foundation-datum.js';
+import { itemOverlapsPolygon } from '../../lib/item-polygon-overlap.js';
+import { area, difference } from '../../lib/polygon-boolean.js';
+import { getRenderableSlabPolygon } from '../../lib/slab-polygon.js';
+import { proceduralFootprint } from '../../procedural-items/query.js';
+import { nodeRegistry } from '../../registry/index.js';
+import { getScaledDimensions, } from '../../schema/index.js';
+import { getStoredLevelHeight } from '../../services/storey.js';
+import { isDerivedNode } from '../../store/derived-node-guard.js';
+import { pointInPolygon } from '../../systems/slab/slab-support.js';
+import { getStairFloorPlacedFootprints } from '../../systems/stair/stair-floor-footprints.js';
+import { roomFace } from './shared.js';
+export function isFloorPlacedIntent(node) {
+    if (isDerivedNode(node) || !('position' in node) || !Array.isArray(node.position))
+        return false;
+    const definition = nodeRegistry.get(node.type);
+    if (definition) {
+        const capability = definition.capabilities?.floorPlaced;
+        return !!capability && (!capability.applies || capability.applies(node));
+    }
+    // Headless authorities do not load renderer definitions.
+    if (node.type === 'item')
+        return !node.asset.attachTo;
+    if (node.type === 'procedural-item')
+        return !node.recipe.mounting;
+    if (node.type === 'duct-terminal')
+        return node.mount === 'floor';
+    return [
+        'cabinet',
+        'cabinet-module',
+        'shelf',
+        'stair',
+        'column',
+        'block',
+        'spawn',
+        'hvac-equipment',
+    ].includes(node.type);
+}
+export function containedMezzanines(nodes, host) {
+    if (host.floor?.support === 'open')
+        return [];
+    const face = roomFace(nodes, host);
+    const footprint = {
+        outer: face?.referencePolygon ?? host.polygon,
+        holes: face?.holes ?? host.holes,
+    };
+    return Object.values(nodes).filter((node) => node.type === 'zone' &&
+        node.floor?.support === 'open' &&
+        node.parentId === host.parentId &&
+        area(difference({ outer: node.polygon, holes: node.holes }, footprint)) <= 1e-6);
+}
+export function mezzanineElevationConflict(nodes, zone) {
+    const level = zone.parentId ? nodes[zone.parentId] : undefined;
+    const thickness = zone.floor?.thickness ?? 0.2;
+    const elevation = zone.floor?.elevation;
+    const maximum = level?.type === 'level'
+        ? resolvedFootprintPlane(nodes, zone, getStoredLevelHeight(level)) - 0.3
+        : 0;
+    return elevation === undefined ||
+        !Number.isFinite(elevation) ||
+        elevation <= thickness ||
+        elevation > maximum
+        ? {
+            code: 'mezzanine-elevation',
+            nodeIds: [zone.id],
+            message: `Mezzanine elevation must be greater than thickness (${thickness} m) and at most ${maximum} m.`,
+        }
+        : undefined;
+}
+export function electedIntentPlate(nodes, node) {
+    if (node.supportSlabId === GROUND_SUPPORT_ID)
+        return undefined;
+    const capability = nodeRegistry.get(node.type)?.capabilities?.floorPlaced;
+    const rotation = Array.isArray(node.rotation)
+        ? node.rotation
+        : [0, node.rotation, 0];
+    const dimensions = node.type === 'item'
+        ? getScaledDimensions(node)
+        : [
+            'width' in node && typeof node.width === 'number' ? node.width : 0.6,
+            1,
+            'depth' in node && typeof node.depth === 'number' ? node.depth : 0.6,
+        ];
+    const footprints = capability
+        ? getFloorPlacedFootprints(capability, node, { nodes })
+        : node.type === 'stair'
+            ? getStairFloorPlacedFootprints(node, nodes)
+            : node.type === 'procedural-item'
+                ? [proceduralFootprint(node)]
+                : [{ dimensions, rotation }];
+    const siblings = Object.values(nodes).filter((n) => n.parentId === node.parentId);
+    const slabs = siblings.filter((n) => n.type === 'slab');
+    const walls = siblings.filter((n) => n.type === 'wall');
+    const supported = slabs.filter((slab) => {
+        const polygon = getRenderableSlabPolygon(slab, {
+            walls,
+            siblingSlabs: slabs.filter((n) => n.id !== slab.id),
+        });
+        return footprints.some((footprint) => {
+            const position = footprint.position ?? node.position;
+            return (itemOverlapsPolygon(position, footprint.dimensions, footprint.rotation, polygon, 0.01) &&
+                !slab.holes.some((hole) => pointInPolygon(position[0], position[2], hole)));
+        });
+    });
+    return (supported.find((slab) => slab.id === node.supportSlabId) ??
+        supported.sort((a, b) => b.elevation - a.elevation)[0]);
+}

package/dist/commands/structure/plan-mezzanine-stair.d.ts

@@ -0,0 +1,7 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+export type MezzanineStairPlan = StructurePlan & {
+    stairId?: string;
+    edgeIndex?: number;
+};
+export declare function planMezzanineStair(nodes: StructureNodes, mezzanineZoneId: string): MezzanineStairPlan;
+//# sourceMappingURL=plan-mezzanine-stair.d.ts.map

package/dist/commands/structure/plan-mezzanine-stair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-mezzanine-stair.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/plan-mezzanine-stair.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAGjB,MAAM,MAAM,kBAAkB,GAAG,aAAa,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzF,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,cAAc,EACrB,eAAe,EAAE,MAAM,GACtB,kBAAkB,CA6HpB"}

package/dist/commands/structure/plan-mezzanine-stair.js

@@ -0,0 +1,127 @@
+import { planFootprintCorners } from '../../lib/plan-footprint.js';
+import { area, difference, intersection, union } from '../../lib/polygon-boolean.js';
+import { roomFloorPlate } from '../../lib/room-floor-plate.js';
+import { getScaledDimensions, StairNode, StairSegmentNode } from '../../schema/index.js';
+import { stairFootprintAABB } from '../../systems/stair/stair-footprint.js';
+import { createSizedStairFlight, DEFAULT_STAIR_DESIGN_TARGETS, } from '../../systems/stair/stair-sizing.js';
+import { conflict, requireZone, } from './shared.js';
+import { mezzanineHostClearance } from './validate-mezzanine.js';
+export function planMezzanineStair(nodes, mezzanineZoneId) {
+    const zone = requireZone(nodes, mezzanineZoneId);
+    const host = nodes[zone.hostZoneId ?? ''];
+    if (zone.floor?.support !== 'open' || host?.type !== 'zone')
+        throw Error('Select a mezzanine with a host room.');
+    const refuse = () => conflict('no-room-for-stair', [zone.id], 'No mezzanine edge has enough free host floor for a straight stair.');
+    const slabs = Object.values(nodes).filter((node) => node.type === 'slab');
+    const deck = slabs.find((node) => node.zoneIds?.includes(zone.id));
+    const floor = roomFloorPlate(slabs, host.id);
+    if (!deck || !floor)
+        return refuse();
+    const rise = deck.elevation - floor.elevation;
+    if (!(rise > 0))
+        return refuse();
+    const defaults = createSizedStairFlight(rise);
+    const stepCount = defaults.stepCount;
+    const preferredRun = defaults.length;
+    const minimumRun = stepCount * DEFAULT_STAIR_DESIGN_TARGETS.minimumGoing;
+    const width = defaults.width;
+    const obstacles = [];
+    for (const node of Object.values(nodes)) {
+        if (node.parentId !== zone.parentId)
+            continue;
+        if (node.type === 'zone' && node.floor?.support === 'open')
+            obstacles.push(node.polygon);
+        if (node.type === 'item' && !node.asset.attachTo)
+            obstacles.push(planFootprintCorners(node.position, getScaledDimensions(node), node.rotation[1]));
+        if (node.type === 'stair') {
+            const box = stairFootprintAABB(node, nodes);
+            if (box)
+                obstacles.push([
+                    [box.minX, box.minZ],
+                    [box.maxX, box.minZ],
+                    [box.maxX, box.maxZ],
+                    [box.minX, box.maxZ],
+                ]);
+        }
+    }
+    const free = difference(mezzanineHostClearance(nodes, host), union(obstacles));
+    const winding = Math.sign(zone.polygon.reduce((sum, p, i) => {
+        const q = zone.polygon[(i + 1) % zone.polygon.length];
+        return sum + p[0] * q[1] - q[0] * p[1];
+    }, 0));
+    const candidates = [];
+    const extent = Math.hypot(Math.max(...host.polygon.map(([x]) => x)) - Math.min(...host.polygon.map(([x]) => x)), Math.max(...host.polygon.map(([, z]) => z)) - Math.min(...host.polygon.map(([, z]) => z)));
+    for (const [edgeIndex, start] of zone.polygon.entries()) {
+        const end = zone.polygon[(edgeIndex + 1) % zone.polygon.length];
+        const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+        if (length < width)
+            continue;
+        const tangent = [(end[0] - start[0]) / length, (end[1] - start[1]) / length];
+        const normal = [winding * tangent[1], -winding * tangent[0]];
+        for (const along of [...new Set([length / 2, width / 2, length - width / 2])]) {
+            const arrival = [start[0] + tangent[0] * along, start[1] + tangent[1] * along];
+            const footprint = (depth) => [
+                [-width / 2, 0],
+                [width / 2, 0],
+                [width / 2, depth],
+                [-width / 2, depth],
+            ].map(([x, z]) => [
+                arrival[0] + tangent[0] * x + normal[0] * z,
+                arrival[1] + tangent[1] * x + normal[1] * z,
+            ]);
+            const fits = (depth) => {
+                const polygon = footprint(depth);
+                return (area(difference(polygon, free)) <= 1e-6 &&
+                    area(difference(polygon, { outer: floor.polygon, holes: floor.holes })) <= 1e-6 &&
+                    area(intersection(polygon, zone.polygon)) <= 1e-6);
+            };
+            if (!fits(minimumRun))
+                continue;
+            let lo = minimumRun, hi = extent;
+            for (let i = 0; i < 16; i++) {
+                const mid = (lo + hi) / 2;
+                if (fits(mid))
+                    lo = mid;
+                else
+                    hi = mid;
+            }
+            candidates.push({ edgeIndex, arrival, normal, freeRun: lo });
+        }
+    }
+    const best = candidates.sort((a, b) => b.freeRun - a.freeRun)[0];
+    if (!best)
+        return refuse();
+    const run = Math.min(preferredRun, best.freeRun);
+    const stair = StairNode.parse({
+        parentId: zone.parentId,
+        name: 'Mezzanine stair',
+        uniformRisers: true,
+        fromLevelId: zone.parentId,
+        supportSlabId: floor.id,
+        deckSlabId: deck.id,
+        width,
+        stepCount,
+        position: [
+            best.arrival[0] + best.normal[0] * run + 0,
+            0,
+            best.arrival[1] + best.normal[1] * run + 0,
+        ],
+        rotation: Math.atan2(-best.normal[0], -best.normal[1]) + 0,
+    });
+    const segment = StairSegmentNode.parse({
+        ...defaults,
+        parentId: stair.id,
+        height: rise,
+        length: run,
+        stepCount,
+    });
+    stair.children = [segment.id];
+    return {
+        stairId: stair.id,
+        edgeIndex: best.edgeIndex,
+        changes: [
+            { op: 'create', node: stair },
+            { op: 'create', node: segment },
+        ],
+    };
+}

package/dist/commands/structure/plan-wall-deletion.d.ts

@@ -0,0 +1,9 @@
+import { type StructureNodes, type StructurePlan } from './shared.js';
+/** Plans user deletion, including room-preserving boundaries, before reconciliation. */
+export declare function planWallDeletion(nodes: StructureNodes, input: {
+    nodeIds: readonly string[];
+    mintId: (kind: 'separator') => string;
+    /** Authored batch state, so replacement walls/separators do not get duplicated. */
+    nextNodes?: StructureNodes;
+}): StructurePlan;
+//# sourceMappingURL=plan-wall-deletion.d.ts.map

package/dist/commands/structure/plan-wall-deletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-wall-deletion.d.ts","sourceRoot":"","sources":["../../../src/commands/structure/plan-wall-deletion.ts"],"names":[],"mappings":"AAKA,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB,wFAAwF;AACxF,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE;IACL,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;IAC1B,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,MAAM,CAAA;IACrC,mFAAmF;IACnF,SAAS,CAAC,EAAE,cAAc,CAAA;CAC3B,GACA,aAAa,CAmKf"}